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");
3379 if (e_flags
& E_FLAG_RX_V2
)
3380 strcat (buf
, ", V2");
3384 if (e_flags
& EF_S390_HIGH_GPRS
)
3385 strcat (buf
, ", highgprs");
3389 if ((e_flags
& EF_C6000_REL
))
3390 strcat (buf
, ", relocatable module");
3394 strcat (buf
, _(": architecture variant: "));
3395 switch (e_flags
& EF_MSP430_MACH
)
3397 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3398 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3399 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3400 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3401 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3402 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3403 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3404 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3405 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3406 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3407 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3408 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3409 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3410 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3411 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3413 strcat (buf
, _(": unknown")); break;
3416 if (e_flags
& ~ EF_MSP430_MACH
)
3417 strcat (buf
, _(": unknown extra flag bits also present"));
3425 get_osabi_name (unsigned int osabi
)
3427 static char buff
[32];
3431 case ELFOSABI_NONE
: return "UNIX - System V";
3432 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3433 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3434 case ELFOSABI_GNU
: return "UNIX - GNU";
3435 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3436 case ELFOSABI_AIX
: return "UNIX - AIX";
3437 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3438 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3439 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3440 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3441 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3442 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3443 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3444 case ELFOSABI_AROS
: return "AROS";
3445 case ELFOSABI_FENIXOS
: return "FenixOS";
3448 switch (elf_header
.e_machine
)
3453 case ELFOSABI_ARM
: return "ARM";
3464 case ELFOSABI_STANDALONE
: return _("Standalone App");
3473 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3474 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3483 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3489 get_aarch64_segment_type (unsigned long type
)
3493 case PT_AARCH64_ARCHEXT
:
3494 return "AARCH64_ARCHEXT";
3503 get_arm_segment_type (unsigned long type
)
3517 get_mips_segment_type (unsigned long type
)
3521 case PT_MIPS_REGINFO
:
3523 case PT_MIPS_RTPROC
:
3525 case PT_MIPS_OPTIONS
:
3527 case PT_MIPS_ABIFLAGS
:
3537 get_parisc_segment_type (unsigned long type
)
3541 case PT_HP_TLS
: return "HP_TLS";
3542 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3543 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3544 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3545 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3546 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3547 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3548 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3549 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3550 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3551 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3552 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3553 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3554 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3555 case PT_HP_STACK
: return "HP_STACK";
3556 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3557 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3558 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3559 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3568 get_ia64_segment_type (unsigned long type
)
3572 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3573 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3574 case PT_HP_TLS
: return "HP_TLS";
3575 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3576 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3577 case PT_IA_64_HP_STACK
: return "HP_STACK";
3586 get_tic6x_segment_type (unsigned long type
)
3590 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3599 get_segment_type (unsigned long p_type
)
3601 static char buff
[32];
3605 case PT_NULL
: return "NULL";
3606 case PT_LOAD
: return "LOAD";
3607 case PT_DYNAMIC
: return "DYNAMIC";
3608 case PT_INTERP
: return "INTERP";
3609 case PT_NOTE
: return "NOTE";
3610 case PT_SHLIB
: return "SHLIB";
3611 case PT_PHDR
: return "PHDR";
3612 case PT_TLS
: return "TLS";
3614 case PT_GNU_EH_FRAME
:
3615 return "GNU_EH_FRAME";
3616 case PT_GNU_STACK
: return "GNU_STACK";
3617 case PT_GNU_RELRO
: return "GNU_RELRO";
3620 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3622 const char * result
;
3624 switch (elf_header
.e_machine
)
3627 result
= get_aarch64_segment_type (p_type
);
3630 result
= get_arm_segment_type (p_type
);
3633 case EM_MIPS_RS3_LE
:
3634 result
= get_mips_segment_type (p_type
);
3637 result
= get_parisc_segment_type (p_type
);
3640 result
= get_ia64_segment_type (p_type
);
3643 result
= get_tic6x_segment_type (p_type
);
3653 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3655 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3657 const char * result
;
3659 switch (elf_header
.e_machine
)
3662 result
= get_parisc_segment_type (p_type
);
3665 result
= get_ia64_segment_type (p_type
);
3675 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3678 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3685 get_mips_section_type_name (unsigned int sh_type
)
3689 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3690 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3691 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3692 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3693 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3694 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3695 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3696 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3697 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3698 case SHT_MIPS_RELD
: return "MIPS_RELD";
3699 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3700 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3701 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3702 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3703 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3704 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3705 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3706 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3707 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3708 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3709 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3710 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3711 case SHT_MIPS_LINE
: return "MIPS_LINE";
3712 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3713 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3714 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3715 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3716 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3717 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3718 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3719 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3720 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3721 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3722 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3723 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3724 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3725 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3726 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3727 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3728 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3736 get_parisc_section_type_name (unsigned int sh_type
)
3740 case SHT_PARISC_EXT
: return "PARISC_EXT";
3741 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3742 case SHT_PARISC_DOC
: return "PARISC_DOC";
3743 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3744 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3745 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3746 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3754 get_ia64_section_type_name (unsigned int sh_type
)
3756 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3757 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3758 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3762 case SHT_IA_64_EXT
: return "IA_64_EXT";
3763 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3764 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3765 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3766 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3767 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3768 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3769 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3770 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3771 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3779 get_x86_64_section_type_name (unsigned int sh_type
)
3783 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3791 get_aarch64_section_type_name (unsigned int sh_type
)
3795 case SHT_AARCH64_ATTRIBUTES
:
3796 return "AARCH64_ATTRIBUTES";
3804 get_arm_section_type_name (unsigned int sh_type
)
3808 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3809 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3810 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3811 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3812 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3820 get_tic6x_section_type_name (unsigned int sh_type
)
3824 case SHT_C6000_UNWIND
:
3825 return "C6000_UNWIND";
3826 case SHT_C6000_PREEMPTMAP
:
3827 return "C6000_PREEMPTMAP";
3828 case SHT_C6000_ATTRIBUTES
:
3829 return "C6000_ATTRIBUTES";
3834 case SHT_TI_HANDLER
:
3835 return "TI_HANDLER";
3836 case SHT_TI_INITINFO
:
3837 return "TI_INITINFO";
3838 case SHT_TI_PHATTRS
:
3839 return "TI_PHATTRS";
3847 get_msp430x_section_type_name (unsigned int sh_type
)
3851 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3852 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3853 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3854 default: return NULL
;
3859 get_v850_section_type_name (unsigned int sh_type
)
3863 case SHT_V850_SCOMMON
: return "V850 Small Common";
3864 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3865 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3866 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3867 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3868 default: return NULL
;
3873 get_section_type_name (unsigned int sh_type
)
3875 static char buff
[32];
3879 case SHT_NULL
: return "NULL";
3880 case SHT_PROGBITS
: return "PROGBITS";
3881 case SHT_SYMTAB
: return "SYMTAB";
3882 case SHT_STRTAB
: return "STRTAB";
3883 case SHT_RELA
: return "RELA";
3884 case SHT_HASH
: return "HASH";
3885 case SHT_DYNAMIC
: return "DYNAMIC";
3886 case SHT_NOTE
: return "NOTE";
3887 case SHT_NOBITS
: return "NOBITS";
3888 case SHT_REL
: return "REL";
3889 case SHT_SHLIB
: return "SHLIB";
3890 case SHT_DYNSYM
: return "DYNSYM";
3891 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3892 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3893 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3894 case SHT_GNU_HASH
: return "GNU_HASH";
3895 case SHT_GROUP
: return "GROUP";
3896 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3897 case SHT_GNU_verdef
: return "VERDEF";
3898 case SHT_GNU_verneed
: return "VERNEED";
3899 case SHT_GNU_versym
: return "VERSYM";
3900 case 0x6ffffff0: return "VERSYM";
3901 case 0x6ffffffc: return "VERDEF";
3902 case 0x7ffffffd: return "AUXILIARY";
3903 case 0x7fffffff: return "FILTER";
3904 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3907 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3909 const char * result
;
3911 switch (elf_header
.e_machine
)
3914 case EM_MIPS_RS3_LE
:
3915 result
= get_mips_section_type_name (sh_type
);
3918 result
= get_parisc_section_type_name (sh_type
);
3921 result
= get_ia64_section_type_name (sh_type
);
3926 result
= get_x86_64_section_type_name (sh_type
);
3929 result
= get_aarch64_section_type_name (sh_type
);
3932 result
= get_arm_section_type_name (sh_type
);
3935 result
= get_tic6x_section_type_name (sh_type
);
3938 result
= get_msp430x_section_type_name (sh_type
);
3942 case EM_CYGNUS_V850
:
3943 result
= get_v850_section_type_name (sh_type
);
3953 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3955 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3957 const char * result
;
3959 switch (elf_header
.e_machine
)
3962 result
= get_ia64_section_type_name (sh_type
);
3972 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3974 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3976 switch (elf_header
.e_machine
)
3980 case EM_CYGNUS_V850
:
3981 return get_v850_section_type_name (sh_type
);
3986 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3989 /* This message is probably going to be displayed in a 15
3990 character wide field, so put the hex value first. */
3991 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3997 #define OPTION_DEBUG_DUMP 512
3998 #define OPTION_DYN_SYMS 513
3999 #define OPTION_DWARF_DEPTH 514
4000 #define OPTION_DWARF_START 515
4001 #define OPTION_DWARF_CHECK 516
4003 static struct option options
[] =
4005 {"all", no_argument
, 0, 'a'},
4006 {"file-header", no_argument
, 0, 'h'},
4007 {"program-headers", no_argument
, 0, 'l'},
4008 {"headers", no_argument
, 0, 'e'},
4009 {"histogram", no_argument
, 0, 'I'},
4010 {"segments", no_argument
, 0, 'l'},
4011 {"sections", no_argument
, 0, 'S'},
4012 {"section-headers", no_argument
, 0, 'S'},
4013 {"section-groups", no_argument
, 0, 'g'},
4014 {"section-details", no_argument
, 0, 't'},
4015 {"full-section-name",no_argument
, 0, 'N'},
4016 {"symbols", no_argument
, 0, 's'},
4017 {"syms", no_argument
, 0, 's'},
4018 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4019 {"relocs", no_argument
, 0, 'r'},
4020 {"notes", no_argument
, 0, 'n'},
4021 {"dynamic", no_argument
, 0, 'd'},
4022 {"arch-specific", no_argument
, 0, 'A'},
4023 {"version-info", no_argument
, 0, 'V'},
4024 {"use-dynamic", no_argument
, 0, 'D'},
4025 {"unwind", no_argument
, 0, 'u'},
4026 {"archive-index", no_argument
, 0, 'c'},
4027 {"hex-dump", required_argument
, 0, 'x'},
4028 {"relocated-dump", required_argument
, 0, 'R'},
4029 {"string-dump", required_argument
, 0, 'p'},
4030 {"decompress", no_argument
, 0, 'z'},
4031 #ifdef SUPPORT_DISASSEMBLY
4032 {"instruction-dump", required_argument
, 0, 'i'},
4034 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4036 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4037 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4038 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4040 {"version", no_argument
, 0, 'v'},
4041 {"wide", no_argument
, 0, 'W'},
4042 {"help", no_argument
, 0, 'H'},
4043 {0, no_argument
, 0, 0}
4047 usage (FILE * stream
)
4049 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4050 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4051 fprintf (stream
, _(" Options are:\n\
4052 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4053 -h --file-header Display the ELF file header\n\
4054 -l --program-headers Display the program headers\n\
4055 --segments An alias for --program-headers\n\
4056 -S --section-headers Display the sections' header\n\
4057 --sections An alias for --section-headers\n\
4058 -g --section-groups Display the section groups\n\
4059 -t --section-details Display the section details\n\
4060 -e --headers Equivalent to: -h -l -S\n\
4061 -s --syms Display the symbol table\n\
4062 --symbols An alias for --syms\n\
4063 --dyn-syms Display the dynamic symbol table\n\
4064 -n --notes Display the core notes (if present)\n\
4065 -r --relocs Display the relocations (if present)\n\
4066 -u --unwind Display the unwind info (if present)\n\
4067 -d --dynamic Display the dynamic section (if present)\n\
4068 -V --version-info Display the version sections (if present)\n\
4069 -A --arch-specific Display architecture specific information (if any)\n\
4070 -c --archive-index Display the symbol/file index in an archive\n\
4071 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4072 -x --hex-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as bytes\n\
4074 -p --string-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as strings\n\
4076 -R --relocated-dump=<number|name>\n\
4077 Dump the contents of section <number|name> as relocated bytes\n\
4078 -z --decompress Decompress section before dumping it\n\
4079 -w[lLiaprmfFsoRt] or\n\
4080 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4081 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4082 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4084 Display the contents of DWARF2 debug sections\n"));
4085 fprintf (stream
, _("\
4086 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4087 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4089 #ifdef SUPPORT_DISASSEMBLY
4090 fprintf (stream
, _("\
4091 -i --instruction-dump=<number|name>\n\
4092 Disassemble the contents of section <number|name>\n"));
4094 fprintf (stream
, _("\
4095 -I --histogram Display histogram of bucket list lengths\n\
4096 -W --wide Allow output width to exceed 80 characters\n\
4097 @<file> Read options from <file>\n\
4098 -H --help Display this information\n\
4099 -v --version Display the version number of readelf\n"));
4101 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4102 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4104 exit (stream
== stdout
? 0 : 1);
4107 /* Record the fact that the user wants the contents of section number
4108 SECTION to be displayed using the method(s) encoded as flags bits
4109 in TYPE. Note, TYPE can be zero if we are creating the array for
4113 request_dump_bynumber (unsigned int section
, dump_type type
)
4115 if (section
>= num_dump_sects
)
4117 dump_type
* new_dump_sects
;
4119 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4120 sizeof (* dump_sects
));
4122 if (new_dump_sects
== NULL
)
4123 error (_("Out of memory allocating dump request table.\n"));
4126 /* Copy current flag settings. */
4127 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4131 dump_sects
= new_dump_sects
;
4132 num_dump_sects
= section
+ 1;
4137 dump_sects
[section
] |= type
;
4142 /* Request a dump by section name. */
4145 request_dump_byname (const char * section
, dump_type type
)
4147 struct dump_list_entry
* new_request
;
4149 new_request
= (struct dump_list_entry
*)
4150 malloc (sizeof (struct dump_list_entry
));
4152 error (_("Out of memory allocating dump request table.\n"));
4154 new_request
->name
= strdup (section
);
4155 if (!new_request
->name
)
4156 error (_("Out of memory allocating dump request table.\n"));
4158 new_request
->type
= type
;
4160 new_request
->next
= dump_sects_byname
;
4161 dump_sects_byname
= new_request
;
4165 request_dump (dump_type type
)
4171 section
= strtoul (optarg
, & cp
, 0);
4173 if (! *cp
&& section
>= 0)
4174 request_dump_bynumber (section
, type
);
4176 request_dump_byname (optarg
, type
);
4181 parse_args (int argc
, char ** argv
)
4188 while ((c
= getopt_long
4189 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4207 do_section_groups
++;
4215 do_section_groups
++;
4220 do_section_details
++;
4264 request_dump (HEX_DUMP
);
4267 request_dump (STRING_DUMP
);
4270 request_dump (RELOC_DUMP
);
4280 dwarf_select_sections_all ();
4285 dwarf_select_sections_by_letters (optarg
);
4288 case OPTION_DEBUG_DUMP
:
4295 dwarf_select_sections_by_names (optarg
);
4298 case OPTION_DWARF_DEPTH
:
4302 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4305 case OPTION_DWARF_START
:
4309 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4312 case OPTION_DWARF_CHECK
:
4315 case OPTION_DYN_SYMS
:
4318 #ifdef SUPPORT_DISASSEMBLY
4320 request_dump (DISASS_DUMP
);
4324 print_version (program_name
);
4333 /* xgettext:c-format */
4334 error (_("Invalid option '-%c'\n"), c
);
4341 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4342 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4343 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4344 && !do_section_groups
&& !do_archive_index
4350 get_elf_class (unsigned int elf_class
)
4352 static char buff
[32];
4356 case ELFCLASSNONE
: return _("none");
4357 case ELFCLASS32
: return "ELF32";
4358 case ELFCLASS64
: return "ELF64";
4360 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4366 get_data_encoding (unsigned int encoding
)
4368 static char buff
[32];
4372 case ELFDATANONE
: return _("none");
4373 case ELFDATA2LSB
: return _("2's complement, little endian");
4374 case ELFDATA2MSB
: return _("2's complement, big endian");
4376 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4381 /* Decode the data held in 'elf_header'. */
4384 process_file_header (void)
4386 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4387 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4388 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4389 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4392 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4396 init_dwarf_regnames (elf_header
.e_machine
);
4402 printf (_("ELF Header:\n"));
4403 printf (_(" Magic: "));
4404 for (i
= 0; i
< EI_NIDENT
; i
++)
4405 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4407 printf (_(" Class: %s\n"),
4408 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4409 printf (_(" Data: %s\n"),
4410 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4411 printf (_(" Version: %d %s\n"),
4412 elf_header
.e_ident
[EI_VERSION
],
4413 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4415 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4416 ? _("<unknown: %lx>")
4418 printf (_(" OS/ABI: %s\n"),
4419 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4420 printf (_(" ABI Version: %d\n"),
4421 elf_header
.e_ident
[EI_ABIVERSION
]);
4422 printf (_(" Type: %s\n"),
4423 get_file_type (elf_header
.e_type
));
4424 printf (_(" Machine: %s\n"),
4425 get_machine_name (elf_header
.e_machine
));
4426 printf (_(" Version: 0x%lx\n"),
4427 (unsigned long) elf_header
.e_version
);
4429 printf (_(" Entry point address: "));
4430 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4431 printf (_("\n Start of program headers: "));
4432 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4433 printf (_(" (bytes into file)\n Start of section headers: "));
4434 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4435 printf (_(" (bytes into file)\n"));
4437 printf (_(" Flags: 0x%lx%s\n"),
4438 (unsigned long) elf_header
.e_flags
,
4439 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4440 printf (_(" Size of this header: %ld (bytes)\n"),
4441 (long) elf_header
.e_ehsize
);
4442 printf (_(" Size of program headers: %ld (bytes)\n"),
4443 (long) elf_header
.e_phentsize
);
4444 printf (_(" Number of program headers: %ld"),
4445 (long) elf_header
.e_phnum
);
4446 if (section_headers
!= NULL
4447 && elf_header
.e_phnum
== PN_XNUM
4448 && section_headers
[0].sh_info
!= 0)
4449 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4450 putc ('\n', stdout
);
4451 printf (_(" Size of section headers: %ld (bytes)\n"),
4452 (long) elf_header
.e_shentsize
);
4453 printf (_(" Number of section headers: %ld"),
4454 (long) elf_header
.e_shnum
);
4455 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4456 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4457 putc ('\n', stdout
);
4458 printf (_(" Section header string table index: %ld"),
4459 (long) elf_header
.e_shstrndx
);
4460 if (section_headers
!= NULL
4461 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4462 printf (" (%u)", section_headers
[0].sh_link
);
4463 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4464 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4465 printf (_(" <corrupt: out of range>"));
4466 putc ('\n', stdout
);
4469 if (section_headers
!= NULL
)
4471 if (elf_header
.e_phnum
== PN_XNUM
4472 && section_headers
[0].sh_info
!= 0)
4473 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4474 if (elf_header
.e_shnum
== SHN_UNDEF
)
4475 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4476 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4477 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4478 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4479 elf_header
.e_shstrndx
= SHN_UNDEF
;
4480 free (section_headers
);
4481 section_headers
= NULL
;
4488 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4490 Elf32_External_Phdr
* phdrs
;
4491 Elf32_External_Phdr
* external
;
4492 Elf_Internal_Phdr
* internal
;
4494 unsigned int size
= elf_header
.e_phentsize
;
4495 unsigned int num
= elf_header
.e_phnum
;
4497 /* PR binutils/17531: Cope with unexpected section header sizes. */
4498 if (size
== 0 || num
== 0)
4500 if (size
< sizeof * phdrs
)
4502 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4505 if (size
> sizeof * phdrs
)
4506 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4508 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4509 size
, num
, _("program headers"));
4513 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4514 i
< elf_header
.e_phnum
;
4515 i
++, internal
++, external
++)
4517 internal
->p_type
= BYTE_GET (external
->p_type
);
4518 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4519 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4520 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4521 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4522 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4523 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4524 internal
->p_align
= BYTE_GET (external
->p_align
);
4532 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4534 Elf64_External_Phdr
* phdrs
;
4535 Elf64_External_Phdr
* external
;
4536 Elf_Internal_Phdr
* internal
;
4538 unsigned int size
= elf_header
.e_phentsize
;
4539 unsigned int num
= elf_header
.e_phnum
;
4541 /* PR binutils/17531: Cope with unexpected section header sizes. */
4542 if (size
== 0 || num
== 0)
4544 if (size
< sizeof * phdrs
)
4546 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4549 if (size
> sizeof * phdrs
)
4550 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4552 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4553 size
, num
, _("program headers"));
4557 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4558 i
< elf_header
.e_phnum
;
4559 i
++, internal
++, external
++)
4561 internal
->p_type
= BYTE_GET (external
->p_type
);
4562 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4563 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4564 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4565 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4566 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4567 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4568 internal
->p_align
= BYTE_GET (external
->p_align
);
4575 /* Returns 1 if the program headers were read into `program_headers'. */
4578 get_program_headers (FILE * file
)
4580 Elf_Internal_Phdr
* phdrs
;
4582 /* Check cache of prior read. */
4583 if (program_headers
!= NULL
)
4586 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4587 sizeof (Elf_Internal_Phdr
));
4591 error (_("Out of memory reading %u program headers\n"),
4592 elf_header
.e_phnum
);
4597 ? get_32bit_program_headers (file
, phdrs
)
4598 : get_64bit_program_headers (file
, phdrs
))
4600 program_headers
= phdrs
;
4608 /* Returns 1 if the program headers were loaded. */
4611 process_program_headers (FILE * file
)
4613 Elf_Internal_Phdr
* segment
;
4616 if (elf_header
.e_phnum
== 0)
4618 /* PR binutils/12467. */
4619 if (elf_header
.e_phoff
!= 0)
4620 warn (_("possibly corrupt ELF header - it has a non-zero program"
4621 " header offset, but no program headers\n"));
4622 else if (do_segments
)
4623 printf (_("\nThere are no program headers in this file.\n"));
4627 if (do_segments
&& !do_header
)
4629 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4630 printf (_("Entry point "));
4631 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4632 printf (_("\nThere are %d program headers, starting at offset "),
4633 elf_header
.e_phnum
);
4634 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4638 if (! get_program_headers (file
))
4643 if (elf_header
.e_phnum
> 1)
4644 printf (_("\nProgram Headers:\n"));
4646 printf (_("\nProgram Headers:\n"));
4650 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4653 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4657 (_(" Type Offset VirtAddr PhysAddr\n"));
4659 (_(" FileSiz MemSiz Flags Align\n"));
4666 for (i
= 0, segment
= program_headers
;
4667 i
< elf_header
.e_phnum
;
4672 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4676 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4677 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4678 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4679 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4680 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4682 (segment
->p_flags
& PF_R
? 'R' : ' '),
4683 (segment
->p_flags
& PF_W
? 'W' : ' '),
4684 (segment
->p_flags
& PF_X
? 'E' : ' '));
4685 printf ("%#lx", (unsigned long) segment
->p_align
);
4689 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4690 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4693 print_vma (segment
->p_offset
, FULL_HEX
);
4697 print_vma (segment
->p_vaddr
, FULL_HEX
);
4699 print_vma (segment
->p_paddr
, FULL_HEX
);
4702 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4703 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4706 print_vma (segment
->p_filesz
, FULL_HEX
);
4710 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4711 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4714 print_vma (segment
->p_memsz
, FULL_HEX
);
4718 (segment
->p_flags
& PF_R
? 'R' : ' '),
4719 (segment
->p_flags
& PF_W
? 'W' : ' '),
4720 (segment
->p_flags
& PF_X
? 'E' : ' '));
4722 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4723 printf ("%#lx", (unsigned long) segment
->p_align
);
4726 print_vma (segment
->p_align
, PREFIX_HEX
);
4731 print_vma (segment
->p_offset
, FULL_HEX
);
4733 print_vma (segment
->p_vaddr
, FULL_HEX
);
4735 print_vma (segment
->p_paddr
, FULL_HEX
);
4737 print_vma (segment
->p_filesz
, FULL_HEX
);
4739 print_vma (segment
->p_memsz
, FULL_HEX
);
4741 (segment
->p_flags
& PF_R
? 'R' : ' '),
4742 (segment
->p_flags
& PF_W
? 'W' : ' '),
4743 (segment
->p_flags
& PF_X
? 'E' : ' '));
4744 print_vma (segment
->p_align
, HEX
);
4749 putc ('\n', stdout
);
4751 switch (segment
->p_type
)
4755 error (_("more than one dynamic segment\n"));
4757 /* By default, assume that the .dynamic section is the first
4758 section in the DYNAMIC segment. */
4759 dynamic_addr
= segment
->p_offset
;
4760 dynamic_size
= segment
->p_filesz
;
4761 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4762 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4764 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4765 dynamic_addr
= dynamic_size
= 0;
4768 /* Try to locate the .dynamic section. If there is
4769 a section header table, we can easily locate it. */
4770 if (section_headers
!= NULL
)
4772 Elf_Internal_Shdr
* sec
;
4774 sec
= find_section (".dynamic");
4775 if (sec
== NULL
|| sec
->sh_size
== 0)
4777 /* A corresponding .dynamic section is expected, but on
4778 IA-64/OpenVMS it is OK for it to be missing. */
4779 if (!is_ia64_vms ())
4780 error (_("no .dynamic section in the dynamic segment\n"));
4784 if (sec
->sh_type
== SHT_NOBITS
)
4790 dynamic_addr
= sec
->sh_offset
;
4791 dynamic_size
= sec
->sh_size
;
4793 if (dynamic_addr
< segment
->p_offset
4794 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4795 warn (_("the .dynamic section is not contained"
4796 " within the dynamic segment\n"));
4797 else if (dynamic_addr
> segment
->p_offset
)
4798 warn (_("the .dynamic section is not the first section"
4799 " in the dynamic segment.\n"));
4804 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4806 error (_("Unable to find program interpreter name\n"));
4810 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4812 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4813 error (_("Internal error: failed to create format string to display program interpreter\n"));
4815 program_interpreter
[0] = 0;
4816 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4817 error (_("Unable to read program interpreter name\n"));
4820 printf (_(" [Requesting program interpreter: %s]\n"),
4821 program_interpreter
);
4827 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4829 printf (_("\n Section to Segment mapping:\n"));
4830 printf (_(" Segment Sections...\n"));
4832 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4835 Elf_Internal_Shdr
* section
;
4837 segment
= program_headers
+ i
;
4838 section
= section_headers
+ 1;
4840 printf (" %2.2d ", i
);
4842 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4844 if (!ELF_TBSS_SPECIAL (section
, segment
)
4845 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4846 printf ("%s ", printable_section_name (section
));
4857 /* Find the file offset corresponding to VMA by using the program headers. */
4860 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4862 Elf_Internal_Phdr
* seg
;
4864 if (! get_program_headers (file
))
4866 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4870 for (seg
= program_headers
;
4871 seg
< program_headers
+ elf_header
.e_phnum
;
4874 if (seg
->p_type
!= PT_LOAD
)
4877 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4878 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4879 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4882 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4883 (unsigned long) vma
);
4888 /* Allocate memory and load the sections headers into the global pointer
4889 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4890 generate any error messages if the load fails. */
4893 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4895 Elf32_External_Shdr
* shdrs
;
4896 Elf_Internal_Shdr
* internal
;
4898 unsigned int size
= elf_header
.e_shentsize
;
4899 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4901 /* PR binutils/17531: Cope with unexpected section header sizes. */
4902 if (size
== 0 || num
== 0)
4904 if (size
< sizeof * shdrs
)
4907 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4910 if (!probe
&& size
> sizeof * shdrs
)
4911 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4913 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4915 probe
? NULL
: _("section headers"));
4919 if (section_headers
!= NULL
)
4920 free (section_headers
);
4921 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4922 sizeof (Elf_Internal_Shdr
));
4923 if (section_headers
== NULL
)
4926 error (_("Out of memory reading %u section headers\n"), num
);
4930 for (i
= 0, internal
= section_headers
;
4934 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4935 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4936 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4937 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4938 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4939 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4940 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4941 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4942 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4943 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4951 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4953 Elf64_External_Shdr
* shdrs
;
4954 Elf_Internal_Shdr
* internal
;
4956 unsigned int size
= elf_header
.e_shentsize
;
4957 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4959 /* PR binutils/17531: Cope with unexpected section header sizes. */
4960 if (size
== 0 || num
== 0)
4962 if (size
< sizeof * shdrs
)
4965 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4968 if (! probe
&& size
> sizeof * shdrs
)
4969 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4971 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4973 probe
? NULL
: _("section headers"));
4977 if (section_headers
!= NULL
)
4978 free (section_headers
);
4979 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4980 sizeof (Elf_Internal_Shdr
));
4981 if (section_headers
== NULL
)
4984 error (_("Out of memory reading %u section headers\n"), num
);
4988 for (i
= 0, internal
= section_headers
;
4992 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4993 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4994 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4995 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4996 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4997 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4998 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4999 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5000 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5001 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5008 static Elf_Internal_Sym
*
5009 get_32bit_elf_symbols (FILE * file
,
5010 Elf_Internal_Shdr
* section
,
5011 unsigned long * num_syms_return
)
5013 unsigned long number
= 0;
5014 Elf32_External_Sym
* esyms
= NULL
;
5015 Elf_External_Sym_Shndx
* shndx
= NULL
;
5016 Elf_Internal_Sym
* isyms
= NULL
;
5017 Elf_Internal_Sym
* psym
;
5020 if (section
->sh_size
== 0)
5022 if (num_syms_return
!= NULL
)
5023 * num_syms_return
= 0;
5027 /* Run some sanity checks first. */
5028 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5030 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5031 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5035 if (section
->sh_size
> current_file_size
)
5037 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5038 printable_section_name (section
), (unsigned long) section
->sh_size
);
5042 number
= section
->sh_size
/ section
->sh_entsize
;
5044 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5046 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5047 (unsigned long) section
->sh_size
,
5048 printable_section_name (section
),
5049 (unsigned long) section
->sh_entsize
);
5053 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5054 section
->sh_size
, _("symbols"));
5059 elf_section_list
* entry
;
5062 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5063 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5065 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5066 entry
->hdr
->sh_offset
,
5067 1, entry
->hdr
->sh_size
,
5068 _("symbol table section indicies"));
5071 /* PR17531: file: heap-buffer-overflow */
5072 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5074 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5075 printable_section_name (entry
->hdr
),
5076 (unsigned long) entry
->hdr
->sh_size
,
5077 (unsigned long) section
->sh_size
);
5083 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5087 error (_("Out of memory reading %lu symbols\n"),
5088 (unsigned long) number
);
5092 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5094 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5095 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5096 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5097 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5098 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5100 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5101 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5102 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5103 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5104 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5113 if (num_syms_return
!= NULL
)
5114 * num_syms_return
= isyms
== NULL
? 0 : number
;
5119 static Elf_Internal_Sym
*
5120 get_64bit_elf_symbols (FILE * file
,
5121 Elf_Internal_Shdr
* section
,
5122 unsigned long * num_syms_return
)
5124 unsigned long number
= 0;
5125 Elf64_External_Sym
* esyms
= NULL
;
5126 Elf_External_Sym_Shndx
* shndx
= NULL
;
5127 Elf_Internal_Sym
* isyms
= NULL
;
5128 Elf_Internal_Sym
* psym
;
5131 if (section
->sh_size
== 0)
5133 if (num_syms_return
!= NULL
)
5134 * num_syms_return
= 0;
5138 /* Run some sanity checks first. */
5139 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5141 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5142 printable_section_name (section
),
5143 (unsigned long) section
->sh_entsize
);
5147 if (section
->sh_size
> current_file_size
)
5149 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5150 printable_section_name (section
),
5151 (unsigned long) section
->sh_size
);
5155 number
= section
->sh_size
/ section
->sh_entsize
;
5157 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5159 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5160 (unsigned long) section
->sh_size
,
5161 printable_section_name (section
),
5162 (unsigned long) section
->sh_entsize
);
5166 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5167 section
->sh_size
, _("symbols"));
5172 elf_section_list
* entry
;
5175 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5176 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5178 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5179 entry
->hdr
->sh_offset
,
5180 1, entry
->hdr
->sh_size
,
5181 _("symbol table section indicies"));
5184 /* PR17531: file: heap-buffer-overflow */
5185 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5187 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5188 printable_section_name (entry
->hdr
),
5189 (unsigned long) entry
->hdr
->sh_size
,
5190 (unsigned long) section
->sh_size
);
5196 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5200 error (_("Out of memory reading %lu symbols\n"),
5201 (unsigned long) number
);
5205 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5207 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5208 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5209 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5210 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5212 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5214 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5215 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5216 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5218 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5219 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5228 if (num_syms_return
!= NULL
)
5229 * num_syms_return
= isyms
== NULL
? 0 : number
;
5235 get_elf_section_flags (bfd_vma sh_flags
)
5237 static char buff
[1024];
5239 int field_size
= is_32bit_elf
? 8 : 16;
5241 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5242 bfd_vma os_flags
= 0;
5243 bfd_vma proc_flags
= 0;
5244 bfd_vma unknown_flags
= 0;
5252 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5253 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5254 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5255 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5256 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5257 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5258 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5259 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5260 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5261 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5262 /* IA-64 specific. */
5263 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5264 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5265 /* IA-64 OpenVMS specific. */
5266 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5267 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5268 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5269 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5270 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5271 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5273 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5274 /* SPARC specific. */
5275 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5276 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5278 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5279 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5280 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5283 if (do_section_details
)
5285 sprintf (buff
, "[%*.*lx]: ",
5286 field_size
, field_size
, (unsigned long) sh_flags
);
5287 p
+= field_size
+ 4;
5294 flag
= sh_flags
& - sh_flags
;
5297 if (do_section_details
)
5301 case SHF_WRITE
: sindex
= 0; break;
5302 case SHF_ALLOC
: sindex
= 1; break;
5303 case SHF_EXECINSTR
: sindex
= 2; break;
5304 case SHF_MERGE
: sindex
= 3; break;
5305 case SHF_STRINGS
: sindex
= 4; break;
5306 case SHF_INFO_LINK
: sindex
= 5; break;
5307 case SHF_LINK_ORDER
: sindex
= 6; break;
5308 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5309 case SHF_GROUP
: sindex
= 8; break;
5310 case SHF_TLS
: sindex
= 9; break;
5311 case SHF_EXCLUDE
: sindex
= 18; break;
5312 case SHF_COMPRESSED
: sindex
= 20; break;
5316 switch (elf_header
.e_machine
)
5319 if (flag
== SHF_IA_64_SHORT
)
5321 else if (flag
== SHF_IA_64_NORECOV
)
5324 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5327 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5328 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5329 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5330 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5331 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5332 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5343 case EM_OLD_SPARCV9
:
5344 case EM_SPARC32PLUS
:
5347 if (flag
== SHF_ORDERED
)
5354 case SHF_ENTRYSECT
: sindex
= 21; break;
5355 case SHF_ARM_NOREAD
: sindex
= 22; break;
5356 case SHF_COMDEF
: sindex
= 23; break;
5368 if (p
!= buff
+ field_size
+ 4)
5370 if (size
< (10 + 2))
5372 warn (_("Internal error: not enough buffer room for section flag info"));
5373 return _("<unknown>");
5380 size
-= flags
[sindex
].len
;
5381 p
= stpcpy (p
, flags
[sindex
].str
);
5383 else if (flag
& SHF_MASKOS
)
5385 else if (flag
& SHF_MASKPROC
)
5388 unknown_flags
|= flag
;
5394 case SHF_WRITE
: *p
= 'W'; break;
5395 case SHF_ALLOC
: *p
= 'A'; break;
5396 case SHF_EXECINSTR
: *p
= 'X'; break;
5397 case SHF_MERGE
: *p
= 'M'; break;
5398 case SHF_STRINGS
: *p
= 'S'; break;
5399 case SHF_INFO_LINK
: *p
= 'I'; break;
5400 case SHF_LINK_ORDER
: *p
= 'L'; break;
5401 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5402 case SHF_GROUP
: *p
= 'G'; break;
5403 case SHF_TLS
: *p
= 'T'; break;
5404 case SHF_EXCLUDE
: *p
= 'E'; break;
5405 case SHF_COMPRESSED
: *p
= 'C'; break;
5408 if ((elf_header
.e_machine
== EM_X86_64
5409 || elf_header
.e_machine
== EM_L1OM
5410 || elf_header
.e_machine
== EM_K1OM
)
5411 && flag
== SHF_X86_64_LARGE
)
5413 else if (flag
& SHF_MASKOS
)
5416 sh_flags
&= ~ SHF_MASKOS
;
5418 else if (flag
& SHF_MASKPROC
)
5421 sh_flags
&= ~ SHF_MASKPROC
;
5431 if (do_section_details
)
5435 size
-= 5 + field_size
;
5436 if (p
!= buff
+ field_size
+ 4)
5440 warn (_("Internal error: not enough buffer room for section flag info"));
5441 return _("<unknown>");
5447 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5448 (unsigned long) os_flags
);
5449 p
+= 5 + field_size
;
5453 size
-= 7 + field_size
;
5454 if (p
!= buff
+ field_size
+ 4)
5458 warn (_("Internal error: not enough buffer room for section flag info"));
5459 return _("<unknown>");
5465 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5466 (unsigned long) proc_flags
);
5467 p
+= 7 + field_size
;
5471 size
-= 10 + field_size
;
5472 if (p
!= buff
+ field_size
+ 4)
5476 warn (_("Internal error: not enough buffer room for section flag info"));
5477 return _("<unknown>");
5483 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5484 (unsigned long) unknown_flags
);
5485 p
+= 10 + field_size
;
5494 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5498 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5499 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5500 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5501 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5502 return sizeof (*echdr
);
5506 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5507 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5508 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5509 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5510 return sizeof (*echdr
);
5515 process_section_headers (FILE * file
)
5517 Elf_Internal_Shdr
* section
;
5520 section_headers
= NULL
;
5522 if (elf_header
.e_shnum
== 0)
5524 /* PR binutils/12467. */
5525 if (elf_header
.e_shoff
!= 0)
5526 warn (_("possibly corrupt ELF file header - it has a non-zero"
5527 " section header offset, but no section headers\n"));
5528 else if (do_sections
)
5529 printf (_("\nThere are no sections in this file.\n"));
5534 if (do_sections
&& !do_header
)
5535 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5536 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5540 if (! get_32bit_section_headers (file
, FALSE
))
5543 else if (! get_64bit_section_headers (file
, FALSE
))
5546 /* Read in the string table, so that we have names to display. */
5547 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5548 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5550 section
= section_headers
+ elf_header
.e_shstrndx
;
5552 if (section
->sh_size
!= 0)
5554 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5555 1, section
->sh_size
,
5558 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5562 /* Scan the sections for the dynamic symbol table
5563 and dynamic string table and debug sections. */
5564 dynamic_symbols
= NULL
;
5565 dynamic_strings
= NULL
;
5566 dynamic_syminfo
= NULL
;
5567 symtab_shndx_list
= NULL
;
5569 eh_addr_size
= is_32bit_elf
? 4 : 8;
5570 switch (elf_header
.e_machine
)
5573 case EM_MIPS_RS3_LE
:
5574 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5575 FDE addresses. However, the ABI also has a semi-official ILP32
5576 variant for which the normal FDE address size rules apply.
5578 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5579 section, where XX is the size of longs in bits. Unfortunately,
5580 earlier compilers provided no way of distinguishing ILP32 objects
5581 from LP64 objects, so if there's any doubt, we should assume that
5582 the official LP64 form is being used. */
5583 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5584 && find_section (".gcc_compiled_long32") == NULL
)
5590 switch (elf_header
.e_flags
& EF_H8_MACH
)
5592 case E_H8_MACH_H8300
:
5593 case E_H8_MACH_H8300HN
:
5594 case E_H8_MACH_H8300SN
:
5595 case E_H8_MACH_H8300SXN
:
5598 case E_H8_MACH_H8300H
:
5599 case E_H8_MACH_H8300S
:
5600 case E_H8_MACH_H8300SX
:
5608 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5610 case EF_M32C_CPU_M16C
:
5617 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5620 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5621 if (section->sh_entsize != expected_entsize) \
5624 sprintf_vma (buf, section->sh_entsize); \
5625 /* Note: coded this way so that there is a single string for \
5627 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5628 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5629 (unsigned) expected_entsize); \
5630 section->sh_entsize = expected_entsize; \
5635 #define CHECK_ENTSIZE(section, i, type) \
5636 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5637 sizeof (Elf64_External_##type))
5639 for (i
= 0, section
= section_headers
;
5640 i
< elf_header
.e_shnum
;
5643 char * name
= SECTION_NAME (section
);
5645 if (section
->sh_type
== SHT_DYNSYM
)
5647 if (dynamic_symbols
!= NULL
)
5649 error (_("File contains multiple dynamic symbol tables\n"));
5653 CHECK_ENTSIZE (section
, i
, Sym
);
5654 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5656 else if (section
->sh_type
== SHT_STRTAB
5657 && streq (name
, ".dynstr"))
5659 if (dynamic_strings
!= NULL
)
5661 error (_("File contains multiple dynamic string tables\n"));
5665 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5666 1, section
->sh_size
,
5667 _("dynamic strings"));
5668 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5670 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5672 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5673 entry
->hdr
= section
;
5674 entry
->next
= symtab_shndx_list
;
5675 symtab_shndx_list
= entry
;
5677 else if (section
->sh_type
== SHT_SYMTAB
)
5678 CHECK_ENTSIZE (section
, i
, Sym
);
5679 else if (section
->sh_type
== SHT_GROUP
)
5680 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5681 else if (section
->sh_type
== SHT_REL
)
5682 CHECK_ENTSIZE (section
, i
, Rel
);
5683 else if (section
->sh_type
== SHT_RELA
)
5684 CHECK_ENTSIZE (section
, i
, Rela
);
5685 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5686 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5687 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5688 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5689 || do_debug_addr
|| do_debug_cu_index
)
5690 && (const_strneq (name
, ".debug_")
5691 || const_strneq (name
, ".zdebug_")))
5694 name
+= sizeof (".zdebug_") - 1;
5696 name
+= sizeof (".debug_") - 1;
5699 || (do_debug_info
&& const_strneq (name
, "info"))
5700 || (do_debug_info
&& const_strneq (name
, "types"))
5701 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5702 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5703 || (do_debug_lines
&& const_strneq (name
, "line."))
5704 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5705 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5706 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5707 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5708 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5709 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5710 || (do_debug_frames
&& const_strneq (name
, "frame"))
5711 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5712 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5713 || (do_debug_str
&& const_strneq (name
, "str"))
5714 || (do_debug_loc
&& const_strneq (name
, "loc"))
5715 || (do_debug_addr
&& const_strneq (name
, "addr"))
5716 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5717 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5719 request_dump_bynumber (i
, DEBUG_DUMP
);
5721 /* Linkonce section to be combined with .debug_info at link time. */
5722 else if ((do_debugging
|| do_debug_info
)
5723 && const_strneq (name
, ".gnu.linkonce.wi."))
5724 request_dump_bynumber (i
, DEBUG_DUMP
);
5725 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5726 request_dump_bynumber (i
, DEBUG_DUMP
);
5727 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5728 request_dump_bynumber (i
, DEBUG_DUMP
);
5729 /* Trace sections for Itanium VMS. */
5730 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5731 || do_trace_aranges
)
5732 && const_strneq (name
, ".trace_"))
5734 name
+= sizeof (".trace_") - 1;
5737 || (do_trace_info
&& streq (name
, "info"))
5738 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5739 || (do_trace_aranges
&& streq (name
, "aranges"))
5741 request_dump_bynumber (i
, DEBUG_DUMP
);
5748 if (elf_header
.e_shnum
> 1)
5749 printf (_("\nSection Headers:\n"));
5751 printf (_("\nSection Header:\n"));
5755 if (do_section_details
)
5757 printf (_(" [Nr] Name\n"));
5758 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5762 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5766 if (do_section_details
)
5768 printf (_(" [Nr] Name\n"));
5769 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5773 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5777 if (do_section_details
)
5779 printf (_(" [Nr] Name\n"));
5780 printf (_(" Type Address Offset Link\n"));
5781 printf (_(" Size EntSize Info Align\n"));
5785 printf (_(" [Nr] Name Type Address Offset\n"));
5786 printf (_(" Size EntSize Flags Link Info Align\n"));
5790 if (do_section_details
)
5791 printf (_(" Flags\n"));
5793 for (i
= 0, section
= section_headers
;
5794 i
< elf_header
.e_shnum
;
5797 printf (" [%2u] ", i
);
5798 if (do_section_details
)
5799 printf ("%s\n ", printable_section_name (section
));
5801 print_symbol (-17, SECTION_NAME (section
));
5803 printf (do_wide
? " %-15s " : " %-15.15s ",
5804 get_section_type_name (section
->sh_type
));
5808 const char * link_too_big
= NULL
;
5810 print_vma (section
->sh_addr
, LONG_HEX
);
5812 printf ( " %6.6lx %6.6lx %2.2lx",
5813 (unsigned long) section
->sh_offset
,
5814 (unsigned long) section
->sh_size
,
5815 (unsigned long) section
->sh_entsize
);
5817 if (do_section_details
)
5818 fputs (" ", stdout
);
5820 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5822 if (section
->sh_link
>= elf_header
.e_shnum
)
5825 /* The sh_link value is out of range. Normally this indicates
5826 an error but it can have special values in Solaris binaries. */
5827 switch (elf_header
.e_machine
)
5834 case EM_OLD_SPARCV9
:
5835 case EM_SPARC32PLUS
:
5838 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5839 link_too_big
= "BEFORE";
5840 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5841 link_too_big
= "AFTER";
5848 if (do_section_details
)
5850 if (link_too_big
!= NULL
&& * link_too_big
)
5851 printf ("<%s> ", link_too_big
);
5853 printf ("%2u ", section
->sh_link
);
5854 printf ("%3u %2lu\n", section
->sh_info
,
5855 (unsigned long) section
->sh_addralign
);
5858 printf ("%2u %3u %2lu\n",
5861 (unsigned long) section
->sh_addralign
);
5863 if (link_too_big
&& ! * link_too_big
)
5864 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5865 i
, section
->sh_link
);
5869 print_vma (section
->sh_addr
, LONG_HEX
);
5871 if ((long) section
->sh_offset
== section
->sh_offset
)
5872 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5876 print_vma (section
->sh_offset
, LONG_HEX
);
5879 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5880 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5884 print_vma (section
->sh_size
, LONG_HEX
);
5887 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5888 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5892 print_vma (section
->sh_entsize
, LONG_HEX
);
5895 if (do_section_details
)
5896 fputs (" ", stdout
);
5898 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5900 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5902 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5903 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5906 print_vma (section
->sh_addralign
, DEC
);
5910 else if (do_section_details
)
5912 printf (" %-15.15s ",
5913 get_section_type_name (section
->sh_type
));
5914 print_vma (section
->sh_addr
, LONG_HEX
);
5915 if ((long) section
->sh_offset
== section
->sh_offset
)
5916 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5920 print_vma (section
->sh_offset
, LONG_HEX
);
5922 printf (" %u\n ", section
->sh_link
);
5923 print_vma (section
->sh_size
, LONG_HEX
);
5925 print_vma (section
->sh_entsize
, LONG_HEX
);
5927 printf (" %-16u %lu\n",
5929 (unsigned long) section
->sh_addralign
);
5934 print_vma (section
->sh_addr
, LONG_HEX
);
5935 if ((long) section
->sh_offset
== section
->sh_offset
)
5936 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5940 print_vma (section
->sh_offset
, LONG_HEX
);
5943 print_vma (section
->sh_size
, LONG_HEX
);
5945 print_vma (section
->sh_entsize
, LONG_HEX
);
5947 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5949 printf (" %2u %3u %lu\n",
5952 (unsigned long) section
->sh_addralign
);
5955 if (do_section_details
)
5957 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5958 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5960 /* Minimum section size is 12 bytes for 32-bit compression
5961 header + 12 bytes for compressed data header. */
5962 unsigned char buf
[24];
5963 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5964 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5965 sizeof (buf
), _("compression header")))
5967 Elf_Internal_Chdr chdr
;
5968 get_compression_header (&chdr
, buf
);
5969 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5972 printf (_(" [<unknown>: 0x%x], "),
5974 print_vma (chdr
.ch_size
, LONG_HEX
);
5975 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
5981 if (!do_section_details
)
5983 if (elf_header
.e_machine
== EM_X86_64
5984 || elf_header
.e_machine
== EM_L1OM
5985 || elf_header
.e_machine
== EM_K1OM
)
5986 printf (_("Key to Flags:\n\
5987 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5988 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5989 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5991 printf (_("Key to Flags:\n\
5992 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5993 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5994 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6001 get_group_flags (unsigned int flags
)
6003 static char buff
[32];
6013 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6020 process_section_groups (FILE * file
)
6022 Elf_Internal_Shdr
* section
;
6024 struct group
* group
;
6025 Elf_Internal_Shdr
* symtab_sec
;
6026 Elf_Internal_Shdr
* strtab_sec
;
6027 Elf_Internal_Sym
* symtab
;
6028 unsigned long num_syms
;
6032 /* Don't process section groups unless needed. */
6033 if (!do_unwind
&& !do_section_groups
)
6036 if (elf_header
.e_shnum
== 0)
6038 if (do_section_groups
)
6039 printf (_("\nThere are no sections to group in this file.\n"));
6044 if (section_headers
== NULL
)
6046 error (_("Section headers are not available!\n"));
6047 /* PR 13622: This can happen with a corrupt ELF header. */
6051 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6052 sizeof (struct group
*));
6054 if (section_headers_groups
== NULL
)
6056 error (_("Out of memory reading %u section group headers\n"),
6057 elf_header
.e_shnum
);
6061 /* Scan the sections for the group section. */
6063 for (i
= 0, section
= section_headers
;
6064 i
< elf_header
.e_shnum
;
6066 if (section
->sh_type
== SHT_GROUP
)
6069 if (group_count
== 0)
6071 if (do_section_groups
)
6072 printf (_("\nThere are no section groups in this file.\n"));
6077 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6079 if (section_groups
== NULL
)
6081 error (_("Out of memory reading %lu groups\n"),
6082 (unsigned long) group_count
);
6092 for (i
= 0, section
= section_headers
, group
= section_groups
;
6093 i
< elf_header
.e_shnum
;
6096 if (section
->sh_type
== SHT_GROUP
)
6098 const char * name
= printable_section_name (section
);
6099 const char * group_name
;
6100 unsigned char * start
;
6101 unsigned char * indices
;
6102 unsigned int entry
, j
, size
;
6103 Elf_Internal_Shdr
* sec
;
6104 Elf_Internal_Sym
* sym
;
6106 /* Get the symbol table. */
6107 if (section
->sh_link
>= elf_header
.e_shnum
6108 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6111 error (_("Bad sh_link in group section `%s'\n"), name
);
6115 if (symtab_sec
!= sec
)
6120 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6125 error (_("Corrupt header in group section `%s'\n"), name
);
6129 if (section
->sh_info
>= num_syms
)
6131 error (_("Bad sh_info in group section `%s'\n"), name
);
6135 sym
= symtab
+ section
->sh_info
;
6137 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6139 if (sym
->st_shndx
== 0
6140 || sym
->st_shndx
>= elf_header
.e_shnum
)
6142 error (_("Bad sh_info in group section `%s'\n"), name
);
6146 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6155 /* Get the string table. */
6156 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6165 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6171 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6172 1, strtab_sec
->sh_size
,
6174 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6176 group_name
= sym
->st_name
< strtab_size
6177 ? strtab
+ sym
->st_name
: _("<corrupt>");
6180 /* PR 17531: file: loop. */
6181 if (section
->sh_entsize
> section
->sh_size
)
6183 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6184 printable_section_name (section
),
6185 (unsigned long) section
->sh_entsize
,
6186 (unsigned long) section
->sh_size
);
6190 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6191 1, section
->sh_size
,
6197 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6198 entry
= byte_get (indices
, 4);
6201 if (do_section_groups
)
6203 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6204 get_group_flags (entry
), i
, name
, group_name
, size
);
6206 printf (_(" [Index] Name\n"));
6209 group
->group_index
= i
;
6211 for (j
= 0; j
< size
; j
++)
6213 struct group_list
* g
;
6215 entry
= byte_get (indices
, 4);
6218 if (entry
>= elf_header
.e_shnum
)
6220 static unsigned num_group_errors
= 0;
6222 if (num_group_errors
++ < 10)
6224 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6225 entry
, i
, elf_header
.e_shnum
- 1);
6226 if (num_group_errors
== 10)
6227 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6232 if (section_headers_groups
[entry
] != NULL
)
6236 static unsigned num_errs
= 0;
6238 if (num_errs
++ < 10)
6240 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6242 section_headers_groups
[entry
]->group_index
);
6244 warn (_("Further error messages about already contained group sections suppressed\n"));
6250 /* Intel C/C++ compiler may put section 0 in a
6251 section group. We just warn it the first time
6252 and ignore it afterwards. */
6253 static int warned
= 0;
6256 error (_("section 0 in group section [%5u]\n"),
6257 section_headers_groups
[entry
]->group_index
);
6263 section_headers_groups
[entry
] = group
;
6265 if (do_section_groups
)
6267 sec
= section_headers
+ entry
;
6268 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6271 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6272 g
->section_index
= entry
;
6273 g
->next
= group
->root
;
6291 /* Data used to display dynamic fixups. */
6293 struct ia64_vms_dynfixup
6295 bfd_vma needed_ident
; /* Library ident number. */
6296 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6297 bfd_vma fixup_needed
; /* Index of the library. */
6298 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6299 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6302 /* Data used to display dynamic relocations. */
6304 struct ia64_vms_dynimgrela
6306 bfd_vma img_rela_cnt
; /* Number of relocations. */
6307 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6310 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6314 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6315 const char *strtab
, unsigned int strtab_sz
)
6317 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6319 const char *lib_name
;
6321 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6322 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6323 _("dynamic section image fixups"));
6327 if (fixup
->needed
< strtab_sz
)
6328 lib_name
= strtab
+ fixup
->needed
;
6331 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6332 (unsigned long) fixup
->needed
);
6335 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6336 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6338 (_("Seg Offset Type SymVec DataType\n"));
6340 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6345 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6346 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6347 type
= BYTE_GET (imfs
[i
].type
);
6348 rtype
= elf_ia64_reloc_type (type
);
6350 printf (" 0x%08x ", type
);
6352 printf (" %-32s ", rtype
);
6353 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6354 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6360 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6363 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6365 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6368 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6369 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6370 _("dynamic section image relocations"));
6374 printf (_("\nImage relocs\n"));
6376 (_("Seg Offset Type Addend Seg Sym Off\n"));
6378 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6383 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6384 printf ("%08" BFD_VMA_FMT
"x ",
6385 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6386 type
= BYTE_GET (imrs
[i
].type
);
6387 rtype
= elf_ia64_reloc_type (type
);
6389 printf ("0x%08x ", type
);
6391 printf ("%-31s ", rtype
);
6392 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6393 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6394 printf ("%08" BFD_VMA_FMT
"x\n",
6395 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6401 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6404 process_ia64_vms_dynamic_relocs (FILE *file
)
6406 struct ia64_vms_dynfixup fixup
;
6407 struct ia64_vms_dynimgrela imgrela
;
6408 Elf_Internal_Dyn
*entry
;
6410 bfd_vma strtab_off
= 0;
6411 bfd_vma strtab_sz
= 0;
6412 char *strtab
= NULL
;
6414 memset (&fixup
, 0, sizeof (fixup
));
6415 memset (&imgrela
, 0, sizeof (imgrela
));
6417 /* Note: the order of the entries is specified by the OpenVMS specs. */
6418 for (entry
= dynamic_section
;
6419 entry
< dynamic_section
+ dynamic_nent
;
6422 switch (entry
->d_tag
)
6424 case DT_IA_64_VMS_STRTAB_OFFSET
:
6425 strtab_off
= entry
->d_un
.d_val
;
6428 strtab_sz
= entry
->d_un
.d_val
;
6430 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6431 1, strtab_sz
, _("dynamic string section"));
6434 case DT_IA_64_VMS_NEEDED_IDENT
:
6435 fixup
.needed_ident
= entry
->d_un
.d_val
;
6438 fixup
.needed
= entry
->d_un
.d_val
;
6440 case DT_IA_64_VMS_FIXUP_NEEDED
:
6441 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6443 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6444 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6446 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6447 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6449 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6452 case DT_IA_64_VMS_IMG_RELA_CNT
:
6453 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6455 case DT_IA_64_VMS_IMG_RELA_OFF
:
6456 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6458 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6478 } dynamic_relocations
[] =
6480 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6481 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6482 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6485 /* Process the reloc section. */
6488 process_relocs (FILE * file
)
6490 unsigned long rel_size
;
6491 unsigned long rel_offset
;
6497 if (do_using_dynamic
)
6501 int has_dynamic_reloc
;
6504 has_dynamic_reloc
= 0;
6506 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6508 is_rela
= dynamic_relocations
[i
].rela
;
6509 name
= dynamic_relocations
[i
].name
;
6510 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6511 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6513 has_dynamic_reloc
|= rel_size
;
6515 if (is_rela
== UNKNOWN
)
6517 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6518 switch (dynamic_info
[DT_PLTREL
])
6532 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6533 name
, rel_offset
, rel_size
);
6535 dump_relocations (file
,
6536 offset_from_vma (file
, rel_offset
, rel_size
),
6538 dynamic_symbols
, num_dynamic_syms
,
6539 dynamic_strings
, dynamic_strings_length
,
6545 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6547 if (! has_dynamic_reloc
)
6548 printf (_("\nThere are no dynamic relocations in this file.\n"));
6552 Elf_Internal_Shdr
* section
;
6556 for (i
= 0, section
= section_headers
;
6557 i
< elf_header
.e_shnum
;
6560 if ( section
->sh_type
!= SHT_RELA
6561 && section
->sh_type
!= SHT_REL
)
6564 rel_offset
= section
->sh_offset
;
6565 rel_size
= section
->sh_size
;
6569 Elf_Internal_Shdr
* strsec
;
6572 printf (_("\nRelocation section "));
6574 if (string_table
== NULL
)
6575 printf ("%d", section
->sh_name
);
6577 printf ("'%s'", printable_section_name (section
));
6579 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6580 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6582 is_rela
= section
->sh_type
== SHT_RELA
;
6584 if (section
->sh_link
!= 0
6585 && section
->sh_link
< elf_header
.e_shnum
)
6587 Elf_Internal_Shdr
* symsec
;
6588 Elf_Internal_Sym
* symtab
;
6589 unsigned long nsyms
;
6590 unsigned long strtablen
= 0;
6591 char * strtab
= NULL
;
6593 symsec
= section_headers
+ section
->sh_link
;
6594 if (symsec
->sh_type
!= SHT_SYMTAB
6595 && symsec
->sh_type
!= SHT_DYNSYM
)
6598 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6603 if (symsec
->sh_link
!= 0
6604 && symsec
->sh_link
< elf_header
.e_shnum
)
6606 strsec
= section_headers
+ symsec
->sh_link
;
6608 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6611 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6614 dump_relocations (file
, rel_offset
, rel_size
,
6615 symtab
, nsyms
, strtab
, strtablen
,
6617 symsec
->sh_type
== SHT_DYNSYM
);
6623 dump_relocations (file
, rel_offset
, rel_size
,
6624 NULL
, 0, NULL
, 0, is_rela
, 0);
6631 printf (_("\nThere are no relocations in this file.\n"));
6637 /* An absolute address consists of a section and an offset. If the
6638 section is NULL, the offset itself is the address, otherwise, the
6639 address equals to LOAD_ADDRESS(section) + offset. */
6643 unsigned short section
;
6647 #define ABSADDR(a) \
6649 ? section_headers [(a).section].sh_addr + (a).offset \
6652 /* Find the nearest symbol at or below ADDR. Returns the symbol
6653 name, if found, and the offset from the symbol to ADDR. */
6656 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6657 unsigned long nsyms
,
6658 const char * strtab
,
6659 unsigned long strtab_size
,
6660 struct absaddr addr
,
6661 const char ** symname
,
6664 bfd_vma dist
= 0x100000;
6665 Elf_Internal_Sym
* sym
;
6666 Elf_Internal_Sym
* beg
;
6667 Elf_Internal_Sym
* end
;
6668 Elf_Internal_Sym
* best
= NULL
;
6670 REMOVE_ARCH_BITS (addr
.offset
);
6672 end
= symtab
+ nsyms
;
6678 sym
= beg
+ (end
- beg
) / 2;
6680 value
= sym
->st_value
;
6681 REMOVE_ARCH_BITS (value
);
6683 if (sym
->st_name
!= 0
6684 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6685 && addr
.offset
>= value
6686 && addr
.offset
- value
< dist
)
6689 dist
= addr
.offset
- value
;
6694 if (addr
.offset
< value
)
6702 *symname
= (best
->st_name
>= strtab_size
6703 ? _("<corrupt>") : strtab
+ best
->st_name
);
6709 *offset
= addr
.offset
;
6713 symcmp (const void *p
, const void *q
)
6715 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6716 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6718 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6721 /* Process the unwind section. */
6723 #include "unwind-ia64.h"
6725 struct ia64_unw_table_entry
6727 struct absaddr start
;
6729 struct absaddr info
;
6732 struct ia64_unw_aux_info
6734 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6735 unsigned long table_len
; /* Length of unwind table. */
6736 unsigned char * info
; /* Unwind info. */
6737 unsigned long info_size
; /* Size of unwind info. */
6738 bfd_vma info_addr
; /* Starting address of unwind info. */
6739 bfd_vma seg_base
; /* Starting address of segment. */
6740 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6741 unsigned long nsyms
; /* Number of symbols. */
6742 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6743 unsigned long nfuns
; /* Number of entries in funtab. */
6744 char * strtab
; /* The string table. */
6745 unsigned long strtab_size
; /* Size of string table. */
6749 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6751 struct ia64_unw_table_entry
* tp
;
6752 unsigned long j
, nfuns
;
6755 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6756 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6757 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6758 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6760 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6762 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6766 const unsigned char * dp
;
6767 const unsigned char * head
;
6768 const unsigned char * end
;
6769 const char * procname
;
6771 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6772 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6774 fputs ("\n<", stdout
);
6778 fputs (procname
, stdout
);
6781 printf ("+%lx", (unsigned long) offset
);
6784 fputs (">: [", stdout
);
6785 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6786 fputc ('-', stdout
);
6787 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6788 printf ("], info at +0x%lx\n",
6789 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6791 /* PR 17531: file: 86232b32. */
6792 if (aux
->info
== NULL
)
6795 /* PR 17531: file: 0997b4d1. */
6796 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6798 warn (_("Invalid offset %lx in table entry %ld\n"),
6799 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6803 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6804 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6806 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6807 (unsigned) UNW_VER (stamp
),
6808 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6809 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6810 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6811 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6813 if (UNW_VER (stamp
) != 1)
6815 printf (_("\tUnknown version.\n"));
6820 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6821 /* PR 17531: file: 16ceda89. */
6822 if (end
> aux
->info
+ aux
->info_size
)
6823 end
= aux
->info
+ aux
->info_size
;
6824 for (dp
= head
+ 8; dp
< end
;)
6825 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6832 slurp_ia64_unwind_table (FILE * file
,
6833 struct ia64_unw_aux_info
* aux
,
6834 Elf_Internal_Shdr
* sec
)
6836 unsigned long size
, nrelas
, i
;
6837 Elf_Internal_Phdr
* seg
;
6838 struct ia64_unw_table_entry
* tep
;
6839 Elf_Internal_Shdr
* relsec
;
6840 Elf_Internal_Rela
* rela
;
6841 Elf_Internal_Rela
* rp
;
6842 unsigned char * table
;
6844 Elf_Internal_Sym
* sym
;
6845 const char * relname
;
6849 /* First, find the starting address of the segment that includes
6852 if (elf_header
.e_phnum
)
6854 if (! get_program_headers (file
))
6857 for (seg
= program_headers
;
6858 seg
< program_headers
+ elf_header
.e_phnum
;
6861 if (seg
->p_type
!= PT_LOAD
)
6864 if (sec
->sh_addr
>= seg
->p_vaddr
6865 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6867 aux
->seg_base
= seg
->p_vaddr
;
6873 /* Second, build the unwind table from the contents of the unwind section: */
6874 size
= sec
->sh_size
;
6875 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6880 aux
->table_len
= size
/ (3 * eh_addr_size
);
6881 aux
->table
= (struct ia64_unw_table_entry
*)
6882 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6885 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6887 tep
->start
.section
= SHN_UNDEF
;
6888 tep
->end
.section
= SHN_UNDEF
;
6889 tep
->info
.section
= SHN_UNDEF
;
6890 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6891 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6892 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6893 tep
->start
.offset
+= aux
->seg_base
;
6894 tep
->end
.offset
+= aux
->seg_base
;
6895 tep
->info
.offset
+= aux
->seg_base
;
6899 /* Third, apply any relocations to the unwind table: */
6900 for (relsec
= section_headers
;
6901 relsec
< section_headers
+ elf_header
.e_shnum
;
6904 if (relsec
->sh_type
!= SHT_RELA
6905 || relsec
->sh_info
>= elf_header
.e_shnum
6906 || section_headers
+ relsec
->sh_info
!= sec
)
6909 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6918 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6920 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6921 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6923 /* PR 17531: file: 9fa67536. */
6924 if (relname
== NULL
)
6926 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6930 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6932 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6936 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6938 /* PR 17531: file: 5bc8d9bf. */
6939 if (i
>= aux
->table_len
)
6941 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6945 switch (rp
->r_offset
/ eh_addr_size
% 3)
6948 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6949 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6952 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6953 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6956 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6957 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6971 ia64_process_unwind (FILE * file
)
6973 Elf_Internal_Shdr
* sec
;
6974 Elf_Internal_Shdr
* unwsec
= NULL
;
6975 Elf_Internal_Shdr
* strsec
;
6976 unsigned long i
, unwcount
= 0, unwstart
= 0;
6977 struct ia64_unw_aux_info aux
;
6979 memset (& aux
, 0, sizeof (aux
));
6981 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6983 if (sec
->sh_type
== SHT_SYMTAB
6984 && sec
->sh_link
< elf_header
.e_shnum
)
6986 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6988 strsec
= section_headers
+ sec
->sh_link
;
6989 if (aux
.strtab
!= NULL
)
6991 error (_("Multiple auxillary string tables encountered\n"));
6994 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6997 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6999 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7004 printf (_("\nThere are no unwind sections in this file.\n"));
7006 while (unwcount
-- > 0)
7011 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7012 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7013 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7018 /* We have already counted the number of SHT_IA64_UNWIND
7019 sections so the loop above should never fail. */
7020 assert (unwsec
!= NULL
);
7023 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7025 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7027 /* We need to find which section group it is in. */
7028 struct group_list
* g
;
7030 if (section_headers_groups
== NULL
7031 || section_headers_groups
[i
] == NULL
)
7032 i
= elf_header
.e_shnum
;
7035 g
= section_headers_groups
[i
]->root
;
7037 for (; g
!= NULL
; g
= g
->next
)
7039 sec
= section_headers
+ g
->section_index
;
7041 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7046 i
= elf_header
.e_shnum
;
7049 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7051 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7052 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7053 suffix
= SECTION_NAME (unwsec
) + len
;
7054 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7056 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7057 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7062 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7063 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7064 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7065 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7067 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7068 suffix
= SECTION_NAME (unwsec
) + len
;
7069 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7071 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7072 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7076 if (i
== elf_header
.e_shnum
)
7078 printf (_("\nCould not find unwind info section for "));
7080 if (string_table
== NULL
)
7081 printf ("%d", unwsec
->sh_name
);
7083 printf ("'%s'", printable_section_name (unwsec
));
7087 aux
.info_addr
= sec
->sh_addr
;
7088 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7091 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7093 printf (_("\nUnwind section "));
7095 if (string_table
== NULL
)
7096 printf ("%d", unwsec
->sh_name
);
7098 printf ("'%s'", printable_section_name (unwsec
));
7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101 (unsigned long) unwsec
->sh_offset
,
7102 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7104 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7105 && aux
.table_len
> 0)
7106 dump_ia64_unwind (& aux
);
7109 free ((char *) aux
.table
);
7111 free ((char *) aux
.info
);
7120 free ((char *) aux
.strtab
);
7123 struct hppa_unw_table_entry
7125 struct absaddr start
;
7127 unsigned int Cannot_unwind
:1; /* 0 */
7128 unsigned int Millicode
:1; /* 1 */
7129 unsigned int Millicode_save_sr0
:1; /* 2 */
7130 unsigned int Region_description
:2; /* 3..4 */
7131 unsigned int reserved1
:1; /* 5 */
7132 unsigned int Entry_SR
:1; /* 6 */
7133 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7134 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7135 unsigned int Args_stored
:1; /* 16 */
7136 unsigned int Variable_Frame
:1; /* 17 */
7137 unsigned int Separate_Package_Body
:1; /* 18 */
7138 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7139 unsigned int Stack_Overflow_Check
:1; /* 20 */
7140 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7141 unsigned int Ada_Region
:1; /* 22 */
7142 unsigned int cxx_info
:1; /* 23 */
7143 unsigned int cxx_try_catch
:1; /* 24 */
7144 unsigned int sched_entry_seq
:1; /* 25 */
7145 unsigned int reserved2
:1; /* 26 */
7146 unsigned int Save_SP
:1; /* 27 */
7147 unsigned int Save_RP
:1; /* 28 */
7148 unsigned int Save_MRP_in_frame
:1; /* 29 */
7149 unsigned int extn_ptr_defined
:1; /* 30 */
7150 unsigned int Cleanup_defined
:1; /* 31 */
7152 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7153 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7154 unsigned int Large_frame
:1; /* 2 */
7155 unsigned int Pseudo_SP_Set
:1; /* 3 */
7156 unsigned int reserved4
:1; /* 4 */
7157 unsigned int Total_frame_size
:27; /* 5..31 */
7160 struct hppa_unw_aux_info
7162 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7163 unsigned long table_len
; /* Length of unwind table. */
7164 bfd_vma seg_base
; /* Starting address of segment. */
7165 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7166 unsigned long nsyms
; /* Number of symbols. */
7167 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7168 unsigned long nfuns
; /* Number of entries in funtab. */
7169 char * strtab
; /* The string table. */
7170 unsigned long strtab_size
; /* Size of string table. */
7174 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7176 struct hppa_unw_table_entry
* tp
;
7177 unsigned long j
, nfuns
;
7179 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7180 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7181 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7182 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7184 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7186 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7189 const char * procname
;
7191 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7192 aux
->strtab_size
, tp
->start
, &procname
,
7195 fputs ("\n<", stdout
);
7199 fputs (procname
, stdout
);
7202 printf ("+%lx", (unsigned long) offset
);
7205 fputs (">: [", stdout
);
7206 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7207 fputc ('-', stdout
);
7208 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7211 #define PF(_m) if (tp->_m) printf (#_m " ");
7212 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7215 PF(Millicode_save_sr0
);
7216 /* PV(Region_description); */
7222 PF(Separate_Package_Body
);
7223 PF(Frame_Extension_Millicode
);
7224 PF(Stack_Overflow_Check
);
7225 PF(Two_Instruction_SP_Increment
);
7229 PF(sched_entry_seq
);
7232 PF(Save_MRP_in_frame
);
7233 PF(extn_ptr_defined
);
7234 PF(Cleanup_defined
);
7235 PF(MPE_XL_interrupt_marker
);
7236 PF(HP_UX_interrupt_marker
);
7239 PV(Total_frame_size
);
7250 slurp_hppa_unwind_table (FILE * file
,
7251 struct hppa_unw_aux_info
* aux
,
7252 Elf_Internal_Shdr
* sec
)
7254 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7255 Elf_Internal_Phdr
* seg
;
7256 struct hppa_unw_table_entry
* tep
;
7257 Elf_Internal_Shdr
* relsec
;
7258 Elf_Internal_Rela
* rela
;
7259 Elf_Internal_Rela
* rp
;
7260 unsigned char * table
;
7262 Elf_Internal_Sym
* sym
;
7263 const char * relname
;
7265 /* First, find the starting address of the segment that includes
7268 if (elf_header
.e_phnum
)
7270 if (! get_program_headers (file
))
7273 for (seg
= program_headers
;
7274 seg
< program_headers
+ elf_header
.e_phnum
;
7277 if (seg
->p_type
!= PT_LOAD
)
7280 if (sec
->sh_addr
>= seg
->p_vaddr
7281 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7283 aux
->seg_base
= seg
->p_vaddr
;
7289 /* Second, build the unwind table from the contents of the unwind
7291 size
= sec
->sh_size
;
7292 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7298 nentries
= size
/ unw_ent_size
;
7299 size
= unw_ent_size
* nentries
;
7301 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7302 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7304 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7306 unsigned int tmp1
, tmp2
;
7308 tep
->start
.section
= SHN_UNDEF
;
7309 tep
->end
.section
= SHN_UNDEF
;
7311 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7312 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7313 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7314 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7316 tep
->start
.offset
+= aux
->seg_base
;
7317 tep
->end
.offset
+= aux
->seg_base
;
7319 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7320 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7321 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7322 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7323 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7324 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7325 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7326 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7327 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7328 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7329 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7330 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7331 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7332 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7333 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7334 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7335 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7336 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7337 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7338 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7339 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7340 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7341 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7342 tep
->Cleanup_defined
= tmp1
& 0x1;
7344 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7345 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7346 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7347 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7348 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7349 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7353 /* Third, apply any relocations to the unwind table. */
7354 for (relsec
= section_headers
;
7355 relsec
< section_headers
+ elf_header
.e_shnum
;
7358 if (relsec
->sh_type
!= SHT_RELA
7359 || relsec
->sh_info
>= elf_header
.e_shnum
7360 || section_headers
+ relsec
->sh_info
!= sec
)
7363 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7367 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7369 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7370 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7372 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7373 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7375 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7379 i
= rp
->r_offset
/ unw_ent_size
;
7381 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7384 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7385 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7388 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7389 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7399 aux
->table_len
= nentries
;
7405 hppa_process_unwind (FILE * file
)
7407 struct hppa_unw_aux_info aux
;
7408 Elf_Internal_Shdr
* unwsec
= NULL
;
7409 Elf_Internal_Shdr
* strsec
;
7410 Elf_Internal_Shdr
* sec
;
7413 if (string_table
== NULL
)
7416 memset (& aux
, 0, sizeof (aux
));
7418 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7420 if (sec
->sh_type
== SHT_SYMTAB
7421 && sec
->sh_link
< elf_header
.e_shnum
)
7423 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7425 strsec
= section_headers
+ sec
->sh_link
;
7426 if (aux
.strtab
!= NULL
)
7428 error (_("Multiple auxillary string tables encountered\n"));
7431 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7434 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7436 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7441 printf (_("\nThere are no unwind sections in this file.\n"));
7443 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7445 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7447 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7448 printable_section_name (sec
),
7449 (unsigned long) sec
->sh_offset
,
7450 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7452 slurp_hppa_unwind_table (file
, &aux
, sec
);
7453 if (aux
.table_len
> 0)
7454 dump_hppa_unwind (&aux
);
7457 free ((char *) aux
.table
);
7465 free ((char *) aux
.strtab
);
7470 unsigned char * data
; /* The unwind data. */
7471 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7472 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7473 unsigned long nrelas
; /* The number of relocations. */
7474 unsigned int rel_type
; /* REL or RELA ? */
7475 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7478 struct arm_unw_aux_info
7480 FILE * file
; /* The file containing the unwind sections. */
7481 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7482 unsigned long nsyms
; /* Number of symbols. */
7483 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7484 unsigned long nfuns
; /* Number of these symbols. */
7485 char * strtab
; /* The file's string table. */
7486 unsigned long strtab_size
; /* Size of string table. */
7490 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7491 bfd_vma fn
, struct absaddr addr
)
7493 const char *procname
;
7496 if (addr
.section
== SHN_UNDEF
)
7499 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7500 aux
->strtab_size
, addr
, &procname
,
7503 print_vma (fn
, PREFIX_HEX
);
7507 fputs (" <", stdout
);
7508 fputs (procname
, stdout
);
7511 printf ("+0x%lx", (unsigned long) sym_offset
);
7512 fputc ('>', stdout
);
7519 arm_free_section (struct arm_section
*arm_sec
)
7521 if (arm_sec
->data
!= NULL
)
7522 free (arm_sec
->data
);
7524 if (arm_sec
->rela
!= NULL
)
7525 free (arm_sec
->rela
);
7528 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7529 cached section and install SEC instead.
7530 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7531 and return its valued in * WORDP, relocating if necessary.
7532 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7533 relocation's offset in ADDR.
7534 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7535 into the string table of the symbol associated with the reloc. If no
7536 reloc was applied store -1 there.
7537 5) Return TRUE upon success, FALSE otherwise. */
7540 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7541 struct arm_section
* arm_sec
,
7542 Elf_Internal_Shdr
* sec
,
7543 bfd_vma word_offset
,
7544 unsigned int * wordp
,
7545 struct absaddr
* addr
,
7548 Elf_Internal_Rela
*rp
;
7549 Elf_Internal_Sym
*sym
;
7550 const char * relname
;
7552 bfd_boolean wrapped
;
7554 if (sec
== NULL
|| arm_sec
== NULL
)
7557 addr
->section
= SHN_UNDEF
;
7560 if (sym_name
!= NULL
)
7561 *sym_name
= (bfd_vma
) -1;
7563 /* If necessary, update the section cache. */
7564 if (sec
!= arm_sec
->sec
)
7566 Elf_Internal_Shdr
*relsec
;
7568 arm_free_section (arm_sec
);
7571 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7572 sec
->sh_size
, _("unwind data"));
7573 arm_sec
->rela
= NULL
;
7574 arm_sec
->nrelas
= 0;
7576 for (relsec
= section_headers
;
7577 relsec
< section_headers
+ elf_header
.e_shnum
;
7580 if (relsec
->sh_info
>= elf_header
.e_shnum
7581 || section_headers
+ relsec
->sh_info
!= sec
7582 /* PR 15745: Check the section type as well. */
7583 || (relsec
->sh_type
!= SHT_REL
7584 && relsec
->sh_type
!= SHT_RELA
))
7587 arm_sec
->rel_type
= relsec
->sh_type
;
7588 if (relsec
->sh_type
== SHT_REL
)
7590 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7592 & arm_sec
->rela
, & arm_sec
->nrelas
))
7595 else /* relsec->sh_type == SHT_RELA */
7597 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7599 & arm_sec
->rela
, & arm_sec
->nrelas
))
7605 arm_sec
->next_rela
= arm_sec
->rela
;
7608 /* If there is no unwind data we can do nothing. */
7609 if (arm_sec
->data
== NULL
)
7612 /* If the offset is invalid then fail. */
7613 if (word_offset
> (sec
->sh_size
- 4)
7615 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7616 || ((bfd_signed_vma
) word_offset
) < 0)
7619 /* Get the word at the required offset. */
7620 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7622 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7623 if (arm_sec
->rela
== NULL
)
7629 /* Look through the relocs to find the one that applies to the provided offset. */
7631 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7633 bfd_vma prelval
, offset
;
7635 if (rp
->r_offset
> word_offset
&& !wrapped
)
7640 if (rp
->r_offset
> word_offset
)
7643 if (rp
->r_offset
& 3)
7645 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7646 (unsigned long) rp
->r_offset
);
7650 if (rp
->r_offset
< word_offset
)
7653 /* PR 17531: file: 027-161405-0.004 */
7654 if (aux
->symtab
== NULL
)
7657 if (arm_sec
->rel_type
== SHT_REL
)
7659 offset
= word
& 0x7fffffff;
7660 if (offset
& 0x40000000)
7661 offset
|= ~ (bfd_vma
) 0x7fffffff;
7663 else if (arm_sec
->rel_type
== SHT_RELA
)
7664 offset
= rp
->r_addend
;
7667 error (_("Unknown section relocation type %d encountered\n"),
7672 /* PR 17531 file: 027-1241568-0.004. */
7673 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7675 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7676 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7680 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7681 offset
+= sym
->st_value
;
7682 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7684 /* Check that we are processing the expected reloc type. */
7685 if (elf_header
.e_machine
== EM_ARM
)
7687 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7688 if (relname
== NULL
)
7690 warn (_("Skipping unknown ARM relocation type: %d\n"),
7691 (int) ELF32_R_TYPE (rp
->r_info
));
7695 if (streq (relname
, "R_ARM_NONE"))
7698 if (! streq (relname
, "R_ARM_PREL31"))
7700 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7704 else if (elf_header
.e_machine
== EM_TI_C6000
)
7706 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7707 if (relname
== NULL
)
7709 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7710 (int) ELF32_R_TYPE (rp
->r_info
));
7714 if (streq (relname
, "R_C6000_NONE"))
7717 if (! streq (relname
, "R_C6000_PREL31"))
7719 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7727 /* This function currently only supports ARM and TI unwinders. */
7728 warn (_("Only TI and ARM unwinders are currently supported\n"));
7732 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7733 addr
->section
= sym
->st_shndx
;
7734 addr
->offset
= offset
;
7737 * sym_name
= sym
->st_name
;
7742 arm_sec
->next_rela
= rp
;
7747 static const char *tic6x_unwind_regnames
[16] =
7749 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7750 "A14", "A13", "A12", "A11", "A10",
7751 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7755 decode_tic6x_unwind_regmask (unsigned int mask
)
7759 for (i
= 12; mask
; mask
>>= 1, i
--)
7763 fputs (tic6x_unwind_regnames
[i
], stdout
);
7765 fputs (", ", stdout
);
7771 if (remaining == 0 && more_words) \
7774 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7775 data_offset, & word, & addr, NULL)) \
7781 #define GET_OP(OP) \
7786 (OP) = word >> 24; \
7791 printf (_("[Truncated opcode]\n")); \
7794 printf ("0x%02x ", OP)
7797 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7799 unsigned int remaining
,
7800 unsigned int more_words
,
7801 bfd_vma data_offset
,
7802 Elf_Internal_Shdr
* data_sec
,
7803 struct arm_section
* data_arm_sec
)
7805 struct absaddr addr
;
7807 /* Decode the unwinding instructions. */
7810 unsigned int op
, op2
;
7819 printf (" 0x%02x ", op
);
7821 if ((op
& 0xc0) == 0x00)
7823 int offset
= ((op
& 0x3f) << 2) + 4;
7825 printf (" vsp = vsp + %d", offset
);
7827 else if ((op
& 0xc0) == 0x40)
7829 int offset
= ((op
& 0x3f) << 2) + 4;
7831 printf (" vsp = vsp - %d", offset
);
7833 else if ((op
& 0xf0) == 0x80)
7836 if (op
== 0x80 && op2
== 0)
7837 printf (_("Refuse to unwind"));
7840 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7845 for (i
= 0; i
< 12; i
++)
7846 if (mask
& (1 << i
))
7852 printf ("r%d", 4 + i
);
7857 else if ((op
& 0xf0) == 0x90)
7859 if (op
== 0x9d || op
== 0x9f)
7860 printf (_(" [Reserved]"));
7862 printf (" vsp = r%d", op
& 0x0f);
7864 else if ((op
& 0xf0) == 0xa0)
7866 int end
= 4 + (op
& 0x07);
7871 for (i
= 4; i
<= end
; i
++)
7887 else if (op
== 0xb0)
7888 printf (_(" finish"));
7889 else if (op
== 0xb1)
7892 if (op2
== 0 || (op2
& 0xf0) != 0)
7893 printf (_("[Spare]"));
7896 unsigned int mask
= op2
& 0x0f;
7901 for (i
= 0; i
< 12; i
++)
7902 if (mask
& (1 << i
))
7913 else if (op
== 0xb2)
7915 unsigned char buf
[9];
7916 unsigned int i
, len
;
7917 unsigned long offset
;
7919 for (i
= 0; i
< sizeof (buf
); i
++)
7922 if ((buf
[i
] & 0x80) == 0)
7925 if (i
== sizeof (buf
))
7926 printf (_("corrupt change to vsp"));
7929 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7930 assert (len
== i
+ 1);
7931 offset
= offset
* 4 + 0x204;
7932 printf ("vsp = vsp + %ld", offset
);
7935 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7937 unsigned int first
, last
;
7944 printf ("pop {D%d", first
);
7946 printf ("-D%d", first
+ last
);
7949 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7951 unsigned int count
= op
& 0x07;
7955 printf ("-D%d", 8 + count
);
7958 else if (op
>= 0xc0 && op
<= 0xc5)
7960 unsigned int count
= op
& 0x07;
7962 printf (" pop {wR10");
7964 printf ("-wR%d", 10 + count
);
7967 else if (op
== 0xc6)
7969 unsigned int first
, last
;
7974 printf ("pop {wR%d", first
);
7976 printf ("-wR%d", first
+ last
);
7979 else if (op
== 0xc7)
7982 if (op2
== 0 || (op2
& 0xf0) != 0)
7983 printf (_("[Spare]"));
7986 unsigned int mask
= op2
& 0x0f;
7991 for (i
= 0; i
< 4; i
++)
7992 if (mask
& (1 << i
))
7998 printf ("wCGR%d", i
);
8004 printf (_(" [unsupported opcode]"));
8010 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8012 unsigned int remaining
,
8013 unsigned int more_words
,
8014 bfd_vma data_offset
,
8015 Elf_Internal_Shdr
* data_sec
,
8016 struct arm_section
* data_arm_sec
)
8018 struct absaddr addr
;
8020 /* Decode the unwinding instructions. */
8023 unsigned int op
, op2
;
8032 printf (" 0x%02x ", op
);
8034 if ((op
& 0xc0) == 0x00)
8036 int offset
= ((op
& 0x3f) << 3) + 8;
8037 printf (" sp = sp + %d", offset
);
8039 else if ((op
& 0xc0) == 0x80)
8042 if (op
== 0x80 && op2
== 0)
8043 printf (_("Refuse to unwind"));
8046 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8048 printf ("pop compact {");
8052 decode_tic6x_unwind_regmask (mask
);
8056 else if ((op
& 0xf0) == 0xc0)
8064 unsigned int offset
;
8068 /* Scan entire instruction first so that GET_OP output is not
8069 interleaved with disassembly. */
8071 for (i
= 0; nregs
< (op
& 0xf); i
++)
8077 regpos
[nregs
].offset
= i
* 2;
8078 regpos
[nregs
].reg
= reg
;
8085 regpos
[nregs
].offset
= i
* 2 + 1;
8086 regpos
[nregs
].reg
= reg
;
8091 printf (_("pop frame {"));
8093 for (i
= i
* 2; i
> 0; i
--)
8095 if (regpos
[reg
].offset
== i
- 1)
8097 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8104 fputs (name
, stdout
);
8111 else if (op
== 0xd0)
8112 printf (" MOV FP, SP");
8113 else if (op
== 0xd1)
8114 printf (" __c6xabi_pop_rts");
8115 else if (op
== 0xd2)
8117 unsigned char buf
[9];
8118 unsigned int i
, len
;
8119 unsigned long offset
;
8121 for (i
= 0; i
< sizeof (buf
); i
++)
8124 if ((buf
[i
] & 0x80) == 0)
8127 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8128 if (i
== sizeof (buf
))
8130 printf ("<corrupt sp adjust>\n");
8131 warn (_("Corrupt stack pointer adjustment detected\n"));
8135 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8136 assert (len
== i
+ 1);
8137 offset
= offset
* 8 + 0x408;
8138 printf (_("sp = sp + %ld"), offset
);
8140 else if ((op
& 0xf0) == 0xe0)
8142 if ((op
& 0x0f) == 7)
8145 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8149 printf (_(" [unsupported opcode]"));
8156 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8160 offset
= word
& 0x7fffffff;
8161 if (offset
& 0x40000000)
8162 offset
|= ~ (bfd_vma
) 0x7fffffff;
8164 if (elf_header
.e_machine
== EM_TI_C6000
)
8167 return offset
+ where
;
8171 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8173 unsigned int remaining
,
8174 bfd_vma data_offset
,
8175 Elf_Internal_Shdr
* data_sec
,
8176 struct arm_section
* data_arm_sec
)
8179 unsigned int more_words
= 0;
8180 struct absaddr addr
;
8181 bfd_vma sym_name
= (bfd_vma
) -1;
8185 /* Fetch the first word.
8186 Note - when decoding an object file the address extracted
8187 here will always be 0. So we also pass in the sym_name
8188 parameter so that we can find the symbol associated with
8189 the personality routine. */
8190 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8191 & word
, & addr
, & sym_name
))
8197 if ((word
& 0x80000000) == 0)
8199 /* Expand prel31 for personality routine. */
8201 const char *procname
;
8203 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8204 printf (_(" Personality routine: "));
8206 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8207 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8209 procname
= aux
->strtab
+ sym_name
;
8210 print_vma (fn
, PREFIX_HEX
);
8213 fputs (" <", stdout
);
8214 fputs (procname
, stdout
);
8215 fputc ('>', stdout
);
8219 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8220 fputc ('\n', stdout
);
8222 /* The GCC personality routines use the standard compact
8223 encoding, starting with one byte giving the number of
8225 if (procname
!= NULL
8226 && (const_strneq (procname
, "__gcc_personality_v0")
8227 || const_strneq (procname
, "__gxx_personality_v0")
8228 || const_strneq (procname
, "__gcj_personality_v0")
8229 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8236 printf (_(" [Truncated data]\n"));
8239 more_words
= word
>> 24;
8249 /* ARM EHABI Section 6.3:
8251 An exception-handling table entry for the compact model looks like:
8255 1 0 index Data for personalityRoutine[index] */
8257 if (elf_header
.e_machine
== EM_ARM
8258 && (word
& 0x70000000))
8259 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8261 per_index
= (word
>> 24) & 0x7f;
8262 printf (_(" Compact model index: %d\n"), per_index
);
8269 else if (per_index
< 3)
8271 more_words
= (word
>> 16) & 0xff;
8277 switch (elf_header
.e_machine
)
8282 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8283 data_offset
, data_sec
, data_arm_sec
);
8287 warn (_("Unknown ARM compact model index encountered\n"));
8288 printf (_(" [reserved]\n"));
8295 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8296 data_offset
, data_sec
, data_arm_sec
);
8298 else if (per_index
< 5)
8300 if (((word
>> 17) & 0x7f) == 0x7f)
8301 printf (_(" Restore stack from frame pointer\n"));
8303 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8304 printf (_(" Registers restored: "));
8306 printf (" (compact) ");
8307 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8309 printf (_(" Return register: %s\n"),
8310 tic6x_unwind_regnames
[word
& 0xf]);
8313 printf (_(" [reserved (%d)]\n"), per_index
);
8317 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8318 elf_header
.e_machine
);
8321 /* Decode the descriptors. Not implemented. */
8325 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8327 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8328 unsigned int i
, exidx_len
;
8329 unsigned long j
, nfuns
;
8331 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8332 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8333 exidx_len
= exidx_sec
->sh_size
/ 8;
8335 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8336 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8337 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8338 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8340 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8342 for (i
= 0; i
< exidx_len
; i
++)
8344 unsigned int exidx_fn
, exidx_entry
;
8345 struct absaddr fn_addr
, entry_addr
;
8348 fputc ('\n', stdout
);
8350 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8351 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8352 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8353 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8356 arm_free_section (& exidx_arm_sec
);
8357 arm_free_section (& extab_arm_sec
);
8361 /* ARM EHABI, Section 5:
8362 An index table entry consists of 2 words.
8363 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8364 if (exidx_fn
& 0x80000000)
8365 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8367 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8369 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8370 fputs (": ", stdout
);
8372 if (exidx_entry
== 1)
8374 print_vma (exidx_entry
, PREFIX_HEX
);
8375 fputs (" [cantunwind]\n", stdout
);
8377 else if (exidx_entry
& 0x80000000)
8379 print_vma (exidx_entry
, PREFIX_HEX
);
8380 fputc ('\n', stdout
);
8381 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8385 bfd_vma table
, table_offset
= 0;
8386 Elf_Internal_Shdr
*table_sec
;
8388 fputs ("@", stdout
);
8389 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8390 print_vma (table
, PREFIX_HEX
);
8393 /* Locate the matching .ARM.extab. */
8394 if (entry_addr
.section
!= SHN_UNDEF
8395 && entry_addr
.section
< elf_header
.e_shnum
)
8397 table_sec
= section_headers
+ entry_addr
.section
;
8398 table_offset
= entry_addr
.offset
;
8400 if (table_offset
> table_sec
->sh_size
8401 || ((bfd_signed_vma
) table_offset
) < 0)
8403 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8404 (unsigned long) table_offset
,
8405 printable_section_name (table_sec
));
8411 table_sec
= find_section_by_address (table
);
8412 if (table_sec
!= NULL
)
8413 table_offset
= table
- table_sec
->sh_addr
;
8415 if (table_sec
== NULL
)
8417 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8418 (unsigned long) table
);
8421 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8429 arm_free_section (&exidx_arm_sec
);
8430 arm_free_section (&extab_arm_sec
);
8433 /* Used for both ARM and C6X unwinding tables. */
8436 arm_process_unwind (FILE *file
)
8438 struct arm_unw_aux_info aux
;
8439 Elf_Internal_Shdr
*unwsec
= NULL
;
8440 Elf_Internal_Shdr
*strsec
;
8441 Elf_Internal_Shdr
*sec
;
8443 unsigned int sec_type
;
8445 switch (elf_header
.e_machine
)
8448 sec_type
= SHT_ARM_EXIDX
;
8452 sec_type
= SHT_C6000_UNWIND
;
8456 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8457 elf_header
.e_machine
);
8461 if (string_table
== NULL
)
8464 memset (& aux
, 0, sizeof (aux
));
8467 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8469 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8471 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8473 strsec
= section_headers
+ sec
->sh_link
;
8475 /* PR binutils/17531 file: 011-12666-0.004. */
8476 if (aux
.strtab
!= NULL
)
8478 error (_("Multiple string tables found in file.\n"));
8481 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8482 1, strsec
->sh_size
, _("string table"));
8483 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8485 else if (sec
->sh_type
== sec_type
)
8490 printf (_("\nThere are no unwind sections in this file.\n"));
8492 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8494 if (sec
->sh_type
== sec_type
)
8496 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8497 printable_section_name (sec
),
8498 (unsigned long) sec
->sh_offset
,
8499 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8501 dump_arm_unwind (&aux
, sec
);
8508 free ((char *) aux
.strtab
);
8512 process_unwind (FILE * file
)
8514 struct unwind_handler
8517 void (* handler
)(FILE *);
8520 { EM_ARM
, arm_process_unwind
},
8521 { EM_IA_64
, ia64_process_unwind
},
8522 { EM_PARISC
, hppa_process_unwind
},
8523 { EM_TI_C6000
, arm_process_unwind
},
8531 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8532 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8534 handlers
[i
].handler (file
);
8538 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8539 get_machine_name (elf_header
.e_machine
));
8543 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8545 switch (entry
->d_tag
)
8548 if (entry
->d_un
.d_val
== 0)
8552 static const char * opts
[] =
8554 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8555 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8556 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8557 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8563 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8564 if (entry
->d_un
.d_val
& (1 << cnt
))
8566 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8572 case DT_MIPS_IVERSION
:
8573 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8574 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8578 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8579 /* Note: coded this way so that there is a single string for translation. */
8580 printf (_("<corrupt: %s>"), buf
);
8584 case DT_MIPS_TIME_STAMP
:
8588 time_t atime
= entry
->d_un
.d_val
;
8590 tmp
= gmtime (&atime
);
8591 /* PR 17531: file: 6accc532. */
8593 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8595 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8596 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8597 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8598 printf (_("Time Stamp: %s"), timebuf
);
8602 case DT_MIPS_RLD_VERSION
:
8603 case DT_MIPS_LOCAL_GOTNO
:
8604 case DT_MIPS_CONFLICTNO
:
8605 case DT_MIPS_LIBLISTNO
:
8606 case DT_MIPS_SYMTABNO
:
8607 case DT_MIPS_UNREFEXTNO
:
8608 case DT_MIPS_HIPAGENO
:
8609 case DT_MIPS_DELTA_CLASS_NO
:
8610 case DT_MIPS_DELTA_INSTANCE_NO
:
8611 case DT_MIPS_DELTA_RELOC_NO
:
8612 case DT_MIPS_DELTA_SYM_NO
:
8613 case DT_MIPS_DELTA_CLASSSYM_NO
:
8614 case DT_MIPS_COMPACT_SIZE
:
8615 print_vma (entry
->d_un
.d_ptr
, DEC
);
8619 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8625 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8627 switch (entry
->d_tag
)
8629 case DT_HP_DLD_FLAGS
:
8638 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8639 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8640 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8641 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8642 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8643 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8644 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8645 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8646 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8647 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8648 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8649 { DT_HP_GST
, "HP_GST" },
8650 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8651 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8652 { DT_HP_NODELETE
, "HP_NODELETE" },
8653 { DT_HP_GROUP
, "HP_GROUP" },
8654 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8658 bfd_vma val
= entry
->d_un
.d_val
;
8660 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8661 if (val
& flags
[cnt
].bit
)
8665 fputs (flags
[cnt
].str
, stdout
);
8667 val
^= flags
[cnt
].bit
;
8670 if (val
!= 0 || first
)
8674 print_vma (val
, HEX
);
8680 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8688 /* VMS vs Unix time offset and factor. */
8690 #define VMS_EPOCH_OFFSET 35067168000000000LL
8691 #define VMS_GRANULARITY_FACTOR 10000000
8693 /* Display a VMS time in a human readable format. */
8696 print_vms_time (bfd_int64_t vmstime
)
8701 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8702 tm
= gmtime (&unxtime
);
8703 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8704 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8705 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8710 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8712 switch (entry
->d_tag
)
8714 case DT_IA_64_PLT_RESERVE
:
8715 /* First 3 slots reserved. */
8716 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8718 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8721 case DT_IA_64_VMS_LINKTIME
:
8723 print_vms_time (entry
->d_un
.d_val
);
8727 case DT_IA_64_VMS_LNKFLAGS
:
8728 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8729 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8730 printf (" CALL_DEBUG");
8731 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8732 printf (" NOP0BUFS");
8733 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8734 printf (" P0IMAGE");
8735 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8736 printf (" MKTHREADS");
8737 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8738 printf (" UPCALLS");
8739 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8741 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8742 printf (" INITIALIZE");
8743 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8745 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8746 printf (" EXE_INIT");
8747 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8748 printf (" TBK_IN_IMG");
8749 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8750 printf (" DBG_IN_IMG");
8751 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8752 printf (" TBK_IN_DSF");
8753 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8754 printf (" DBG_IN_DSF");
8755 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8756 printf (" SIGNATURES");
8757 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8758 printf (" REL_SEG_OFF");
8762 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8769 get_32bit_dynamic_section (FILE * file
)
8771 Elf32_External_Dyn
* edyn
;
8772 Elf32_External_Dyn
* ext
;
8773 Elf_Internal_Dyn
* entry
;
8775 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8776 dynamic_size
, _("dynamic section"));
8780 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8781 might not have the luxury of section headers. Look for the DT_NULL
8782 terminator to determine the number of entries. */
8783 for (ext
= edyn
, dynamic_nent
= 0;
8784 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8788 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8792 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8794 if (dynamic_section
== NULL
)
8796 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8797 (unsigned long) dynamic_nent
);
8802 for (ext
= edyn
, entry
= dynamic_section
;
8803 entry
< dynamic_section
+ dynamic_nent
;
8806 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8807 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8816 get_64bit_dynamic_section (FILE * file
)
8818 Elf64_External_Dyn
* edyn
;
8819 Elf64_External_Dyn
* ext
;
8820 Elf_Internal_Dyn
* entry
;
8822 /* Read in the data. */
8823 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8824 dynamic_size
, _("dynamic section"));
8828 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8829 might not have the luxury of section headers. Look for the DT_NULL
8830 terminator to determine the number of entries. */
8831 for (ext
= edyn
, dynamic_nent
= 0;
8832 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8833 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8837 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8841 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8843 if (dynamic_section
== NULL
)
8845 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8846 (unsigned long) dynamic_nent
);
8851 /* Convert from external to internal formats. */
8852 for (ext
= edyn
, entry
= dynamic_section
;
8853 entry
< dynamic_section
+ dynamic_nent
;
8856 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8857 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8866 print_dynamic_flags (bfd_vma flags
)
8874 flag
= flags
& - flags
;
8884 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8885 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8886 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8887 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8888 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8889 default: fputs (_("unknown"), stdout
); break;
8895 /* Parse and display the contents of the dynamic section. */
8898 process_dynamic_section (FILE * file
)
8900 Elf_Internal_Dyn
* entry
;
8902 if (dynamic_size
== 0)
8905 printf (_("\nThere is no dynamic section in this file.\n"));
8912 if (! get_32bit_dynamic_section (file
))
8915 else if (! get_64bit_dynamic_section (file
))
8918 /* Find the appropriate symbol table. */
8919 if (dynamic_symbols
== NULL
)
8921 for (entry
= dynamic_section
;
8922 entry
< dynamic_section
+ dynamic_nent
;
8925 Elf_Internal_Shdr section
;
8927 if (entry
->d_tag
!= DT_SYMTAB
)
8930 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8932 /* Since we do not know how big the symbol table is,
8933 we default to reading in the entire file (!) and
8934 processing that. This is overkill, I know, but it
8936 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8938 if (archive_file_offset
!= 0)
8939 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8942 if (fseek (file
, 0, SEEK_END
))
8943 error (_("Unable to seek to end of file!\n"));
8945 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8949 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8951 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8952 section
.sh_name
= string_table_length
;
8954 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8955 if (num_dynamic_syms
< 1)
8957 error (_("Unable to determine the number of symbols to load\n"));
8963 /* Similarly find a string table. */
8964 if (dynamic_strings
== NULL
)
8966 for (entry
= dynamic_section
;
8967 entry
< dynamic_section
+ dynamic_nent
;
8970 unsigned long offset
;
8973 if (entry
->d_tag
!= DT_STRTAB
)
8976 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8978 /* Since we do not know how big the string table is,
8979 we default to reading in the entire file (!) and
8980 processing that. This is overkill, I know, but it
8983 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8985 if (archive_file_offset
!= 0)
8986 str_tab_len
= archive_file_size
- offset
;
8989 if (fseek (file
, 0, SEEK_END
))
8990 error (_("Unable to seek to end of file\n"));
8991 str_tab_len
= ftell (file
) - offset
;
8994 if (str_tab_len
< 1)
8997 (_("Unable to determine the length of the dynamic string table\n"));
9001 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9003 _("dynamic string table"));
9004 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9009 /* And find the syminfo section if available. */
9010 if (dynamic_syminfo
== NULL
)
9012 unsigned long syminsz
= 0;
9014 for (entry
= dynamic_section
;
9015 entry
< dynamic_section
+ dynamic_nent
;
9018 if (entry
->d_tag
== DT_SYMINENT
)
9020 /* Note: these braces are necessary to avoid a syntax
9021 error from the SunOS4 C compiler. */
9022 /* PR binutils/17531: A corrupt file can trigger this test.
9023 So do not use an assert, instead generate an error message. */
9024 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9025 error (_("Bad value (%d) for SYMINENT entry\n"),
9026 (int) entry
->d_un
.d_val
);
9028 else if (entry
->d_tag
== DT_SYMINSZ
)
9029 syminsz
= entry
->d_un
.d_val
;
9030 else if (entry
->d_tag
== DT_SYMINFO
)
9031 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9035 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9037 Elf_External_Syminfo
* extsyminfo
;
9038 Elf_External_Syminfo
* extsym
;
9039 Elf_Internal_Syminfo
* syminfo
;
9041 /* There is a syminfo section. Read the data. */
9042 extsyminfo
= (Elf_External_Syminfo
*)
9043 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9044 _("symbol information"));
9048 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9049 if (dynamic_syminfo
== NULL
)
9051 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9052 (unsigned long) syminsz
);
9056 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9057 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9058 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9059 ++syminfo
, ++extsym
)
9061 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9062 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9069 if (do_dynamic
&& dynamic_addr
)
9070 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9071 dynamic_addr
, (unsigned long) dynamic_nent
);
9073 printf (_(" Tag Type Name/Value\n"));
9075 for (entry
= dynamic_section
;
9076 entry
< dynamic_section
+ dynamic_nent
;
9084 print_vma (entry
->d_tag
, FULL_HEX
);
9085 dtype
= get_dynamic_type (entry
->d_tag
);
9086 printf (" (%s)%*s", dtype
,
9087 ((is_32bit_elf
? 27 : 19)
9088 - (int) strlen (dtype
)),
9092 switch (entry
->d_tag
)
9096 print_dynamic_flags (entry
->d_un
.d_val
);
9106 switch (entry
->d_tag
)
9109 printf (_("Auxiliary library"));
9113 printf (_("Filter library"));
9117 printf (_("Configuration file"));
9121 printf (_("Dependency audit library"));
9125 printf (_("Audit library"));
9129 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9130 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9134 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9143 printf (_("Flags:"));
9145 if (entry
->d_un
.d_val
== 0)
9146 printf (_(" None\n"));
9149 unsigned long int val
= entry
->d_un
.d_val
;
9151 if (val
& DTF_1_PARINIT
)
9153 printf (" PARINIT");
9154 val
^= DTF_1_PARINIT
;
9156 if (val
& DTF_1_CONFEXP
)
9158 printf (" CONFEXP");
9159 val
^= DTF_1_CONFEXP
;
9162 printf (" %lx", val
);
9171 printf (_("Flags:"));
9173 if (entry
->d_un
.d_val
== 0)
9174 printf (_(" None\n"));
9177 unsigned long int val
= entry
->d_un
.d_val
;
9179 if (val
& DF_P1_LAZYLOAD
)
9181 printf (" LAZYLOAD");
9182 val
^= DF_P1_LAZYLOAD
;
9184 if (val
& DF_P1_GROUPPERM
)
9186 printf (" GROUPPERM");
9187 val
^= DF_P1_GROUPPERM
;
9190 printf (" %lx", val
);
9199 printf (_("Flags:"));
9200 if (entry
->d_un
.d_val
== 0)
9201 printf (_(" None\n"));
9204 unsigned long int val
= entry
->d_un
.d_val
;
9211 if (val
& DF_1_GLOBAL
)
9216 if (val
& DF_1_GROUP
)
9221 if (val
& DF_1_NODELETE
)
9223 printf (" NODELETE");
9224 val
^= DF_1_NODELETE
;
9226 if (val
& DF_1_LOADFLTR
)
9228 printf (" LOADFLTR");
9229 val
^= DF_1_LOADFLTR
;
9231 if (val
& DF_1_INITFIRST
)
9233 printf (" INITFIRST");
9234 val
^= DF_1_INITFIRST
;
9236 if (val
& DF_1_NOOPEN
)
9241 if (val
& DF_1_ORIGIN
)
9246 if (val
& DF_1_DIRECT
)
9251 if (val
& DF_1_TRANS
)
9256 if (val
& DF_1_INTERPOSE
)
9258 printf (" INTERPOSE");
9259 val
^= DF_1_INTERPOSE
;
9261 if (val
& DF_1_NODEFLIB
)
9263 printf (" NODEFLIB");
9264 val
^= DF_1_NODEFLIB
;
9266 if (val
& DF_1_NODUMP
)
9271 if (val
& DF_1_CONFALT
)
9273 printf (" CONFALT");
9274 val
^= DF_1_CONFALT
;
9276 if (val
& DF_1_ENDFILTEE
)
9278 printf (" ENDFILTEE");
9279 val
^= DF_1_ENDFILTEE
;
9281 if (val
& DF_1_DISPRELDNE
)
9283 printf (" DISPRELDNE");
9284 val
^= DF_1_DISPRELDNE
;
9286 if (val
& DF_1_DISPRELPND
)
9288 printf (" DISPRELPND");
9289 val
^= DF_1_DISPRELPND
;
9291 if (val
& DF_1_NODIRECT
)
9293 printf (" NODIRECT");
9294 val
^= DF_1_NODIRECT
;
9296 if (val
& DF_1_IGNMULDEF
)
9298 printf (" IGNMULDEF");
9299 val
^= DF_1_IGNMULDEF
;
9301 if (val
& DF_1_NOKSYMS
)
9303 printf (" NOKSYMS");
9304 val
^= DF_1_NOKSYMS
;
9306 if (val
& DF_1_NOHDR
)
9311 if (val
& DF_1_EDITED
)
9316 if (val
& DF_1_NORELOC
)
9318 printf (" NORELOC");
9319 val
^= DF_1_NORELOC
;
9321 if (val
& DF_1_SYMINTPOSE
)
9323 printf (" SYMINTPOSE");
9324 val
^= DF_1_SYMINTPOSE
;
9326 if (val
& DF_1_GLOBAUDIT
)
9328 printf (" GLOBAUDIT");
9329 val
^= DF_1_GLOBAUDIT
;
9331 if (val
& DF_1_SINGLETON
)
9333 printf (" SINGLETON");
9334 val
^= DF_1_SINGLETON
;
9336 if (val
& DF_1_STUB
)
9347 printf (" %lx", val
);
9354 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9356 puts (get_dynamic_type (entry
->d_un
.d_val
));
9376 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9382 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9383 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9389 switch (entry
->d_tag
)
9392 printf (_("Shared library: [%s]"), name
);
9394 if (streq (name
, program_interpreter
))
9395 printf (_(" program interpreter"));
9399 printf (_("Library soname: [%s]"), name
);
9403 printf (_("Library rpath: [%s]"), name
);
9407 printf (_("Library runpath: [%s]"), name
);
9411 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9416 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9429 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9433 case DT_INIT_ARRAYSZ
:
9434 case DT_FINI_ARRAYSZ
:
9435 case DT_GNU_CONFLICTSZ
:
9436 case DT_GNU_LIBLISTSZ
:
9439 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9440 printf (_(" (bytes)\n"));
9450 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9463 if (entry
->d_tag
== DT_USED
9464 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9466 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9470 printf (_("Not needed object: [%s]\n"), name
);
9475 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9481 /* The value of this entry is ignored. */
9486 case DT_GNU_PRELINKED
:
9490 time_t atime
= entry
->d_un
.d_val
;
9492 tmp
= gmtime (&atime
);
9493 /* PR 17533 file: 041-1244816-0.004. */
9495 printf (_("<corrupt time val: %lx"),
9496 (unsigned long) atime
);
9498 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9499 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9500 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9506 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9509 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9515 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9516 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9521 switch (elf_header
.e_machine
)
9524 case EM_MIPS_RS3_LE
:
9525 dynamic_section_mips_val (entry
);
9528 dynamic_section_parisc_val (entry
);
9531 dynamic_section_ia64_val (entry
);
9534 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9546 get_ver_flags (unsigned int flags
)
9548 static char buff
[32];
9555 if (flags
& VER_FLG_BASE
)
9556 strcat (buff
, "BASE ");
9558 if (flags
& VER_FLG_WEAK
)
9560 if (flags
& VER_FLG_BASE
)
9561 strcat (buff
, "| ");
9563 strcat (buff
, "WEAK ");
9566 if (flags
& VER_FLG_INFO
)
9568 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9569 strcat (buff
, "| ");
9571 strcat (buff
, "INFO ");
9574 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9575 strcat (buff
, _("| <unknown>"));
9580 /* Display the contents of the version sections. */
9583 process_version_sections (FILE * file
)
9585 Elf_Internal_Shdr
* section
;
9592 for (i
= 0, section
= section_headers
;
9593 i
< elf_header
.e_shnum
;
9596 switch (section
->sh_type
)
9598 case SHT_GNU_verdef
:
9600 Elf_External_Verdef
* edefs
;
9607 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9608 printable_section_name (section
),
9611 printf (_(" Addr: 0x"));
9612 printf_vma (section
->sh_addr
);
9613 printf (_(" Offset: %#08lx Link: %u (%s)"),
9614 (unsigned long) section
->sh_offset
, section
->sh_link
,
9615 printable_section_name_from_index (section
->sh_link
));
9617 edefs
= (Elf_External_Verdef
*)
9618 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9619 _("version definition section"));
9622 endbuf
= (char *) edefs
+ section
->sh_size
;
9624 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9627 Elf_External_Verdef
* edef
;
9628 Elf_Internal_Verdef ent
;
9629 Elf_External_Verdaux
* eaux
;
9630 Elf_Internal_Verdaux aux
;
9634 /* Check for very large indicies. */
9635 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9638 vstart
= ((char *) edefs
) + idx
;
9639 if (vstart
+ sizeof (*edef
) > endbuf
)
9642 edef
= (Elf_External_Verdef
*) vstart
;
9644 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9645 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9646 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9647 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9648 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9649 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9650 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9652 printf (_(" %#06x: Rev: %d Flags: %s"),
9653 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9655 printf (_(" Index: %d Cnt: %d "),
9656 ent
.vd_ndx
, ent
.vd_cnt
);
9658 /* Check for overflow. */
9659 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9662 vstart
+= ent
.vd_aux
;
9664 eaux
= (Elf_External_Verdaux
*) vstart
;
9666 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9667 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9669 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9670 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9672 printf (_("Name index: %ld\n"), aux
.vda_name
);
9674 isum
= idx
+ ent
.vd_aux
;
9676 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9678 /* Check for overflow. */
9679 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9682 isum
+= aux
.vda_next
;
9683 vstart
+= aux
.vda_next
;
9685 eaux
= (Elf_External_Verdaux
*) vstart
;
9686 if (vstart
+ sizeof (*eaux
) > endbuf
)
9689 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9690 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9692 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9693 printf (_(" %#06x: Parent %d: %s\n"),
9694 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9696 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9697 isum
, j
, aux
.vda_name
);
9701 printf (_(" Version def aux past end of section\n"));
9703 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9704 if (idx
+ ent
.vd_next
<= idx
)
9710 if (cnt
< section
->sh_info
)
9711 printf (_(" Version definition past end of section\n"));
9717 case SHT_GNU_verneed
:
9719 Elf_External_Verneed
* eneed
;
9726 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9727 printable_section_name (section
), section
->sh_info
);
9729 printf (_(" Addr: 0x"));
9730 printf_vma (section
->sh_addr
);
9731 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9732 (unsigned long) section
->sh_offset
, section
->sh_link
,
9733 printable_section_name_from_index (section
->sh_link
));
9735 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9736 section
->sh_offset
, 1,
9738 _("Version Needs section"));
9741 endbuf
= (char *) eneed
+ section
->sh_size
;
9743 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9745 Elf_External_Verneed
* entry
;
9746 Elf_Internal_Verneed ent
;
9751 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9754 vstart
= ((char *) eneed
) + idx
;
9755 if (vstart
+ sizeof (*entry
) > endbuf
)
9758 entry
= (Elf_External_Verneed
*) vstart
;
9760 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9761 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9762 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9763 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9764 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9766 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9768 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9769 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9771 printf (_(" File: %lx"), ent
.vn_file
);
9773 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9775 /* Check for overflow. */
9776 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9778 vstart
+= ent
.vn_aux
;
9780 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9782 Elf_External_Vernaux
* eaux
;
9783 Elf_Internal_Vernaux aux
;
9785 if (vstart
+ sizeof (*eaux
) > endbuf
)
9787 eaux
= (Elf_External_Vernaux
*) vstart
;
9789 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9790 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9791 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9792 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9793 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9795 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9796 printf (_(" %#06x: Name: %s"),
9797 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9799 printf (_(" %#06x: Name index: %lx"),
9800 isum
, aux
.vna_name
);
9802 printf (_(" Flags: %s Version: %d\n"),
9803 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9805 /* Check for overflow. */
9806 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9807 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9809 warn (_("Invalid vna_next field of %lx\n"),
9814 isum
+= aux
.vna_next
;
9815 vstart
+= aux
.vna_next
;
9819 warn (_("Missing Version Needs auxillary information\n"));
9821 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9823 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9824 cnt
= section
->sh_info
;
9830 if (cnt
< section
->sh_info
)
9831 warn (_("Missing Version Needs information\n"));
9837 case SHT_GNU_versym
:
9839 Elf_Internal_Shdr
* link_section
;
9842 unsigned char * edata
;
9843 unsigned short * data
;
9845 Elf_Internal_Sym
* symbols
;
9846 Elf_Internal_Shdr
* string_sec
;
9847 unsigned long num_syms
;
9850 if (section
->sh_link
>= elf_header
.e_shnum
)
9853 link_section
= section_headers
+ section
->sh_link
;
9854 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9856 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9861 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9862 if (symbols
== NULL
)
9865 string_sec
= section_headers
+ link_section
->sh_link
;
9867 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9868 string_sec
->sh_size
,
9869 _("version string table"));
9876 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9877 printable_section_name (section
), (unsigned long) total
);
9879 printf (_(" Addr: "));
9880 printf_vma (section
->sh_addr
);
9881 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9882 (unsigned long) section
->sh_offset
, section
->sh_link
,
9883 printable_section_name (link_section
));
9885 off
= offset_from_vma (file
,
9886 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9887 total
* sizeof (short));
9888 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9890 _("version symbol data"));
9898 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9900 for (cnt
= total
; cnt
--;)
9901 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9906 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9910 char *invalid
= _("*invalid*");
9912 printf (" %03x:", cnt
);
9914 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9915 switch (data
[cnt
+ j
])
9918 fputs (_(" 0 (*local*) "), stdout
);
9922 fputs (_(" 1 (*global*) "), stdout
);
9926 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9927 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9929 /* If this index value is greater than the size of the symbols
9930 array, break to avoid an out-of-bounds read. */
9931 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9933 warn (_("invalid index into symbol array\n"));
9938 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9940 Elf_Internal_Verneed ivn
;
9941 unsigned long offset
;
9943 offset
= offset_from_vma
9944 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9945 sizeof (Elf_External_Verneed
));
9949 Elf_Internal_Vernaux ivna
;
9950 Elf_External_Verneed evn
;
9951 Elf_External_Vernaux evna
;
9952 unsigned long a_off
;
9954 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9955 _("version need")) == NULL
)
9958 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9959 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9961 a_off
= offset
+ ivn
.vn_aux
;
9965 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9966 1, _("version need aux (2)")) == NULL
)
9973 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9974 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9977 a_off
+= ivna
.vna_next
;
9979 while (ivna
.vna_other
!= data
[cnt
+ j
]
9980 && ivna
.vna_next
!= 0);
9982 if (ivna
.vna_other
== data
[cnt
+ j
])
9984 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9986 if (ivna
.vna_name
>= string_sec
->sh_size
)
9989 name
= strtab
+ ivna
.vna_name
;
9993 offset
+= ivn
.vn_next
;
9995 while (ivn
.vn_next
);
9998 if (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
)
10047 else if (name
!= NULL
&& name
!= invalid
)
10048 name
= _("*both*");
10050 name
= strtab
+ ivda
.vda_name
;
10054 nn
+= printf ("(%s%-*s",
10056 12 - (int) strlen (name
),
10060 printf ("%*c", 18 - nn
, ' ');
10078 printf (_("\nNo version information found in this file.\n"));
10083 static const char *
10084 get_symbol_binding (unsigned int binding
)
10086 static char buff
[32];
10090 case STB_LOCAL
: return "LOCAL";
10091 case STB_GLOBAL
: return "GLOBAL";
10092 case STB_WEAK
: return "WEAK";
10094 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10095 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10097 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10099 if (binding
== STB_GNU_UNIQUE
10100 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10101 /* GNU is still using the default value 0. */
10102 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10104 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10107 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10112 static const char *
10113 get_symbol_type (unsigned int type
)
10115 static char buff
[32];
10119 case STT_NOTYPE
: return "NOTYPE";
10120 case STT_OBJECT
: return "OBJECT";
10121 case STT_FUNC
: return "FUNC";
10122 case STT_SECTION
: return "SECTION";
10123 case STT_FILE
: return "FILE";
10124 case STT_COMMON
: return "COMMON";
10125 case STT_TLS
: return "TLS";
10126 case STT_RELC
: return "RELC";
10127 case STT_SRELC
: return "SRELC";
10129 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10131 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10132 return "THUMB_FUNC";
10134 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10137 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10138 return "PARISC_MILLI";
10140 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10142 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10144 if (elf_header
.e_machine
== EM_PARISC
)
10146 if (type
== STT_HP_OPAQUE
)
10147 return "HP_OPAQUE";
10148 if (type
== STT_HP_STUB
)
10152 if (type
== STT_GNU_IFUNC
10153 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10154 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10155 /* GNU is still using the default value 0. */
10156 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10159 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10162 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10167 static const char *
10168 get_symbol_visibility (unsigned int visibility
)
10170 switch (visibility
)
10172 case STV_DEFAULT
: return "DEFAULT";
10173 case STV_INTERNAL
: return "INTERNAL";
10174 case STV_HIDDEN
: return "HIDDEN";
10175 case STV_PROTECTED
: return "PROTECTED";
10177 error (_("Unrecognized visibility value: %u"), visibility
);
10178 return _("<unknown>");
10182 static const char *
10183 get_mips_symbol_other (unsigned int other
)
10193 case STO_MICROMIPS
:
10194 return "MICROMIPS";
10195 case STO_MICROMIPS
| STO_MIPS_PIC
:
10196 return "MICROMIPS, MIPS PIC";
10204 static const char *
10205 get_ia64_symbol_other (unsigned int other
)
10207 if (is_ia64_vms ())
10209 static char res
[32];
10213 /* Function types is for images and .STB files only. */
10214 switch (elf_header
.e_type
)
10218 switch (VMS_ST_FUNC_TYPE (other
))
10220 case VMS_SFT_CODE_ADDR
:
10221 strcat (res
, " CA");
10223 case VMS_SFT_SYMV_IDX
:
10224 strcat (res
, " VEC");
10227 strcat (res
, " FD");
10229 case VMS_SFT_RESERVE
:
10230 strcat (res
, " RSV");
10233 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10234 VMS_ST_FUNC_TYPE (other
));
10235 strcat (res
, " <unknown>");
10242 switch (VMS_ST_LINKAGE (other
))
10244 case VMS_STL_IGNORE
:
10245 strcat (res
, " IGN");
10247 case VMS_STL_RESERVE
:
10248 strcat (res
, " RSV");
10251 strcat (res
, " STD");
10254 strcat (res
, " LNK");
10257 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10258 VMS_ST_LINKAGE (other
));
10259 strcat (res
, " <unknown>");
10271 static const char *
10272 get_ppc64_symbol_other (unsigned int other
)
10274 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10276 static char buf
[32];
10277 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10278 PPC64_LOCAL_ENTRY_OFFSET (other
));
10284 static const char *
10285 get_symbol_other (unsigned int other
)
10287 const char * result
= NULL
;
10288 static char buff
[32];
10293 switch (elf_header
.e_machine
)
10296 result
= get_mips_symbol_other (other
);
10299 result
= get_ia64_symbol_other (other
);
10302 result
= get_ppc64_symbol_other (other
);
10311 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10315 static const char *
10316 get_symbol_index_type (unsigned int type
)
10318 static char buff
[32];
10322 case SHN_UNDEF
: return "UND";
10323 case SHN_ABS
: return "ABS";
10324 case SHN_COMMON
: return "COM";
10326 if (type
== SHN_IA_64_ANSI_COMMON
10327 && elf_header
.e_machine
== EM_IA_64
10328 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10330 else if ((elf_header
.e_machine
== EM_X86_64
10331 || elf_header
.e_machine
== EM_L1OM
10332 || elf_header
.e_machine
== EM_K1OM
)
10333 && type
== SHN_X86_64_LCOMMON
)
10334 return "LARGE_COM";
10335 else if ((type
== SHN_MIPS_SCOMMON
10336 && elf_header
.e_machine
== EM_MIPS
)
10337 || (type
== SHN_TIC6X_SCOMMON
10338 && elf_header
.e_machine
== EM_TI_C6000
))
10340 else if (type
== SHN_MIPS_SUNDEFINED
10341 && elf_header
.e_machine
== EM_MIPS
)
10343 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10344 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10345 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10346 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10347 else if (type
>= SHN_LORESERVE
)
10348 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10349 else if (type
>= elf_header
.e_shnum
)
10350 sprintf (buff
, _("bad section index[%3d]"), type
);
10352 sprintf (buff
, "%3d", type
);
10360 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10362 unsigned char * e_data
;
10365 /* If the size_t type is smaller than the bfd_size_type, eg because
10366 you are building a 32-bit tool on a 64-bit host, then make sure
10367 that when (number) is cast to (size_t) no information is lost. */
10368 if (sizeof (size_t) < sizeof (bfd_size_type
)
10369 && (bfd_size_type
) ((size_t) number
) != number
)
10371 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10372 (unsigned long long) number
, ent_size
);
10376 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10377 attempting to allocate memory when the read is bound to fail. */
10378 if (ent_size
* number
> current_file_size
)
10380 error (_("Invalid number of dynamic entries: %llu\n"),
10381 (unsigned long long) number
);
10385 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10386 if (e_data
== NULL
)
10388 error (_("Out of memory reading %llu dynamic entries\n"),
10389 (unsigned long long) number
);
10393 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10395 error (_("Unable to read in %llu bytes of dynamic data\n"),
10396 (unsigned long long) (number
* ent_size
));
10401 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10402 if (i_data
== NULL
)
10404 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10405 (unsigned long long) number
);
10411 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10419 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10421 Elf_Internal_Sym
* psym
;
10424 n
= print_vma (si
, DEC_5
);
10426 fputs (&" "[n
], stdout
);
10427 printf (" %3lu: ", hn
);
10429 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10431 printf (_("<No info available for dynamic symbol number %lu>\n"),
10432 (unsigned long) si
);
10436 psym
= dynamic_symbols
+ si
;
10437 print_vma (psym
->st_value
, LONG_HEX
);
10439 print_vma (psym
->st_size
, DEC_5
);
10441 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10442 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10443 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10444 /* Check to see if any other bits in the st_other field are set.
10445 Note - displaying this information disrupts the layout of the
10446 table being generated, but for the moment this case is very
10448 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10449 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10450 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10451 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10452 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10454 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10458 static const char *
10459 get_symbol_version_string (FILE *file
, int is_dynsym
,
10460 const char *strtab
,
10461 unsigned long int strtab_size
,
10462 unsigned int si
, Elf_Internal_Sym
*psym
,
10463 enum versioned_symbol_info
*sym_info
,
10464 unsigned short *vna_other
)
10466 unsigned char data
[2];
10467 unsigned short vers_data
;
10468 unsigned long offset
;
10471 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10474 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10475 sizeof data
+ si
* sizeof (vers_data
));
10477 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10478 sizeof (data
), 1, _("version data")) == NULL
)
10481 vers_data
= byte_get (data
, 2);
10483 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10486 /* Usually we'd only see verdef for defined symbols, and verneed for
10487 undefined symbols. However, symbols defined by the linker in
10488 .dynbss for variables copied from a shared library in order to
10489 avoid text relocations are defined yet have verneed. We could
10490 use a heuristic to detect the special case, for example, check
10491 for verneed first on symbols defined in SHT_NOBITS sections, but
10492 it is simpler and more reliable to just look for both verdef and
10493 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10495 if (psym
->st_shndx
!= SHN_UNDEF
10496 && vers_data
!= 0x8001
10497 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10499 Elf_Internal_Verdef ivd
;
10500 Elf_Internal_Verdaux ivda
;
10501 Elf_External_Verdaux evda
;
10504 off
= offset_from_vma (file
,
10505 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10506 sizeof (Elf_External_Verdef
));
10510 Elf_External_Verdef evd
;
10512 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10513 _("version def")) == NULL
)
10521 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10522 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10523 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10526 off
+= ivd
.vd_next
;
10528 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10530 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10532 off
-= ivd
.vd_next
;
10535 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10536 _("version def aux")) != NULL
)
10538 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10540 if (psym
->st_name
!= ivda
.vda_name
)
10542 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10543 ? symbol_hidden
: symbol_public
);
10544 return (ivda
.vda_name
< strtab_size
10545 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10551 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10553 Elf_External_Verneed evn
;
10554 Elf_Internal_Verneed ivn
;
10555 Elf_Internal_Vernaux ivna
;
10557 offset
= offset_from_vma (file
,
10558 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10562 unsigned long vna_off
;
10564 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10565 _("version need")) == NULL
)
10568 ivna
.vna_other
= 0;
10573 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10574 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10576 vna_off
= offset
+ ivn
.vn_aux
;
10580 Elf_External_Vernaux evna
;
10582 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10583 _("version need aux (3)")) == NULL
)
10586 ivna
.vna_other
= 0;
10591 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10592 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10593 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10596 vna_off
+= ivna
.vna_next
;
10598 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10600 if (ivna
.vna_other
== vers_data
)
10603 offset
+= ivn
.vn_next
;
10605 while (ivn
.vn_next
!= 0);
10607 if (ivna
.vna_other
== vers_data
)
10609 *sym_info
= symbol_undefined
;
10610 *vna_other
= ivna
.vna_other
;
10611 return (ivna
.vna_name
< strtab_size
10612 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10618 /* Dump the symbol table. */
10620 process_symbol_table (FILE * file
)
10622 Elf_Internal_Shdr
* section
;
10623 bfd_size_type nbuckets
= 0;
10624 bfd_size_type nchains
= 0;
10625 bfd_vma
* buckets
= NULL
;
10626 bfd_vma
* chains
= NULL
;
10627 bfd_vma ngnubuckets
= 0;
10628 bfd_vma
* gnubuckets
= NULL
;
10629 bfd_vma
* gnuchains
= NULL
;
10630 bfd_vma gnusymidx
= 0;
10631 bfd_size_type ngnuchains
= 0;
10633 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10636 if (dynamic_info
[DT_HASH
]
10638 || (do_using_dynamic
10640 && dynamic_strings
!= NULL
)))
10642 unsigned char nb
[8];
10643 unsigned char nc
[8];
10644 unsigned int hash_ent_size
= 4;
10646 if ((elf_header
.e_machine
== EM_ALPHA
10647 || elf_header
.e_machine
== EM_S390
10648 || elf_header
.e_machine
== EM_S390_OLD
)
10649 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10653 (archive_file_offset
10654 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10655 sizeof nb
+ sizeof nc
)),
10658 error (_("Unable to seek to start of dynamic information\n"));
10662 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10664 error (_("Failed to read in number of buckets\n"));
10668 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10670 error (_("Failed to read in number of chains\n"));
10674 nbuckets
= byte_get (nb
, hash_ent_size
);
10675 nchains
= byte_get (nc
, hash_ent_size
);
10677 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10678 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10681 if (buckets
== NULL
|| chains
== NULL
)
10683 if (do_using_dynamic
)
10694 if (dynamic_info_DT_GNU_HASH
10696 || (do_using_dynamic
10698 && dynamic_strings
!= NULL
)))
10700 unsigned char nb
[16];
10701 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10702 bfd_vma buckets_vma
;
10705 (archive_file_offset
10706 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10710 error (_("Unable to seek to start of dynamic information\n"));
10714 if (fread (nb
, 16, 1, file
) != 1)
10716 error (_("Failed to read in number of buckets\n"));
10720 ngnubuckets
= byte_get (nb
, 4);
10721 gnusymidx
= byte_get (nb
+ 4, 4);
10722 bitmaskwords
= byte_get (nb
+ 8, 4);
10723 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10725 buckets_vma
+= bitmaskwords
* 4;
10727 buckets_vma
+= bitmaskwords
* 8;
10730 (archive_file_offset
10731 + offset_from_vma (file
, buckets_vma
, 4)),
10734 error (_("Unable to seek to start of dynamic information\n"));
10738 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10740 if (gnubuckets
== NULL
)
10743 for (i
= 0; i
< ngnubuckets
; i
++)
10744 if (gnubuckets
[i
] != 0)
10746 if (gnubuckets
[i
] < gnusymidx
)
10749 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10750 maxchain
= gnubuckets
[i
];
10753 if (maxchain
== 0xffffffff)
10756 maxchain
-= gnusymidx
;
10759 (archive_file_offset
10760 + offset_from_vma (file
, buckets_vma
10761 + 4 * (ngnubuckets
+ maxchain
), 4)),
10764 error (_("Unable to seek to start of dynamic information\n"));
10770 if (fread (nb
, 4, 1, file
) != 1)
10772 error (_("Failed to determine last chain length\n"));
10776 if (maxchain
+ 1 == 0)
10781 while ((byte_get (nb
, 4) & 1) == 0);
10784 (archive_file_offset
10785 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10788 error (_("Unable to seek to start of dynamic information\n"));
10792 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10793 ngnuchains
= maxchain
;
10796 if (gnuchains
== NULL
)
10801 if (do_using_dynamic
)
10806 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10808 && do_using_dynamic
10809 && dynamic_strings
!= NULL
10810 && dynamic_symbols
!= NULL
)
10814 if (dynamic_info
[DT_HASH
])
10818 printf (_("\nSymbol table for image:\n"));
10820 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10822 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10824 for (hn
= 0; hn
< nbuckets
; hn
++)
10829 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10830 print_dynamic_symbol (si
, hn
);
10834 if (dynamic_info_DT_GNU_HASH
)
10836 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10838 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10840 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10842 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10843 if (gnubuckets
[hn
] != 0)
10845 bfd_vma si
= gnubuckets
[hn
];
10846 bfd_vma off
= si
- gnusymidx
;
10850 print_dynamic_symbol (si
, hn
);
10853 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10857 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10858 && section_headers
!= NULL
)
10862 for (i
= 0, section
= section_headers
;
10863 i
< elf_header
.e_shnum
;
10867 char * strtab
= NULL
;
10868 unsigned long int strtab_size
= 0;
10869 Elf_Internal_Sym
* symtab
;
10870 Elf_Internal_Sym
* psym
;
10871 unsigned long num_syms
;
10873 if ((section
->sh_type
!= SHT_SYMTAB
10874 && section
->sh_type
!= SHT_DYNSYM
)
10876 && section
->sh_type
== SHT_SYMTAB
))
10879 if (section
->sh_entsize
== 0)
10881 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10882 printable_section_name (section
));
10886 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10887 printable_section_name (section
),
10888 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10891 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10893 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10895 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10896 if (symtab
== NULL
)
10899 if (section
->sh_link
== elf_header
.e_shstrndx
)
10901 strtab
= string_table
;
10902 strtab_size
= string_table_length
;
10904 else if (section
->sh_link
< elf_header
.e_shnum
)
10906 Elf_Internal_Shdr
* string_sec
;
10908 string_sec
= section_headers
+ section
->sh_link
;
10910 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10911 1, string_sec
->sh_size
,
10912 _("string table"));
10913 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10916 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10918 const char *version_string
;
10919 enum versioned_symbol_info sym_info
;
10920 unsigned short vna_other
;
10922 printf ("%6d: ", si
);
10923 print_vma (psym
->st_value
, LONG_HEX
);
10925 print_vma (psym
->st_size
, DEC_5
);
10926 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10927 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10928 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10929 /* Check to see if any other bits in the st_other field are set.
10930 Note - displaying this information disrupts the layout of the
10931 table being generated, but for the moment this case is very rare. */
10932 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10933 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10934 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10935 print_symbol (25, psym
->st_name
< strtab_size
10936 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10939 = get_symbol_version_string (file
,
10940 section
->sh_type
== SHT_DYNSYM
,
10941 strtab
, strtab_size
, si
,
10942 psym
, &sym_info
, &vna_other
);
10943 if (version_string
)
10945 if (sym_info
== symbol_undefined
)
10946 printf ("@%s (%d)", version_string
, vna_other
);
10948 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10956 if (strtab
!= string_table
)
10962 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10964 if (do_histogram
&& buckets
!= NULL
)
10966 unsigned long * lengths
;
10967 unsigned long * counts
;
10970 unsigned long maxlength
= 0;
10971 unsigned long nzero_counts
= 0;
10972 unsigned long nsyms
= 0;
10973 unsigned long chained
;
10975 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10976 (unsigned long) nbuckets
);
10978 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10979 if (lengths
== NULL
)
10981 error (_("Out of memory allocating space for histogram buckets\n"));
10985 printf (_(" Length Number %% of total Coverage\n"));
10986 for (hn
= 0; hn
< nbuckets
; ++hn
)
10988 for (si
= buckets
[hn
], chained
= 0;
10989 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10990 si
= chains
[si
], ++chained
)
10993 if (maxlength
< ++lengths
[hn
])
10997 /* PR binutils/17531: A corrupt binary could contain broken
10998 histogram data. Do not go into an infinite loop trying
11000 if (chained
> nchains
)
11002 error (_("histogram chain is corrupt\n"));
11007 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11008 if (counts
== NULL
)
11011 error (_("Out of memory allocating space for histogram counts\n"));
11015 for (hn
= 0; hn
< nbuckets
; ++hn
)
11016 ++counts
[lengths
[hn
]];
11021 printf (" 0 %-10lu (%5.1f%%)\n",
11022 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11023 for (i
= 1; i
<= maxlength
; ++i
)
11025 nzero_counts
+= counts
[i
] * i
;
11026 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11027 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11028 (nzero_counts
* 100.0) / nsyms
);
11036 if (buckets
!= NULL
)
11042 if (do_histogram
&& gnubuckets
!= NULL
)
11044 unsigned long * lengths
;
11045 unsigned long * counts
;
11047 unsigned long maxlength
= 0;
11048 unsigned long nzero_counts
= 0;
11049 unsigned long nsyms
= 0;
11051 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11052 (unsigned long) ngnubuckets
);
11054 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11055 if (lengths
== NULL
)
11057 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11061 printf (_(" Length Number %% of total Coverage\n"));
11063 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11064 if (gnubuckets
[hn
] != 0)
11066 bfd_vma off
, length
= 1;
11068 for (off
= gnubuckets
[hn
] - gnusymidx
;
11069 /* PR 17531 file: 010-77222-0.004. */
11070 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11073 lengths
[hn
] = length
;
11074 if (length
> maxlength
)
11075 maxlength
= length
;
11079 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11080 if (counts
== NULL
)
11083 error (_("Out of memory allocating space for gnu histogram counts\n"));
11087 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11088 ++counts
[lengths
[hn
]];
11090 if (ngnubuckets
> 0)
11093 printf (" 0 %-10lu (%5.1f%%)\n",
11094 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11095 for (j
= 1; j
<= maxlength
; ++j
)
11097 nzero_counts
+= counts
[j
] * j
;
11098 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11099 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11100 (nzero_counts
* 100.0) / nsyms
);
11114 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11118 if (dynamic_syminfo
== NULL
11120 /* No syminfo, this is ok. */
11123 /* There better should be a dynamic symbol section. */
11124 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11128 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11129 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11131 printf (_(" Num: Name BoundTo Flags\n"));
11132 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11134 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11136 printf ("%4d: ", i
);
11137 if (i
>= num_dynamic_syms
)
11138 printf (_("<corrupt index>"));
11139 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11140 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11142 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11145 switch (dynamic_syminfo
[i
].si_boundto
)
11147 case SYMINFO_BT_SELF
:
11148 fputs ("SELF ", stdout
);
11150 case SYMINFO_BT_PARENT
:
11151 fputs ("PARENT ", stdout
);
11154 if (dynamic_syminfo
[i
].si_boundto
> 0
11155 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11156 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11158 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11162 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11166 if (flags
& SYMINFO_FLG_DIRECT
)
11167 printf (" DIRECT");
11168 if (flags
& SYMINFO_FLG_PASSTHRU
)
11169 printf (" PASSTHRU");
11170 if (flags
& SYMINFO_FLG_COPY
)
11172 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11173 printf (" LAZYLOAD");
11181 /* Check to see if the given reloc needs to be handled in a target specific
11182 manner. If so then process the reloc and return TRUE otherwise return
11186 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11187 unsigned char * start
,
11188 Elf_Internal_Sym
* symtab
)
11190 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11192 switch (elf_header
.e_machine
)
11195 case EM_MSP430_OLD
:
11197 static Elf_Internal_Sym
* saved_sym
= NULL
;
11199 switch (reloc_type
)
11201 case 10: /* R_MSP430_SYM_DIFF */
11202 if (uses_msp430x_relocs ())
11204 case 21: /* R_MSP430X_SYM_DIFF */
11205 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11208 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11209 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11210 goto handle_sym_diff
;
11212 case 5: /* R_MSP430_16_BYTE */
11213 case 9: /* R_MSP430_8 */
11214 if (uses_msp430x_relocs ())
11216 goto handle_sym_diff
;
11218 case 2: /* R_MSP430_ABS16 */
11219 case 15: /* R_MSP430X_ABS16 */
11220 if (! uses_msp430x_relocs ())
11222 goto handle_sym_diff
;
11225 if (saved_sym
!= NULL
)
11229 value
= reloc
->r_addend
11230 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11231 - saved_sym
->st_value
);
11233 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11241 if (saved_sym
!= NULL
)
11242 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11249 case EM_CYGNUS_MN10300
:
11251 static Elf_Internal_Sym
* saved_sym
= NULL
;
11253 switch (reloc_type
)
11255 case 34: /* R_MN10300_ALIGN */
11257 case 33: /* R_MN10300_SYM_DIFF */
11258 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11260 case 1: /* R_MN10300_32 */
11261 case 2: /* R_MN10300_16 */
11262 if (saved_sym
!= NULL
)
11266 value
= reloc
->r_addend
11267 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11268 - saved_sym
->st_value
);
11270 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11277 if (saved_sym
!= NULL
)
11278 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11286 static bfd_vma saved_sym1
= 0;
11287 static bfd_vma saved_sym2
= 0;
11288 static bfd_vma value
;
11290 switch (reloc_type
)
11292 case 0x80: /* R_RL78_SYM. */
11293 saved_sym1
= saved_sym2
;
11294 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11295 saved_sym2
+= reloc
->r_addend
;
11298 case 0x83: /* R_RL78_OPsub. */
11299 value
= saved_sym1
- saved_sym2
;
11300 saved_sym2
= saved_sym1
= 0;
11304 case 0x41: /* R_RL78_ABS32. */
11305 byte_put (start
+ reloc
->r_offset
, value
, 4);
11309 case 0x43: /* R_RL78_ABS16. */
11310 byte_put (start
+ reloc
->r_offset
, value
, 2);
11324 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11325 DWARF debug sections. This is a target specific test. Note - we do not
11326 go through the whole including-target-headers-multiple-times route, (as
11327 we have already done with <elf/h8.h>) because this would become very
11328 messy and even then this function would have to contain target specific
11329 information (the names of the relocs instead of their numeric values).
11330 FIXME: This is not the correct way to solve this problem. The proper way
11331 is to have target specific reloc sizing and typing functions created by
11332 the reloc-macros.h header, in the same way that it already creates the
11333 reloc naming functions. */
11336 is_32bit_abs_reloc (unsigned int reloc_type
)
11338 switch (elf_header
.e_machine
)
11342 return reloc_type
== 1; /* R_386_32. */
11344 return reloc_type
== 1; /* R_68K_32. */
11346 return reloc_type
== 1; /* R_860_32. */
11348 return reloc_type
== 2; /* R_960_32. */
11350 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11352 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11354 return reloc_type
== 1; /* R_ARC_32. */
11355 case EM_ARC_COMPACT
:
11356 case EM_ARC_COMPACT2
:
11357 return reloc_type
== 4; /* R_ARC_32. */
11359 return reloc_type
== 2; /* R_ARM_ABS32 */
11362 return reloc_type
== 1;
11363 case EM_ADAPTEVA_EPIPHANY
:
11364 return reloc_type
== 3;
11366 return reloc_type
== 0x12; /* R_byte4_data. */
11368 return reloc_type
== 3; /* R_CRIS_32. */
11370 return reloc_type
== 3; /* R_CR16_NUM32. */
11372 return reloc_type
== 15; /* R_CRX_NUM32. */
11373 case EM_CYGNUS_FRV
:
11374 return reloc_type
== 1;
11375 case EM_CYGNUS_D10V
:
11377 return reloc_type
== 6; /* R_D10V_32. */
11378 case EM_CYGNUS_D30V
:
11380 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11382 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11383 case EM_CYGNUS_FR30
:
11385 return reloc_type
== 3; /* R_FR30_32. */
11387 return reloc_type
== 1; /* R_FT32_32. */
11391 return reloc_type
== 1; /* R_H8_DIR32. */
11393 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11394 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11397 return reloc_type
== 2; /* R_IP2K_32. */
11399 return reloc_type
== 2; /* R_IQ2000_32. */
11400 case EM_LATTICEMICO32
:
11401 return reloc_type
== 3; /* R_LM32_32. */
11404 return reloc_type
== 3; /* R_M32C_32. */
11406 return reloc_type
== 34; /* R_M32R_32_RELA. */
11408 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11409 case EM_CYGNUS_MEP
:
11410 return reloc_type
== 4; /* R_MEP_32. */
11412 return reloc_type
== 2; /* R_METAG_ADDR32. */
11413 case EM_MICROBLAZE
:
11414 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11416 return reloc_type
== 2; /* R_MIPS_32. */
11418 return reloc_type
== 4; /* R_MMIX_32. */
11419 case EM_CYGNUS_MN10200
:
11421 return reloc_type
== 1; /* R_MN10200_32. */
11422 case EM_CYGNUS_MN10300
:
11424 return reloc_type
== 1; /* R_MN10300_32. */
11426 return reloc_type
== 1; /* R_MOXIE_32. */
11427 case EM_MSP430_OLD
:
11429 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11431 return reloc_type
== 2; /* R_MT_32. */
11433 return reloc_type
== 20; /* R_NDS32_RELA. */
11434 case EM_ALTERA_NIOS2
:
11435 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11437 return reloc_type
== 1; /* R_NIOS_32. */
11439 return reloc_type
== 1; /* R_OR1K_32. */
11441 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11442 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11445 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11447 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11449 return reloc_type
== 1; /* R_PPC_ADDR32. */
11451 return reloc_type
== 1; /* R_RL78_DIR32. */
11453 return reloc_type
== 1; /* R_RX_DIR32. */
11455 return reloc_type
== 1; /* R_I370_ADDR31. */
11458 return reloc_type
== 4; /* R_S390_32. */
11460 return reloc_type
== 8; /* R_SCORE_ABS32. */
11462 return reloc_type
== 1; /* R_SH_DIR32. */
11463 case EM_SPARC32PLUS
:
11466 return reloc_type
== 3 /* R_SPARC_32. */
11467 || reloc_type
== 23; /* R_SPARC_UA32. */
11469 return reloc_type
== 6; /* R_SPU_ADDR32 */
11471 return reloc_type
== 1; /* R_C6000_ABS32. */
11473 return reloc_type
== 2; /* R_TILEGX_32. */
11475 return reloc_type
== 1; /* R_TILEPRO_32. */
11476 case EM_CYGNUS_V850
:
11478 return reloc_type
== 6; /* R_V850_ABS32. */
11480 return reloc_type
== 0x33; /* R_V810_WORD. */
11482 return reloc_type
== 1; /* R_VAX_32. */
11484 return reloc_type
== 3; /* R_VISIUM_32. */
11488 return reloc_type
== 10; /* R_X86_64_32. */
11491 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11493 return reloc_type
== 4; /* R_XGATE_32. */
11495 return reloc_type
== 1; /* R_XSTROMY16_32. */
11496 case EM_XTENSA_OLD
:
11498 return reloc_type
== 1; /* R_XTENSA_32. */
11501 static unsigned int prev_warn
= 0;
11503 /* Avoid repeating the same warning multiple times. */
11504 if (prev_warn
!= elf_header
.e_machine
)
11505 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11506 elf_header
.e_machine
);
11507 prev_warn
= elf_header
.e_machine
;
11513 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11514 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11517 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11519 switch (elf_header
.e_machine
)
11523 return reloc_type
== 2; /* R_386_PC32. */
11525 return reloc_type
== 4; /* R_68K_PC32. */
11527 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11528 case EM_ADAPTEVA_EPIPHANY
:
11529 return reloc_type
== 6;
11531 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11533 return reloc_type
== 3; /* R_ARM_REL32 */
11534 case EM_MICROBLAZE
:
11535 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11537 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11539 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11541 return reloc_type
== 26; /* R_PPC_REL32. */
11543 return reloc_type
== 26; /* R_PPC64_REL32. */
11546 return reloc_type
== 5; /* R_390_PC32. */
11548 return reloc_type
== 2; /* R_SH_REL32. */
11549 case EM_SPARC32PLUS
:
11552 return reloc_type
== 6; /* R_SPARC_DISP32. */
11554 return reloc_type
== 13; /* R_SPU_REL32. */
11556 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11558 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11560 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11564 return reloc_type
== 2; /* R_X86_64_PC32. */
11565 case EM_XTENSA_OLD
:
11567 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11569 /* Do not abort or issue an error message here. Not all targets use
11570 pc-relative 32-bit relocs in their DWARF debug information and we
11571 have already tested for target coverage in is_32bit_abs_reloc. A
11572 more helpful warning message will be generated by apply_relocations
11573 anyway, so just return. */
11578 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11579 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11582 is_64bit_abs_reloc (unsigned int reloc_type
)
11584 switch (elf_header
.e_machine
)
11587 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11589 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11591 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11593 return reloc_type
== 80; /* R_PARISC_DIR64. */
11595 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11596 case EM_SPARC32PLUS
:
11599 return reloc_type
== 54; /* R_SPARC_UA64. */
11603 return reloc_type
== 1; /* R_X86_64_64. */
11606 return reloc_type
== 22; /* R_S390_64. */
11608 return reloc_type
== 1; /* R_TILEGX_64. */
11610 return reloc_type
== 18; /* R_MIPS_64. */
11616 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11617 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11620 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11622 switch (elf_header
.e_machine
)
11625 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11627 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11629 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11631 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11633 return reloc_type
== 44; /* R_PPC64_REL64. */
11634 case EM_SPARC32PLUS
:
11637 return reloc_type
== 46; /* R_SPARC_DISP64. */
11641 return reloc_type
== 24; /* R_X86_64_PC64. */
11644 return reloc_type
== 23; /* R_S390_PC64. */
11646 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11652 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11653 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11656 is_24bit_abs_reloc (unsigned int reloc_type
)
11658 switch (elf_header
.e_machine
)
11660 case EM_CYGNUS_MN10200
:
11662 return reloc_type
== 4; /* R_MN10200_24. */
11668 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11669 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11672 is_16bit_abs_reloc (unsigned int reloc_type
)
11674 switch (elf_header
.e_machine
)
11677 case EM_ARC_COMPACT
:
11678 case EM_ARC_COMPACT2
:
11679 return reloc_type
== 2; /* R_ARC_16. */
11682 return reloc_type
== 4; /* R_AVR_16. */
11683 case EM_ADAPTEVA_EPIPHANY
:
11684 return reloc_type
== 5;
11685 case EM_CYGNUS_D10V
:
11687 return reloc_type
== 3; /* R_D10V_16. */
11691 return reloc_type
== R_H8_DIR16
;
11694 return reloc_type
== 1; /* R_IP2K_16. */
11697 return reloc_type
== 1; /* R_M32C_16 */
11699 if (uses_msp430x_relocs ())
11700 return reloc_type
== 2; /* R_MSP430_ABS16. */
11701 case EM_MSP430_OLD
:
11702 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11704 return reloc_type
== 19; /* R_NDS32_RELA. */
11705 case EM_ALTERA_NIOS2
:
11706 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11708 return reloc_type
== 9; /* R_NIOS_16. */
11710 return reloc_type
== 2; /* R_OR1K_16. */
11712 return reloc_type
== 2; /* R_C6000_ABS16. */
11715 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11716 case EM_CYGNUS_MN10200
:
11718 return reloc_type
== 2; /* R_MN10200_16. */
11719 case EM_CYGNUS_MN10300
:
11721 return reloc_type
== 2; /* R_MN10300_16. */
11723 return reloc_type
== 2; /* R_VISIUM_16. */
11725 return reloc_type
== 3; /* R_XGATE_16. */
11731 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11732 relocation entries (possibly formerly used for SHT_GROUP sections). */
11735 is_none_reloc (unsigned int reloc_type
)
11737 switch (elf_header
.e_machine
)
11739 case EM_68K
: /* R_68K_NONE. */
11740 case EM_386
: /* R_386_NONE. */
11741 case EM_SPARC32PLUS
:
11743 case EM_SPARC
: /* R_SPARC_NONE. */
11744 case EM_MIPS
: /* R_MIPS_NONE. */
11745 case EM_PARISC
: /* R_PARISC_NONE. */
11746 case EM_ALPHA
: /* R_ALPHA_NONE. */
11747 case EM_ADAPTEVA_EPIPHANY
:
11748 case EM_PPC
: /* R_PPC_NONE. */
11749 case EM_PPC64
: /* R_PPC64_NONE. */
11750 case EM_ARC
: /* R_ARC_NONE. */
11751 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11752 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11753 case EM_ARM
: /* R_ARM_NONE. */
11754 case EM_IA_64
: /* R_IA64_NONE. */
11755 case EM_SH
: /* R_SH_NONE. */
11757 case EM_S390
: /* R_390_NONE. */
11758 case EM_CRIS
: /* R_CRIS_NONE. */
11759 case EM_X86_64
: /* R_X86_64_NONE. */
11760 case EM_L1OM
: /* R_X86_64_NONE. */
11761 case EM_K1OM
: /* R_X86_64_NONE. */
11762 case EM_MN10300
: /* R_MN10300_NONE. */
11763 case EM_FT32
: /* R_FT32_NONE. */
11764 case EM_MOXIE
: /* R_MOXIE_NONE. */
11765 case EM_M32R
: /* R_M32R_NONE. */
11766 case EM_TI_C6000
:/* R_C6000_NONE. */
11767 case EM_TILEGX
: /* R_TILEGX_NONE. */
11768 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11770 case EM_C166
: /* R_XC16X_NONE. */
11771 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11772 case EM_NIOS32
: /* R_NIOS_NONE. */
11773 case EM_OR1K
: /* R_OR1K_NONE. */
11774 return reloc_type
== 0;
11776 return reloc_type
== 0 || reloc_type
== 256;
11778 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11779 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11780 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11781 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11782 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11783 case EM_XTENSA_OLD
:
11785 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11786 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11787 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11788 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11790 return reloc_type
== 3; /* R_METAG_NONE. */
11795 /* Returns TRUE if there is a relocation against
11796 section NAME at OFFSET bytes. */
11799 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11801 Elf_Internal_Rela
* relocs
;
11802 Elf_Internal_Rela
* rp
;
11804 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11807 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11809 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11810 if (rp
->r_offset
== offset
)
11816 /* Apply relocations to a section.
11817 Note: So far support has been added only for those relocations
11818 which can be found in debug sections.
11819 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11820 loaded relocs. It is then the caller's responsibility to free them.
11821 FIXME: Add support for more relocations ? */
11824 apply_relocations (void * file
,
11825 const Elf_Internal_Shdr
* section
,
11826 unsigned char * start
,
11827 bfd_size_type size
,
11828 void ** relocs_return
,
11829 unsigned long * num_relocs_return
)
11831 Elf_Internal_Shdr
* relsec
;
11832 unsigned char * end
= start
+ size
;
11834 if (relocs_return
!= NULL
)
11836 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11837 * num_relocs_return
= 0;
11840 if (elf_header
.e_type
!= ET_REL
)
11843 /* Find the reloc section associated with the section. */
11844 for (relsec
= section_headers
;
11845 relsec
< section_headers
+ elf_header
.e_shnum
;
11848 bfd_boolean is_rela
;
11849 unsigned long num_relocs
;
11850 Elf_Internal_Rela
* relocs
;
11851 Elf_Internal_Rela
* rp
;
11852 Elf_Internal_Shdr
* symsec
;
11853 Elf_Internal_Sym
* symtab
;
11854 unsigned long num_syms
;
11855 Elf_Internal_Sym
* sym
;
11857 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11858 || relsec
->sh_info
>= elf_header
.e_shnum
11859 || section_headers
+ relsec
->sh_info
!= section
11860 || relsec
->sh_size
== 0
11861 || relsec
->sh_link
>= elf_header
.e_shnum
)
11864 is_rela
= relsec
->sh_type
== SHT_RELA
;
11868 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11869 relsec
->sh_size
, & relocs
, & num_relocs
))
11874 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11875 relsec
->sh_size
, & relocs
, & num_relocs
))
11879 /* SH uses RELA but uses in place value instead of the addend field. */
11880 if (elf_header
.e_machine
== EM_SH
)
11883 symsec
= section_headers
+ relsec
->sh_link
;
11884 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11886 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11889 unsigned int reloc_type
;
11890 unsigned int reloc_size
;
11891 unsigned char * rloc
;
11892 unsigned long sym_index
;
11894 reloc_type
= get_reloc_type (rp
->r_info
);
11896 if (target_specific_reloc_handling (rp
, start
, symtab
))
11898 else if (is_none_reloc (reloc_type
))
11900 else if (is_32bit_abs_reloc (reloc_type
)
11901 || is_32bit_pcrel_reloc (reloc_type
))
11903 else if (is_64bit_abs_reloc (reloc_type
)
11904 || is_64bit_pcrel_reloc (reloc_type
))
11906 else if (is_24bit_abs_reloc (reloc_type
))
11908 else if (is_16bit_abs_reloc (reloc_type
))
11912 static unsigned int prev_reloc
= 0;
11913 if (reloc_type
!= prev_reloc
)
11914 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11915 reloc_type
, printable_section_name (section
));
11916 prev_reloc
= reloc_type
;
11920 rloc
= start
+ rp
->r_offset
;
11921 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11923 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11924 (unsigned long) rp
->r_offset
,
11925 printable_section_name (section
));
11929 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11930 if (sym_index
>= num_syms
)
11932 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11933 sym_index
, printable_section_name (section
));
11936 sym
= symtab
+ sym_index
;
11938 /* If the reloc has a symbol associated with it,
11939 make sure that it is of an appropriate type.
11941 Relocations against symbols without type can happen.
11942 Gcc -feliminate-dwarf2-dups may generate symbols
11943 without type for debug info.
11945 Icc generates relocations against function symbols
11946 instead of local labels.
11948 Relocations against object symbols can happen, eg when
11949 referencing a global array. For an example of this see
11950 the _clz.o binary in libgcc.a. */
11952 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11954 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11955 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11956 (long int)(rp
- relocs
),
11957 printable_section_name (relsec
));
11963 addend
+= rp
->r_addend
;
11964 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11965 partial_inplace. */
11967 || (elf_header
.e_machine
== EM_XTENSA
11968 && reloc_type
== 1)
11969 || ((elf_header
.e_machine
== EM_PJ
11970 || elf_header
.e_machine
== EM_PJ_OLD
)
11971 && reloc_type
== 1)
11972 || ((elf_header
.e_machine
== EM_D30V
11973 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11974 && reloc_type
== 12))
11975 addend
+= byte_get (rloc
, reloc_size
);
11977 if (is_32bit_pcrel_reloc (reloc_type
)
11978 || is_64bit_pcrel_reloc (reloc_type
))
11980 /* On HPPA, all pc-relative relocations are biased by 8. */
11981 if (elf_header
.e_machine
== EM_PARISC
)
11983 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11987 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11994 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
11995 * num_relocs_return
= num_relocs
;
12004 #ifdef SUPPORT_DISASSEMBLY
12006 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12008 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12010 /* FIXME: XXX -- to be done --- XXX */
12016 /* Reads in the contents of SECTION from FILE, returning a pointer
12017 to a malloc'ed buffer or NULL if something went wrong. */
12020 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12022 bfd_size_type num_bytes
;
12024 num_bytes
= section
->sh_size
;
12026 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12028 printf (_("\nSection '%s' has no data to dump.\n"),
12029 printable_section_name (section
));
12033 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12034 _("section contents"));
12037 /* Uncompresses a section that was compressed using zlib, in place. */
12040 uncompress_section_contents (unsigned char **buffer
,
12041 dwarf_size_type uncompressed_size
,
12042 dwarf_size_type
*size
)
12044 dwarf_size_type compressed_size
= *size
;
12045 unsigned char * compressed_buffer
= *buffer
;
12046 unsigned char * uncompressed_buffer
;
12050 /* It is possible the section consists of several compressed
12051 buffers concatenated together, so we uncompress in a loop. */
12052 /* PR 18313: The state field in the z_stream structure is supposed
12053 to be invisible to the user (ie us), but some compilers will
12054 still complain about it being used without initialisation. So
12055 we first zero the entire z_stream structure and then set the fields
12057 memset (& strm
, 0, sizeof strm
);
12058 strm
.avail_in
= compressed_size
;
12059 strm
.next_in
= (Bytef
*) compressed_buffer
;
12060 strm
.avail_out
= uncompressed_size
;
12061 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12063 rc
= inflateInit (& strm
);
12064 while (strm
.avail_in
> 0)
12068 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12069 + (uncompressed_size
- strm
.avail_out
));
12070 rc
= inflate (&strm
, Z_FINISH
);
12071 if (rc
!= Z_STREAM_END
)
12073 rc
= inflateReset (& strm
);
12075 rc
= inflateEnd (& strm
);
12077 || strm
.avail_out
!= 0)
12080 *buffer
= uncompressed_buffer
;
12081 *size
= uncompressed_size
;
12085 free (uncompressed_buffer
);
12086 /* Indicate decompression failure. */
12092 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12094 Elf_Internal_Shdr
* relsec
;
12095 bfd_size_type num_bytes
;
12096 unsigned char * data
;
12097 unsigned char * end
;
12098 unsigned char * real_start
;
12099 unsigned char * start
;
12100 bfd_boolean some_strings_shown
;
12102 real_start
= start
= (unsigned char *) get_section_contents (section
,
12106 num_bytes
= section
->sh_size
;
12108 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12110 if (decompress_dumps
)
12112 dwarf_size_type new_size
= num_bytes
;
12113 dwarf_size_type uncompressed_size
= 0;
12115 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12117 Elf_Internal_Chdr chdr
;
12118 unsigned int compression_header_size
12119 = get_compression_header (& chdr
, (unsigned char *) start
);
12121 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12123 warn (_("section '%s' has unsupported compress type: %d\n"),
12124 printable_section_name (section
), chdr
.ch_type
);
12127 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12129 warn (_("compressed section '%s' is corrupted\n"),
12130 printable_section_name (section
));
12133 uncompressed_size
= chdr
.ch_size
;
12134 start
+= compression_header_size
;
12135 new_size
-= compression_header_size
;
12137 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12139 /* Read the zlib header. In this case, it should be "ZLIB"
12140 followed by the uncompressed section size, 8 bytes in
12141 big-endian order. */
12142 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12143 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12144 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12145 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12146 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12147 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12148 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12149 uncompressed_size
+= start
[11];
12154 if (uncompressed_size
12155 && uncompress_section_contents (& start
,
12156 uncompressed_size
, & new_size
))
12157 num_bytes
= new_size
;
12160 /* If the section being dumped has relocations against it the user might
12161 be expecting these relocations to have been applied. Check for this
12162 case and issue a warning message in order to avoid confusion.
12163 FIXME: Maybe we ought to have an option that dumps a section with
12164 relocs applied ? */
12165 for (relsec
= section_headers
;
12166 relsec
< section_headers
+ elf_header
.e_shnum
;
12169 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12170 || relsec
->sh_info
>= elf_header
.e_shnum
12171 || section_headers
+ relsec
->sh_info
!= section
12172 || relsec
->sh_size
== 0
12173 || relsec
->sh_link
>= elf_header
.e_shnum
)
12176 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12181 end
= start
+ num_bytes
;
12182 some_strings_shown
= FALSE
;
12186 while (!ISPRINT (* data
))
12187 if (++ data
>= end
)
12192 size_t maxlen
= end
- data
;
12195 /* PR 11128: Use two separate invocations in order to work
12196 around bugs in the Solaris 8 implementation of printf. */
12197 printf (" [%6tx] ", data
- start
);
12199 printf (" [%6Ix] ", (size_t) (data
- start
));
12203 print_symbol ((int) maxlen
, (const char *) data
);
12205 data
+= strnlen ((const char *) data
, maxlen
);
12209 printf (_("<corrupt>\n"));
12212 some_strings_shown
= TRUE
;
12216 if (! some_strings_shown
)
12217 printf (_(" No strings found in this section."));
12225 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12227 bfd_boolean relocate
)
12229 Elf_Internal_Shdr
* relsec
;
12230 bfd_size_type bytes
;
12231 bfd_size_type section_size
;
12233 unsigned char * data
;
12234 unsigned char * real_start
;
12235 unsigned char * start
;
12237 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12240 section_size
= section
->sh_size
;
12242 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12244 if (decompress_dumps
)
12246 dwarf_size_type new_size
= section_size
;
12247 dwarf_size_type uncompressed_size
= 0;
12249 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12251 Elf_Internal_Chdr chdr
;
12252 unsigned int compression_header_size
12253 = get_compression_header (& chdr
, start
);
12255 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12257 warn (_("section '%s' has unsupported compress type: %d\n"),
12258 printable_section_name (section
), chdr
.ch_type
);
12261 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12263 warn (_("compressed section '%s' is corrupted\n"),
12264 printable_section_name (section
));
12267 uncompressed_size
= chdr
.ch_size
;
12268 start
+= compression_header_size
;
12269 new_size
-= compression_header_size
;
12271 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12273 /* Read the zlib header. In this case, it should be "ZLIB"
12274 followed by the uncompressed section size, 8 bytes in
12275 big-endian order. */
12276 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12277 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12278 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12279 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12280 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12281 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12282 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12283 uncompressed_size
+= start
[11];
12288 if (uncompressed_size
12289 && uncompress_section_contents (& start
, uncompressed_size
,
12291 section_size
= new_size
;
12296 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12300 /* If the section being dumped has relocations against it the user might
12301 be expecting these relocations to have been applied. Check for this
12302 case and issue a warning message in order to avoid confusion.
12303 FIXME: Maybe we ought to have an option that dumps a section with
12304 relocs applied ? */
12305 for (relsec
= section_headers
;
12306 relsec
< section_headers
+ elf_header
.e_shnum
;
12309 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12310 || relsec
->sh_info
>= elf_header
.e_shnum
12311 || section_headers
+ relsec
->sh_info
!= section
12312 || relsec
->sh_size
== 0
12313 || relsec
->sh_link
>= elf_header
.e_shnum
)
12316 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12321 addr
= section
->sh_addr
;
12322 bytes
= section_size
;
12331 lbytes
= (bytes
> 16 ? 16 : bytes
);
12333 printf (" 0x%8.8lx ", (unsigned long) addr
);
12335 for (j
= 0; j
< 16; j
++)
12338 printf ("%2.2x", data
[j
]);
12346 for (j
= 0; j
< lbytes
; j
++)
12349 if (k
>= ' ' && k
< 0x7f)
12368 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12369 const Elf_Internal_Shdr
* sec
, void * file
)
12371 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12374 /* If it is already loaded, do nothing. */
12375 if (section
->start
!= NULL
)
12378 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12379 section
->address
= sec
->sh_addr
;
12380 section
->user_data
= NULL
;
12381 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12383 sec
->sh_size
, buf
);
12384 if (section
->start
== NULL
)
12388 unsigned char *start
= section
->start
;
12389 dwarf_size_type size
= sec
->sh_size
;
12390 dwarf_size_type uncompressed_size
= 0;
12392 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12394 Elf_Internal_Chdr chdr
;
12395 unsigned int compression_header_size
12396 = get_compression_header (&chdr
, start
);
12397 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12399 warn (_("section '%s' has unsupported compress type: %d\n"),
12400 section
->name
, chdr
.ch_type
);
12403 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12405 warn (_("compressed section '%s' is corrupted\n"),
12409 uncompressed_size
= chdr
.ch_size
;
12410 start
+= compression_header_size
;
12411 size
-= compression_header_size
;
12413 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12415 /* Read the zlib header. In this case, it should be "ZLIB"
12416 followed by the uncompressed section size, 8 bytes in
12417 big-endian order. */
12418 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12419 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12420 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12421 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12422 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12423 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12424 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12425 uncompressed_size
+= start
[11];
12430 if (uncompressed_size
12431 && uncompress_section_contents (&start
, uncompressed_size
,
12434 /* Free the compressed buffer, update the section buffer
12435 and the section size if uncompress is successful. */
12436 free (section
->start
);
12437 section
->start
= start
;
12439 section
->size
= size
;
12442 if (section
->start
== NULL
)
12445 if (debug_displays
[debug
].relocate
)
12446 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12447 & section
->reloc_info
, & section
->num_relocs
);
12450 section
->reloc_info
= NULL
;
12451 section
->num_relocs
= 0;
12457 /* If this is not NULL, load_debug_section will only look for sections
12458 within the list of sections given here. */
12459 unsigned int *section_subset
= NULL
;
12462 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12464 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12465 Elf_Internal_Shdr
* sec
;
12467 /* Locate the debug section. */
12468 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12470 section
->name
= section
->uncompressed_name
;
12473 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12475 section
->name
= section
->compressed_name
;
12480 /* If we're loading from a subset of sections, and we've loaded
12481 a section matching this name before, it's likely that it's a
12483 if (section_subset
!= NULL
)
12484 free_debug_section (debug
);
12486 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12490 free_debug_section (enum dwarf_section_display_enum debug
)
12492 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12494 if (section
->start
== NULL
)
12497 free ((char *) section
->start
);
12498 section
->start
= NULL
;
12499 section
->address
= 0;
12504 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12506 char * name
= SECTION_NAME (section
);
12507 const char * print_name
= printable_section_name (section
);
12508 bfd_size_type length
;
12512 length
= section
->sh_size
;
12515 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12518 if (section
->sh_type
== SHT_NOBITS
)
12520 /* There is no point in dumping the contents of a debugging section
12521 which has the NOBITS type - the bits in the file will be random.
12522 This can happen when a file containing a .eh_frame section is
12523 stripped with the --only-keep-debug command line option. */
12524 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12529 if (const_strneq (name
, ".gnu.linkonce.wi."))
12530 name
= ".debug_info";
12532 /* See if we know how to display the contents of this section. */
12533 for (i
= 0; i
< max
; i
++)
12534 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12535 || (i
== line
&& const_strneq (name
, ".debug_line."))
12536 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12538 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12539 int secondary
= (section
!= find_section (name
));
12542 free_debug_section ((enum dwarf_section_display_enum
) i
);
12544 if (i
== line
&& const_strneq (name
, ".debug_line."))
12546 else if (streq (sec
->uncompressed_name
, name
))
12547 sec
->name
= sec
->uncompressed_name
;
12549 sec
->name
= sec
->compressed_name
;
12550 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12553 /* If this debug section is part of a CU/TU set in a .dwp file,
12554 restrict load_debug_section to the sections in that set. */
12555 section_subset
= find_cu_tu_set (file
, shndx
);
12557 result
&= debug_displays
[i
].display (sec
, file
);
12559 section_subset
= NULL
;
12561 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12562 free_debug_section ((enum dwarf_section_display_enum
) i
);
12570 printf (_("Unrecognized debug section: %s\n"), print_name
);
12577 /* Set DUMP_SECTS for all sections where dumps were requested
12578 based on section name. */
12581 initialise_dumps_byname (void)
12583 struct dump_list_entry
* cur
;
12585 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12590 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12591 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12593 request_dump_bynumber (i
, cur
->type
);
12598 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12604 process_section_contents (FILE * file
)
12606 Elf_Internal_Shdr
* section
;
12612 initialise_dumps_byname ();
12614 for (i
= 0, section
= section_headers
;
12615 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12618 #ifdef SUPPORT_DISASSEMBLY
12619 if (dump_sects
[i
] & DISASS_DUMP
)
12620 disassemble_section (section
, file
);
12622 if (dump_sects
[i
] & HEX_DUMP
)
12623 dump_section_as_bytes (section
, file
, FALSE
);
12625 if (dump_sects
[i
] & RELOC_DUMP
)
12626 dump_section_as_bytes (section
, file
, TRUE
);
12628 if (dump_sects
[i
] & STRING_DUMP
)
12629 dump_section_as_strings (section
, file
);
12631 if (dump_sects
[i
] & DEBUG_DUMP
)
12632 display_debug_section (i
, section
, file
);
12635 /* Check to see if the user requested a
12636 dump of a section that does not exist. */
12637 while (i
++ < num_dump_sects
)
12639 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12643 process_mips_fpe_exception (int mask
)
12648 if (mask
& OEX_FPU_INEX
)
12649 fputs ("INEX", stdout
), first
= 0;
12650 if (mask
& OEX_FPU_UFLO
)
12651 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12652 if (mask
& OEX_FPU_OFLO
)
12653 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12654 if (mask
& OEX_FPU_DIV0
)
12655 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12656 if (mask
& OEX_FPU_INVAL
)
12657 printf ("%sINVAL", first
? "" : "|");
12660 fputs ("0", stdout
);
12663 /* Display's the value of TAG at location P. If TAG is
12664 greater than 0 it is assumed to be an unknown tag, and
12665 a message is printed to this effect. Otherwise it is
12666 assumed that a message has already been printed.
12668 If the bottom bit of TAG is set it assumed to have a
12669 string value, otherwise it is assumed to have an integer
12672 Returns an updated P pointing to the first unread byte
12673 beyond the end of TAG's value.
12675 Reads at or beyond END will not be made. */
12677 static unsigned char *
12678 display_tag_value (int tag
,
12680 const unsigned char * const end
)
12685 printf (" Tag_unknown_%d: ", tag
);
12689 warn (_("<corrupt tag>\n"));
12693 /* PR 17531 file: 027-19978-0.004. */
12694 size_t maxlen
= (end
- p
) - 1;
12699 print_symbol ((int) maxlen
, (const char *) p
);
12700 p
+= strnlen ((char *) p
, maxlen
) + 1;
12704 printf (_("<corrupt string tag>"));
12705 p
= (unsigned char *) end
;
12713 val
= read_uleb128 (p
, &len
, end
);
12715 printf ("%ld (0x%lx)\n", val
, val
);
12722 /* ARM EABI attributes section. */
12727 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12729 const char ** table
;
12730 } arm_attr_public_tag
;
12732 static const char * arm_attr_tag_CPU_arch
[] =
12733 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12734 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12735 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12736 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12737 {"No", "Thumb-1", "Thumb-2"};
12738 static const char * arm_attr_tag_FP_arch
[] =
12739 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12740 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12741 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12742 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12743 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12744 static const char * arm_attr_tag_PCS_config
[] =
12745 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12746 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12747 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12748 {"V6", "SB", "TLS", "Unused"};
12749 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12750 {"Absolute", "PC-relative", "SB-relative", "None"};
12751 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12752 {"Absolute", "PC-relative", "None"};
12753 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12754 {"None", "direct", "GOT-indirect"};
12755 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12756 {"None", "??? 1", "2", "??? 3", "4"};
12757 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12758 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12759 {"Unused", "Needed", "Sign only"};
12760 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12761 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12762 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12763 {"Unused", "Finite", "RTABI", "IEEE 754"};
12764 static const char * arm_attr_tag_ABI_enum_size
[] =
12765 {"Unused", "small", "int", "forced to int"};
12766 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12767 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12768 static const char * arm_attr_tag_ABI_VFP_args
[] =
12769 {"AAPCS", "VFP registers", "custom", "compatible"};
12770 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12771 {"AAPCS", "WMMX registers", "custom"};
12772 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12773 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12774 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12775 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12776 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12777 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12778 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12779 static const char * arm_attr_tag_FP_HP_extension
[] =
12780 {"Not Allowed", "Allowed"};
12781 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12782 {"None", "IEEE 754", "Alternative Format"};
12783 static const char * arm_attr_tag_MPextension_use
[] =
12784 {"Not Allowed", "Allowed"};
12785 static const char * arm_attr_tag_DIV_use
[] =
12786 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12787 "Allowed in v7-A with integer division extension"};
12788 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12789 static const char * arm_attr_tag_Virtualization_use
[] =
12790 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12791 "TrustZone and Virtualization Extensions"};
12792 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12793 {"Not Allowed", "Allowed"};
12795 #define LOOKUP(id, name) \
12796 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12797 static arm_attr_public_tag arm_attr_public_tags
[] =
12799 {4, "CPU_raw_name", 1, NULL
},
12800 {5, "CPU_name", 1, NULL
},
12801 LOOKUP(6, CPU_arch
),
12802 {7, "CPU_arch_profile", 0, NULL
},
12803 LOOKUP(8, ARM_ISA_use
),
12804 LOOKUP(9, THUMB_ISA_use
),
12805 LOOKUP(10, FP_arch
),
12806 LOOKUP(11, WMMX_arch
),
12807 LOOKUP(12, Advanced_SIMD_arch
),
12808 LOOKUP(13, PCS_config
),
12809 LOOKUP(14, ABI_PCS_R9_use
),
12810 LOOKUP(15, ABI_PCS_RW_data
),
12811 LOOKUP(16, ABI_PCS_RO_data
),
12812 LOOKUP(17, ABI_PCS_GOT_use
),
12813 LOOKUP(18, ABI_PCS_wchar_t
),
12814 LOOKUP(19, ABI_FP_rounding
),
12815 LOOKUP(20, ABI_FP_denormal
),
12816 LOOKUP(21, ABI_FP_exceptions
),
12817 LOOKUP(22, ABI_FP_user_exceptions
),
12818 LOOKUP(23, ABI_FP_number_model
),
12819 {24, "ABI_align_needed", 0, NULL
},
12820 {25, "ABI_align_preserved", 0, NULL
},
12821 LOOKUP(26, ABI_enum_size
),
12822 LOOKUP(27, ABI_HardFP_use
),
12823 LOOKUP(28, ABI_VFP_args
),
12824 LOOKUP(29, ABI_WMMX_args
),
12825 LOOKUP(30, ABI_optimization_goals
),
12826 LOOKUP(31, ABI_FP_optimization_goals
),
12827 {32, "compatibility", 0, NULL
},
12828 LOOKUP(34, CPU_unaligned_access
),
12829 LOOKUP(36, FP_HP_extension
),
12830 LOOKUP(38, ABI_FP_16bit_format
),
12831 LOOKUP(42, MPextension_use
),
12832 LOOKUP(44, DIV_use
),
12833 {64, "nodefaults", 0, NULL
},
12834 {65, "also_compatible_with", 0, NULL
},
12835 LOOKUP(66, T2EE_use
),
12836 {67, "conformance", 1, NULL
},
12837 LOOKUP(68, Virtualization_use
),
12838 LOOKUP(70, MPextension_use_legacy
)
12842 static unsigned char *
12843 display_arm_attribute (unsigned char * p
,
12844 const unsigned char * const end
)
12849 arm_attr_public_tag
* attr
;
12853 tag
= read_uleb128 (p
, &len
, end
);
12856 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12858 if (arm_attr_public_tags
[i
].tag
== tag
)
12860 attr
= &arm_attr_public_tags
[i
];
12867 printf (" Tag_%s: ", attr
->name
);
12868 switch (attr
->type
)
12873 case 7: /* Tag_CPU_arch_profile. */
12874 val
= read_uleb128 (p
, &len
, end
);
12878 case 0: printf (_("None\n")); break;
12879 case 'A': printf (_("Application\n")); break;
12880 case 'R': printf (_("Realtime\n")); break;
12881 case 'M': printf (_("Microcontroller\n")); break;
12882 case 'S': printf (_("Application or Realtime\n")); break;
12883 default: printf ("??? (%d)\n", val
); break;
12887 case 24: /* Tag_align_needed. */
12888 val
= read_uleb128 (p
, &len
, end
);
12892 case 0: printf (_("None\n")); break;
12893 case 1: printf (_("8-byte\n")); break;
12894 case 2: printf (_("4-byte\n")); break;
12895 case 3: printf ("??? 3\n"); break;
12898 printf (_("8-byte and up to %d-byte extended\n"),
12901 printf ("??? (%d)\n", val
);
12906 case 25: /* Tag_align_preserved. */
12907 val
= read_uleb128 (p
, &len
, end
);
12911 case 0: printf (_("None\n")); break;
12912 case 1: printf (_("8-byte, except leaf SP\n")); break;
12913 case 2: printf (_("8-byte\n")); break;
12914 case 3: printf ("??? 3\n"); break;
12917 printf (_("8-byte and up to %d-byte extended\n"),
12920 printf ("??? (%d)\n", val
);
12925 case 32: /* Tag_compatibility. */
12927 val
= read_uleb128 (p
, &len
, end
);
12929 printf (_("flag = %d, vendor = "), val
);
12932 size_t maxlen
= (end
- p
) - 1;
12934 print_symbol ((int) maxlen
, (const char *) p
);
12935 p
+= strnlen ((char *) p
, maxlen
) + 1;
12939 printf (_("<corrupt>"));
12940 p
= (unsigned char *) end
;
12946 case 64: /* Tag_nodefaults. */
12947 /* PR 17531: file: 001-505008-0.01. */
12950 printf (_("True\n"));
12953 case 65: /* Tag_also_compatible_with. */
12954 val
= read_uleb128 (p
, &len
, end
);
12956 if (val
== 6 /* Tag_CPU_arch. */)
12958 val
= read_uleb128 (p
, &len
, end
);
12960 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12961 printf ("??? (%d)\n", val
);
12963 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12967 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12972 printf (_("<unknown: %d>\n"), tag
);
12978 return display_tag_value (-1, p
, end
);
12980 return display_tag_value (0, p
, end
);
12983 assert (attr
->type
& 0x80);
12984 val
= read_uleb128 (p
, &len
, end
);
12986 type
= attr
->type
& 0x7f;
12988 printf ("??? (%d)\n", val
);
12990 printf ("%s\n", attr
->table
[val
]);
12995 return display_tag_value (tag
, p
, end
);
12998 static unsigned char *
12999 display_gnu_attribute (unsigned char * p
,
13000 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13001 const unsigned char * const end
)
13007 tag
= read_uleb128 (p
, &len
, end
);
13010 /* Tag_compatibility is the only generic GNU attribute defined at
13014 val
= read_uleb128 (p
, &len
, end
);
13017 printf (_("flag = %d, vendor = "), val
);
13020 printf (_("<corrupt>\n"));
13021 warn (_("corrupt vendor attribute\n"));
13027 size_t maxlen
= (end
- p
) - 1;
13029 print_symbol ((int) maxlen
, (const char *) p
);
13030 p
+= strnlen ((char *) p
, maxlen
) + 1;
13034 printf (_("<corrupt>"));
13035 p
= (unsigned char *) end
;
13042 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13043 return display_proc_gnu_attribute (p
, tag
, end
);
13045 return display_tag_value (tag
, p
, end
);
13048 static unsigned char *
13049 display_power_gnu_attribute (unsigned char * p
,
13051 const unsigned char * const end
)
13056 if (tag
== Tag_GNU_Power_ABI_FP
)
13058 val
= read_uleb128 (p
, &len
, end
);
13060 printf (" Tag_GNU_Power_ABI_FP: ");
13065 printf (_("Hard or soft float\n"));
13068 printf (_("Hard float\n"));
13071 printf (_("Soft float\n"));
13074 printf (_("Single-precision hard float\n"));
13077 printf ("??? (%d)\n", val
);
13083 if (tag
== Tag_GNU_Power_ABI_Vector
)
13085 val
= read_uleb128 (p
, &len
, end
);
13087 printf (" Tag_GNU_Power_ABI_Vector: ");
13091 printf (_("Any\n"));
13094 printf (_("Generic\n"));
13097 printf ("AltiVec\n");
13103 printf ("??? (%d)\n", val
);
13109 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13113 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13117 val
= read_uleb128 (p
, &len
, end
);
13119 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13123 printf (_("Any\n"));
13126 printf ("r3/r4\n");
13129 printf (_("Memory\n"));
13132 printf ("??? (%d)\n", val
);
13138 return display_tag_value (tag
& 1, p
, end
);
13141 static unsigned char *
13142 display_s390_gnu_attribute (unsigned char * p
,
13144 const unsigned char * const end
)
13149 if (tag
== Tag_GNU_S390_ABI_Vector
)
13151 val
= read_uleb128 (p
, &len
, end
);
13153 printf (" Tag_GNU_S390_ABI_Vector: ");
13158 printf (_("any\n"));
13161 printf (_("software\n"));
13164 printf (_("hardware\n"));
13167 printf ("??? (%d)\n", val
);
13173 return display_tag_value (tag
& 1, p
, end
);
13177 display_sparc_hwcaps (int mask
)
13183 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13184 fputs ("mul32", stdout
), first
= 0;
13185 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13186 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13187 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13188 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13189 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13190 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13191 if (mask
& ELF_SPARC_HWCAP_POPC
)
13192 printf ("%spopc", first
? "" : "|"), first
= 0;
13193 if (mask
& ELF_SPARC_HWCAP_VIS
)
13194 printf ("%svis", first
? "" : "|"), first
= 0;
13195 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13196 printf ("%svis2", first
? "" : "|"), first
= 0;
13197 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13198 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13199 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13200 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13201 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13202 printf ("%svis3", first
? "" : "|"), first
= 0;
13203 if (mask
& ELF_SPARC_HWCAP_HPC
)
13204 printf ("%shpc", first
? "" : "|"), first
= 0;
13205 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13206 printf ("%srandom", first
? "" : "|"), first
= 0;
13207 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13208 printf ("%strans", first
? "" : "|"), first
= 0;
13209 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13210 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13211 if (mask
& ELF_SPARC_HWCAP_IMA
)
13212 printf ("%sima", first
? "" : "|"), first
= 0;
13213 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13214 printf ("%scspare", first
? "" : "|"), first
= 0;
13217 fputc ('0', stdout
);
13218 fputc ('\n', stdout
);
13222 display_sparc_hwcaps2 (int mask
)
13228 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13229 fputs ("fjathplus", stdout
), first
= 0;
13230 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13231 printf ("%svis3b", first
? "" : "|"), first
= 0;
13232 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13233 printf ("%sadp", first
? "" : "|"), first
= 0;
13234 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13235 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13236 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13237 printf ("%smwait", first
? "" : "|"), first
= 0;
13238 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13239 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13240 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13241 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13242 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13243 printf ("%snsec", first
? "" : "|"), first
= 0;
13244 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13245 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13246 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13247 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13248 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13249 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13252 fputc ('0', stdout
);
13253 fputc ('\n', stdout
);
13256 static unsigned char *
13257 display_sparc_gnu_attribute (unsigned char * p
,
13259 const unsigned char * const end
)
13264 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13266 val
= read_uleb128 (p
, &len
, end
);
13268 printf (" Tag_GNU_Sparc_HWCAPS: ");
13269 display_sparc_hwcaps (val
);
13272 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13274 val
= read_uleb128 (p
, &len
, end
);
13276 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13277 display_sparc_hwcaps2 (val
);
13281 return display_tag_value (tag
, p
, end
);
13285 print_mips_fp_abi_value (int val
)
13289 case Val_GNU_MIPS_ABI_FP_ANY
:
13290 printf (_("Hard or soft float\n"));
13292 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13293 printf (_("Hard float (double precision)\n"));
13295 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13296 printf (_("Hard float (single precision)\n"));
13298 case Val_GNU_MIPS_ABI_FP_SOFT
:
13299 printf (_("Soft float\n"));
13301 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13302 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13304 case Val_GNU_MIPS_ABI_FP_XX
:
13305 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13307 case Val_GNU_MIPS_ABI_FP_64
:
13308 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13310 case Val_GNU_MIPS_ABI_FP_64A
:
13311 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13313 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13314 printf (_("NaN 2008 compatibility\n"));
13317 printf ("??? (%d)\n", val
);
13322 static unsigned char *
13323 display_mips_gnu_attribute (unsigned char * p
,
13325 const unsigned char * const end
)
13327 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13332 val
= read_uleb128 (p
, &len
, end
);
13334 printf (" Tag_GNU_MIPS_ABI_FP: ");
13336 print_mips_fp_abi_value (val
);
13341 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13346 val
= read_uleb128 (p
, &len
, end
);
13348 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13352 case Val_GNU_MIPS_ABI_MSA_ANY
:
13353 printf (_("Any MSA or not\n"));
13355 case Val_GNU_MIPS_ABI_MSA_128
:
13356 printf (_("128-bit MSA\n"));
13359 printf ("??? (%d)\n", val
);
13365 return display_tag_value (tag
& 1, p
, end
);
13368 static unsigned char *
13369 display_tic6x_attribute (unsigned char * p
,
13370 const unsigned char * const end
)
13376 tag
= read_uleb128 (p
, &len
, end
);
13382 val
= read_uleb128 (p
, &len
, end
);
13384 printf (" Tag_ISA: ");
13388 case C6XABI_Tag_ISA_none
:
13389 printf (_("None\n"));
13391 case C6XABI_Tag_ISA_C62X
:
13394 case C6XABI_Tag_ISA_C67X
:
13397 case C6XABI_Tag_ISA_C67XP
:
13398 printf ("C67x+\n");
13400 case C6XABI_Tag_ISA_C64X
:
13403 case C6XABI_Tag_ISA_C64XP
:
13404 printf ("C64x+\n");
13406 case C6XABI_Tag_ISA_C674X
:
13407 printf ("C674x\n");
13410 printf ("??? (%d)\n", val
);
13415 case Tag_ABI_wchar_t
:
13416 val
= read_uleb128 (p
, &len
, end
);
13418 printf (" Tag_ABI_wchar_t: ");
13422 printf (_("Not used\n"));
13425 printf (_("2 bytes\n"));
13428 printf (_("4 bytes\n"));
13431 printf ("??? (%d)\n", val
);
13436 case Tag_ABI_stack_align_needed
:
13437 val
= read_uleb128 (p
, &len
, end
);
13439 printf (" Tag_ABI_stack_align_needed: ");
13443 printf (_("8-byte\n"));
13446 printf (_("16-byte\n"));
13449 printf ("??? (%d)\n", val
);
13454 case Tag_ABI_stack_align_preserved
:
13455 val
= read_uleb128 (p
, &len
, end
);
13457 printf (" Tag_ABI_stack_align_preserved: ");
13461 printf (_("8-byte\n"));
13464 printf (_("16-byte\n"));
13467 printf ("??? (%d)\n", val
);
13473 val
= read_uleb128 (p
, &len
, end
);
13475 printf (" Tag_ABI_DSBT: ");
13479 printf (_("DSBT addressing not used\n"));
13482 printf (_("DSBT addressing used\n"));
13485 printf ("??? (%d)\n", val
);
13491 val
= read_uleb128 (p
, &len
, end
);
13493 printf (" Tag_ABI_PID: ");
13497 printf (_("Data addressing position-dependent\n"));
13500 printf (_("Data addressing position-independent, GOT near DP\n"));
13503 printf (_("Data addressing position-independent, GOT far from DP\n"));
13506 printf ("??? (%d)\n", val
);
13512 val
= read_uleb128 (p
, &len
, end
);
13514 printf (" Tag_ABI_PIC: ");
13518 printf (_("Code addressing position-dependent\n"));
13521 printf (_("Code addressing position-independent\n"));
13524 printf ("??? (%d)\n", val
);
13529 case Tag_ABI_array_object_alignment
:
13530 val
= read_uleb128 (p
, &len
, end
);
13532 printf (" Tag_ABI_array_object_alignment: ");
13536 printf (_("8-byte\n"));
13539 printf (_("4-byte\n"));
13542 printf (_("16-byte\n"));
13545 printf ("??? (%d)\n", val
);
13550 case Tag_ABI_array_object_align_expected
:
13551 val
= read_uleb128 (p
, &len
, end
);
13553 printf (" Tag_ABI_array_object_align_expected: ");
13557 printf (_("8-byte\n"));
13560 printf (_("4-byte\n"));
13563 printf (_("16-byte\n"));
13566 printf ("??? (%d)\n", val
);
13571 case Tag_ABI_compatibility
:
13573 val
= read_uleb128 (p
, &len
, end
);
13575 printf (" Tag_ABI_compatibility: ");
13576 printf (_("flag = %d, vendor = "), val
);
13579 size_t maxlen
= (end
- p
) - 1;
13581 print_symbol ((int) maxlen
, (const char *) p
);
13582 p
+= strnlen ((char *) p
, maxlen
) + 1;
13586 printf (_("<corrupt>"));
13587 p
= (unsigned char *) end
;
13593 case Tag_ABI_conformance
:
13595 printf (" Tag_ABI_conformance: \"");
13598 size_t maxlen
= (end
- p
) - 1;
13600 print_symbol ((int) maxlen
, (const char *) p
);
13601 p
+= strnlen ((char *) p
, maxlen
) + 1;
13605 printf (_("<corrupt>"));
13606 p
= (unsigned char *) end
;
13613 return display_tag_value (tag
, p
, end
);
13617 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13619 unsigned long addr
= 0;
13620 size_t bytes
= end
- p
;
13627 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13629 printf (" 0x%8.8lx ", addr
);
13631 for (j
= 0; j
< 16; j
++)
13634 printf ("%2.2x", p
[j
]);
13642 for (j
= 0; j
< lbytes
; j
++)
13645 if (k
>= ' ' && k
< 0x7f)
13661 static unsigned char *
13662 display_msp430x_attribute (unsigned char * p
,
13663 const unsigned char * const end
)
13669 tag
= read_uleb128 (p
, & len
, end
);
13674 case OFBA_MSPABI_Tag_ISA
:
13675 val
= read_uleb128 (p
, &len
, end
);
13677 printf (" Tag_ISA: ");
13680 case 0: printf (_("None\n")); break;
13681 case 1: printf (_("MSP430\n")); break;
13682 case 2: printf (_("MSP430X\n")); break;
13683 default: printf ("??? (%d)\n", val
); break;
13687 case OFBA_MSPABI_Tag_Code_Model
:
13688 val
= read_uleb128 (p
, &len
, end
);
13690 printf (" Tag_Code_Model: ");
13693 case 0: printf (_("None\n")); break;
13694 case 1: printf (_("Small\n")); break;
13695 case 2: printf (_("Large\n")); break;
13696 default: printf ("??? (%d)\n", val
); break;
13700 case OFBA_MSPABI_Tag_Data_Model
:
13701 val
= read_uleb128 (p
, &len
, end
);
13703 printf (" Tag_Data_Model: ");
13706 case 0: printf (_("None\n")); break;
13707 case 1: printf (_("Small\n")); break;
13708 case 2: printf (_("Large\n")); break;
13709 case 3: printf (_("Restricted Large\n")); break;
13710 default: printf ("??? (%d)\n", val
); break;
13715 printf (_(" <unknown tag %d>: "), tag
);
13722 size_t maxlen
= (end
- p
) - 1;
13724 print_symbol ((int) maxlen
, (const char *) p
);
13725 p
+= strnlen ((char *) p
, maxlen
) + 1;
13729 printf (_("<corrupt>"));
13730 p
= (unsigned char *) end
;
13736 val
= read_uleb128 (p
, &len
, end
);
13738 printf ("%d (0x%x)\n", val
, val
);
13748 process_attributes (FILE * file
,
13749 const char * public_name
,
13750 unsigned int proc_type
,
13751 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13752 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13754 Elf_Internal_Shdr
* sect
;
13757 /* Find the section header so that we get the size. */
13758 for (i
= 0, sect
= section_headers
;
13759 i
< elf_header
.e_shnum
;
13762 unsigned char * contents
;
13765 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13768 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13769 sect
->sh_size
, _("attributes"));
13770 if (contents
== NULL
)
13776 bfd_vma section_len
;
13778 section_len
= sect
->sh_size
- 1;
13781 while (section_len
> 0)
13784 unsigned int namelen
;
13785 bfd_boolean public_section
;
13786 bfd_boolean gnu_section
;
13788 if (section_len
<= 4)
13790 error (_("Tag section ends prematurely\n"));
13793 attr_len
= byte_get (p
, 4);
13796 if (attr_len
> section_len
)
13798 error (_("Bad attribute length (%u > %u)\n"),
13799 (unsigned) attr_len
, (unsigned) section_len
);
13800 attr_len
= section_len
;
13802 /* PR 17531: file: 001-101425-0.004 */
13803 else if (attr_len
< 5)
13805 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13809 section_len
-= attr_len
;
13812 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13813 if (namelen
== 0 || namelen
>= attr_len
)
13815 error (_("Corrupt attribute section name\n"));
13819 printf (_("Attribute Section: "));
13820 print_symbol (INT_MAX
, (const char *) p
);
13823 if (public_name
&& streq ((char *) p
, public_name
))
13824 public_section
= TRUE
;
13826 public_section
= FALSE
;
13828 if (streq ((char *) p
, "gnu"))
13829 gnu_section
= TRUE
;
13831 gnu_section
= FALSE
;
13834 attr_len
-= namelen
;
13836 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13841 unsigned char * end
;
13843 /* PR binutils/17531: Safe handling of corrupt files. */
13846 error (_("Unused bytes at end of section\n"));
13852 size
= byte_get (p
, 4);
13853 if (size
> attr_len
)
13855 error (_("Bad subsection length (%u > %u)\n"),
13856 (unsigned) size
, (unsigned) attr_len
);
13859 /* PR binutils/17531: Safe handling of corrupt files. */
13862 error (_("Bad subsection length (%u < 6)\n"),
13869 end
= p
+ size
- 1;
13870 assert (end
<= contents
+ sect
->sh_size
);
13876 printf (_("File Attributes\n"));
13879 printf (_("Section Attributes:"));
13882 printf (_("Symbol Attributes:"));
13888 val
= read_uleb128 (p
, &j
, end
);
13892 printf (" %d", val
);
13897 printf (_("Unknown tag: %d\n"), tag
);
13898 public_section
= FALSE
;
13902 if (public_section
&& display_pub_attribute
!= NULL
)
13905 p
= display_pub_attribute (p
, end
);
13908 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13911 p
= display_gnu_attribute (p
,
13912 display_proc_gnu_attribute
,
13918 printf (_(" Unknown attribute:\n"));
13919 display_raw_attribute (p
, end
);
13928 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13936 process_arm_specific (FILE * file
)
13938 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13939 display_arm_attribute
, NULL
);
13943 process_power_specific (FILE * file
)
13945 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13946 display_power_gnu_attribute
);
13950 process_s390_specific (FILE * file
)
13952 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13953 display_s390_gnu_attribute
);
13957 process_sparc_specific (FILE * file
)
13959 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13960 display_sparc_gnu_attribute
);
13964 process_tic6x_specific (FILE * file
)
13966 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13967 display_tic6x_attribute
, NULL
);
13971 process_msp430x_specific (FILE * file
)
13973 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13974 display_msp430x_attribute
, NULL
);
13977 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13978 Print the Address, Access and Initial fields of an entry at VMA ADDR
13979 and return the VMA of the next entry, or -1 if there was a problem.
13980 Does not read from DATA_END or beyond. */
13983 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13984 unsigned char * data_end
)
13987 print_vma (addr
, LONG_HEX
);
13989 if (addr
< pltgot
+ 0xfff0)
13990 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13992 printf ("%10s", "");
13995 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13999 unsigned char * from
= data
+ addr
- pltgot
;
14001 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14003 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14004 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14005 return (bfd_vma
) -1;
14009 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14010 print_vma (entry
, LONG_HEX
);
14013 return addr
+ (is_32bit_elf
? 4 : 8);
14016 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14017 PLTGOT. Print the Address and Initial fields of an entry at VMA
14018 ADDR and return the VMA of the next entry. */
14021 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14024 print_vma (addr
, LONG_HEX
);
14027 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14032 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14033 print_vma (entry
, LONG_HEX
);
14035 return addr
+ (is_32bit_elf
? 4 : 8);
14039 print_mips_ases (unsigned int mask
)
14041 if (mask
& AFL_ASE_DSP
)
14042 fputs ("\n\tDSP ASE", stdout
);
14043 if (mask
& AFL_ASE_DSPR2
)
14044 fputs ("\n\tDSP R2 ASE", stdout
);
14045 if (mask
& AFL_ASE_EVA
)
14046 fputs ("\n\tEnhanced VA Scheme", stdout
);
14047 if (mask
& AFL_ASE_MCU
)
14048 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14049 if (mask
& AFL_ASE_MDMX
)
14050 fputs ("\n\tMDMX ASE", stdout
);
14051 if (mask
& AFL_ASE_MIPS3D
)
14052 fputs ("\n\tMIPS-3D ASE", stdout
);
14053 if (mask
& AFL_ASE_MT
)
14054 fputs ("\n\tMT ASE", stdout
);
14055 if (mask
& AFL_ASE_SMARTMIPS
)
14056 fputs ("\n\tSmartMIPS ASE", stdout
);
14057 if (mask
& AFL_ASE_VIRT
)
14058 fputs ("\n\tVZ ASE", stdout
);
14059 if (mask
& AFL_ASE_MSA
)
14060 fputs ("\n\tMSA ASE", stdout
);
14061 if (mask
& AFL_ASE_MIPS16
)
14062 fputs ("\n\tMIPS16 ASE", stdout
);
14063 if (mask
& AFL_ASE_MICROMIPS
)
14064 fputs ("\n\tMICROMIPS ASE", stdout
);
14065 if (mask
& AFL_ASE_XPA
)
14066 fputs ("\n\tXPA ASE", stdout
);
14068 fprintf (stdout
, "\n\t%s", _("None"));
14069 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14070 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14074 print_mips_isa_ext (unsigned int isa_ext
)
14079 fputs (_("None"), stdout
);
14082 fputs ("RMI XLR", stdout
);
14084 case AFL_EXT_OCTEON3
:
14085 fputs ("Cavium Networks Octeon3", stdout
);
14087 case AFL_EXT_OCTEON2
:
14088 fputs ("Cavium Networks Octeon2", stdout
);
14090 case AFL_EXT_OCTEONP
:
14091 fputs ("Cavium Networks OcteonP", stdout
);
14093 case AFL_EXT_LOONGSON_3A
:
14094 fputs ("Loongson 3A", stdout
);
14096 case AFL_EXT_OCTEON
:
14097 fputs ("Cavium Networks Octeon", stdout
);
14100 fputs ("Toshiba R5900", stdout
);
14103 fputs ("MIPS R4650", stdout
);
14106 fputs ("LSI R4010", stdout
);
14109 fputs ("NEC VR4100", stdout
);
14112 fputs ("Toshiba R3900", stdout
);
14114 case AFL_EXT_10000
:
14115 fputs ("MIPS R10000", stdout
);
14118 fputs ("Broadcom SB-1", stdout
);
14121 fputs ("NEC VR4111/VR4181", stdout
);
14124 fputs ("NEC VR4120", stdout
);
14127 fputs ("NEC VR5400", stdout
);
14130 fputs ("NEC VR5500", stdout
);
14132 case AFL_EXT_LOONGSON_2E
:
14133 fputs ("ST Microelectronics Loongson 2E", stdout
);
14135 case AFL_EXT_LOONGSON_2F
:
14136 fputs ("ST Microelectronics Loongson 2F", stdout
);
14139 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14144 get_mips_reg_size (int reg_size
)
14146 return (reg_size
== AFL_REG_NONE
) ? 0
14147 : (reg_size
== AFL_REG_32
) ? 32
14148 : (reg_size
== AFL_REG_64
) ? 64
14149 : (reg_size
== AFL_REG_128
) ? 128
14154 process_mips_specific (FILE * file
)
14156 Elf_Internal_Dyn
* entry
;
14157 Elf_Internal_Shdr
*sect
= NULL
;
14158 size_t liblist_offset
= 0;
14159 size_t liblistno
= 0;
14160 size_t conflictsno
= 0;
14161 size_t options_offset
= 0;
14162 size_t conflicts_offset
= 0;
14163 size_t pltrelsz
= 0;
14165 bfd_vma pltgot
= 0;
14166 bfd_vma mips_pltgot
= 0;
14167 bfd_vma jmprel
= 0;
14168 bfd_vma local_gotno
= 0;
14169 bfd_vma gotsym
= 0;
14170 bfd_vma symtabno
= 0;
14172 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14173 display_mips_gnu_attribute
);
14175 sect
= find_section (".MIPS.abiflags");
14179 Elf_External_ABIFlags_v0
*abiflags_ext
;
14180 Elf_Internal_ABIFlags_v0 abiflags_in
;
14182 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14183 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14186 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14187 sect
->sh_size
, _("MIPS ABI Flags section"));
14190 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14191 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14192 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14193 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14194 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14195 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14196 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14197 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14198 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14199 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14200 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14202 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14203 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14204 if (abiflags_in
.isa_rev
> 1)
14205 printf ("r%d", abiflags_in
.isa_rev
);
14206 printf ("\nGPR size: %d",
14207 get_mips_reg_size (abiflags_in
.gpr_size
));
14208 printf ("\nCPR1 size: %d",
14209 get_mips_reg_size (abiflags_in
.cpr1_size
));
14210 printf ("\nCPR2 size: %d",
14211 get_mips_reg_size (abiflags_in
.cpr2_size
));
14212 fputs ("\nFP ABI: ", stdout
);
14213 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14214 fputs ("ISA Extension: ", stdout
);
14215 print_mips_isa_ext (abiflags_in
.isa_ext
);
14216 fputs ("\nASEs:", stdout
);
14217 print_mips_ases (abiflags_in
.ases
);
14218 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14219 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14220 fputc ('\n', stdout
);
14221 free (abiflags_ext
);
14226 /* We have a lot of special sections. Thanks SGI! */
14227 if (dynamic_section
== NULL
)
14228 /* No information available. */
14231 for (entry
= dynamic_section
;
14232 /* PR 17531 file: 012-50589-0.004. */
14233 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14235 switch (entry
->d_tag
)
14237 case DT_MIPS_LIBLIST
:
14239 = offset_from_vma (file
, entry
->d_un
.d_val
,
14240 liblistno
* sizeof (Elf32_External_Lib
));
14242 case DT_MIPS_LIBLISTNO
:
14243 liblistno
= entry
->d_un
.d_val
;
14245 case DT_MIPS_OPTIONS
:
14246 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14248 case DT_MIPS_CONFLICT
:
14250 = offset_from_vma (file
, entry
->d_un
.d_val
,
14251 conflictsno
* sizeof (Elf32_External_Conflict
));
14253 case DT_MIPS_CONFLICTNO
:
14254 conflictsno
= entry
->d_un
.d_val
;
14257 pltgot
= entry
->d_un
.d_ptr
;
14259 case DT_MIPS_LOCAL_GOTNO
:
14260 local_gotno
= entry
->d_un
.d_val
;
14262 case DT_MIPS_GOTSYM
:
14263 gotsym
= entry
->d_un
.d_val
;
14265 case DT_MIPS_SYMTABNO
:
14266 symtabno
= entry
->d_un
.d_val
;
14268 case DT_MIPS_PLTGOT
:
14269 mips_pltgot
= entry
->d_un
.d_ptr
;
14272 pltrel
= entry
->d_un
.d_val
;
14275 pltrelsz
= entry
->d_un
.d_val
;
14278 jmprel
= entry
->d_un
.d_ptr
;
14284 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14286 Elf32_External_Lib
* elib
;
14289 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14291 sizeof (Elf32_External_Lib
),
14292 _("liblist section data"));
14295 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14296 (unsigned long) liblistno
);
14297 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14300 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14307 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14308 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14309 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14310 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14311 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14313 tmp
= gmtime (&atime
);
14314 snprintf (timebuf
, sizeof (timebuf
),
14315 "%04u-%02u-%02uT%02u:%02u:%02u",
14316 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14317 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14319 printf ("%3lu: ", (unsigned long) cnt
);
14320 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14321 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14323 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14324 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14325 liblist
.l_version
);
14327 if (liblist
.l_flags
== 0)
14331 static const struct
14338 { " EXACT_MATCH", LL_EXACT_MATCH
},
14339 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14340 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14341 { " EXPORTS", LL_EXPORTS
},
14342 { " DELAY_LOAD", LL_DELAY_LOAD
},
14343 { " DELTA", LL_DELTA
}
14345 int flags
= liblist
.l_flags
;
14348 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14349 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14351 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14352 flags
^= l_flags_vals
[fcnt
].bit
;
14355 printf (" %#x", (unsigned int) flags
);
14365 if (options_offset
!= 0)
14367 Elf_External_Options
* eopt
;
14368 Elf_Internal_Options
* iopt
;
14369 Elf_Internal_Options
* option
;
14372 sect
= section_headers
;
14374 /* Find the section header so that we get the size. */
14375 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14376 /* PR 17533 file: 012-277276-0.004. */
14379 error (_("No MIPS_OPTIONS header found\n"));
14383 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14384 sect
->sh_size
, _("options"));
14387 iopt
= (Elf_Internal_Options
*)
14388 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14391 error (_("Out of memory allocatinf space for MIPS options\n"));
14398 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14400 Elf_External_Options
* eoption
;
14402 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14404 option
->kind
= BYTE_GET (eoption
->kind
);
14405 option
->size
= BYTE_GET (eoption
->size
);
14406 option
->section
= BYTE_GET (eoption
->section
);
14407 option
->info
= BYTE_GET (eoption
->info
);
14409 /* PR 17531: file: ffa0fa3b. */
14410 if (option
->size
< sizeof (* eopt
)
14411 || offset
+ option
->size
> sect
->sh_size
)
14413 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14416 offset
+= option
->size
;
14422 printf (_("\nSection '%s' contains %d entries:\n"),
14423 printable_section_name (sect
), cnt
);
14432 switch (option
->kind
)
14435 /* This shouldn't happen. */
14436 printf (" NULL %d %lx", option
->section
, option
->info
);
14439 printf (" REGINFO ");
14440 if (elf_header
.e_machine
== EM_MIPS
)
14443 Elf32_External_RegInfo
* ereg
;
14444 Elf32_RegInfo reginfo
;
14446 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14447 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14448 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14449 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14450 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14451 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14452 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14454 printf ("GPR %08lx GP 0x%lx\n",
14455 reginfo
.ri_gprmask
,
14456 (unsigned long) reginfo
.ri_gp_value
);
14457 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14458 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14459 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14464 Elf64_External_RegInfo
* ereg
;
14465 Elf64_Internal_RegInfo reginfo
;
14467 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14468 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14469 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14470 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14471 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14472 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14473 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14475 printf ("GPR %08lx GP 0x",
14476 reginfo
.ri_gprmask
);
14477 printf_vma (reginfo
.ri_gp_value
);
14480 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14481 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14482 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14486 case ODK_EXCEPTIONS
:
14487 fputs (" EXCEPTIONS fpe_min(", stdout
);
14488 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14489 fputs (") fpe_max(", stdout
);
14490 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14491 fputs (")", stdout
);
14493 if (option
->info
& OEX_PAGE0
)
14494 fputs (" PAGE0", stdout
);
14495 if (option
->info
& OEX_SMM
)
14496 fputs (" SMM", stdout
);
14497 if (option
->info
& OEX_FPDBUG
)
14498 fputs (" FPDBUG", stdout
);
14499 if (option
->info
& OEX_DISMISS
)
14500 fputs (" DISMISS", stdout
);
14503 fputs (" PAD ", stdout
);
14504 if (option
->info
& OPAD_PREFIX
)
14505 fputs (" PREFIX", stdout
);
14506 if (option
->info
& OPAD_POSTFIX
)
14507 fputs (" POSTFIX", stdout
);
14508 if (option
->info
& OPAD_SYMBOL
)
14509 fputs (" SYMBOL", stdout
);
14512 fputs (" HWPATCH ", stdout
);
14513 if (option
->info
& OHW_R4KEOP
)
14514 fputs (" R4KEOP", stdout
);
14515 if (option
->info
& OHW_R8KPFETCH
)
14516 fputs (" R8KPFETCH", stdout
);
14517 if (option
->info
& OHW_R5KEOP
)
14518 fputs (" R5KEOP", stdout
);
14519 if (option
->info
& OHW_R5KCVTL
)
14520 fputs (" R5KCVTL", stdout
);
14523 fputs (" FILL ", stdout
);
14524 /* XXX Print content of info word? */
14527 fputs (" TAGS ", stdout
);
14528 /* XXX Print content of info word? */
14531 fputs (" HWAND ", stdout
);
14532 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14533 fputs (" R4KEOP_CHECKED", stdout
);
14534 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14535 fputs (" R4KEOP_CLEAN", stdout
);
14538 fputs (" HWOR ", stdout
);
14539 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14540 fputs (" R4KEOP_CHECKED", stdout
);
14541 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14542 fputs (" R4KEOP_CLEAN", stdout
);
14545 printf (" GP_GROUP %#06lx self-contained %#06lx",
14546 option
->info
& OGP_GROUP
,
14547 (option
->info
& OGP_SELF
) >> 16);
14550 printf (" IDENT %#06lx self-contained %#06lx",
14551 option
->info
& OGP_GROUP
,
14552 (option
->info
& OGP_SELF
) >> 16);
14555 /* This shouldn't happen. */
14556 printf (" %3d ??? %d %lx",
14557 option
->kind
, option
->section
, option
->info
);
14561 len
= sizeof (* eopt
);
14562 while (len
< option
->size
)
14564 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14566 if (ISPRINT (datum
))
14567 printf ("%c", datum
);
14569 printf ("\\%03o", datum
);
14572 fputs ("\n", stdout
);
14574 offset
+= option
->size
;
14582 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14584 Elf32_Conflict
* iconf
;
14587 if (dynamic_symbols
== NULL
)
14589 error (_("conflict list found without a dynamic symbol table\n"));
14593 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14596 error (_("Out of memory allocating space for dynamic conflicts\n"));
14602 Elf32_External_Conflict
* econf32
;
14604 econf32
= (Elf32_External_Conflict
*)
14605 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14606 sizeof (* econf32
), _("conflict"));
14610 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14611 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14617 Elf64_External_Conflict
* econf64
;
14619 econf64
= (Elf64_External_Conflict
*)
14620 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14621 sizeof (* econf64
), _("conflict"));
14625 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14626 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14631 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14632 (unsigned long) conflictsno
);
14633 puts (_(" Num: Index Value Name"));
14635 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14637 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14639 if (iconf
[cnt
] >= num_dynamic_syms
)
14640 printf (_("<corrupt symbol index>"));
14643 Elf_Internal_Sym
* psym
;
14645 psym
= & dynamic_symbols
[iconf
[cnt
]];
14646 print_vma (psym
->st_value
, FULL_HEX
);
14648 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14649 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14651 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14659 if (pltgot
!= 0 && local_gotno
!= 0)
14661 bfd_vma ent
, local_end
, global_end
;
14663 unsigned char * data
;
14664 unsigned char * data_end
;
14668 addr_size
= (is_32bit_elf
? 4 : 8);
14669 local_end
= pltgot
+ local_gotno
* addr_size
;
14671 /* PR binutils/17533 file: 012-111227-0.004 */
14672 if (symtabno
< gotsym
)
14674 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14675 (unsigned long) gotsym
, (unsigned long) symtabno
);
14679 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14680 /* PR 17531: file: 54c91a34. */
14681 if (global_end
< local_end
)
14683 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14687 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14688 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14689 global_end
- pltgot
, 1,
14690 _("Global Offset Table data"));
14693 data_end
= data
+ (global_end
- pltgot
);
14695 printf (_("\nPrimary GOT:\n"));
14696 printf (_(" Canonical gp value: "));
14697 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14700 printf (_(" Reserved entries:\n"));
14701 printf (_(" %*s %10s %*s Purpose\n"),
14702 addr_size
* 2, _("Address"), _("Access"),
14703 addr_size
* 2, _("Initial"));
14704 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14705 printf (_(" Lazy resolver\n"));
14706 if (ent
== (bfd_vma
) -1)
14707 goto got_print_fail
;
14709 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14710 >> (addr_size
* 8 - 1)) != 0)
14712 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14713 printf (_(" Module pointer (GNU extension)\n"));
14714 if (ent
== (bfd_vma
) -1)
14715 goto got_print_fail
;
14719 if (ent
< local_end
)
14721 printf (_(" Local entries:\n"));
14722 printf (" %*s %10s %*s\n",
14723 addr_size
* 2, _("Address"), _("Access"),
14724 addr_size
* 2, _("Initial"));
14725 while (ent
< local_end
)
14727 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14729 if (ent
== (bfd_vma
) -1)
14730 goto got_print_fail
;
14735 if (gotsym
< symtabno
)
14739 printf (_(" Global entries:\n"));
14740 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14741 addr_size
* 2, _("Address"),
14743 addr_size
* 2, _("Initial"),
14744 addr_size
* 2, _("Sym.Val."),
14746 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14747 _("Ndx"), _("Name"));
14749 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14751 for (i
= gotsym
; i
< symtabno
; i
++)
14753 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14756 if (dynamic_symbols
== NULL
)
14757 printf (_("<no dynamic symbols>"));
14758 else if (i
< num_dynamic_syms
)
14760 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14762 print_vma (psym
->st_value
, LONG_HEX
);
14763 printf (" %-7s %3s ",
14764 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14765 get_symbol_index_type (psym
->st_shndx
));
14767 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14768 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14770 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14773 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14774 (unsigned long) i
);
14777 if (ent
== (bfd_vma
) -1)
14788 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14791 size_t offset
, rel_offset
;
14792 unsigned long count
, i
;
14793 unsigned char * data
;
14794 int addr_size
, sym_width
;
14795 Elf_Internal_Rela
* rels
;
14797 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14798 if (pltrel
== DT_RELA
)
14800 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14805 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14810 addr_size
= (is_32bit_elf
? 4 : 8);
14811 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14813 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14814 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14815 1, _("Procedure Linkage Table data"));
14819 printf ("\nPLT GOT:\n\n");
14820 printf (_(" Reserved entries:\n"));
14821 printf (_(" %*s %*s Purpose\n"),
14822 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14823 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14824 printf (_(" PLT lazy resolver\n"));
14825 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14826 printf (_(" Module pointer\n"));
14829 printf (_(" Entries:\n"));
14830 printf (" %*s %*s %*s %-7s %3s %s\n",
14831 addr_size
* 2, _("Address"),
14832 addr_size
* 2, _("Initial"),
14833 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14834 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14835 for (i
= 0; i
< count
; i
++)
14837 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14839 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14842 if (idx
>= num_dynamic_syms
)
14843 printf (_("<corrupt symbol index: %lu>"), idx
);
14846 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14848 print_vma (psym
->st_value
, LONG_HEX
);
14849 printf (" %-7s %3s ",
14850 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14851 get_symbol_index_type (psym
->st_shndx
));
14852 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14853 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14855 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14870 process_nds32_specific (FILE * file
)
14872 Elf_Internal_Shdr
*sect
= NULL
;
14874 sect
= find_section (".nds32_e_flags");
14877 unsigned int *flag
;
14879 printf ("\nNDS32 elf flags section:\n");
14880 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14881 sect
->sh_size
, _("NDS32 elf flags section"));
14883 switch ((*flag
) & 0x3)
14886 printf ("(VEC_SIZE):\tNo entry.\n");
14889 printf ("(VEC_SIZE):\t4 bytes\n");
14892 printf ("(VEC_SIZE):\t16 bytes\n");
14895 printf ("(VEC_SIZE):\treserved\n");
14904 process_gnu_liblist (FILE * file
)
14906 Elf_Internal_Shdr
* section
;
14907 Elf_Internal_Shdr
* string_sec
;
14908 Elf32_External_Lib
* elib
;
14910 size_t strtab_size
;
14917 for (i
= 0, section
= section_headers
;
14918 i
< elf_header
.e_shnum
;
14921 switch (section
->sh_type
)
14923 case SHT_GNU_LIBLIST
:
14924 if (section
->sh_link
>= elf_header
.e_shnum
)
14927 elib
= (Elf32_External_Lib
*)
14928 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14929 _("liblist section data"));
14933 string_sec
= section_headers
+ section
->sh_link
;
14935 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14936 string_sec
->sh_size
,
14937 _("liblist string table"));
14939 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14945 strtab_size
= string_sec
->sh_size
;
14947 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14948 printable_section_name (section
),
14949 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14951 puts (_(" Library Time Stamp Checksum Version Flags"));
14953 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14961 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14962 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14963 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14964 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14965 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14967 tmp
= gmtime (&atime
);
14968 snprintf (timebuf
, sizeof (timebuf
),
14969 "%04u-%02u-%02uT%02u:%02u:%02u",
14970 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14971 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14973 printf ("%3lu: ", (unsigned long) cnt
);
14975 printf ("%-20s", liblist
.l_name
< strtab_size
14976 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14978 printf ("%-20.20s", liblist
.l_name
< strtab_size
14979 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14980 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14981 liblist
.l_version
, liblist
.l_flags
);
14992 static const char *
14993 get_note_type (unsigned e_type
)
14995 static char buff
[64];
14997 if (elf_header
.e_type
== ET_CORE
)
15001 return _("NT_AUXV (auxiliary vector)");
15003 return _("NT_PRSTATUS (prstatus structure)");
15005 return _("NT_FPREGSET (floating point registers)");
15007 return _("NT_PRPSINFO (prpsinfo structure)");
15008 case NT_TASKSTRUCT
:
15009 return _("NT_TASKSTRUCT (task structure)");
15011 return _("NT_PRXFPREG (user_xfpregs structure)");
15013 return _("NT_PPC_VMX (ppc Altivec registers)");
15015 return _("NT_PPC_VSX (ppc VSX registers)");
15017 return _("NT_386_TLS (x86 TLS information)");
15018 case NT_386_IOPERM
:
15019 return _("NT_386_IOPERM (x86 I/O permissions)");
15020 case NT_X86_XSTATE
:
15021 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15022 case NT_S390_HIGH_GPRS
:
15023 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15024 case NT_S390_TIMER
:
15025 return _("NT_S390_TIMER (s390 timer register)");
15026 case NT_S390_TODCMP
:
15027 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15028 case NT_S390_TODPREG
:
15029 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15031 return _("NT_S390_CTRS (s390 control registers)");
15032 case NT_S390_PREFIX
:
15033 return _("NT_S390_PREFIX (s390 prefix register)");
15034 case NT_S390_LAST_BREAK
:
15035 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15036 case NT_S390_SYSTEM_CALL
:
15037 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15039 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15040 case NT_S390_VXRS_LOW
:
15041 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15042 case NT_S390_VXRS_HIGH
:
15043 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15045 return _("NT_ARM_VFP (arm VFP registers)");
15047 return _("NT_ARM_TLS (AArch TLS registers)");
15048 case NT_ARM_HW_BREAK
:
15049 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15050 case NT_ARM_HW_WATCH
:
15051 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15053 return _("NT_PSTATUS (pstatus structure)");
15055 return _("NT_FPREGS (floating point registers)");
15057 return _("NT_PSINFO (psinfo structure)");
15059 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15061 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15062 case NT_WIN32PSTATUS
:
15063 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15065 return _("NT_SIGINFO (siginfo_t data)");
15067 return _("NT_FILE (mapped files)");
15075 return _("NT_VERSION (version)");
15077 return _("NT_ARCH (architecture)");
15082 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15087 print_core_note (Elf_Internal_Note
*pnote
)
15089 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15090 bfd_vma count
, page_size
;
15091 unsigned char *descdata
, *filenames
, *descend
;
15093 if (pnote
->type
!= NT_FILE
)
15099 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15100 /* Still "successful". */
15105 if (pnote
->descsz
< 2 * addr_size
)
15107 printf (_(" Malformed note - too short for header\n"));
15111 descdata
= (unsigned char *) pnote
->descdata
;
15112 descend
= descdata
+ pnote
->descsz
;
15114 if (descdata
[pnote
->descsz
- 1] != '\0')
15116 printf (_(" Malformed note - does not end with \\0\n"));
15120 count
= byte_get (descdata
, addr_size
);
15121 descdata
+= addr_size
;
15123 page_size
= byte_get (descdata
, addr_size
);
15124 descdata
+= addr_size
;
15126 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15128 printf (_(" Malformed note - too short for supplied file count\n"));
15132 printf (_(" Page size: "));
15133 print_vma (page_size
, DEC
);
15136 printf (_(" %*s%*s%*s\n"),
15137 (int) (2 + 2 * addr_size
), _("Start"),
15138 (int) (4 + 2 * addr_size
), _("End"),
15139 (int) (4 + 2 * addr_size
), _("Page Offset"));
15140 filenames
= descdata
+ count
* 3 * addr_size
;
15141 while (count
-- > 0)
15143 bfd_vma start
, end
, file_ofs
;
15145 if (filenames
== descend
)
15147 printf (_(" Malformed note - filenames end too early\n"));
15151 start
= byte_get (descdata
, addr_size
);
15152 descdata
+= addr_size
;
15153 end
= byte_get (descdata
, addr_size
);
15154 descdata
+= addr_size
;
15155 file_ofs
= byte_get (descdata
, addr_size
);
15156 descdata
+= addr_size
;
15159 print_vma (start
, FULL_HEX
);
15161 print_vma (end
, FULL_HEX
);
15163 print_vma (file_ofs
, FULL_HEX
);
15164 printf ("\n %s\n", filenames
);
15166 filenames
+= 1 + strlen ((char *) filenames
);
15172 static const char *
15173 get_gnu_elf_note_type (unsigned e_type
)
15175 static char buff
[64];
15179 case NT_GNU_ABI_TAG
:
15180 return _("NT_GNU_ABI_TAG (ABI version tag)");
15182 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15183 case NT_GNU_BUILD_ID
:
15184 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15185 case NT_GNU_GOLD_VERSION
:
15186 return _("NT_GNU_GOLD_VERSION (gold version)");
15191 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15196 print_gnu_note (Elf_Internal_Note
*pnote
)
15198 switch (pnote
->type
)
15200 case NT_GNU_BUILD_ID
:
15204 printf (_(" Build ID: "));
15205 for (i
= 0; i
< pnote
->descsz
; ++i
)
15206 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15211 case NT_GNU_ABI_TAG
:
15213 unsigned long os
, major
, minor
, subminor
;
15214 const char *osname
;
15216 /* PR 17531: file: 030-599401-0.004. */
15217 if (pnote
->descsz
< 16)
15219 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15223 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15224 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15225 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15226 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15230 case GNU_ABI_TAG_LINUX
:
15233 case GNU_ABI_TAG_HURD
:
15236 case GNU_ABI_TAG_SOLARIS
:
15237 osname
= "Solaris";
15239 case GNU_ABI_TAG_FREEBSD
:
15240 osname
= "FreeBSD";
15242 case GNU_ABI_TAG_NETBSD
:
15245 case GNU_ABI_TAG_SYLLABLE
:
15246 osname
= "Syllable";
15248 case GNU_ABI_TAG_NACL
:
15252 osname
= "Unknown";
15256 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15257 major
, minor
, subminor
);
15261 case NT_GNU_GOLD_VERSION
:
15265 printf (_(" Version: "));
15266 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15267 printf ("%c", pnote
->descdata
[i
]);
15276 static const char *
15277 get_v850_elf_note_type (enum v850_notes n_type
)
15279 static char buff
[64];
15283 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15284 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15285 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15286 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15287 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15288 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15290 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15296 print_v850_note (Elf_Internal_Note
* pnote
)
15300 if (pnote
->descsz
!= 4)
15302 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15306 printf (_("not set\n"));
15310 switch (pnote
->type
)
15312 case V850_NOTE_ALIGNMENT
:
15315 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15316 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15320 case V850_NOTE_DATA_SIZE
:
15323 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15324 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15328 case V850_NOTE_FPU_INFO
:
15331 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15332 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15336 case V850_NOTE_MMU_INFO
:
15337 case V850_NOTE_CACHE_INFO
:
15338 case V850_NOTE_SIMD_INFO
:
15339 if (val
== EF_RH850_SIMD
)
15341 printf (_("yes\n"));
15347 /* An 'unknown note type' message will already have been displayed. */
15351 printf (_("unknown value: %x\n"), val
);
15356 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15358 unsigned int version
;
15360 switch (pnote
->type
)
15362 case NT_NETBSD_IDENT
:
15363 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15364 if ((version
/ 10000) % 100)
15365 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15366 version
, version
/ 100000000, (version
/ 1000000) % 100,
15367 (version
/ 10000) % 100 > 26 ? "Z" : "",
15368 'A' + (version
/ 10000) % 26);
15370 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15371 version
, version
/ 100000000, (version
/ 1000000) % 100,
15372 (version
/ 100) % 100);
15375 case NT_NETBSD_MARCH
:
15376 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15384 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15389 static const char *
15390 get_netbsd_elfcore_note_type (unsigned e_type
)
15392 static char buff
[64];
15394 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15396 /* NetBSD core "procinfo" structure. */
15397 return _("NetBSD procinfo structure");
15400 /* As of Jan 2002 there are no other machine-independent notes
15401 defined for NetBSD core files. If the note type is less
15402 than the start of the machine-dependent note types, we don't
15405 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15407 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15411 switch (elf_header
.e_machine
)
15413 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15414 and PT_GETFPREGS == mach+2. */
15419 case EM_SPARC32PLUS
:
15423 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15424 return _("PT_GETREGS (reg structure)");
15425 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15426 return _("PT_GETFPREGS (fpreg structure)");
15432 /* On all other arch's, PT_GETREGS == mach+1 and
15433 PT_GETFPREGS == mach+3. */
15437 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15438 return _("PT_GETREGS (reg structure)");
15439 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15440 return _("PT_GETFPREGS (fpreg structure)");
15446 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15447 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15451 static const char *
15452 get_stapsdt_note_type (unsigned e_type
)
15454 static char buff
[64];
15459 return _("NT_STAPSDT (SystemTap probe descriptors)");
15465 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15470 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15472 int addr_size
= is_32bit_elf
? 4 : 8;
15473 char *data
= pnote
->descdata
;
15474 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15475 bfd_vma pc
, base_addr
, semaphore
;
15476 char *provider
, *probe
, *arg_fmt
;
15478 pc
= byte_get ((unsigned char *) data
, addr_size
);
15480 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15482 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15486 data
+= strlen (data
) + 1;
15488 data
+= strlen (data
) + 1;
15490 data
+= strlen (data
) + 1;
15492 printf (_(" Provider: %s\n"), provider
);
15493 printf (_(" Name: %s\n"), probe
);
15494 printf (_(" Location: "));
15495 print_vma (pc
, FULL_HEX
);
15496 printf (_(", Base: "));
15497 print_vma (base_addr
, FULL_HEX
);
15498 printf (_(", Semaphore: "));
15499 print_vma (semaphore
, FULL_HEX
);
15501 printf (_(" Arguments: %s\n"), arg_fmt
);
15503 return data
== data_end
;
15506 static const char *
15507 get_ia64_vms_note_type (unsigned e_type
)
15509 static char buff
[64];
15514 return _("NT_VMS_MHD (module header)");
15516 return _("NT_VMS_LNM (language name)");
15518 return _("NT_VMS_SRC (source files)");
15520 return "NT_VMS_TITLE";
15522 return _("NT_VMS_EIDC (consistency check)");
15523 case NT_VMS_FPMODE
:
15524 return _("NT_VMS_FPMODE (FP mode)");
15525 case NT_VMS_LINKTIME
:
15526 return "NT_VMS_LINKTIME";
15527 case NT_VMS_IMGNAM
:
15528 return _("NT_VMS_IMGNAM (image name)");
15530 return _("NT_VMS_IMGID (image id)");
15531 case NT_VMS_LINKID
:
15532 return _("NT_VMS_LINKID (link id)");
15533 case NT_VMS_IMGBID
:
15534 return _("NT_VMS_IMGBID (build id)");
15535 case NT_VMS_GSTNAM
:
15536 return _("NT_VMS_GSTNAM (sym table name)");
15537 case NT_VMS_ORIG_DYN
:
15538 return "NT_VMS_ORIG_DYN";
15539 case NT_VMS_PATCHTIME
:
15540 return "NT_VMS_PATCHTIME";
15542 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15548 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15550 switch (pnote
->type
)
15553 if (pnote
->descsz
> 36)
15555 size_t l
= strlen (pnote
->descdata
+ 34);
15556 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15557 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15558 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15559 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15562 printf (_(" Invalid size\n"));
15565 printf (_(" Language: %s\n"), pnote
->descdata
);
15568 case NT_VMS_FPMODE
:
15569 printf (_(" Floating Point mode: "));
15570 printf ("0x%016" BFD_VMA_FMT
"x\n",
15571 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15573 case NT_VMS_LINKTIME
:
15574 printf (_(" Link time: "));
15576 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15579 case NT_VMS_PATCHTIME
:
15580 printf (_(" Patch time: "));
15582 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15585 case NT_VMS_ORIG_DYN
:
15586 printf (_(" Major id: %u, minor id: %u\n"),
15587 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15588 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15589 printf (_(" Last modified : "));
15591 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15592 printf (_("\n Link flags : "));
15593 printf ("0x%016" BFD_VMA_FMT
"x\n",
15594 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15595 printf (_(" Header flags: 0x%08x\n"),
15596 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15597 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15600 case NT_VMS_IMGNAM
:
15601 printf (_(" Image name: %s\n"), pnote
->descdata
);
15603 case NT_VMS_GSTNAM
:
15604 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15607 printf (_(" Image id: %s\n"), pnote
->descdata
);
15609 case NT_VMS_LINKID
:
15610 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15618 /* Note that by the ELF standard, the name field is already null byte
15619 terminated, and namesz includes the terminating null byte.
15620 I.E. the value of namesz for the name "FSF" is 4.
15622 If the value of namesz is zero, there is no name present. */
15624 process_note (Elf_Internal_Note
* pnote
)
15626 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15629 if (pnote
->namesz
== 0)
15630 /* If there is no note name, then use the default set of
15631 note type strings. */
15632 nt
= get_note_type (pnote
->type
);
15634 else if (const_strneq (pnote
->namedata
, "GNU"))
15635 /* GNU-specific object file notes. */
15636 nt
= get_gnu_elf_note_type (pnote
->type
);
15638 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15639 /* NetBSD-specific core file notes. */
15640 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15642 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15643 /* NetBSD-specific core file notes. */
15644 return process_netbsd_elf_note (pnote
);
15646 else if (strneq (pnote
->namedata
, "SPU/", 4))
15648 /* SPU-specific core file notes. */
15649 nt
= pnote
->namedata
+ 4;
15653 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15654 /* VMS/ia64-specific file notes. */
15655 nt
= get_ia64_vms_note_type (pnote
->type
);
15657 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15658 nt
= get_stapsdt_note_type (pnote
->type
);
15661 /* Don't recognize this note name; just use the default set of
15662 note type strings. */
15663 nt
= get_note_type (pnote
->type
);
15665 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15667 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15668 return print_ia64_vms_note (pnote
);
15669 else if (const_strneq (pnote
->namedata
, "GNU"))
15670 return print_gnu_note (pnote
);
15671 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15672 return print_stapsdt_note (pnote
);
15673 else if (const_strneq (pnote
->namedata
, "CORE"))
15674 return print_core_note (pnote
);
15681 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15683 Elf_External_Note
* pnotes
;
15684 Elf_External_Note
* external
;
15691 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15693 if (pnotes
== NULL
)
15698 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15699 (unsigned long) offset
, (unsigned long) length
);
15700 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15702 end
= (char *) pnotes
+ length
;
15703 while ((char *) external
< end
)
15705 Elf_Internal_Note inote
;
15708 char * temp
= NULL
;
15709 size_t data_remaining
= end
- (char *) external
;
15711 if (!is_ia64_vms ())
15713 /* PR binutils/15191
15714 Make sure that there is enough data to read. */
15715 min_notesz
= offsetof (Elf_External_Note
, name
);
15716 if (data_remaining
< min_notesz
)
15718 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15719 (int) data_remaining
);
15722 inote
.type
= BYTE_GET (external
->type
);
15723 inote
.namesz
= BYTE_GET (external
->namesz
);
15724 inote
.namedata
= external
->name
;
15725 inote
.descsz
= BYTE_GET (external
->descsz
);
15726 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15727 /* PR 17531: file: 3443835e. */
15728 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15730 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15731 inote
.descdata
= inote
.namedata
;
15735 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15736 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15740 Elf64_External_VMS_Note
*vms_external
;
15742 /* PR binutils/15191
15743 Make sure that there is enough data to read. */
15744 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15745 if (data_remaining
< min_notesz
)
15747 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15748 (int) data_remaining
);
15752 vms_external
= (Elf64_External_VMS_Note
*) external
;
15753 inote
.type
= BYTE_GET (vms_external
->type
);
15754 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15755 inote
.namedata
= vms_external
->name
;
15756 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15757 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15758 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15759 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15762 if (inote
.descdata
< (char *) external
+ min_notesz
15763 || next
< (char *) external
+ min_notesz
15764 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15765 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15766 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15767 || data_remaining
< (size_t)(next
- (char *) external
))
15769 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15770 (unsigned long) ((char *) external
- (char *) pnotes
));
15771 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15772 inote
.type
, inote
.namesz
, inote
.descsz
);
15776 external
= (Elf_External_Note
*) next
;
15778 /* Verify that name is null terminated. It appears that at least
15779 one version of Linux (RedHat 6.0) generates corefiles that don't
15780 comply with the ELF spec by failing to include the null byte in
15782 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15784 temp
= (char *) malloc (inote
.namesz
+ 1);
15787 error (_("Out of memory allocating space for inote name\n"));
15792 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15793 temp
[inote
.namesz
] = 0;
15795 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15796 inote
.namedata
= temp
;
15799 res
&= process_note (& inote
);
15814 process_corefile_note_segments (FILE * file
)
15816 Elf_Internal_Phdr
* segment
;
15820 if (! get_program_headers (file
))
15823 for (i
= 0, segment
= program_headers
;
15824 i
< elf_header
.e_phnum
;
15827 if (segment
->p_type
== PT_NOTE
)
15828 res
&= process_corefile_note_segment (file
,
15829 (bfd_vma
) segment
->p_offset
,
15830 (bfd_vma
) segment
->p_filesz
);
15837 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15839 Elf_External_Note
* pnotes
;
15840 Elf_External_Note
* external
;
15847 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15849 if (pnotes
== NULL
)
15853 end
= (char*) pnotes
+ length
;
15855 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15856 (unsigned long) offset
, (unsigned long) length
);
15858 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15860 Elf_External_Note
* next
;
15861 Elf_Internal_Note inote
;
15863 inote
.type
= BYTE_GET (external
->type
);
15864 inote
.namesz
= BYTE_GET (external
->namesz
);
15865 inote
.namedata
= external
->name
;
15866 inote
.descsz
= BYTE_GET (external
->descsz
);
15867 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15868 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15870 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15872 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15873 inote
.descdata
= inote
.namedata
;
15877 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15879 if ( ((char *) next
> end
)
15880 || ((char *) next
< (char *) pnotes
))
15882 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15883 (unsigned long) ((char *) external
- (char *) pnotes
));
15884 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15885 inote
.type
, inote
.namesz
, inote
.descsz
);
15891 /* Prevent out-of-bounds indexing. */
15892 if ( inote
.namedata
+ inote
.namesz
> end
15893 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15895 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15896 (unsigned long) ((char *) external
- (char *) pnotes
));
15897 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15898 inote
.type
, inote
.namesz
, inote
.descsz
);
15902 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15904 if (! print_v850_note (& inote
))
15907 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15908 inote
.namesz
, inote
.descsz
);
15918 process_note_sections (FILE * file
)
15920 Elf_Internal_Shdr
* section
;
15925 for (i
= 0, section
= section_headers
;
15926 i
< elf_header
.e_shnum
&& section
!= NULL
;
15929 if (section
->sh_type
== SHT_NOTE
)
15931 res
&= process_corefile_note_segment (file
,
15932 (bfd_vma
) section
->sh_offset
,
15933 (bfd_vma
) section
->sh_size
);
15937 if (( elf_header
.e_machine
== EM_V800
15938 || elf_header
.e_machine
== EM_V850
15939 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15940 && section
->sh_type
== SHT_RENESAS_INFO
)
15942 res
&= process_v850_notes (file
,
15943 (bfd_vma
) section
->sh_offset
,
15944 (bfd_vma
) section
->sh_size
);
15950 /* Try processing NOTE segments instead. */
15951 return process_corefile_note_segments (file
);
15957 process_notes (FILE * file
)
15959 /* If we have not been asked to display the notes then do nothing. */
15963 if (elf_header
.e_type
!= ET_CORE
)
15964 return process_note_sections (file
);
15966 /* No program headers means no NOTE segment. */
15967 if (elf_header
.e_phnum
> 0)
15968 return process_corefile_note_segments (file
);
15970 printf (_("No note segments present in the core file.\n"));
15975 process_arch_specific (FILE * file
)
15980 switch (elf_header
.e_machine
)
15983 return process_arm_specific (file
);
15985 case EM_MIPS_RS3_LE
:
15986 return process_mips_specific (file
);
15989 return process_nds32_specific (file
);
15992 return process_power_specific (file
);
15996 return process_s390_specific (file
);
15999 case EM_SPARC32PLUS
:
16001 return process_sparc_specific (file
);
16004 return process_tic6x_specific (file
);
16007 return process_msp430x_specific (file
);
16015 get_file_header (FILE * file
)
16017 /* Read in the identity array. */
16018 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16021 /* Determine how to read the rest of the header. */
16022 switch (elf_header
.e_ident
[EI_DATA
])
16024 default: /* fall through */
16025 case ELFDATANONE
: /* fall through */
16027 byte_get
= byte_get_little_endian
;
16028 byte_put
= byte_put_little_endian
;
16031 byte_get
= byte_get_big_endian
;
16032 byte_put
= byte_put_big_endian
;
16036 /* For now we only support 32 bit and 64 bit ELF files. */
16037 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16039 /* Read in the rest of the header. */
16042 Elf32_External_Ehdr ehdr32
;
16044 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16047 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16048 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16049 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16050 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16051 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16052 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16053 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16054 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16055 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16056 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16057 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16058 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16059 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16063 Elf64_External_Ehdr ehdr64
;
16065 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16066 we will not be able to cope with the 64bit data found in
16067 64 ELF files. Detect this now and abort before we start
16068 overwriting things. */
16069 if (sizeof (bfd_vma
) < 8)
16071 error (_("This instance of readelf has been built without support for a\n\
16072 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16076 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16079 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16080 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16081 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16082 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16083 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16084 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16085 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16086 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16087 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16088 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16089 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16090 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16091 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16094 if (elf_header
.e_shoff
)
16096 /* There may be some extensions in the first section header. Don't
16097 bomb if we can't read it. */
16099 get_32bit_section_headers (file
, TRUE
);
16101 get_64bit_section_headers (file
, TRUE
);
16107 /* Process one ELF object file according to the command line options.
16108 This file may actually be stored in an archive. The file is
16109 positioned at the start of the ELF object. */
16112 process_object (char * file_name
, FILE * file
)
16116 if (! get_file_header (file
))
16118 error (_("%s: Failed to read file header\n"), file_name
);
16122 /* Initialise per file variables. */
16123 for (i
= ARRAY_SIZE (version_info
); i
--;)
16124 version_info
[i
] = 0;
16126 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16127 dynamic_info
[i
] = 0;
16128 dynamic_info_DT_GNU_HASH
= 0;
16130 /* Process the file. */
16132 printf (_("\nFile: %s\n"), file_name
);
16134 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16135 Note we do this even if cmdline_dump_sects is empty because we
16136 must make sure that the dump_sets array is zeroed out before each
16137 object file is processed. */
16138 if (num_dump_sects
> num_cmdline_dump_sects
)
16139 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16141 if (num_cmdline_dump_sects
> 0)
16143 if (num_dump_sects
== 0)
16144 /* A sneaky way of allocating the dump_sects array. */
16145 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16147 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16148 memcpy (dump_sects
, cmdline_dump_sects
,
16149 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16152 if (! process_file_header ())
16155 if (! process_section_headers (file
))
16157 /* Without loaded section headers we cannot process lots of
16159 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16161 if (! do_using_dynamic
)
16162 do_syms
= do_dyn_syms
= do_reloc
= 0;
16165 if (! process_section_groups (file
))
16167 /* Without loaded section groups we cannot process unwind. */
16171 if (process_program_headers (file
))
16172 process_dynamic_section (file
);
16174 process_relocs (file
);
16176 process_unwind (file
);
16178 process_symbol_table (file
);
16180 process_syminfo (file
);
16182 process_version_sections (file
);
16184 process_section_contents (file
);
16186 process_notes (file
);
16188 process_gnu_liblist (file
);
16190 process_arch_specific (file
);
16192 if (program_headers
)
16194 free (program_headers
);
16195 program_headers
= NULL
;
16198 if (section_headers
)
16200 free (section_headers
);
16201 section_headers
= NULL
;
16206 free (string_table
);
16207 string_table
= NULL
;
16208 string_table_length
= 0;
16211 if (dynamic_strings
)
16213 free (dynamic_strings
);
16214 dynamic_strings
= NULL
;
16215 dynamic_strings_length
= 0;
16218 if (dynamic_symbols
)
16220 free (dynamic_symbols
);
16221 dynamic_symbols
= NULL
;
16222 num_dynamic_syms
= 0;
16225 if (dynamic_syminfo
)
16227 free (dynamic_syminfo
);
16228 dynamic_syminfo
= NULL
;
16231 if (dynamic_section
)
16233 free (dynamic_section
);
16234 dynamic_section
= NULL
;
16237 if (section_headers_groups
)
16239 free (section_headers_groups
);
16240 section_headers_groups
= NULL
;
16243 if (section_groups
)
16245 struct group_list
* g
;
16246 struct group_list
* next
;
16248 for (i
= 0; i
< group_count
; i
++)
16250 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16257 free (section_groups
);
16258 section_groups
= NULL
;
16261 free_debug_memory ();
16266 /* Process an ELF archive.
16267 On entry the file is positioned just after the ARMAG string. */
16270 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16272 struct archive_info arch
;
16273 struct archive_info nested_arch
;
16279 /* The ARCH structure is used to hold information about this archive. */
16280 arch
.file_name
= NULL
;
16282 arch
.index_array
= NULL
;
16283 arch
.sym_table
= NULL
;
16284 arch
.longnames
= NULL
;
16286 /* The NESTED_ARCH structure is used as a single-item cache of information
16287 about a nested archive (when members of a thin archive reside within
16288 another regular archive file). */
16289 nested_arch
.file_name
= NULL
;
16290 nested_arch
.file
= NULL
;
16291 nested_arch
.index_array
= NULL
;
16292 nested_arch
.sym_table
= NULL
;
16293 nested_arch
.longnames
= NULL
;
16295 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16301 if (do_archive_index
)
16303 if (arch
.sym_table
== NULL
)
16304 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16307 unsigned long i
, l
;
16308 unsigned long current_pos
;
16310 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16311 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16312 current_pos
= ftell (file
);
16314 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16316 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16318 char * member_name
;
16320 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16322 if (member_name
!= NULL
)
16324 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16326 if (qualified_name
!= NULL
)
16328 printf (_("Contents of binary %s at offset "), qualified_name
);
16329 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16331 free (qualified_name
);
16336 if (l
>= arch
.sym_size
)
16338 error (_("%s: end of the symbol table reached before the end of the index\n"),
16342 /* PR 17531: file: 0b6630b2. */
16343 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16344 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16347 if (arch
.uses_64bit_indicies
)
16352 if (l
< arch
.sym_size
)
16353 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16354 file_name
, arch
.sym_size
- l
);
16356 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16358 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16364 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16365 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16366 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16367 && !do_section_groups
&& !do_dyn_syms
)
16369 ret
= 0; /* Archive index only. */
16380 char * qualified_name
;
16382 /* Read the next archive header. */
16383 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16385 error (_("%s: failed to seek to next archive header\n"), file_name
);
16388 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16389 if (got
!= sizeof arch
.arhdr
)
16393 error (_("%s: failed to read archive header\n"), file_name
);
16397 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16399 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16404 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16406 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16407 if (archive_file_size
& 01)
16408 ++archive_file_size
;
16410 name
= get_archive_member_name (&arch
, &nested_arch
);
16413 error (_("%s: bad archive file name\n"), file_name
);
16417 namelen
= strlen (name
);
16419 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16420 if (qualified_name
== NULL
)
16422 error (_("%s: bad archive file name\n"), file_name
);
16427 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16429 /* This is a proxy for an external member of a thin archive. */
16430 FILE * member_file
;
16431 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16432 if (member_file_name
== NULL
)
16438 member_file
= fopen (member_file_name
, "rb");
16439 if (member_file
== NULL
)
16441 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16442 free (member_file_name
);
16447 archive_file_offset
= arch
.nested_member_origin
;
16449 ret
|= process_object (qualified_name
, member_file
);
16451 fclose (member_file
);
16452 free (member_file_name
);
16454 else if (is_thin_archive
)
16456 /* PR 15140: Allow for corrupt thin archives. */
16457 if (nested_arch
.file
== NULL
)
16459 error (_("%s: contains corrupt thin archive: %s\n"),
16465 /* This is a proxy for a member of a nested archive. */
16466 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16468 /* The nested archive file will have been opened and setup by
16469 get_archive_member_name. */
16470 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16472 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16477 ret
|= process_object (qualified_name
, nested_arch
.file
);
16481 archive_file_offset
= arch
.next_arhdr_offset
;
16482 arch
.next_arhdr_offset
+= archive_file_size
;
16484 ret
|= process_object (qualified_name
, file
);
16487 if (dump_sects
!= NULL
)
16491 num_dump_sects
= 0;
16494 free (qualified_name
);
16498 if (nested_arch
.file
!= NULL
)
16499 fclose (nested_arch
.file
);
16500 release_archive (&nested_arch
);
16501 release_archive (&arch
);
16507 process_file (char * file_name
)
16510 struct stat statbuf
;
16511 char armag
[SARMAG
];
16514 if (stat (file_name
, &statbuf
) < 0)
16516 if (errno
== ENOENT
)
16517 error (_("'%s': No such file\n"), file_name
);
16519 error (_("Could not locate '%s'. System error message: %s\n"),
16520 file_name
, strerror (errno
));
16524 if (! S_ISREG (statbuf
.st_mode
))
16526 error (_("'%s' is not an ordinary file\n"), file_name
);
16530 file
= fopen (file_name
, "rb");
16533 error (_("Input file '%s' is not readable.\n"), file_name
);
16537 if (fread (armag
, SARMAG
, 1, file
) != 1)
16539 error (_("%s: Failed to read file's magic number\n"), file_name
);
16544 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16546 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16547 ret
= process_archive (file_name
, file
, FALSE
);
16548 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16549 ret
= process_archive (file_name
, file
, TRUE
);
16552 if (do_archive_index
)
16553 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16557 archive_file_size
= archive_file_offset
= 0;
16558 ret
= process_object (file_name
, file
);
16563 current_file_size
= 0;
16567 #ifdef SUPPORT_DISASSEMBLY
16568 /* Needed by the i386 disassembler. For extra credit, someone could
16569 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16573 print_address (unsigned int addr
, FILE * outfile
)
16575 fprintf (outfile
,"0x%8.8x", addr
);
16578 /* Needed by the i386 disassembler. */
16580 db_task_printsym (unsigned int addr
)
16582 print_address (addr
, stderr
);
16587 main (int argc
, char ** argv
)
16591 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16592 setlocale (LC_MESSAGES
, "");
16594 #if defined (HAVE_SETLOCALE)
16595 setlocale (LC_CTYPE
, "");
16597 bindtextdomain (PACKAGE
, LOCALEDIR
);
16598 textdomain (PACKAGE
);
16600 expandargv (&argc
, &argv
);
16602 parse_args (argc
, argv
);
16604 if (num_dump_sects
> 0)
16606 /* Make a copy of the dump_sects array. */
16607 cmdline_dump_sects
= (dump_type
*)
16608 malloc (num_dump_sects
* sizeof (* dump_sects
));
16609 if (cmdline_dump_sects
== NULL
)
16610 error (_("Out of memory allocating dump request table.\n"));
16613 memcpy (cmdline_dump_sects
, dump_sects
,
16614 num_dump_sects
* sizeof (* dump_sects
));
16615 num_cmdline_dump_sects
= num_dump_sects
;
16619 if (optind
< (argc
- 1))
16621 else if (optind
>= argc
)
16623 warn (_("Nothing to do.\n"));
16628 while (optind
< argc
)
16629 err
|= process_file (argv
[optind
++]);
16631 if (dump_sects
!= NULL
)
16633 if (cmdline_dump_sects
!= NULL
)
16634 free (cmdline_dump_sects
);