1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 typedef struct elf_section_list
169 Elf_Internal_Shdr
* hdr
;
170 struct elf_section_list
* next
;
173 char * program_name
= "readelf";
174 static unsigned long archive_file_offset
;
175 static unsigned long archive_file_size
;
176 static bfd_size_type current_file_size
;
177 static unsigned long dynamic_addr
;
178 static bfd_size_type dynamic_size
;
179 static size_t dynamic_nent
;
180 static char * dynamic_strings
;
181 static unsigned long dynamic_strings_length
;
182 static char * string_table
;
183 static unsigned long string_table_length
;
184 static unsigned long num_dynamic_syms
;
185 static Elf_Internal_Sym
* dynamic_symbols
;
186 static Elf_Internal_Syminfo
* dynamic_syminfo
;
187 static unsigned long dynamic_syminfo_offset
;
188 static unsigned int dynamic_syminfo_nent
;
189 static char program_interpreter
[PATH_MAX
];
190 static bfd_vma dynamic_info
[DT_ENCODING
];
191 static bfd_vma dynamic_info_DT_GNU_HASH
;
192 static bfd_vma version_info
[16];
193 static Elf_Internal_Ehdr elf_header
;
194 static Elf_Internal_Shdr
* section_headers
;
195 static Elf_Internal_Phdr
* program_headers
;
196 static Elf_Internal_Dyn
* dynamic_section
;
197 static elf_section_list
* symtab_shndx_list
;
198 static int show_name
;
199 static int do_dynamic
;
201 static int do_dyn_syms
;
203 static int do_sections
;
204 static int do_section_groups
;
205 static int do_section_details
;
206 static int do_segments
;
207 static int do_unwind
;
208 static int do_using_dynamic
;
209 static int do_header
;
211 static int do_version
;
212 static int do_histogram
;
213 static int do_debugging
;
216 static int do_archive_index
;
217 static int is_32bit_elf
;
218 static int decompress_dumps
;
222 struct group_list
* next
;
223 unsigned int section_index
;
228 struct group_list
* root
;
229 unsigned int group_index
;
232 static size_t group_count
;
233 static struct group
* section_groups
;
234 static struct group
** section_headers_groups
;
237 /* Flag bits indicating particular types of dump. */
238 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
239 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
242 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
244 typedef unsigned char dump_type
;
246 /* A linked list of the section names for which dumps were requested. */
247 struct dump_list_entry
251 struct dump_list_entry
* next
;
253 static struct dump_list_entry
* dump_sects_byname
;
255 /* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257 static dump_type
* cmdline_dump_sects
= NULL
;
258 static unsigned int num_cmdline_dump_sects
= 0;
260 /* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
265 static dump_type
* dump_sects
= NULL
;
266 static unsigned int num_dump_sects
= 0;
269 /* How to print a vma value. */
270 typedef enum print_mode
282 /* Versioned symbol info. */
283 enum versioned_symbol_info
290 static const char *get_symbol_version_string
291 (FILE *file
, int is_dynsym
, const char *strtab
,
292 unsigned long int strtab_size
, unsigned int si
,
293 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
294 unsigned short *vna_other
);
298 #define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
304 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306 #define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
310 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
315 #define REMOVE_ARCH_BITS(ADDR) \
318 if (elf_header.e_machine == EM_ARM) \
323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
328 and REASON is not NULL then emit an error message using REASON as part of the
332 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
333 bfd_size_type nmemb
, const char * reason
)
336 bfd_size_type amt
= size
* nmemb
;
338 if (size
== 0 || nmemb
== 0)
341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type
)
345 && ( (bfd_size_type
) ((size_t) size
) != size
346 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
349 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
350 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
354 /* Check for size overflow. */
358 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
359 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
363 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
364 attempting to allocate memory when the read is bound to fail. */
365 if (amt
> current_file_size
366 || offset
+ archive_file_offset
+ amt
> current_file_size
)
369 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
370 (unsigned long long) amt
, reason
);
374 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
377 error (_("Unable to seek to 0x%lx for %s\n"),
378 (unsigned long) archive_file_offset
+ offset
, reason
);
385 /* Check for overflow. */
386 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
387 /* + 1 so that we can '\0' terminate invalid string table sections. */
388 mvar
= malloc ((size_t) amt
+ 1);
393 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
394 (unsigned long long) amt
, reason
);
398 ((char *) mvar
)[amt
] = '\0';
401 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
404 error (_("Unable to read in 0x%llx bytes of %s\n"),
405 (unsigned long long) amt
, reason
);
414 /* Print a VMA value. */
417 print_vma (bfd_vma vma
, print_mode mode
)
430 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
437 return printf ("%5" BFD_VMA_FMT
"d", vma
);
445 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
448 return printf ("%" BFD_VMA_FMT
"d", vma
);
451 return printf ("%" BFD_VMA_FMT
"u", vma
);
456 /* Display a symbol on stdout. Handles the display of control characters and
457 multibye characters (assuming the host environment supports them).
459 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
461 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
462 padding as necessary.
464 Returns the number of emitted characters. */
467 print_symbol (int width
, const char *symbol
)
469 bfd_boolean extra_padding
= FALSE
;
471 #ifdef HAVE_MBSTATE_T
478 /* Keep the width positive. This also helps. */
480 extra_padding
= TRUE
;
485 /* Set the remaining width to a very large value.
486 This simplifies the code below. */
487 width_remaining
= INT_MAX
;
489 width_remaining
= width
;
491 #ifdef HAVE_MBSTATE_T
492 /* Initialise the multibyte conversion state. */
493 memset (& state
, 0, sizeof (state
));
496 while (width_remaining
)
499 const char c
= *symbol
++;
504 /* Do not print control characters directly as they can affect terminal
505 settings. Such characters usually appear in the names generated
506 by the assembler for local labels. */
509 if (width_remaining
< 2)
512 printf ("^%c", c
+ 0x40);
513 width_remaining
-= 2;
516 else if (ISPRINT (c
))
524 #ifdef HAVE_MBSTATE_T
527 /* Let printf do the hard work of displaying multibyte characters. */
528 printf ("%.1s", symbol
- 1);
532 #ifdef HAVE_MBSTATE_T
533 /* Try to find out how many bytes made up the character that was
534 just printed. Advance the symbol pointer past the bytes that
536 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
540 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
545 if (extra_padding
&& num_printed
< width
)
547 /* Fill in the remaining spaces. */
548 printf ("%-*s", width
- num_printed
, " ");
555 /* Returns a pointer to a static buffer containing a printable version of
556 the given section's name. Like print_symbol, except that it does not try
557 to print multibyte characters, it just interprets them as hex values. */
560 printable_section_name (const Elf_Internal_Shdr
* sec
)
562 #define MAX_PRINT_SEC_NAME_LEN 128
563 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
564 const char * name
= SECTION_NAME (sec
);
565 char * buf
= sec_name_buf
;
567 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
569 while ((c
= * name
++) != 0)
580 else if (ISPRINT (c
))
587 static char hex
[17] = "0123456789ABCDEF";
592 * buf
++ = hex
[(c
& 0xf0) >> 4];
593 * buf
++ = hex
[c
& 0x0f];
607 printable_section_name_from_index (unsigned long ndx
)
609 if (ndx
>= elf_header
.e_shnum
)
610 return _("<corrupt>");
612 return printable_section_name (section_headers
+ ndx
);
615 /* Return a pointer to section NAME, or NULL if no such section exists. */
617 static Elf_Internal_Shdr
*
618 find_section (const char * name
)
622 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
623 if (streq (SECTION_NAME (section_headers
+ i
), name
))
624 return section_headers
+ i
;
629 /* Return a pointer to a section containing ADDR, or NULL if no such
632 static Elf_Internal_Shdr
*
633 find_section_by_address (bfd_vma addr
)
637 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
639 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
640 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
647 static Elf_Internal_Shdr
*
648 find_section_by_type (unsigned int type
)
652 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
654 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
655 if (sec
->sh_type
== type
)
662 /* Return a pointer to section NAME, or NULL if no such section exists,
663 restricted to the list of sections given in SET. */
665 static Elf_Internal_Shdr
*
666 find_section_in_set (const char * name
, unsigned int * set
)
672 while ((i
= *set
++) > 0)
673 if (streq (SECTION_NAME (section_headers
+ i
), name
))
674 return section_headers
+ i
;
677 return find_section (name
);
680 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
683 static inline unsigned long
684 read_uleb128 (unsigned char *data
,
685 unsigned int *length_return
,
686 const unsigned char * const end
)
688 return read_leb128 (data
, length_return
, FALSE
, end
);
691 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
692 This OS has so many departures from the ELF standard that we test it at
698 return elf_header
.e_machine
== EM_IA_64
699 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
702 /* Guess the relocation size commonly used by the specific machines. */
705 guess_is_rela (unsigned int e_machine
)
709 /* Targets that use REL relocations. */
724 /* Targets that use RELA relocations. */
728 case EM_ADAPTEVA_EPIPHANY
:
730 case EM_ALTERA_NIOS2
:
733 case EM_ARC_COMPACT2
:
753 case EM_LATTICEMICO32
:
762 case EM_CYGNUS_MN10200
:
764 case EM_CYGNUS_MN10300
:
798 case EM_MICROBLAZE_OLD
:
819 warn (_("Don't know about relocations on this machine architecture\n"));
825 slurp_rela_relocs (FILE * file
,
826 unsigned long rel_offset
,
827 unsigned long rel_size
,
828 Elf_Internal_Rela
** relasp
,
829 unsigned long * nrelasp
)
831 Elf_Internal_Rela
* relas
;
837 Elf32_External_Rela
* erelas
;
839 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
840 rel_size
, _("32-bit relocation data"));
844 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
846 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
847 sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs\n"));
856 for (i
= 0; i
< nrelas
; i
++)
858 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
859 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
860 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
867 Elf64_External_Rela
* erelas
;
869 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
870 rel_size
, _("64-bit relocation data"));
874 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
876 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
877 sizeof (Elf_Internal_Rela
));
882 error (_("out of memory parsing relocs\n"));
886 for (i
= 0; i
< nrelas
; i
++)
888 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
889 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
890 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
892 /* The #ifdef BFD64 below is to prevent a compile time
893 warning. We know that if we do not have a 64 bit data
894 type that we will never execute this code anyway. */
896 if (elf_header
.e_machine
== EM_MIPS
897 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
899 /* In little-endian objects, r_info isn't really a
900 64-bit little-endian value: it has a 32-bit
901 little-endian symbol index followed by four
902 individual byte fields. Reorder INFO
904 bfd_vma inf
= relas
[i
].r_info
;
905 inf
= (((inf
& 0xffffffff) << 32)
906 | ((inf
>> 56) & 0xff)
907 | ((inf
>> 40) & 0xff00)
908 | ((inf
>> 24) & 0xff0000)
909 | ((inf
>> 8) & 0xff000000));
910 relas
[i
].r_info
= inf
;
923 slurp_rel_relocs (FILE * file
,
924 unsigned long rel_offset
,
925 unsigned long rel_size
,
926 Elf_Internal_Rela
** relsp
,
927 unsigned long * nrelsp
)
929 Elf_Internal_Rela
* rels
;
935 Elf32_External_Rel
* erels
;
937 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
938 rel_size
, _("32-bit relocation data"));
942 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
944 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
949 error (_("out of memory parsing relocs\n"));
953 for (i
= 0; i
< nrels
; i
++)
955 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
956 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
957 rels
[i
].r_addend
= 0;
964 Elf64_External_Rel
* erels
;
966 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
967 rel_size
, _("64-bit relocation data"));
971 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
973 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
978 error (_("out of memory parsing relocs\n"));
982 for (i
= 0; i
< nrels
; i
++)
984 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
985 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
986 rels
[i
].r_addend
= 0;
988 /* The #ifdef BFD64 below is to prevent a compile time
989 warning. We know that if we do not have a 64 bit data
990 type that we will never execute this code anyway. */
992 if (elf_header
.e_machine
== EM_MIPS
993 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
995 /* In little-endian objects, r_info isn't really a
996 64-bit little-endian value: it has a 32-bit
997 little-endian symbol index followed by four
998 individual byte fields. Reorder INFO
1000 bfd_vma inf
= rels
[i
].r_info
;
1001 inf
= (((inf
& 0xffffffff) << 32)
1002 | ((inf
>> 56) & 0xff)
1003 | ((inf
>> 40) & 0xff00)
1004 | ((inf
>> 24) & 0xff0000)
1005 | ((inf
>> 8) & 0xff000000));
1006 rels
[i
].r_info
= inf
;
1018 /* Returns the reloc type extracted from the reloc info field. */
1021 get_reloc_type (bfd_vma reloc_info
)
1024 return ELF32_R_TYPE (reloc_info
);
1026 switch (elf_header
.e_machine
)
1029 /* Note: We assume that reloc_info has already been adjusted for us. */
1030 return ELF64_MIPS_R_TYPE (reloc_info
);
1033 return ELF64_R_TYPE_ID (reloc_info
);
1036 return ELF64_R_TYPE (reloc_info
);
1040 /* Return the symbol index extracted from the reloc info field. */
1043 get_reloc_symindex (bfd_vma reloc_info
)
1045 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1048 static inline bfd_boolean
1049 uses_msp430x_relocs (void)
1052 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1053 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1054 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1055 /* TI compiler uses ELFOSABI_NONE. */
1056 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1059 /* Display the contents of the relocation data found at the specified
1063 dump_relocations (FILE * file
,
1064 unsigned long rel_offset
,
1065 unsigned long rel_size
,
1066 Elf_Internal_Sym
* symtab
,
1067 unsigned long nsyms
,
1069 unsigned long strtablen
,
1074 Elf_Internal_Rela
* rels
;
1076 if (is_rela
== UNKNOWN
)
1077 is_rela
= guess_is_rela (elf_header
.e_machine
);
1081 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1086 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1095 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1097 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1102 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1104 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1112 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1114 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1119 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1121 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1125 for (i
= 0; i
< rel_size
; i
++)
1130 bfd_vma symtab_index
;
1133 offset
= rels
[i
].r_offset
;
1134 inf
= rels
[i
].r_info
;
1136 type
= get_reloc_type (inf
);
1137 symtab_index
= get_reloc_symindex (inf
);
1141 printf ("%8.8lx %8.8lx ",
1142 (unsigned long) offset
& 0xffffffff,
1143 (unsigned long) inf
& 0xffffffff);
1147 #if BFD_HOST_64BIT_LONG
1149 ? "%16.16lx %16.16lx "
1150 : "%12.12lx %12.12lx ",
1152 #elif BFD_HOST_64BIT_LONG_LONG
1155 ? "%16.16llx %16.16llx "
1156 : "%12.12llx %12.12llx ",
1160 ? "%16.16I64x %16.16I64x "
1161 : "%12.12I64x %12.12I64x ",
1166 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1167 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1168 _bfd_int64_high (offset
),
1169 _bfd_int64_low (offset
),
1170 _bfd_int64_high (inf
),
1171 _bfd_int64_low (inf
));
1175 switch (elf_header
.e_machine
)
1182 rtype
= elf_aarch64_reloc_type (type
);
1186 case EM_CYGNUS_M32R
:
1187 rtype
= elf_m32r_reloc_type (type
);
1192 rtype
= elf_i386_reloc_type (type
);
1197 rtype
= elf_m68hc11_reloc_type (type
);
1201 rtype
= elf_m68k_reloc_type (type
);
1205 rtype
= elf_i960_reloc_type (type
);
1210 rtype
= elf_avr_reloc_type (type
);
1213 case EM_OLD_SPARCV9
:
1214 case EM_SPARC32PLUS
:
1217 rtype
= elf_sparc_reloc_type (type
);
1221 rtype
= elf_spu_reloc_type (type
);
1225 rtype
= v800_reloc_type (type
);
1228 case EM_CYGNUS_V850
:
1229 rtype
= v850_reloc_type (type
);
1233 case EM_CYGNUS_D10V
:
1234 rtype
= elf_d10v_reloc_type (type
);
1238 case EM_CYGNUS_D30V
:
1239 rtype
= elf_d30v_reloc_type (type
);
1243 rtype
= elf_dlx_reloc_type (type
);
1247 rtype
= elf_sh_reloc_type (type
);
1251 case EM_CYGNUS_MN10300
:
1252 rtype
= elf_mn10300_reloc_type (type
);
1256 case EM_CYGNUS_MN10200
:
1257 rtype
= elf_mn10200_reloc_type (type
);
1261 case EM_CYGNUS_FR30
:
1262 rtype
= elf_fr30_reloc_type (type
);
1266 rtype
= elf_frv_reloc_type (type
);
1270 rtype
= elf_ft32_reloc_type (type
);
1274 rtype
= elf_mcore_reloc_type (type
);
1278 rtype
= elf_mmix_reloc_type (type
);
1282 rtype
= elf_moxie_reloc_type (type
);
1286 if (uses_msp430x_relocs ())
1288 rtype
= elf_msp430x_reloc_type (type
);
1292 rtype
= elf_msp430_reloc_type (type
);
1296 rtype
= elf_nds32_reloc_type (type
);
1300 rtype
= elf_ppc_reloc_type (type
);
1304 rtype
= elf_ppc64_reloc_type (type
);
1308 case EM_MIPS_RS3_LE
:
1309 rtype
= elf_mips_reloc_type (type
);
1313 rtype
= elf_alpha_reloc_type (type
);
1317 rtype
= elf_arm_reloc_type (type
);
1321 case EM_ARC_COMPACT
:
1322 case EM_ARC_COMPACT2
:
1323 rtype
= elf_arc_reloc_type (type
);
1327 rtype
= elf_hppa_reloc_type (type
);
1333 rtype
= elf_h8_reloc_type (type
);
1337 rtype
= elf_or1k_reloc_type (type
);
1342 rtype
= elf_pj_reloc_type (type
);
1345 rtype
= elf_ia64_reloc_type (type
);
1349 rtype
= elf_cris_reloc_type (type
);
1353 rtype
= elf_i860_reloc_type (type
);
1359 rtype
= elf_x86_64_reloc_type (type
);
1363 rtype
= i370_reloc_type (type
);
1368 rtype
= elf_s390_reloc_type (type
);
1372 rtype
= elf_score_reloc_type (type
);
1376 rtype
= elf_xstormy16_reloc_type (type
);
1380 rtype
= elf_crx_reloc_type (type
);
1384 rtype
= elf_vax_reloc_type (type
);
1388 rtype
= elf_visium_reloc_type (type
);
1391 case EM_ADAPTEVA_EPIPHANY
:
1392 rtype
= elf_epiphany_reloc_type (type
);
1397 rtype
= elf_ip2k_reloc_type (type
);
1401 rtype
= elf_iq2000_reloc_type (type
);
1406 rtype
= elf_xtensa_reloc_type (type
);
1409 case EM_LATTICEMICO32
:
1410 rtype
= elf_lm32_reloc_type (type
);
1415 rtype
= elf_m32c_reloc_type (type
);
1419 rtype
= elf_mt_reloc_type (type
);
1423 rtype
= elf_bfin_reloc_type (type
);
1427 rtype
= elf_mep_reloc_type (type
);
1431 rtype
= elf_cr16_reloc_type (type
);
1435 case EM_MICROBLAZE_OLD
:
1436 rtype
= elf_microblaze_reloc_type (type
);
1440 rtype
= elf_rl78_reloc_type (type
);
1444 rtype
= elf_rx_reloc_type (type
);
1448 rtype
= elf_metag_reloc_type (type
);
1453 rtype
= elf_xc16x_reloc_type (type
);
1457 rtype
= elf_tic6x_reloc_type (type
);
1461 rtype
= elf_tilegx_reloc_type (type
);
1465 rtype
= elf_tilepro_reloc_type (type
);
1469 rtype
= elf_xgate_reloc_type (type
);
1472 case EM_ALTERA_NIOS2
:
1473 rtype
= elf_nios2_reloc_type (type
);
1478 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1480 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1482 if (elf_header
.e_machine
== EM_ALPHA
1484 && streq (rtype
, "R_ALPHA_LITUSE")
1487 switch (rels
[i
].r_addend
)
1489 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1490 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1491 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1492 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1493 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1494 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1495 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1496 default: rtype
= NULL
;
1499 printf (" (%s)", rtype
);
1503 printf (_("<unknown addend: %lx>"),
1504 (unsigned long) rels
[i
].r_addend
);
1507 else if (symtab_index
)
1509 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1510 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1513 Elf_Internal_Sym
* psym
;
1514 const char * version_string
;
1515 enum versioned_symbol_info sym_info
;
1516 unsigned short vna_other
;
1518 psym
= symtab
+ symtab_index
;
1521 = get_symbol_version_string (file
, is_dynsym
,
1530 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1534 unsigned int width
= is_32bit_elf
? 8 : 14;
1536 /* Relocations against GNU_IFUNC symbols do not use the value
1537 of the symbol as the address to relocate against. Instead
1538 they invoke the function named by the symbol and use its
1539 result as the address for relocation.
1541 To indicate this to the user, do not display the value of
1542 the symbol in the "Symbols's Value" field. Instead show
1543 its name followed by () as a hint that the symbol is
1547 || psym
->st_name
== 0
1548 || psym
->st_name
>= strtablen
)
1551 name
= strtab
+ psym
->st_name
;
1553 len
= print_symbol (width
, name
);
1555 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1557 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1561 print_vma (psym
->st_value
, LONG_HEX
);
1563 printf (is_32bit_elf
? " " : " ");
1566 if (psym
->st_name
== 0)
1568 const char * sec_name
= "<null>";
1571 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1573 if (psym
->st_shndx
< elf_header
.e_shnum
)
1574 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1575 else if (psym
->st_shndx
== SHN_ABS
)
1577 else if (psym
->st_shndx
== SHN_COMMON
)
1578 sec_name
= "COMMON";
1579 else if ((elf_header
.e_machine
== EM_MIPS
1580 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1581 || (elf_header
.e_machine
== EM_TI_C6000
1582 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1583 sec_name
= "SCOMMON";
1584 else if (elf_header
.e_machine
== EM_MIPS
1585 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1586 sec_name
= "SUNDEF";
1587 else if ((elf_header
.e_machine
== EM_X86_64
1588 || elf_header
.e_machine
== EM_L1OM
1589 || elf_header
.e_machine
== EM_K1OM
)
1590 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1591 sec_name
= "LARGE_COMMON";
1592 else if (elf_header
.e_machine
== EM_IA_64
1593 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1594 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1595 sec_name
= "ANSI_COM";
1596 else if (is_ia64_vms ()
1597 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1598 sec_name
= "VMS_SYMVEC";
1601 sprintf (name_buf
, "<section 0x%x>",
1602 (unsigned int) psym
->st_shndx
);
1603 sec_name
= name_buf
;
1606 print_symbol (22, sec_name
);
1608 else if (strtab
== NULL
)
1609 printf (_("<string table index: %3ld>"), psym
->st_name
);
1610 else if (psym
->st_name
>= strtablen
)
1611 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1614 print_symbol (22, strtab
+ psym
->st_name
);
1616 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1622 bfd_vma off
= rels
[i
].r_addend
;
1624 if ((bfd_signed_vma
) off
< 0)
1625 printf (" - %" BFD_VMA_FMT
"x", - off
);
1627 printf (" + %" BFD_VMA_FMT
"x", off
);
1633 bfd_vma off
= rels
[i
].r_addend
;
1635 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1636 if ((bfd_signed_vma
) off
< 0)
1637 printf ("-%" BFD_VMA_FMT
"x", - off
);
1639 printf ("%" BFD_VMA_FMT
"x", off
);
1642 if (elf_header
.e_machine
== EM_SPARCV9
1644 && streq (rtype
, "R_SPARC_OLO10"))
1645 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1650 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1652 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1653 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1654 const char * rtype2
= elf_mips_reloc_type (type2
);
1655 const char * rtype3
= elf_mips_reloc_type (type3
);
1657 printf (" Type2: ");
1660 printf (_("unrecognized: %-7lx"),
1661 (unsigned long) type2
& 0xffffffff);
1663 printf ("%-17.17s", rtype2
);
1665 printf ("\n Type3: ");
1668 printf (_("unrecognized: %-7lx"),
1669 (unsigned long) type3
& 0xffffffff);
1671 printf ("%-17.17s", rtype3
);
1682 get_mips_dynamic_type (unsigned long type
)
1686 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1687 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1688 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1689 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1690 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1691 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1692 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1693 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1694 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1695 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1696 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1697 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1698 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1699 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1700 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1701 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1702 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1703 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1704 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1705 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1706 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1707 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1708 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1709 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1710 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1711 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1712 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1713 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1714 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1715 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1716 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1717 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1718 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1719 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1720 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1721 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1722 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1723 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1724 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1725 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1727 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1728 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1729 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1730 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1731 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1738 get_sparc64_dynamic_type (unsigned long type
)
1742 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1749 get_ppc_dynamic_type (unsigned long type
)
1753 case DT_PPC_GOT
: return "PPC_GOT";
1754 case DT_PPC_OPT
: return "PPC_OPT";
1761 get_ppc64_dynamic_type (unsigned long type
)
1765 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1766 case DT_PPC64_OPD
: return "PPC64_OPD";
1767 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1768 case DT_PPC64_OPT
: return "PPC64_OPT";
1775 get_parisc_dynamic_type (unsigned long type
)
1779 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1780 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1781 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1782 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1783 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1784 case DT_HP_PREINIT
: return "HP_PREINIT";
1785 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1786 case DT_HP_NEEDED
: return "HP_NEEDED";
1787 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1788 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1789 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1790 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1791 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1792 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1793 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1794 case DT_HP_FILTERED
: return "HP_FILTERED";
1795 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1796 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1797 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1798 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1799 case DT_PLT
: return "PLT";
1800 case DT_PLT_SIZE
: return "PLT_SIZE";
1801 case DT_DLT
: return "DLT";
1802 case DT_DLT_SIZE
: return "DLT_SIZE";
1809 get_ia64_dynamic_type (unsigned long type
)
1813 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1814 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1815 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1816 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1817 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1818 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1819 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1820 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1821 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1822 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1823 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1824 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1825 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1826 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1827 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1828 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1829 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1830 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1831 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1832 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1833 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1834 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1835 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1836 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1837 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1838 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1839 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1840 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1841 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1842 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1843 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1850 get_alpha_dynamic_type (unsigned long type
)
1854 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1861 get_score_dynamic_type (unsigned long type
)
1865 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1866 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1867 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1868 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1869 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1870 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1877 get_tic6x_dynamic_type (unsigned long type
)
1881 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1882 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1883 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1884 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1885 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1886 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1893 get_nios2_dynamic_type (unsigned long type
)
1897 case DT_NIOS2_GP
: return "NIOS2_GP";
1904 get_dynamic_type (unsigned long type
)
1906 static char buff
[64];
1910 case DT_NULL
: return "NULL";
1911 case DT_NEEDED
: return "NEEDED";
1912 case DT_PLTRELSZ
: return "PLTRELSZ";
1913 case DT_PLTGOT
: return "PLTGOT";
1914 case DT_HASH
: return "HASH";
1915 case DT_STRTAB
: return "STRTAB";
1916 case DT_SYMTAB
: return "SYMTAB";
1917 case DT_RELA
: return "RELA";
1918 case DT_RELASZ
: return "RELASZ";
1919 case DT_RELAENT
: return "RELAENT";
1920 case DT_STRSZ
: return "STRSZ";
1921 case DT_SYMENT
: return "SYMENT";
1922 case DT_INIT
: return "INIT";
1923 case DT_FINI
: return "FINI";
1924 case DT_SONAME
: return "SONAME";
1925 case DT_RPATH
: return "RPATH";
1926 case DT_SYMBOLIC
: return "SYMBOLIC";
1927 case DT_REL
: return "REL";
1928 case DT_RELSZ
: return "RELSZ";
1929 case DT_RELENT
: return "RELENT";
1930 case DT_PLTREL
: return "PLTREL";
1931 case DT_DEBUG
: return "DEBUG";
1932 case DT_TEXTREL
: return "TEXTREL";
1933 case DT_JMPREL
: return "JMPREL";
1934 case DT_BIND_NOW
: return "BIND_NOW";
1935 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1936 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1937 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1938 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1939 case DT_RUNPATH
: return "RUNPATH";
1940 case DT_FLAGS
: return "FLAGS";
1942 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1943 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1945 case DT_CHECKSUM
: return "CHECKSUM";
1946 case DT_PLTPADSZ
: return "PLTPADSZ";
1947 case DT_MOVEENT
: return "MOVEENT";
1948 case DT_MOVESZ
: return "MOVESZ";
1949 case DT_FEATURE
: return "FEATURE";
1950 case DT_POSFLAG_1
: return "POSFLAG_1";
1951 case DT_SYMINSZ
: return "SYMINSZ";
1952 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1954 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1955 case DT_CONFIG
: return "CONFIG";
1956 case DT_DEPAUDIT
: return "DEPAUDIT";
1957 case DT_AUDIT
: return "AUDIT";
1958 case DT_PLTPAD
: return "PLTPAD";
1959 case DT_MOVETAB
: return "MOVETAB";
1960 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1962 case DT_VERSYM
: return "VERSYM";
1964 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1965 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1966 case DT_RELACOUNT
: return "RELACOUNT";
1967 case DT_RELCOUNT
: return "RELCOUNT";
1968 case DT_FLAGS_1
: return "FLAGS_1";
1969 case DT_VERDEF
: return "VERDEF";
1970 case DT_VERDEFNUM
: return "VERDEFNUM";
1971 case DT_VERNEED
: return "VERNEED";
1972 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1974 case DT_AUXILIARY
: return "AUXILIARY";
1975 case DT_USED
: return "USED";
1976 case DT_FILTER
: return "FILTER";
1978 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1979 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1980 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1981 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1982 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1983 case DT_GNU_HASH
: return "GNU_HASH";
1986 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1988 const char * result
;
1990 switch (elf_header
.e_machine
)
1993 case EM_MIPS_RS3_LE
:
1994 result
= get_mips_dynamic_type (type
);
1997 result
= get_sparc64_dynamic_type (type
);
2000 result
= get_ppc_dynamic_type (type
);
2003 result
= get_ppc64_dynamic_type (type
);
2006 result
= get_ia64_dynamic_type (type
);
2009 result
= get_alpha_dynamic_type (type
);
2012 result
= get_score_dynamic_type (type
);
2015 result
= get_tic6x_dynamic_type (type
);
2017 case EM_ALTERA_NIOS2
:
2018 result
= get_nios2_dynamic_type (type
);
2028 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2030 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2031 || (elf_header
.e_machine
== EM_PARISC
2032 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2034 const char * result
;
2036 switch (elf_header
.e_machine
)
2039 result
= get_parisc_dynamic_type (type
);
2042 result
= get_ia64_dynamic_type (type
);
2052 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2056 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2063 get_file_type (unsigned e_type
)
2065 static char buff
[32];
2069 case ET_NONE
: return _("NONE (None)");
2070 case ET_REL
: return _("REL (Relocatable file)");
2071 case ET_EXEC
: return _("EXEC (Executable file)");
2072 case ET_DYN
: return _("DYN (Shared object file)");
2073 case ET_CORE
: return _("CORE (Core file)");
2076 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2077 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2078 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2079 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2081 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2087 get_machine_name (unsigned e_machine
)
2089 static char buff
[64]; /* XXX */
2093 case EM_NONE
: return _("None");
2094 case EM_AARCH64
: return "AArch64";
2095 case EM_M32
: return "WE32100";
2096 case EM_SPARC
: return "Sparc";
2097 case EM_SPU
: return "SPU";
2098 case EM_386
: return "Intel 80386";
2099 case EM_68K
: return "MC68000";
2100 case EM_88K
: return "MC88000";
2101 case EM_IAMCU
: return "Intel MCU";
2102 case EM_860
: return "Intel 80860";
2103 case EM_MIPS
: return "MIPS R3000";
2104 case EM_S370
: return "IBM System/370";
2105 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2106 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2107 case EM_PARISC
: return "HPPA";
2108 case EM_PPC_OLD
: return "Power PC (old)";
2109 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2110 case EM_960
: return "Intel 90860";
2111 case EM_PPC
: return "PowerPC";
2112 case EM_PPC64
: return "PowerPC64";
2113 case EM_FR20
: return "Fujitsu FR20";
2114 case EM_FT32
: return "FTDI FT32";
2115 case EM_RH32
: return "TRW RH32";
2116 case EM_MCORE
: return "MCORE";
2117 case EM_ARM
: return "ARM";
2118 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2119 case EM_SH
: return "Renesas / SuperH SH";
2120 case EM_SPARCV9
: return "Sparc v9";
2121 case EM_TRICORE
: return "Siemens Tricore";
2122 case EM_ARC
: return "ARC";
2123 case EM_ARC_COMPACT
: return "ARCompact";
2124 case EM_ARC_COMPACT2
: return "ARCv2";
2125 case EM_H8_300
: return "Renesas H8/300";
2126 case EM_H8_300H
: return "Renesas H8/300H";
2127 case EM_H8S
: return "Renesas H8S";
2128 case EM_H8_500
: return "Renesas H8/500";
2129 case EM_IA_64
: return "Intel IA-64";
2130 case EM_MIPS_X
: return "Stanford MIPS-X";
2131 case EM_COLDFIRE
: return "Motorola Coldfire";
2132 case EM_ALPHA
: return "Alpha";
2133 case EM_CYGNUS_D10V
:
2134 case EM_D10V
: return "d10v";
2135 case EM_CYGNUS_D30V
:
2136 case EM_D30V
: return "d30v";
2137 case EM_CYGNUS_M32R
:
2138 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2139 case EM_CYGNUS_V850
:
2140 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2141 case EM_V850
: return "Renesas V850";
2142 case EM_CYGNUS_MN10300
:
2143 case EM_MN10300
: return "mn10300";
2144 case EM_CYGNUS_MN10200
:
2145 case EM_MN10200
: return "mn10200";
2146 case EM_MOXIE
: return "Moxie";
2147 case EM_CYGNUS_FR30
:
2148 case EM_FR30
: return "Fujitsu FR30";
2149 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2151 case EM_PJ
: return "picoJava";
2152 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2153 case EM_PCP
: return "Siemens PCP";
2154 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2155 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2156 case EM_STARCORE
: return "Motorola Star*Core processor";
2157 case EM_ME16
: return "Toyota ME16 processor";
2158 case EM_ST100
: return "STMicroelectronics ST100 processor";
2159 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2160 case EM_PDSP
: return "Sony DSP processor";
2161 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2162 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2163 case EM_FX66
: return "Siemens FX66 microcontroller";
2164 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2166 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2167 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2168 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2169 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2170 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2171 case EM_SVX
: return "Silicon Graphics SVx";
2172 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2173 case EM_VAX
: return "Digital VAX";
2174 case EM_VISIUM
: return "CDS VISIUMcore processor";
2176 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2177 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2178 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2179 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2180 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2181 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2182 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2183 case EM_PRISM
: return "Vitesse Prism";
2184 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2185 case EM_L1OM
: return "Intel L1OM";
2186 case EM_K1OM
: return "Intel K1OM";
2188 case EM_S390
: return "IBM S/390";
2189 case EM_SCORE
: return "SUNPLUS S+Core";
2190 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2191 case EM_OR1K
: return "OpenRISC 1000";
2192 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2193 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2194 case EM_DLX
: return "OpenDLX";
2196 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2197 case EM_IQ2000
: return "Vitesse IQ2000";
2199 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2200 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2201 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2202 case EM_NS32K
: return "National Semiconductor 32000 series";
2203 case EM_TPC
: return "Tenor Network TPC processor";
2204 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2205 case EM_MAX
: return "MAX Processor";
2206 case EM_CR
: return "National Semiconductor CompactRISC";
2207 case EM_F2MC16
: return "Fujitsu F2MC16";
2208 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2209 case EM_LATTICEMICO32
: return "Lattice Mico32";
2211 case EM_M32C
: return "Renesas M32c";
2212 case EM_MT
: return "Morpho Techologies MT processor";
2213 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2214 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2215 case EM_SEP
: return "Sharp embedded microprocessor";
2216 case EM_ARCA
: return "Arca RISC microprocessor";
2217 case EM_UNICORE
: return "Unicore";
2218 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2219 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2220 case EM_NIOS32
: return "Altera Nios";
2221 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2223 case EM_XC16X
: return "Infineon Technologies xc16x";
2224 case EM_M16C
: return "Renesas M16C series microprocessors";
2225 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2226 case EM_CE
: return "Freescale Communication Engine RISC core";
2227 case EM_TSK3000
: return "Altium TSK3000 core";
2228 case EM_RS08
: return "Freescale RS08 embedded processor";
2229 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2230 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2231 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2232 case EM_SE_C17
: return "Seiko Epson C17 family";
2233 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2234 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2235 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2236 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2238 case EM_R32C
: return "Renesas R32C series microprocessors";
2239 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2240 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2241 case EM_8051
: return "Intel 8051 and variants";
2242 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2243 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2244 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2245 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2247 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2248 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2249 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2252 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2253 case EM_RL78
: return "Renesas RL78";
2254 case EM_RX
: return "Renesas RX";
2255 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2256 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2257 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2258 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2259 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2260 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2261 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2262 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2263 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2264 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2265 case EM_CUDA
: return "NVIDIA CUDA architecture";
2266 case EM_XGATE
: return "Motorola XGATE embedded processor";
2268 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2274 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2279 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2280 e_flags
&= ~ EF_ARM_EABIMASK
;
2282 /* Handle "generic" ARM flags. */
2283 if (e_flags
& EF_ARM_RELEXEC
)
2285 strcat (buf
, ", relocatable executable");
2286 e_flags
&= ~ EF_ARM_RELEXEC
;
2289 /* Now handle EABI specific flags. */
2293 strcat (buf
, ", <unrecognized EABI>");
2298 case EF_ARM_EABI_VER1
:
2299 strcat (buf
, ", Version1 EABI");
2304 /* Process flags one bit at a time. */
2305 flag
= e_flags
& - e_flags
;
2310 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2311 strcat (buf
, ", sorted symbol tables");
2321 case EF_ARM_EABI_VER2
:
2322 strcat (buf
, ", Version2 EABI");
2327 /* Process flags one bit at a time. */
2328 flag
= e_flags
& - e_flags
;
2333 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf
, ", sorted symbol tables");
2337 case EF_ARM_DYNSYMSUSESEGIDX
:
2338 strcat (buf
, ", dynamic symbols use segment index");
2341 case EF_ARM_MAPSYMSFIRST
:
2342 strcat (buf
, ", mapping symbols precede others");
2352 case EF_ARM_EABI_VER3
:
2353 strcat (buf
, ", Version3 EABI");
2356 case EF_ARM_EABI_VER4
:
2357 strcat (buf
, ", Version4 EABI");
2362 /* Process flags one bit at a time. */
2363 flag
= e_flags
& - e_flags
;
2369 strcat (buf
, ", BE8");
2373 strcat (buf
, ", LE8");
2384 case EF_ARM_EABI_VER5
:
2385 strcat (buf
, ", Version5 EABI");
2390 /* Process flags one bit at a time. */
2391 flag
= e_flags
& - e_flags
;
2397 strcat (buf
, ", BE8");
2401 strcat (buf
, ", LE8");
2404 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf
, ", soft-float ABI");
2408 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf
, ", hard-float ABI");
2419 case EF_ARM_EABI_UNKNOWN
:
2420 strcat (buf
, ", GNU EABI");
2425 /* Process flags one bit at a time. */
2426 flag
= e_flags
& - e_flags
;
2431 case EF_ARM_INTERWORK
:
2432 strcat (buf
, ", interworking enabled");
2435 case EF_ARM_APCS_26
:
2436 strcat (buf
, ", uses APCS/26");
2439 case EF_ARM_APCS_FLOAT
:
2440 strcat (buf
, ", uses APCS/float");
2444 strcat (buf
, ", position independent");
2448 strcat (buf
, ", 8 bit structure alignment");
2451 case EF_ARM_NEW_ABI
:
2452 strcat (buf
, ", uses new ABI");
2455 case EF_ARM_OLD_ABI
:
2456 strcat (buf
, ", uses old ABI");
2459 case EF_ARM_SOFT_FLOAT
:
2460 strcat (buf
, ", software FP");
2463 case EF_ARM_VFP_FLOAT
:
2464 strcat (buf
, ", VFP");
2467 case EF_ARM_MAVERICK_FLOAT
:
2468 strcat (buf
, ", Maverick FP");
2479 strcat (buf
,_(", <unknown>"));
2483 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2485 --size
; /* Leave space for null terminator. */
2487 switch (e_flags
& EF_AVR_MACH
)
2489 case E_AVR_MACH_AVR1
:
2490 strncat (buf
, ", avr:1", size
);
2492 case E_AVR_MACH_AVR2
:
2493 strncat (buf
, ", avr:2", size
);
2495 case E_AVR_MACH_AVR25
:
2496 strncat (buf
, ", avr:25", size
);
2498 case E_AVR_MACH_AVR3
:
2499 strncat (buf
, ", avr:3", size
);
2501 case E_AVR_MACH_AVR31
:
2502 strncat (buf
, ", avr:31", size
);
2504 case E_AVR_MACH_AVR35
:
2505 strncat (buf
, ", avr:35", size
);
2507 case E_AVR_MACH_AVR4
:
2508 strncat (buf
, ", avr:4", size
);
2510 case E_AVR_MACH_AVR5
:
2511 strncat (buf
, ", avr:5", size
);
2513 case E_AVR_MACH_AVR51
:
2514 strncat (buf
, ", avr:51", size
);
2516 case E_AVR_MACH_AVR6
:
2517 strncat (buf
, ", avr:6", size
);
2519 case E_AVR_MACH_AVRTINY
:
2520 strncat (buf
, ", avr:100", size
);
2522 case E_AVR_MACH_XMEGA1
:
2523 strncat (buf
, ", avr:101", size
);
2525 case E_AVR_MACH_XMEGA2
:
2526 strncat (buf
, ", avr:102", size
);
2528 case E_AVR_MACH_XMEGA3
:
2529 strncat (buf
, ", avr:103", size
);
2531 case E_AVR_MACH_XMEGA4
:
2532 strncat (buf
, ", avr:104", size
);
2534 case E_AVR_MACH_XMEGA5
:
2535 strncat (buf
, ", avr:105", size
);
2537 case E_AVR_MACH_XMEGA6
:
2538 strncat (buf
, ", avr:106", size
);
2540 case E_AVR_MACH_XMEGA7
:
2541 strncat (buf
, ", avr:107", size
);
2544 strncat (buf
, ", avr:<unknown>", size
);
2548 size
-= strlen (buf
);
2549 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2550 strncat (buf
, ", link-relax", size
);
2554 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2563 static const char *ABI_STRINGS
[] =
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
2572 static const char *VER_STRINGS
[] =
2574 "Andes ELF V1.3 or older",
2578 static const char *ARCH_STRINGS
[] =
2587 abi
= EF_NDS_ABI
& e_flags
;
2588 arch
= EF_NDS_ARCH
& e_flags
;
2589 config
= EF_NDS_INST
& e_flags
;
2590 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2592 memset (buf
, 0, size
);
2599 case E_NDS_ABI_V2FP
:
2600 case E_NDS_ABI_AABI
:
2601 case E_NDS_ABI_V2FP_PLUS
:
2602 /* In case there are holes in the array. */
2603 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2607 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2613 case E_NDS32_ELF_VER_1_2
:
2614 case E_NDS32_ELF_VER_1_3
:
2615 case E_NDS32_ELF_VER_1_4
:
2616 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2620 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2624 if (E_NDS_ABI_V0
== abi
)
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2629 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2635 case E_NDS_ARCH_STAR_V1_0
:
2636 case E_NDS_ARCH_STAR_V2_0
:
2637 case E_NDS_ARCH_STAR_V3_0
:
2638 case E_NDS_ARCH_STAR_V3_M
:
2639 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2643 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2652 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2655 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2656 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2658 if (config
& E_NDS32_HAS_DIV_INST
)
2659 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2661 if (config
& E_NDS32_HAS_16BIT_INST
)
2662 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2666 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2668 if (version
<= E_NDS32_ELF_VER_1_3
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2671 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2674 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2677 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2678 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2680 if (config
& E_NDS32_HAS_16BIT_INST
)
2682 if (version
<= E_NDS32_ELF_VER_1_3
)
2683 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2685 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2689 if (config
& E_NDS32_HAS_EXT_INST
)
2690 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2692 if (config
& E_NDS32_HAS_EXT2_INST
)
2693 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2695 if (config
& E_NDS32_HAS_FPU_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2701 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2707 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2710 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2715 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2717 case E_NDS32_FPU_REG_8SP_4DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2720 case E_NDS32_FPU_REG_16SP_8DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2723 case E_NDS32_FPU_REG_32SP_16DP
:
2724 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2726 case E_NDS32_FPU_REG_32SP_32DP
:
2727 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2732 if (config
& E_NDS32_HAS_AUDIO_INST
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2735 if (config
& E_NDS32_HAS_STRING_INST
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2738 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2739 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2741 if (config
& E_NDS32_HAS_VIDEO_INST
)
2743 if (version
<= E_NDS32_ELF_VER_1_3
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2746 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2749 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2750 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2752 if (config
& E_NDS32_HAS_L2C_INST
)
2753 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2757 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2759 static char buf
[1024];
2770 case EM_ARC_COMPACT2
:
2771 switch (e_flags
& EF_ARC_MACH_MSK
)
2773 case EF_ARC_CPU_ARCV2EM
:
2774 strcat (buf
, ", ARC EM");
2776 case EF_ARC_CPU_ARCV2HS
:
2777 strcat (buf
, ", ARC HS");
2779 case EF_ARC_CPU_GENERIC
:
2780 strcat (buf
, ", ARC generic");
2782 case E_ARC_MACH_ARC600
:
2783 strcat (buf
, ", ARC600");
2785 case E_ARC_MACH_ARC601
:
2786 strcat (buf
, ", ARC601");
2788 case E_ARC_MACH_ARC700
:
2789 strcat (buf
, ", ARC700");
2792 strcat (buf
, ", unrecognized cpu flag for ARCv2");
2795 switch (e_flags
& EF_ARC_OSABI_MSK
)
2797 case E_ARC_OSABI_ORIG
:
2798 strcat (buf
, ", (ABI:legacy)");
2800 case E_ARC_OSABI_V2
:
2801 strcat (buf
, ", (ABI:v2)");
2803 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2804 case E_ARC_OSABI_V3
:
2805 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2808 strcat (buf
, ", unrecognised ARC OSABI flag");
2813 case EM_ARC_COMPACT
:
2814 switch (e_flags
& EF_ARC_MACH_MSK
)
2816 case E_ARC_MACH_ARC600
:
2817 strcat (buf
, ", ARC 600");
2819 case E_ARC_MACH_ARC601
:
2820 strcat (buf
, ", ARC 601");
2822 case E_ARC_MACH_ARC700
:
2823 strcat (buf
, ", ARC 700");
2826 strcat (buf
, ", Generic ARCompact");
2829 switch (e_flags
& EF_ARC_OSABI_MSK
)
2831 case E_ARC_OSABI_ORIG
:
2832 strcat (buf
, ", legacy syscall ABI");
2834 case E_ARC_OSABI_V2
:
2835 /* For 3.2+ Linux kernels which use asm-generic
2837 strcat (buf
, ", v2 syscall ABI");
2839 case E_ARC_OSABI_V3
:
2840 /* Upstream 3.9+ kernels which don't use any legacy
2842 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2848 decode_ARM_machine_flags (e_flags
, buf
);
2852 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2856 if (e_flags
& EF_BFIN_PIC
)
2857 strcat (buf
, ", PIC");
2859 if (e_flags
& EF_BFIN_FDPIC
)
2860 strcat (buf
, ", FDPIC");
2862 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2863 strcat (buf
, ", code in L1");
2865 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2866 strcat (buf
, ", data in L1");
2871 switch (e_flags
& EF_FRV_CPU_MASK
)
2873 case EF_FRV_CPU_GENERIC
:
2877 strcat (buf
, ", fr???");
2880 case EF_FRV_CPU_FR300
:
2881 strcat (buf
, ", fr300");
2884 case EF_FRV_CPU_FR400
:
2885 strcat (buf
, ", fr400");
2887 case EF_FRV_CPU_FR405
:
2888 strcat (buf
, ", fr405");
2891 case EF_FRV_CPU_FR450
:
2892 strcat (buf
, ", fr450");
2895 case EF_FRV_CPU_FR500
:
2896 strcat (buf
, ", fr500");
2898 case EF_FRV_CPU_FR550
:
2899 strcat (buf
, ", fr550");
2902 case EF_FRV_CPU_SIMPLE
:
2903 strcat (buf
, ", simple");
2905 case EF_FRV_CPU_TOMCAT
:
2906 strcat (buf
, ", tomcat");
2912 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2913 strcat (buf
, ", m68000");
2914 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2915 strcat (buf
, ", cpu32");
2916 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2917 strcat (buf
, ", fido_a");
2920 char const * isa
= _("unknown");
2921 char const * mac
= _("unknown mac");
2922 char const * additional
= NULL
;
2924 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2926 case EF_M68K_CF_ISA_A_NODIV
:
2928 additional
= ", nodiv";
2930 case EF_M68K_CF_ISA_A
:
2933 case EF_M68K_CF_ISA_A_PLUS
:
2936 case EF_M68K_CF_ISA_B_NOUSP
:
2938 additional
= ", nousp";
2940 case EF_M68K_CF_ISA_B
:
2943 case EF_M68K_CF_ISA_C
:
2946 case EF_M68K_CF_ISA_C_NODIV
:
2948 additional
= ", nodiv";
2951 strcat (buf
, ", cf, isa ");
2954 strcat (buf
, additional
);
2955 if (e_flags
& EF_M68K_CF_FLOAT
)
2956 strcat (buf
, ", float");
2957 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2962 case EF_M68K_CF_MAC
:
2965 case EF_M68K_CF_EMAC
:
2968 case EF_M68K_CF_EMAC_B
:
2981 switch (e_flags
& EF_MEP_CPU_MASK
)
2983 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2984 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2985 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2986 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2987 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2988 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2989 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2992 switch (e_flags
& EF_MEP_COP_MASK
)
2994 case EF_MEP_COP_NONE
: break;
2995 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2996 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2997 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
2998 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
2999 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3002 if (e_flags
& EF_MEP_LIBRARY
)
3003 strcat (buf
, ", Built for Library");
3005 if (e_flags
& EF_MEP_INDEX_MASK
)
3006 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3007 e_flags
& EF_MEP_INDEX_MASK
);
3009 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3010 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3011 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3015 if (e_flags
& EF_PPC_EMB
)
3016 strcat (buf
, ", emb");
3018 if (e_flags
& EF_PPC_RELOCATABLE
)
3019 strcat (buf
, _(", relocatable"));
3021 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3022 strcat (buf
, _(", relocatable-lib"));
3026 if (e_flags
& EF_PPC64_ABI
)
3028 char abi
[] = ", abiv0";
3030 abi
[6] += e_flags
& EF_PPC64_ABI
;
3036 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3037 strcat (buf
, ", RH850 ABI");
3039 if (e_flags
& EF_V800_850E3
)
3040 strcat (buf
, ", V3 architecture");
3042 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3043 strcat (buf
, ", FPU not used");
3045 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3046 strcat (buf
, ", regmode: COMMON");
3048 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3049 strcat (buf
, ", r4 not used");
3051 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3052 strcat (buf
, ", r30 not used");
3054 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3055 strcat (buf
, ", r5 not used");
3057 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3058 strcat (buf
, ", r2 not used");
3060 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3062 switch (e_flags
& - e_flags
)
3064 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3065 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3066 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3067 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3068 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3069 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3070 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3071 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3072 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3073 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3074 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3075 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3082 case EM_CYGNUS_V850
:
3083 switch (e_flags
& EF_V850_ARCH
)
3085 case E_V850E3V5_ARCH
:
3086 strcat (buf
, ", v850e3v5");
3088 case E_V850E2V3_ARCH
:
3089 strcat (buf
, ", v850e2v3");
3092 strcat (buf
, ", v850e2");
3095 strcat (buf
, ", v850e1");
3098 strcat (buf
, ", v850e");
3101 strcat (buf
, ", v850");
3104 strcat (buf
, _(", unknown v850 architecture variant"));
3110 case EM_CYGNUS_M32R
:
3111 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3112 strcat (buf
, ", m32r");
3116 case EM_MIPS_RS3_LE
:
3117 if (e_flags
& EF_MIPS_NOREORDER
)
3118 strcat (buf
, ", noreorder");
3120 if (e_flags
& EF_MIPS_PIC
)
3121 strcat (buf
, ", pic");
3123 if (e_flags
& EF_MIPS_CPIC
)
3124 strcat (buf
, ", cpic");
3126 if (e_flags
& EF_MIPS_UCODE
)
3127 strcat (buf
, ", ugen_reserved");
3129 if (e_flags
& EF_MIPS_ABI2
)
3130 strcat (buf
, ", abi2");
3132 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3133 strcat (buf
, ", odk first");
3135 if (e_flags
& EF_MIPS_32BITMODE
)
3136 strcat (buf
, ", 32bitmode");
3138 if (e_flags
& EF_MIPS_NAN2008
)
3139 strcat (buf
, ", nan2008");
3141 if (e_flags
& EF_MIPS_FP64
)
3142 strcat (buf
, ", fp64");
3144 switch ((e_flags
& EF_MIPS_MACH
))
3146 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3147 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3148 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3149 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3150 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3151 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3152 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3153 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3154 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3155 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3156 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3157 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3158 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3159 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3160 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3161 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3162 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3164 /* We simply ignore the field in this case to avoid confusion:
3165 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3168 default: strcat (buf
, _(", unknown CPU")); break;
3171 switch ((e_flags
& EF_MIPS_ABI
))
3173 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3174 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3175 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3176 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3178 /* We simply ignore the field in this case to avoid confusion:
3179 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3180 This means it is likely to be an o32 file, but not for
3183 default: strcat (buf
, _(", unknown ABI")); break;
3186 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3187 strcat (buf
, ", mdmx");
3189 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3190 strcat (buf
, ", mips16");
3192 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3193 strcat (buf
, ", micromips");
3195 switch ((e_flags
& EF_MIPS_ARCH
))
3197 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3198 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3199 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3200 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3201 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3202 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3203 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3204 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3205 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3206 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3207 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3208 default: strcat (buf
, _(", unknown ISA")); break;
3213 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3217 switch ((e_flags
& EF_SH_MACH_MASK
))
3219 case EF_SH1
: strcat (buf
, ", sh1"); break;
3220 case EF_SH2
: strcat (buf
, ", sh2"); break;
3221 case EF_SH3
: strcat (buf
, ", sh3"); break;
3222 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3223 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3224 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3225 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3226 case EF_SH4
: strcat (buf
, ", sh4"); break;
3227 case EF_SH5
: strcat (buf
, ", sh5"); break;
3228 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3229 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3230 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3231 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3232 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3233 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3234 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3235 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3236 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3237 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3238 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3239 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3240 default: strcat (buf
, _(", unknown ISA")); break;
3243 if (e_flags
& EF_SH_PIC
)
3244 strcat (buf
, ", pic");
3246 if (e_flags
& EF_SH_FDPIC
)
3247 strcat (buf
, ", fdpic");
3251 if (e_flags
& EF_OR1K_NODELAY
)
3252 strcat (buf
, ", no delay");
3256 if (e_flags
& EF_SPARC_32PLUS
)
3257 strcat (buf
, ", v8+");
3259 if (e_flags
& EF_SPARC_SUN_US1
)
3260 strcat (buf
, ", ultrasparcI");
3262 if (e_flags
& EF_SPARC_SUN_US3
)
3263 strcat (buf
, ", ultrasparcIII");
3265 if (e_flags
& EF_SPARC_HAL_R1
)
3266 strcat (buf
, ", halr1");
3268 if (e_flags
& EF_SPARC_LEDATA
)
3269 strcat (buf
, ", ledata");
3271 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3272 strcat (buf
, ", tso");
3274 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3275 strcat (buf
, ", pso");
3277 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3278 strcat (buf
, ", rmo");
3282 switch (e_flags
& EF_PARISC_ARCH
)
3284 case EFA_PARISC_1_0
:
3285 strcpy (buf
, ", PA-RISC 1.0");
3287 case EFA_PARISC_1_1
:
3288 strcpy (buf
, ", PA-RISC 1.1");
3290 case EFA_PARISC_2_0
:
3291 strcpy (buf
, ", PA-RISC 2.0");
3296 if (e_flags
& EF_PARISC_TRAPNIL
)
3297 strcat (buf
, ", trapnil");
3298 if (e_flags
& EF_PARISC_EXT
)
3299 strcat (buf
, ", ext");
3300 if (e_flags
& EF_PARISC_LSB
)
3301 strcat (buf
, ", lsb");
3302 if (e_flags
& EF_PARISC_WIDE
)
3303 strcat (buf
, ", wide");
3304 if (e_flags
& EF_PARISC_NO_KABP
)
3305 strcat (buf
, ", no kabp");
3306 if (e_flags
& EF_PARISC_LAZYSWAP
)
3307 strcat (buf
, ", lazyswap");
3312 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3313 strcat (buf
, ", new calling convention");
3315 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3316 strcat (buf
, ", gnu calling convention");
3320 if ((e_flags
& EF_IA_64_ABI64
))
3321 strcat (buf
, ", 64-bit");
3323 strcat (buf
, ", 32-bit");
3324 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3325 strcat (buf
, ", reduced fp model");
3326 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3327 strcat (buf
, ", no function descriptors, constant gp");
3328 else if ((e_flags
& EF_IA_64_CONS_GP
))
3329 strcat (buf
, ", constant gp");
3330 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3331 strcat (buf
, ", absolute");
3332 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3334 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3335 strcat (buf
, ", vms_linkages");
3336 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3338 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3340 case EF_IA_64_VMS_COMCOD_WARNING
:
3341 strcat (buf
, ", warning");
3343 case EF_IA_64_VMS_COMCOD_ERROR
:
3344 strcat (buf
, ", error");
3346 case EF_IA_64_VMS_COMCOD_ABORT
:
3347 strcat (buf
, ", abort");
3350 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3351 e_flags
& EF_IA_64_VMS_COMCOD
);
3352 strcat (buf
, ", <unknown>");
3358 if ((e_flags
& EF_VAX_NONPIC
))
3359 strcat (buf
, ", non-PIC");
3360 if ((e_flags
& EF_VAX_DFLOAT
))
3361 strcat (buf
, ", D-Float");
3362 if ((e_flags
& EF_VAX_GFLOAT
))
3363 strcat (buf
, ", G-Float");
3367 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3368 strcat (buf
, ", mcm");
3369 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3370 strcat (buf
, ", mcm24");
3371 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3372 strcat (buf
, ", gr6");
3376 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3378 case E_FLAG_RL78_ANY_CPU
: break;
3379 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3380 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3381 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3383 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3384 strcat (buf
, ", 64-bit doubles");
3388 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3389 strcat (buf
, ", 64-bit doubles");
3390 if (e_flags
& E_FLAG_RX_DSP
)
3391 strcat (buf
, ", dsp");
3392 if (e_flags
& E_FLAG_RX_PID
)
3393 strcat (buf
, ", pid");
3394 if (e_flags
& E_FLAG_RX_ABI
)
3395 strcat (buf
, ", RX ABI");
3396 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3397 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3398 ? ", uses String instructions" : ", bans String instructions");
3399 if (e_flags
& E_FLAG_RX_V2
)
3400 strcat (buf
, ", V2");
3404 if (e_flags
& EF_S390_HIGH_GPRS
)
3405 strcat (buf
, ", highgprs");
3409 if ((e_flags
& EF_C6000_REL
))
3410 strcat (buf
, ", relocatable module");
3414 strcat (buf
, _(": architecture variant: "));
3415 switch (e_flags
& EF_MSP430_MACH
)
3417 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3418 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3419 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3420 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3421 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3422 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3423 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3424 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3425 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3426 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3427 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3428 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3429 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3430 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3431 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3433 strcat (buf
, _(": unknown")); break;
3436 if (e_flags
& ~ EF_MSP430_MACH
)
3437 strcat (buf
, _(": unknown extra flag bits also present"));
3445 get_osabi_name (unsigned int osabi
)
3447 static char buff
[32];
3451 case ELFOSABI_NONE
: return "UNIX - System V";
3452 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3453 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3454 case ELFOSABI_GNU
: return "UNIX - GNU";
3455 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3456 case ELFOSABI_AIX
: return "UNIX - AIX";
3457 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3458 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3459 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3460 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3461 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3462 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3463 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3464 case ELFOSABI_AROS
: return "AROS";
3465 case ELFOSABI_FENIXOS
: return "FenixOS";
3468 switch (elf_header
.e_machine
)
3473 case ELFOSABI_ARM
: return "ARM";
3484 case ELFOSABI_STANDALONE
: return _("Standalone App");
3493 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3494 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3503 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3509 get_aarch64_segment_type (unsigned long type
)
3513 case PT_AARCH64_ARCHEXT
:
3514 return "AARCH64_ARCHEXT";
3523 get_arm_segment_type (unsigned long type
)
3537 get_mips_segment_type (unsigned long type
)
3541 case PT_MIPS_REGINFO
:
3543 case PT_MIPS_RTPROC
:
3545 case PT_MIPS_OPTIONS
:
3547 case PT_MIPS_ABIFLAGS
:
3557 get_parisc_segment_type (unsigned long type
)
3561 case PT_HP_TLS
: return "HP_TLS";
3562 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3563 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3564 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3565 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3566 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3567 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3568 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3569 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3570 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3571 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3572 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3573 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3574 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3575 case PT_HP_STACK
: return "HP_STACK";
3576 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3577 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3578 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3579 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3588 get_ia64_segment_type (unsigned long type
)
3592 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3593 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3594 case PT_HP_TLS
: return "HP_TLS";
3595 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3596 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3597 case PT_IA_64_HP_STACK
: return "HP_STACK";
3606 get_tic6x_segment_type (unsigned long type
)
3610 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3619 get_segment_type (unsigned long p_type
)
3621 static char buff
[32];
3625 case PT_NULL
: return "NULL";
3626 case PT_LOAD
: return "LOAD";
3627 case PT_DYNAMIC
: return "DYNAMIC";
3628 case PT_INTERP
: return "INTERP";
3629 case PT_NOTE
: return "NOTE";
3630 case PT_SHLIB
: return "SHLIB";
3631 case PT_PHDR
: return "PHDR";
3632 case PT_TLS
: return "TLS";
3634 case PT_GNU_EH_FRAME
:
3635 return "GNU_EH_FRAME";
3636 case PT_GNU_STACK
: return "GNU_STACK";
3637 case PT_GNU_RELRO
: return "GNU_RELRO";
3640 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3642 const char * result
;
3644 switch (elf_header
.e_machine
)
3647 result
= get_aarch64_segment_type (p_type
);
3650 result
= get_arm_segment_type (p_type
);
3653 case EM_MIPS_RS3_LE
:
3654 result
= get_mips_segment_type (p_type
);
3657 result
= get_parisc_segment_type (p_type
);
3660 result
= get_ia64_segment_type (p_type
);
3663 result
= get_tic6x_segment_type (p_type
);
3673 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3675 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3677 const char * result
;
3679 switch (elf_header
.e_machine
)
3682 result
= get_parisc_segment_type (p_type
);
3685 result
= get_ia64_segment_type (p_type
);
3695 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3698 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3705 get_mips_section_type_name (unsigned int sh_type
)
3709 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3710 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3711 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3712 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3713 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3714 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3715 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3716 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3717 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3718 case SHT_MIPS_RELD
: return "MIPS_RELD";
3719 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3720 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3721 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3722 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3723 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3724 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3725 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3726 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3727 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3728 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3729 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3730 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3731 case SHT_MIPS_LINE
: return "MIPS_LINE";
3732 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3733 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3734 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3735 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3736 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3737 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3738 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3739 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3740 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3741 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3742 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3743 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3744 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3745 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3746 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3747 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3748 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3756 get_parisc_section_type_name (unsigned int sh_type
)
3760 case SHT_PARISC_EXT
: return "PARISC_EXT";
3761 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3762 case SHT_PARISC_DOC
: return "PARISC_DOC";
3763 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3764 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3765 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3766 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3774 get_ia64_section_type_name (unsigned int sh_type
)
3776 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3777 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3778 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3782 case SHT_IA_64_EXT
: return "IA_64_EXT";
3783 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3784 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3785 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3786 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3787 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3788 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3789 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3790 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3791 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3799 get_x86_64_section_type_name (unsigned int sh_type
)
3803 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3811 get_aarch64_section_type_name (unsigned int sh_type
)
3815 case SHT_AARCH64_ATTRIBUTES
:
3816 return "AARCH64_ATTRIBUTES";
3824 get_arm_section_type_name (unsigned int sh_type
)
3828 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3829 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3830 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3831 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3832 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3840 get_tic6x_section_type_name (unsigned int sh_type
)
3844 case SHT_C6000_UNWIND
:
3845 return "C6000_UNWIND";
3846 case SHT_C6000_PREEMPTMAP
:
3847 return "C6000_PREEMPTMAP";
3848 case SHT_C6000_ATTRIBUTES
:
3849 return "C6000_ATTRIBUTES";
3854 case SHT_TI_HANDLER
:
3855 return "TI_HANDLER";
3856 case SHT_TI_INITINFO
:
3857 return "TI_INITINFO";
3858 case SHT_TI_PHATTRS
:
3859 return "TI_PHATTRS";
3867 get_msp430x_section_type_name (unsigned int sh_type
)
3871 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3872 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3873 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3874 default: return NULL
;
3879 get_v850_section_type_name (unsigned int sh_type
)
3883 case SHT_V850_SCOMMON
: return "V850 Small Common";
3884 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3885 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3886 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3887 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3888 default: return NULL
;
3893 get_section_type_name (unsigned int sh_type
)
3895 static char buff
[32];
3899 case SHT_NULL
: return "NULL";
3900 case SHT_PROGBITS
: return "PROGBITS";
3901 case SHT_SYMTAB
: return "SYMTAB";
3902 case SHT_STRTAB
: return "STRTAB";
3903 case SHT_RELA
: return "RELA";
3904 case SHT_HASH
: return "HASH";
3905 case SHT_DYNAMIC
: return "DYNAMIC";
3906 case SHT_NOTE
: return "NOTE";
3907 case SHT_NOBITS
: return "NOBITS";
3908 case SHT_REL
: return "REL";
3909 case SHT_SHLIB
: return "SHLIB";
3910 case SHT_DYNSYM
: return "DYNSYM";
3911 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3912 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3913 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3914 case SHT_GNU_HASH
: return "GNU_HASH";
3915 case SHT_GROUP
: return "GROUP";
3916 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3917 case SHT_GNU_verdef
: return "VERDEF";
3918 case SHT_GNU_verneed
: return "VERNEED";
3919 case SHT_GNU_versym
: return "VERSYM";
3920 case 0x6ffffff0: return "VERSYM";
3921 case 0x6ffffffc: return "VERDEF";
3922 case 0x7ffffffd: return "AUXILIARY";
3923 case 0x7fffffff: return "FILTER";
3924 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3927 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3929 const char * result
;
3931 switch (elf_header
.e_machine
)
3934 case EM_MIPS_RS3_LE
:
3935 result
= get_mips_section_type_name (sh_type
);
3938 result
= get_parisc_section_type_name (sh_type
);
3941 result
= get_ia64_section_type_name (sh_type
);
3946 result
= get_x86_64_section_type_name (sh_type
);
3949 result
= get_aarch64_section_type_name (sh_type
);
3952 result
= get_arm_section_type_name (sh_type
);
3955 result
= get_tic6x_section_type_name (sh_type
);
3958 result
= get_msp430x_section_type_name (sh_type
);
3962 case EM_CYGNUS_V850
:
3963 result
= get_v850_section_type_name (sh_type
);
3973 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3975 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3977 const char * result
;
3979 switch (elf_header
.e_machine
)
3982 result
= get_ia64_section_type_name (sh_type
);
3992 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3994 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3996 switch (elf_header
.e_machine
)
4000 case EM_CYGNUS_V850
:
4001 return get_v850_section_type_name (sh_type
);
4006 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
4009 /* This message is probably going to be displayed in a 15
4010 character wide field, so put the hex value first. */
4011 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4017 #define OPTION_DEBUG_DUMP 512
4018 #define OPTION_DYN_SYMS 513
4019 #define OPTION_DWARF_DEPTH 514
4020 #define OPTION_DWARF_START 515
4021 #define OPTION_DWARF_CHECK 516
4023 static struct option options
[] =
4025 {"all", no_argument
, 0, 'a'},
4026 {"file-header", no_argument
, 0, 'h'},
4027 {"program-headers", no_argument
, 0, 'l'},
4028 {"headers", no_argument
, 0, 'e'},
4029 {"histogram", no_argument
, 0, 'I'},
4030 {"segments", no_argument
, 0, 'l'},
4031 {"sections", no_argument
, 0, 'S'},
4032 {"section-headers", no_argument
, 0, 'S'},
4033 {"section-groups", no_argument
, 0, 'g'},
4034 {"section-details", no_argument
, 0, 't'},
4035 {"full-section-name",no_argument
, 0, 'N'},
4036 {"symbols", no_argument
, 0, 's'},
4037 {"syms", no_argument
, 0, 's'},
4038 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4039 {"relocs", no_argument
, 0, 'r'},
4040 {"notes", no_argument
, 0, 'n'},
4041 {"dynamic", no_argument
, 0, 'd'},
4042 {"arch-specific", no_argument
, 0, 'A'},
4043 {"version-info", no_argument
, 0, 'V'},
4044 {"use-dynamic", no_argument
, 0, 'D'},
4045 {"unwind", no_argument
, 0, 'u'},
4046 {"archive-index", no_argument
, 0, 'c'},
4047 {"hex-dump", required_argument
, 0, 'x'},
4048 {"relocated-dump", required_argument
, 0, 'R'},
4049 {"string-dump", required_argument
, 0, 'p'},
4050 {"decompress", no_argument
, 0, 'z'},
4051 #ifdef SUPPORT_DISASSEMBLY
4052 {"instruction-dump", required_argument
, 0, 'i'},
4054 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4056 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4057 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4058 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4060 {"version", no_argument
, 0, 'v'},
4061 {"wide", no_argument
, 0, 'W'},
4062 {"help", no_argument
, 0, 'H'},
4063 {0, no_argument
, 0, 0}
4067 usage (FILE * stream
)
4069 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4070 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4071 fprintf (stream
, _(" Options are:\n\
4072 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4073 -h --file-header Display the ELF file header\n\
4074 -l --program-headers Display the program headers\n\
4075 --segments An alias for --program-headers\n\
4076 -S --section-headers Display the sections' header\n\
4077 --sections An alias for --section-headers\n\
4078 -g --section-groups Display the section groups\n\
4079 -t --section-details Display the section details\n\
4080 -e --headers Equivalent to: -h -l -S\n\
4081 -s --syms Display the symbol table\n\
4082 --symbols An alias for --syms\n\
4083 --dyn-syms Display the dynamic symbol table\n\
4084 -n --notes Display the core notes (if present)\n\
4085 -r --relocs Display the relocations (if present)\n\
4086 -u --unwind Display the unwind info (if present)\n\
4087 -d --dynamic Display the dynamic section (if present)\n\
4088 -V --version-info Display the version sections (if present)\n\
4089 -A --arch-specific Display architecture specific information (if any)\n\
4090 -c --archive-index Display the symbol/file index in an archive\n\
4091 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4092 -x --hex-dump=<number|name>\n\
4093 Dump the contents of section <number|name> as bytes\n\
4094 -p --string-dump=<number|name>\n\
4095 Dump the contents of section <number|name> as strings\n\
4096 -R --relocated-dump=<number|name>\n\
4097 Dump the contents of section <number|name> as relocated bytes\n\
4098 -z --decompress Decompress section before dumping it\n\
4099 -w[lLiaprmfFsoRt] or\n\
4100 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4101 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4102 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4104 Display the contents of DWARF2 debug sections\n"));
4105 fprintf (stream
, _("\
4106 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4107 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4109 #ifdef SUPPORT_DISASSEMBLY
4110 fprintf (stream
, _("\
4111 -i --instruction-dump=<number|name>\n\
4112 Disassemble the contents of section <number|name>\n"));
4114 fprintf (stream
, _("\
4115 -I --histogram Display histogram of bucket list lengths\n\
4116 -W --wide Allow output width to exceed 80 characters\n\
4117 @<file> Read options from <file>\n\
4118 -H --help Display this information\n\
4119 -v --version Display the version number of readelf\n"));
4121 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4122 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4124 exit (stream
== stdout
? 0 : 1);
4127 /* Record the fact that the user wants the contents of section number
4128 SECTION to be displayed using the method(s) encoded as flags bits
4129 in TYPE. Note, TYPE can be zero if we are creating the array for
4133 request_dump_bynumber (unsigned int section
, dump_type type
)
4135 if (section
>= num_dump_sects
)
4137 dump_type
* new_dump_sects
;
4139 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4140 sizeof (* dump_sects
));
4142 if (new_dump_sects
== NULL
)
4143 error (_("Out of memory allocating dump request table.\n"));
4146 /* Copy current flag settings. */
4147 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4151 dump_sects
= new_dump_sects
;
4152 num_dump_sects
= section
+ 1;
4157 dump_sects
[section
] |= type
;
4162 /* Request a dump by section name. */
4165 request_dump_byname (const char * section
, dump_type type
)
4167 struct dump_list_entry
* new_request
;
4169 new_request
= (struct dump_list_entry
*)
4170 malloc (sizeof (struct dump_list_entry
));
4172 error (_("Out of memory allocating dump request table.\n"));
4174 new_request
->name
= strdup (section
);
4175 if (!new_request
->name
)
4176 error (_("Out of memory allocating dump request table.\n"));
4178 new_request
->type
= type
;
4180 new_request
->next
= dump_sects_byname
;
4181 dump_sects_byname
= new_request
;
4185 request_dump (dump_type type
)
4191 section
= strtoul (optarg
, & cp
, 0);
4193 if (! *cp
&& section
>= 0)
4194 request_dump_bynumber (section
, type
);
4196 request_dump_byname (optarg
, type
);
4201 parse_args (int argc
, char ** argv
)
4208 while ((c
= getopt_long
4209 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4227 do_section_groups
++;
4235 do_section_groups
++;
4240 do_section_details
++;
4284 request_dump (HEX_DUMP
);
4287 request_dump (STRING_DUMP
);
4290 request_dump (RELOC_DUMP
);
4300 dwarf_select_sections_all ();
4305 dwarf_select_sections_by_letters (optarg
);
4308 case OPTION_DEBUG_DUMP
:
4315 dwarf_select_sections_by_names (optarg
);
4318 case OPTION_DWARF_DEPTH
:
4322 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4325 case OPTION_DWARF_START
:
4329 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4332 case OPTION_DWARF_CHECK
:
4335 case OPTION_DYN_SYMS
:
4338 #ifdef SUPPORT_DISASSEMBLY
4340 request_dump (DISASS_DUMP
);
4344 print_version (program_name
);
4353 /* xgettext:c-format */
4354 error (_("Invalid option '-%c'\n"), c
);
4361 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4362 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4363 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4364 && !do_section_groups
&& !do_archive_index
4370 get_elf_class (unsigned int elf_class
)
4372 static char buff
[32];
4376 case ELFCLASSNONE
: return _("none");
4377 case ELFCLASS32
: return "ELF32";
4378 case ELFCLASS64
: return "ELF64";
4380 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4386 get_data_encoding (unsigned int encoding
)
4388 static char buff
[32];
4392 case ELFDATANONE
: return _("none");
4393 case ELFDATA2LSB
: return _("2's complement, little endian");
4394 case ELFDATA2MSB
: return _("2's complement, big endian");
4396 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4401 /* Decode the data held in 'elf_header'. */
4404 process_file_header (void)
4406 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4407 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4408 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4409 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4412 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4416 init_dwarf_regnames (elf_header
.e_machine
);
4422 printf (_("ELF Header:\n"));
4423 printf (_(" Magic: "));
4424 for (i
= 0; i
< EI_NIDENT
; i
++)
4425 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4427 printf (_(" Class: %s\n"),
4428 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4429 printf (_(" Data: %s\n"),
4430 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4431 printf (_(" Version: %d %s\n"),
4432 elf_header
.e_ident
[EI_VERSION
],
4433 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4435 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4436 ? _("<unknown: %lx>")
4438 printf (_(" OS/ABI: %s\n"),
4439 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4440 printf (_(" ABI Version: %d\n"),
4441 elf_header
.e_ident
[EI_ABIVERSION
]);
4442 printf (_(" Type: %s\n"),
4443 get_file_type (elf_header
.e_type
));
4444 printf (_(" Machine: %s\n"),
4445 get_machine_name (elf_header
.e_machine
));
4446 printf (_(" Version: 0x%lx\n"),
4447 (unsigned long) elf_header
.e_version
);
4449 printf (_(" Entry point address: "));
4450 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4451 printf (_("\n Start of program headers: "));
4452 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4453 printf (_(" (bytes into file)\n Start of section headers: "));
4454 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4455 printf (_(" (bytes into file)\n"));
4457 printf (_(" Flags: 0x%lx%s\n"),
4458 (unsigned long) elf_header
.e_flags
,
4459 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4460 printf (_(" Size of this header: %ld (bytes)\n"),
4461 (long) elf_header
.e_ehsize
);
4462 printf (_(" Size of program headers: %ld (bytes)\n"),
4463 (long) elf_header
.e_phentsize
);
4464 printf (_(" Number of program headers: %ld"),
4465 (long) elf_header
.e_phnum
);
4466 if (section_headers
!= NULL
4467 && elf_header
.e_phnum
== PN_XNUM
4468 && section_headers
[0].sh_info
!= 0)
4469 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4470 putc ('\n', stdout
);
4471 printf (_(" Size of section headers: %ld (bytes)\n"),
4472 (long) elf_header
.e_shentsize
);
4473 printf (_(" Number of section headers: %ld"),
4474 (long) elf_header
.e_shnum
);
4475 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4476 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4477 putc ('\n', stdout
);
4478 printf (_(" Section header string table index: %ld"),
4479 (long) elf_header
.e_shstrndx
);
4480 if (section_headers
!= NULL
4481 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4482 printf (" (%u)", section_headers
[0].sh_link
);
4483 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4484 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4485 printf (_(" <corrupt: out of range>"));
4486 putc ('\n', stdout
);
4489 if (section_headers
!= NULL
)
4491 if (elf_header
.e_phnum
== PN_XNUM
4492 && section_headers
[0].sh_info
!= 0)
4493 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4494 if (elf_header
.e_shnum
== SHN_UNDEF
)
4495 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4496 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4497 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4498 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4499 elf_header
.e_shstrndx
= SHN_UNDEF
;
4500 free (section_headers
);
4501 section_headers
= NULL
;
4508 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4510 Elf32_External_Phdr
* phdrs
;
4511 Elf32_External_Phdr
* external
;
4512 Elf_Internal_Phdr
* internal
;
4514 unsigned int size
= elf_header
.e_phentsize
;
4515 unsigned int num
= elf_header
.e_phnum
;
4517 /* PR binutils/17531: Cope with unexpected section header sizes. */
4518 if (size
== 0 || num
== 0)
4520 if (size
< sizeof * phdrs
)
4522 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4525 if (size
> sizeof * phdrs
)
4526 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4528 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4529 size
, num
, _("program headers"));
4533 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4534 i
< elf_header
.e_phnum
;
4535 i
++, internal
++, external
++)
4537 internal
->p_type
= BYTE_GET (external
->p_type
);
4538 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4539 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4540 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4541 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4542 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4543 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4544 internal
->p_align
= BYTE_GET (external
->p_align
);
4552 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4554 Elf64_External_Phdr
* phdrs
;
4555 Elf64_External_Phdr
* external
;
4556 Elf_Internal_Phdr
* internal
;
4558 unsigned int size
= elf_header
.e_phentsize
;
4559 unsigned int num
= elf_header
.e_phnum
;
4561 /* PR binutils/17531: Cope with unexpected section header sizes. */
4562 if (size
== 0 || num
== 0)
4564 if (size
< sizeof * phdrs
)
4566 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4569 if (size
> sizeof * phdrs
)
4570 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4572 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4573 size
, num
, _("program headers"));
4577 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4578 i
< elf_header
.e_phnum
;
4579 i
++, internal
++, external
++)
4581 internal
->p_type
= BYTE_GET (external
->p_type
);
4582 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4583 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4584 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4585 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4586 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4587 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4588 internal
->p_align
= BYTE_GET (external
->p_align
);
4595 /* Returns 1 if the program headers were read into `program_headers'. */
4598 get_program_headers (FILE * file
)
4600 Elf_Internal_Phdr
* phdrs
;
4602 /* Check cache of prior read. */
4603 if (program_headers
!= NULL
)
4606 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4607 sizeof (Elf_Internal_Phdr
));
4611 error (_("Out of memory reading %u program headers\n"),
4612 elf_header
.e_phnum
);
4617 ? get_32bit_program_headers (file
, phdrs
)
4618 : get_64bit_program_headers (file
, phdrs
))
4620 program_headers
= phdrs
;
4628 /* Returns 1 if the program headers were loaded. */
4631 process_program_headers (FILE * file
)
4633 Elf_Internal_Phdr
* segment
;
4636 if (elf_header
.e_phnum
== 0)
4638 /* PR binutils/12467. */
4639 if (elf_header
.e_phoff
!= 0)
4640 warn (_("possibly corrupt ELF header - it has a non-zero program"
4641 " header offset, but no program headers\n"));
4642 else if (do_segments
)
4643 printf (_("\nThere are no program headers in this file.\n"));
4647 if (do_segments
&& !do_header
)
4649 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4650 printf (_("Entry point "));
4651 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4652 printf (_("\nThere are %d program headers, starting at offset "),
4653 elf_header
.e_phnum
);
4654 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4658 if (! get_program_headers (file
))
4663 if (elf_header
.e_phnum
> 1)
4664 printf (_("\nProgram Headers:\n"));
4666 printf (_("\nProgram Headers:\n"));
4670 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4673 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4677 (_(" Type Offset VirtAddr PhysAddr\n"));
4679 (_(" FileSiz MemSiz Flags Align\n"));
4686 for (i
= 0, segment
= program_headers
;
4687 i
< elf_header
.e_phnum
;
4692 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4696 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4697 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4698 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4699 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4700 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4702 (segment
->p_flags
& PF_R
? 'R' : ' '),
4703 (segment
->p_flags
& PF_W
? 'W' : ' '),
4704 (segment
->p_flags
& PF_X
? 'E' : ' '));
4705 printf ("%#lx", (unsigned long) segment
->p_align
);
4709 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4710 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4713 print_vma (segment
->p_offset
, FULL_HEX
);
4717 print_vma (segment
->p_vaddr
, FULL_HEX
);
4719 print_vma (segment
->p_paddr
, FULL_HEX
);
4722 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4723 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4726 print_vma (segment
->p_filesz
, FULL_HEX
);
4730 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4731 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4734 print_vma (segment
->p_memsz
, FULL_HEX
);
4738 (segment
->p_flags
& PF_R
? 'R' : ' '),
4739 (segment
->p_flags
& PF_W
? 'W' : ' '),
4740 (segment
->p_flags
& PF_X
? 'E' : ' '));
4742 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4743 printf ("%#lx", (unsigned long) segment
->p_align
);
4746 print_vma (segment
->p_align
, PREFIX_HEX
);
4751 print_vma (segment
->p_offset
, FULL_HEX
);
4753 print_vma (segment
->p_vaddr
, FULL_HEX
);
4755 print_vma (segment
->p_paddr
, FULL_HEX
);
4757 print_vma (segment
->p_filesz
, FULL_HEX
);
4759 print_vma (segment
->p_memsz
, FULL_HEX
);
4761 (segment
->p_flags
& PF_R
? 'R' : ' '),
4762 (segment
->p_flags
& PF_W
? 'W' : ' '),
4763 (segment
->p_flags
& PF_X
? 'E' : ' '));
4764 print_vma (segment
->p_align
, HEX
);
4769 putc ('\n', stdout
);
4771 switch (segment
->p_type
)
4775 error (_("more than one dynamic segment\n"));
4777 /* By default, assume that the .dynamic section is the first
4778 section in the DYNAMIC segment. */
4779 dynamic_addr
= segment
->p_offset
;
4780 dynamic_size
= segment
->p_filesz
;
4781 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4782 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4784 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4785 dynamic_addr
= dynamic_size
= 0;
4788 /* Try to locate the .dynamic section. If there is
4789 a section header table, we can easily locate it. */
4790 if (section_headers
!= NULL
)
4792 Elf_Internal_Shdr
* sec
;
4794 sec
= find_section (".dynamic");
4795 if (sec
== NULL
|| sec
->sh_size
== 0)
4797 /* A corresponding .dynamic section is expected, but on
4798 IA-64/OpenVMS it is OK for it to be missing. */
4799 if (!is_ia64_vms ())
4800 error (_("no .dynamic section in the dynamic segment\n"));
4804 if (sec
->sh_type
== SHT_NOBITS
)
4810 dynamic_addr
= sec
->sh_offset
;
4811 dynamic_size
= sec
->sh_size
;
4813 if (dynamic_addr
< segment
->p_offset
4814 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4815 warn (_("the .dynamic section is not contained"
4816 " within the dynamic segment\n"));
4817 else if (dynamic_addr
> segment
->p_offset
)
4818 warn (_("the .dynamic section is not the first section"
4819 " in the dynamic segment.\n"));
4824 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4826 error (_("Unable to find program interpreter name\n"));
4830 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4832 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4833 error (_("Internal error: failed to create format string to display program interpreter\n"));
4835 program_interpreter
[0] = 0;
4836 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4837 error (_("Unable to read program interpreter name\n"));
4840 printf (_(" [Requesting program interpreter: %s]\n"),
4841 program_interpreter
);
4847 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4849 printf (_("\n Section to Segment mapping:\n"));
4850 printf (_(" Segment Sections...\n"));
4852 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4855 Elf_Internal_Shdr
* section
;
4857 segment
= program_headers
+ i
;
4858 section
= section_headers
+ 1;
4860 printf (" %2.2d ", i
);
4862 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4864 if (!ELF_TBSS_SPECIAL (section
, segment
)
4865 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4866 printf ("%s ", printable_section_name (section
));
4877 /* Find the file offset corresponding to VMA by using the program headers. */
4880 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4882 Elf_Internal_Phdr
* seg
;
4884 if (! get_program_headers (file
))
4886 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4890 for (seg
= program_headers
;
4891 seg
< program_headers
+ elf_header
.e_phnum
;
4894 if (seg
->p_type
!= PT_LOAD
)
4897 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4898 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4899 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4902 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4903 (unsigned long) vma
);
4908 /* Allocate memory and load the sections headers into the global pointer
4909 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4910 generate any error messages if the load fails. */
4913 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4915 Elf32_External_Shdr
* shdrs
;
4916 Elf_Internal_Shdr
* internal
;
4918 unsigned int size
= elf_header
.e_shentsize
;
4919 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4921 /* PR binutils/17531: Cope with unexpected section header sizes. */
4922 if (size
== 0 || num
== 0)
4924 if (size
< sizeof * shdrs
)
4927 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4930 if (!probe
&& size
> sizeof * shdrs
)
4931 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4933 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4935 probe
? NULL
: _("section headers"));
4939 if (section_headers
!= NULL
)
4940 free (section_headers
);
4941 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4942 sizeof (Elf_Internal_Shdr
));
4943 if (section_headers
== NULL
)
4946 error (_("Out of memory reading %u section headers\n"), num
);
4950 for (i
= 0, internal
= section_headers
;
4954 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4955 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4956 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4957 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4958 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4959 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4960 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4961 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4962 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4963 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4971 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4973 Elf64_External_Shdr
* shdrs
;
4974 Elf_Internal_Shdr
* internal
;
4976 unsigned int size
= elf_header
.e_shentsize
;
4977 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4979 /* PR binutils/17531: Cope with unexpected section header sizes. */
4980 if (size
== 0 || num
== 0)
4982 if (size
< sizeof * shdrs
)
4985 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4988 if (! probe
&& size
> sizeof * shdrs
)
4989 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4991 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4993 probe
? NULL
: _("section headers"));
4997 if (section_headers
!= NULL
)
4998 free (section_headers
);
4999 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5000 sizeof (Elf_Internal_Shdr
));
5001 if (section_headers
== NULL
)
5004 error (_("Out of memory reading %u section headers\n"), num
);
5008 for (i
= 0, internal
= section_headers
;
5012 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5013 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5014 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5015 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5016 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5017 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5018 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5019 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5020 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5021 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5028 static Elf_Internal_Sym
*
5029 get_32bit_elf_symbols (FILE * file
,
5030 Elf_Internal_Shdr
* section
,
5031 unsigned long * num_syms_return
)
5033 unsigned long number
= 0;
5034 Elf32_External_Sym
* esyms
= NULL
;
5035 Elf_External_Sym_Shndx
* shndx
= NULL
;
5036 Elf_Internal_Sym
* isyms
= NULL
;
5037 Elf_Internal_Sym
* psym
;
5040 if (section
->sh_size
== 0)
5042 if (num_syms_return
!= NULL
)
5043 * num_syms_return
= 0;
5047 /* Run some sanity checks first. */
5048 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5050 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5051 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5055 if (section
->sh_size
> current_file_size
)
5057 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5058 printable_section_name (section
), (unsigned long) section
->sh_size
);
5062 number
= section
->sh_size
/ section
->sh_entsize
;
5064 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5066 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5067 (unsigned long) section
->sh_size
,
5068 printable_section_name (section
),
5069 (unsigned long) section
->sh_entsize
);
5073 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5074 section
->sh_size
, _("symbols"));
5079 elf_section_list
* entry
;
5082 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5083 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5085 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5086 entry
->hdr
->sh_offset
,
5087 1, entry
->hdr
->sh_size
,
5088 _("symbol table section indicies"));
5091 /* PR17531: file: heap-buffer-overflow */
5092 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5094 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5095 printable_section_name (entry
->hdr
),
5096 (unsigned long) entry
->hdr
->sh_size
,
5097 (unsigned long) section
->sh_size
);
5103 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5107 error (_("Out of memory reading %lu symbols\n"),
5108 (unsigned long) number
);
5112 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5114 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5115 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5116 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5117 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5118 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5120 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5121 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5122 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5123 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5124 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5133 if (num_syms_return
!= NULL
)
5134 * num_syms_return
= isyms
== NULL
? 0 : number
;
5139 static Elf_Internal_Sym
*
5140 get_64bit_elf_symbols (FILE * file
,
5141 Elf_Internal_Shdr
* section
,
5142 unsigned long * num_syms_return
)
5144 unsigned long number
= 0;
5145 Elf64_External_Sym
* esyms
= NULL
;
5146 Elf_External_Sym_Shndx
* shndx
= NULL
;
5147 Elf_Internal_Sym
* isyms
= NULL
;
5148 Elf_Internal_Sym
* psym
;
5151 if (section
->sh_size
== 0)
5153 if (num_syms_return
!= NULL
)
5154 * num_syms_return
= 0;
5158 /* Run some sanity checks first. */
5159 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5161 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5162 printable_section_name (section
),
5163 (unsigned long) section
->sh_entsize
);
5167 if (section
->sh_size
> current_file_size
)
5169 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5170 printable_section_name (section
),
5171 (unsigned long) section
->sh_size
);
5175 number
= section
->sh_size
/ section
->sh_entsize
;
5177 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5179 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5180 (unsigned long) section
->sh_size
,
5181 printable_section_name (section
),
5182 (unsigned long) section
->sh_entsize
);
5186 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5187 section
->sh_size
, _("symbols"));
5192 elf_section_list
* entry
;
5195 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5196 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5198 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5199 entry
->hdr
->sh_offset
,
5200 1, entry
->hdr
->sh_size
,
5201 _("symbol table section indicies"));
5204 /* PR17531: file: heap-buffer-overflow */
5205 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5207 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5208 printable_section_name (entry
->hdr
),
5209 (unsigned long) entry
->hdr
->sh_size
,
5210 (unsigned long) section
->sh_size
);
5216 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5220 error (_("Out of memory reading %lu symbols\n"),
5221 (unsigned long) number
);
5225 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5227 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5228 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5229 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5230 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5232 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5234 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5235 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5236 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5238 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5239 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5248 if (num_syms_return
!= NULL
)
5249 * num_syms_return
= isyms
== NULL
? 0 : number
;
5255 get_elf_section_flags (bfd_vma sh_flags
)
5257 static char buff
[1024];
5259 int field_size
= is_32bit_elf
? 8 : 16;
5261 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5262 bfd_vma os_flags
= 0;
5263 bfd_vma proc_flags
= 0;
5264 bfd_vma unknown_flags
= 0;
5272 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5273 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5274 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5275 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5276 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5277 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5278 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5279 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5280 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5281 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5282 /* IA-64 specific. */
5283 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5284 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5285 /* IA-64 OpenVMS specific. */
5286 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5287 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5288 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5289 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5290 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5291 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5293 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5294 /* SPARC specific. */
5295 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5296 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5298 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5299 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5300 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5303 if (do_section_details
)
5305 sprintf (buff
, "[%*.*lx]: ",
5306 field_size
, field_size
, (unsigned long) sh_flags
);
5307 p
+= field_size
+ 4;
5314 flag
= sh_flags
& - sh_flags
;
5317 if (do_section_details
)
5321 case SHF_WRITE
: sindex
= 0; break;
5322 case SHF_ALLOC
: sindex
= 1; break;
5323 case SHF_EXECINSTR
: sindex
= 2; break;
5324 case SHF_MERGE
: sindex
= 3; break;
5325 case SHF_STRINGS
: sindex
= 4; break;
5326 case SHF_INFO_LINK
: sindex
= 5; break;
5327 case SHF_LINK_ORDER
: sindex
= 6; break;
5328 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5329 case SHF_GROUP
: sindex
= 8; break;
5330 case SHF_TLS
: sindex
= 9; break;
5331 case SHF_EXCLUDE
: sindex
= 18; break;
5332 case SHF_COMPRESSED
: sindex
= 20; break;
5336 switch (elf_header
.e_machine
)
5339 if (flag
== SHF_IA_64_SHORT
)
5341 else if (flag
== SHF_IA_64_NORECOV
)
5344 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5347 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5348 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5349 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5350 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5351 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5352 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5363 case EM_OLD_SPARCV9
:
5364 case EM_SPARC32PLUS
:
5367 if (flag
== SHF_ORDERED
)
5374 case SHF_ENTRYSECT
: sindex
= 21; break;
5375 case SHF_ARM_NOREAD
: sindex
= 22; break;
5376 case SHF_COMDEF
: sindex
= 23; break;
5388 if (p
!= buff
+ field_size
+ 4)
5390 if (size
< (10 + 2))
5392 warn (_("Internal error: not enough buffer room for section flag info"));
5393 return _("<unknown>");
5400 size
-= flags
[sindex
].len
;
5401 p
= stpcpy (p
, flags
[sindex
].str
);
5403 else if (flag
& SHF_MASKOS
)
5405 else if (flag
& SHF_MASKPROC
)
5408 unknown_flags
|= flag
;
5414 case SHF_WRITE
: *p
= 'W'; break;
5415 case SHF_ALLOC
: *p
= 'A'; break;
5416 case SHF_EXECINSTR
: *p
= 'X'; break;
5417 case SHF_MERGE
: *p
= 'M'; break;
5418 case SHF_STRINGS
: *p
= 'S'; break;
5419 case SHF_INFO_LINK
: *p
= 'I'; break;
5420 case SHF_LINK_ORDER
: *p
= 'L'; break;
5421 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5422 case SHF_GROUP
: *p
= 'G'; break;
5423 case SHF_TLS
: *p
= 'T'; break;
5424 case SHF_EXCLUDE
: *p
= 'E'; break;
5425 case SHF_COMPRESSED
: *p
= 'C'; break;
5428 if ((elf_header
.e_machine
== EM_X86_64
5429 || elf_header
.e_machine
== EM_L1OM
5430 || elf_header
.e_machine
== EM_K1OM
)
5431 && flag
== SHF_X86_64_LARGE
)
5433 else if (elf_header
.e_machine
== EM_ARM
5434 && flag
== SHF_ARM_NOREAD
)
5436 else if (flag
& SHF_MASKOS
)
5439 sh_flags
&= ~ SHF_MASKOS
;
5441 else if (flag
& SHF_MASKPROC
)
5444 sh_flags
&= ~ SHF_MASKPROC
;
5454 if (do_section_details
)
5458 size
-= 5 + field_size
;
5459 if (p
!= buff
+ field_size
+ 4)
5463 warn (_("Internal error: not enough buffer room for section flag info"));
5464 return _("<unknown>");
5470 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5471 (unsigned long) os_flags
);
5472 p
+= 5 + field_size
;
5476 size
-= 7 + field_size
;
5477 if (p
!= buff
+ field_size
+ 4)
5481 warn (_("Internal error: not enough buffer room for section flag info"));
5482 return _("<unknown>");
5488 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5489 (unsigned long) proc_flags
);
5490 p
+= 7 + field_size
;
5494 size
-= 10 + field_size
;
5495 if (p
!= buff
+ field_size
+ 4)
5499 warn (_("Internal error: not enough buffer room for section flag info"));
5500 return _("<unknown>");
5506 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5507 (unsigned long) unknown_flags
);
5508 p
+= 10 + field_size
;
5517 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5521 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5522 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5523 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5524 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5525 return sizeof (*echdr
);
5529 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5530 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5531 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5532 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5533 return sizeof (*echdr
);
5538 process_section_headers (FILE * file
)
5540 Elf_Internal_Shdr
* section
;
5543 section_headers
= NULL
;
5545 if (elf_header
.e_shnum
== 0)
5547 /* PR binutils/12467. */
5548 if (elf_header
.e_shoff
!= 0)
5549 warn (_("possibly corrupt ELF file header - it has a non-zero"
5550 " section header offset, but no section headers\n"));
5551 else if (do_sections
)
5552 printf (_("\nThere are no sections in this file.\n"));
5557 if (do_sections
&& !do_header
)
5558 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5559 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5563 if (! get_32bit_section_headers (file
, FALSE
))
5566 else if (! get_64bit_section_headers (file
, FALSE
))
5569 /* Read in the string table, so that we have names to display. */
5570 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5571 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5573 section
= section_headers
+ elf_header
.e_shstrndx
;
5575 if (section
->sh_size
!= 0)
5577 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5578 1, section
->sh_size
,
5581 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5585 /* Scan the sections for the dynamic symbol table
5586 and dynamic string table and debug sections. */
5587 dynamic_symbols
= NULL
;
5588 dynamic_strings
= NULL
;
5589 dynamic_syminfo
= NULL
;
5590 symtab_shndx_list
= NULL
;
5592 eh_addr_size
= is_32bit_elf
? 4 : 8;
5593 switch (elf_header
.e_machine
)
5596 case EM_MIPS_RS3_LE
:
5597 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5598 FDE addresses. However, the ABI also has a semi-official ILP32
5599 variant for which the normal FDE address size rules apply.
5601 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5602 section, where XX is the size of longs in bits. Unfortunately,
5603 earlier compilers provided no way of distinguishing ILP32 objects
5604 from LP64 objects, so if there's any doubt, we should assume that
5605 the official LP64 form is being used. */
5606 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5607 && find_section (".gcc_compiled_long32") == NULL
)
5613 switch (elf_header
.e_flags
& EF_H8_MACH
)
5615 case E_H8_MACH_H8300
:
5616 case E_H8_MACH_H8300HN
:
5617 case E_H8_MACH_H8300SN
:
5618 case E_H8_MACH_H8300SXN
:
5621 case E_H8_MACH_H8300H
:
5622 case E_H8_MACH_H8300S
:
5623 case E_H8_MACH_H8300SX
:
5631 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5633 case EF_M32C_CPU_M16C
:
5640 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5643 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5644 if (section->sh_entsize != expected_entsize) \
5647 sprintf_vma (buf, section->sh_entsize); \
5648 /* Note: coded this way so that there is a single string for \
5650 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5651 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5652 (unsigned) expected_entsize); \
5653 section->sh_entsize = expected_entsize; \
5658 #define CHECK_ENTSIZE(section, i, type) \
5659 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5660 sizeof (Elf64_External_##type))
5662 for (i
= 0, section
= section_headers
;
5663 i
< elf_header
.e_shnum
;
5666 char * name
= SECTION_NAME (section
);
5668 if (section
->sh_type
== SHT_DYNSYM
)
5670 if (dynamic_symbols
!= NULL
)
5672 error (_("File contains multiple dynamic symbol tables\n"));
5676 CHECK_ENTSIZE (section
, i
, Sym
);
5677 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5679 else if (section
->sh_type
== SHT_STRTAB
5680 && streq (name
, ".dynstr"))
5682 if (dynamic_strings
!= NULL
)
5684 error (_("File contains multiple dynamic string tables\n"));
5688 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5689 1, section
->sh_size
,
5690 _("dynamic strings"));
5691 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5693 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5695 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5696 entry
->hdr
= section
;
5697 entry
->next
= symtab_shndx_list
;
5698 symtab_shndx_list
= entry
;
5700 else if (section
->sh_type
== SHT_SYMTAB
)
5701 CHECK_ENTSIZE (section
, i
, Sym
);
5702 else if (section
->sh_type
== SHT_GROUP
)
5703 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5704 else if (section
->sh_type
== SHT_REL
)
5705 CHECK_ENTSIZE (section
, i
, Rel
);
5706 else if (section
->sh_type
== SHT_RELA
)
5707 CHECK_ENTSIZE (section
, i
, Rela
);
5708 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5709 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5710 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5711 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5712 || do_debug_addr
|| do_debug_cu_index
)
5713 && (const_strneq (name
, ".debug_")
5714 || const_strneq (name
, ".zdebug_")))
5717 name
+= sizeof (".zdebug_") - 1;
5719 name
+= sizeof (".debug_") - 1;
5722 || (do_debug_info
&& const_strneq (name
, "info"))
5723 || (do_debug_info
&& const_strneq (name
, "types"))
5724 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5725 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5726 || (do_debug_lines
&& const_strneq (name
, "line."))
5727 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5728 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5729 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5730 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5731 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5732 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5733 || (do_debug_frames
&& const_strneq (name
, "frame"))
5734 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5735 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5736 || (do_debug_str
&& const_strneq (name
, "str"))
5737 || (do_debug_loc
&& const_strneq (name
, "loc"))
5738 || (do_debug_addr
&& const_strneq (name
, "addr"))
5739 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5740 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5742 request_dump_bynumber (i
, DEBUG_DUMP
);
5744 /* Linkonce section to be combined with .debug_info at link time. */
5745 else if ((do_debugging
|| do_debug_info
)
5746 && const_strneq (name
, ".gnu.linkonce.wi."))
5747 request_dump_bynumber (i
, DEBUG_DUMP
);
5748 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5749 request_dump_bynumber (i
, DEBUG_DUMP
);
5750 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5751 request_dump_bynumber (i
, DEBUG_DUMP
);
5752 /* Trace sections for Itanium VMS. */
5753 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5754 || do_trace_aranges
)
5755 && const_strneq (name
, ".trace_"))
5757 name
+= sizeof (".trace_") - 1;
5760 || (do_trace_info
&& streq (name
, "info"))
5761 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5762 || (do_trace_aranges
&& streq (name
, "aranges"))
5764 request_dump_bynumber (i
, DEBUG_DUMP
);
5771 if (elf_header
.e_shnum
> 1)
5772 printf (_("\nSection Headers:\n"));
5774 printf (_("\nSection Header:\n"));
5778 if (do_section_details
)
5780 printf (_(" [Nr] Name\n"));
5781 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5785 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5789 if (do_section_details
)
5791 printf (_(" [Nr] Name\n"));
5792 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5796 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5800 if (do_section_details
)
5802 printf (_(" [Nr] Name\n"));
5803 printf (_(" Type Address Offset Link\n"));
5804 printf (_(" Size EntSize Info Align\n"));
5808 printf (_(" [Nr] Name Type Address Offset\n"));
5809 printf (_(" Size EntSize Flags Link Info Align\n"));
5813 if (do_section_details
)
5814 printf (_(" Flags\n"));
5816 for (i
= 0, section
= section_headers
;
5817 i
< elf_header
.e_shnum
;
5820 printf (" [%2u] ", i
);
5821 if (do_section_details
)
5822 printf ("%s\n ", printable_section_name (section
));
5824 print_symbol (-17, SECTION_NAME (section
));
5826 printf (do_wide
? " %-15s " : " %-15.15s ",
5827 get_section_type_name (section
->sh_type
));
5831 const char * link_too_big
= NULL
;
5833 print_vma (section
->sh_addr
, LONG_HEX
);
5835 printf ( " %6.6lx %6.6lx %2.2lx",
5836 (unsigned long) section
->sh_offset
,
5837 (unsigned long) section
->sh_size
,
5838 (unsigned long) section
->sh_entsize
);
5840 if (do_section_details
)
5841 fputs (" ", stdout
);
5843 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5845 if (section
->sh_link
>= elf_header
.e_shnum
)
5848 /* The sh_link value is out of range. Normally this indicates
5849 an error but it can have special values in Solaris binaries. */
5850 switch (elf_header
.e_machine
)
5857 case EM_OLD_SPARCV9
:
5858 case EM_SPARC32PLUS
:
5861 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5862 link_too_big
= "BEFORE";
5863 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5864 link_too_big
= "AFTER";
5871 if (do_section_details
)
5873 if (link_too_big
!= NULL
&& * link_too_big
)
5874 printf ("<%s> ", link_too_big
);
5876 printf ("%2u ", section
->sh_link
);
5877 printf ("%3u %2lu\n", section
->sh_info
,
5878 (unsigned long) section
->sh_addralign
);
5881 printf ("%2u %3u %2lu\n",
5884 (unsigned long) section
->sh_addralign
);
5886 if (link_too_big
&& ! * link_too_big
)
5887 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5888 i
, section
->sh_link
);
5892 print_vma (section
->sh_addr
, LONG_HEX
);
5894 if ((long) section
->sh_offset
== section
->sh_offset
)
5895 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5899 print_vma (section
->sh_offset
, LONG_HEX
);
5902 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5903 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5907 print_vma (section
->sh_size
, LONG_HEX
);
5910 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5911 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5915 print_vma (section
->sh_entsize
, LONG_HEX
);
5918 if (do_section_details
)
5919 fputs (" ", stdout
);
5921 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5923 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5925 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5926 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5929 print_vma (section
->sh_addralign
, DEC
);
5933 else if (do_section_details
)
5935 printf (" %-15.15s ",
5936 get_section_type_name (section
->sh_type
));
5937 print_vma (section
->sh_addr
, LONG_HEX
);
5938 if ((long) section
->sh_offset
== section
->sh_offset
)
5939 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5943 print_vma (section
->sh_offset
, LONG_HEX
);
5945 printf (" %u\n ", section
->sh_link
);
5946 print_vma (section
->sh_size
, LONG_HEX
);
5948 print_vma (section
->sh_entsize
, LONG_HEX
);
5950 printf (" %-16u %lu\n",
5952 (unsigned long) section
->sh_addralign
);
5957 print_vma (section
->sh_addr
, LONG_HEX
);
5958 if ((long) section
->sh_offset
== section
->sh_offset
)
5959 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5963 print_vma (section
->sh_offset
, LONG_HEX
);
5966 print_vma (section
->sh_size
, LONG_HEX
);
5968 print_vma (section
->sh_entsize
, LONG_HEX
);
5970 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5972 printf (" %2u %3u %lu\n",
5975 (unsigned long) section
->sh_addralign
);
5978 if (do_section_details
)
5980 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5981 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5983 /* Minimum section size is 12 bytes for 32-bit compression
5984 header + 12 bytes for compressed data header. */
5985 unsigned char buf
[24];
5986 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5987 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5988 sizeof (buf
), _("compression header")))
5990 Elf_Internal_Chdr chdr
;
5991 get_compression_header (&chdr
, buf
);
5992 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5995 printf (_(" [<unknown>: 0x%x], "),
5997 print_vma (chdr
.ch_size
, LONG_HEX
);
5998 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6004 if (!do_section_details
)
6006 if (elf_header
.e_machine
== EM_X86_64
6007 || elf_header
.e_machine
== EM_L1OM
6008 || elf_header
.e_machine
== EM_K1OM
)
6009 printf (_("Key to Flags:\n\
6010 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
6011 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
6012 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6013 else if (elf_header
.e_machine
== EM_ARM
)
6014 printf (_("Key to Flags:\n\
6015 W (write), A (alloc), X (execute), M (merge), S (strings), y (noread)\n\
6016 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
6017 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6019 printf (_("Key to Flags:\n\
6020 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
6021 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
6022 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6029 get_group_flags (unsigned int flags
)
6031 static char buff
[32];
6041 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6048 process_section_groups (FILE * file
)
6050 Elf_Internal_Shdr
* section
;
6052 struct group
* group
;
6053 Elf_Internal_Shdr
* symtab_sec
;
6054 Elf_Internal_Shdr
* strtab_sec
;
6055 Elf_Internal_Sym
* symtab
;
6056 unsigned long num_syms
;
6060 /* Don't process section groups unless needed. */
6061 if (!do_unwind
&& !do_section_groups
)
6064 if (elf_header
.e_shnum
== 0)
6066 if (do_section_groups
)
6067 printf (_("\nThere are no sections to group in this file.\n"));
6072 if (section_headers
== NULL
)
6074 error (_("Section headers are not available!\n"));
6075 /* PR 13622: This can happen with a corrupt ELF header. */
6079 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6080 sizeof (struct group
*));
6082 if (section_headers_groups
== NULL
)
6084 error (_("Out of memory reading %u section group headers\n"),
6085 elf_header
.e_shnum
);
6089 /* Scan the sections for the group section. */
6091 for (i
= 0, section
= section_headers
;
6092 i
< elf_header
.e_shnum
;
6094 if (section
->sh_type
== SHT_GROUP
)
6097 if (group_count
== 0)
6099 if (do_section_groups
)
6100 printf (_("\nThere are no section groups in this file.\n"));
6105 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6107 if (section_groups
== NULL
)
6109 error (_("Out of memory reading %lu groups\n"),
6110 (unsigned long) group_count
);
6120 for (i
= 0, section
= section_headers
, group
= section_groups
;
6121 i
< elf_header
.e_shnum
;
6124 if (section
->sh_type
== SHT_GROUP
)
6126 const char * name
= printable_section_name (section
);
6127 const char * group_name
;
6128 unsigned char * start
;
6129 unsigned char * indices
;
6130 unsigned int entry
, j
, size
;
6131 Elf_Internal_Shdr
* sec
;
6132 Elf_Internal_Sym
* sym
;
6134 /* Get the symbol table. */
6135 if (section
->sh_link
>= elf_header
.e_shnum
6136 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6139 error (_("Bad sh_link in group section `%s'\n"), name
);
6143 if (symtab_sec
!= sec
)
6148 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6153 error (_("Corrupt header in group section `%s'\n"), name
);
6157 if (section
->sh_info
>= num_syms
)
6159 error (_("Bad sh_info in group section `%s'\n"), name
);
6163 sym
= symtab
+ section
->sh_info
;
6165 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6167 if (sym
->st_shndx
== 0
6168 || sym
->st_shndx
>= elf_header
.e_shnum
)
6170 error (_("Bad sh_info in group section `%s'\n"), name
);
6174 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6183 /* Get the string table. */
6184 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6193 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6199 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6200 1, strtab_sec
->sh_size
,
6202 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6204 group_name
= sym
->st_name
< strtab_size
6205 ? strtab
+ sym
->st_name
: _("<corrupt>");
6208 /* PR 17531: file: loop. */
6209 if (section
->sh_entsize
> section
->sh_size
)
6211 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6212 printable_section_name (section
),
6213 (unsigned long) section
->sh_entsize
,
6214 (unsigned long) section
->sh_size
);
6218 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6219 1, section
->sh_size
,
6225 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6226 entry
= byte_get (indices
, 4);
6229 if (do_section_groups
)
6231 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6232 get_group_flags (entry
), i
, name
, group_name
, size
);
6234 printf (_(" [Index] Name\n"));
6237 group
->group_index
= i
;
6239 for (j
= 0; j
< size
; j
++)
6241 struct group_list
* g
;
6243 entry
= byte_get (indices
, 4);
6246 if (entry
>= elf_header
.e_shnum
)
6248 static unsigned num_group_errors
= 0;
6250 if (num_group_errors
++ < 10)
6252 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6253 entry
, i
, elf_header
.e_shnum
- 1);
6254 if (num_group_errors
== 10)
6255 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6260 if (section_headers_groups
[entry
] != NULL
)
6264 static unsigned num_errs
= 0;
6266 if (num_errs
++ < 10)
6268 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6270 section_headers_groups
[entry
]->group_index
);
6272 warn (_("Further error messages about already contained group sections suppressed\n"));
6278 /* Intel C/C++ compiler may put section 0 in a
6279 section group. We just warn it the first time
6280 and ignore it afterwards. */
6281 static int warned
= 0;
6284 error (_("section 0 in group section [%5u]\n"),
6285 section_headers_groups
[entry
]->group_index
);
6291 section_headers_groups
[entry
] = group
;
6293 if (do_section_groups
)
6295 sec
= section_headers
+ entry
;
6296 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6299 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6300 g
->section_index
= entry
;
6301 g
->next
= group
->root
;
6319 /* Data used to display dynamic fixups. */
6321 struct ia64_vms_dynfixup
6323 bfd_vma needed_ident
; /* Library ident number. */
6324 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6325 bfd_vma fixup_needed
; /* Index of the library. */
6326 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6327 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6330 /* Data used to display dynamic relocations. */
6332 struct ia64_vms_dynimgrela
6334 bfd_vma img_rela_cnt
; /* Number of relocations. */
6335 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6338 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6342 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6343 const char *strtab
, unsigned int strtab_sz
)
6345 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6347 const char *lib_name
;
6349 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6350 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6351 _("dynamic section image fixups"));
6355 if (fixup
->needed
< strtab_sz
)
6356 lib_name
= strtab
+ fixup
->needed
;
6359 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6360 (unsigned long) fixup
->needed
);
6363 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6364 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6366 (_("Seg Offset Type SymVec DataType\n"));
6368 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6373 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6374 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6375 type
= BYTE_GET (imfs
[i
].type
);
6376 rtype
= elf_ia64_reloc_type (type
);
6378 printf (" 0x%08x ", type
);
6380 printf (" %-32s ", rtype
);
6381 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6382 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6388 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6391 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6393 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6396 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6397 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6398 _("dynamic section image relocations"));
6402 printf (_("\nImage relocs\n"));
6404 (_("Seg Offset Type Addend Seg Sym Off\n"));
6406 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6411 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6412 printf ("%08" BFD_VMA_FMT
"x ",
6413 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6414 type
= BYTE_GET (imrs
[i
].type
);
6415 rtype
= elf_ia64_reloc_type (type
);
6417 printf ("0x%08x ", type
);
6419 printf ("%-31s ", rtype
);
6420 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6421 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6422 printf ("%08" BFD_VMA_FMT
"x\n",
6423 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6429 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6432 process_ia64_vms_dynamic_relocs (FILE *file
)
6434 struct ia64_vms_dynfixup fixup
;
6435 struct ia64_vms_dynimgrela imgrela
;
6436 Elf_Internal_Dyn
*entry
;
6438 bfd_vma strtab_off
= 0;
6439 bfd_vma strtab_sz
= 0;
6440 char *strtab
= NULL
;
6442 memset (&fixup
, 0, sizeof (fixup
));
6443 memset (&imgrela
, 0, sizeof (imgrela
));
6445 /* Note: the order of the entries is specified by the OpenVMS specs. */
6446 for (entry
= dynamic_section
;
6447 entry
< dynamic_section
+ dynamic_nent
;
6450 switch (entry
->d_tag
)
6452 case DT_IA_64_VMS_STRTAB_OFFSET
:
6453 strtab_off
= entry
->d_un
.d_val
;
6456 strtab_sz
= entry
->d_un
.d_val
;
6458 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6459 1, strtab_sz
, _("dynamic string section"));
6462 case DT_IA_64_VMS_NEEDED_IDENT
:
6463 fixup
.needed_ident
= entry
->d_un
.d_val
;
6466 fixup
.needed
= entry
->d_un
.d_val
;
6468 case DT_IA_64_VMS_FIXUP_NEEDED
:
6469 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6471 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6472 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6474 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6475 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6477 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6480 case DT_IA_64_VMS_IMG_RELA_CNT
:
6481 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6483 case DT_IA_64_VMS_IMG_RELA_OFF
:
6484 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6486 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6506 } dynamic_relocations
[] =
6508 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6509 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6510 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6513 /* Process the reloc section. */
6516 process_relocs (FILE * file
)
6518 unsigned long rel_size
;
6519 unsigned long rel_offset
;
6525 if (do_using_dynamic
)
6529 int has_dynamic_reloc
;
6532 has_dynamic_reloc
= 0;
6534 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6536 is_rela
= dynamic_relocations
[i
].rela
;
6537 name
= dynamic_relocations
[i
].name
;
6538 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6539 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6541 has_dynamic_reloc
|= rel_size
;
6543 if (is_rela
== UNKNOWN
)
6545 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6546 switch (dynamic_info
[DT_PLTREL
])
6560 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6561 name
, rel_offset
, rel_size
);
6563 dump_relocations (file
,
6564 offset_from_vma (file
, rel_offset
, rel_size
),
6566 dynamic_symbols
, num_dynamic_syms
,
6567 dynamic_strings
, dynamic_strings_length
,
6573 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6575 if (! has_dynamic_reloc
)
6576 printf (_("\nThere are no dynamic relocations in this file.\n"));
6580 Elf_Internal_Shdr
* section
;
6584 for (i
= 0, section
= section_headers
;
6585 i
< elf_header
.e_shnum
;
6588 if ( section
->sh_type
!= SHT_RELA
6589 && section
->sh_type
!= SHT_REL
)
6592 rel_offset
= section
->sh_offset
;
6593 rel_size
= section
->sh_size
;
6597 Elf_Internal_Shdr
* strsec
;
6600 printf (_("\nRelocation section "));
6602 if (string_table
== NULL
)
6603 printf ("%d", section
->sh_name
);
6605 printf ("'%s'", printable_section_name (section
));
6607 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6608 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6610 is_rela
= section
->sh_type
== SHT_RELA
;
6612 if (section
->sh_link
!= 0
6613 && section
->sh_link
< elf_header
.e_shnum
)
6615 Elf_Internal_Shdr
* symsec
;
6616 Elf_Internal_Sym
* symtab
;
6617 unsigned long nsyms
;
6618 unsigned long strtablen
= 0;
6619 char * strtab
= NULL
;
6621 symsec
= section_headers
+ section
->sh_link
;
6622 if (symsec
->sh_type
!= SHT_SYMTAB
6623 && symsec
->sh_type
!= SHT_DYNSYM
)
6626 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6631 if (symsec
->sh_link
!= 0
6632 && symsec
->sh_link
< elf_header
.e_shnum
)
6634 strsec
= section_headers
+ symsec
->sh_link
;
6636 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6639 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6642 dump_relocations (file
, rel_offset
, rel_size
,
6643 symtab
, nsyms
, strtab
, strtablen
,
6645 symsec
->sh_type
== SHT_DYNSYM
);
6651 dump_relocations (file
, rel_offset
, rel_size
,
6652 NULL
, 0, NULL
, 0, is_rela
, 0);
6659 printf (_("\nThere are no relocations in this file.\n"));
6665 /* An absolute address consists of a section and an offset. If the
6666 section is NULL, the offset itself is the address, otherwise, the
6667 address equals to LOAD_ADDRESS(section) + offset. */
6671 unsigned short section
;
6675 #define ABSADDR(a) \
6677 ? section_headers [(a).section].sh_addr + (a).offset \
6680 /* Find the nearest symbol at or below ADDR. Returns the symbol
6681 name, if found, and the offset from the symbol to ADDR. */
6684 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6685 unsigned long nsyms
,
6686 const char * strtab
,
6687 unsigned long strtab_size
,
6688 struct absaddr addr
,
6689 const char ** symname
,
6692 bfd_vma dist
= 0x100000;
6693 Elf_Internal_Sym
* sym
;
6694 Elf_Internal_Sym
* beg
;
6695 Elf_Internal_Sym
* end
;
6696 Elf_Internal_Sym
* best
= NULL
;
6698 REMOVE_ARCH_BITS (addr
.offset
);
6700 end
= symtab
+ nsyms
;
6706 sym
= beg
+ (end
- beg
) / 2;
6708 value
= sym
->st_value
;
6709 REMOVE_ARCH_BITS (value
);
6711 if (sym
->st_name
!= 0
6712 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6713 && addr
.offset
>= value
6714 && addr
.offset
- value
< dist
)
6717 dist
= addr
.offset
- value
;
6722 if (addr
.offset
< value
)
6730 *symname
= (best
->st_name
>= strtab_size
6731 ? _("<corrupt>") : strtab
+ best
->st_name
);
6737 *offset
= addr
.offset
;
6741 symcmp (const void *p
, const void *q
)
6743 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6744 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6746 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6749 /* Process the unwind section. */
6751 #include "unwind-ia64.h"
6753 struct ia64_unw_table_entry
6755 struct absaddr start
;
6757 struct absaddr info
;
6760 struct ia64_unw_aux_info
6762 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6763 unsigned long table_len
; /* Length of unwind table. */
6764 unsigned char * info
; /* Unwind info. */
6765 unsigned long info_size
; /* Size of unwind info. */
6766 bfd_vma info_addr
; /* Starting address of unwind info. */
6767 bfd_vma seg_base
; /* Starting address of segment. */
6768 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6769 unsigned long nsyms
; /* Number of symbols. */
6770 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6771 unsigned long nfuns
; /* Number of entries in funtab. */
6772 char * strtab
; /* The string table. */
6773 unsigned long strtab_size
; /* Size of string table. */
6777 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6779 struct ia64_unw_table_entry
* tp
;
6780 unsigned long j
, nfuns
;
6783 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6784 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6785 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6786 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6788 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6790 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6794 const unsigned char * dp
;
6795 const unsigned char * head
;
6796 const unsigned char * end
;
6797 const char * procname
;
6799 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6800 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6802 fputs ("\n<", stdout
);
6806 fputs (procname
, stdout
);
6809 printf ("+%lx", (unsigned long) offset
);
6812 fputs (">: [", stdout
);
6813 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6814 fputc ('-', stdout
);
6815 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6816 printf ("], info at +0x%lx\n",
6817 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6819 /* PR 17531: file: 86232b32. */
6820 if (aux
->info
== NULL
)
6823 /* PR 17531: file: 0997b4d1. */
6824 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6826 warn (_("Invalid offset %lx in table entry %ld\n"),
6827 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6831 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6832 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6834 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6835 (unsigned) UNW_VER (stamp
),
6836 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6837 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6838 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6839 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6841 if (UNW_VER (stamp
) != 1)
6843 printf (_("\tUnknown version.\n"));
6848 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6849 /* PR 17531: file: 16ceda89. */
6850 if (end
> aux
->info
+ aux
->info_size
)
6851 end
= aux
->info
+ aux
->info_size
;
6852 for (dp
= head
+ 8; dp
< end
;)
6853 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6860 slurp_ia64_unwind_table (FILE * file
,
6861 struct ia64_unw_aux_info
* aux
,
6862 Elf_Internal_Shdr
* sec
)
6864 unsigned long size
, nrelas
, i
;
6865 Elf_Internal_Phdr
* seg
;
6866 struct ia64_unw_table_entry
* tep
;
6867 Elf_Internal_Shdr
* relsec
;
6868 Elf_Internal_Rela
* rela
;
6869 Elf_Internal_Rela
* rp
;
6870 unsigned char * table
;
6872 Elf_Internal_Sym
* sym
;
6873 const char * relname
;
6877 /* First, find the starting address of the segment that includes
6880 if (elf_header
.e_phnum
)
6882 if (! get_program_headers (file
))
6885 for (seg
= program_headers
;
6886 seg
< program_headers
+ elf_header
.e_phnum
;
6889 if (seg
->p_type
!= PT_LOAD
)
6892 if (sec
->sh_addr
>= seg
->p_vaddr
6893 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6895 aux
->seg_base
= seg
->p_vaddr
;
6901 /* Second, build the unwind table from the contents of the unwind section: */
6902 size
= sec
->sh_size
;
6903 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6908 aux
->table_len
= size
/ (3 * eh_addr_size
);
6909 aux
->table
= (struct ia64_unw_table_entry
*)
6910 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6913 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6915 tep
->start
.section
= SHN_UNDEF
;
6916 tep
->end
.section
= SHN_UNDEF
;
6917 tep
->info
.section
= SHN_UNDEF
;
6918 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6919 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6920 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6921 tep
->start
.offset
+= aux
->seg_base
;
6922 tep
->end
.offset
+= aux
->seg_base
;
6923 tep
->info
.offset
+= aux
->seg_base
;
6927 /* Third, apply any relocations to the unwind table: */
6928 for (relsec
= section_headers
;
6929 relsec
< section_headers
+ elf_header
.e_shnum
;
6932 if (relsec
->sh_type
!= SHT_RELA
6933 || relsec
->sh_info
>= elf_header
.e_shnum
6934 || section_headers
+ relsec
->sh_info
!= sec
)
6937 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6946 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6948 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6949 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6951 /* PR 17531: file: 9fa67536. */
6952 if (relname
== NULL
)
6954 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6958 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6960 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6964 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6966 /* PR 17531: file: 5bc8d9bf. */
6967 if (i
>= aux
->table_len
)
6969 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6973 switch (rp
->r_offset
/ eh_addr_size
% 3)
6976 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6977 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6980 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6981 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6984 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6985 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6999 ia64_process_unwind (FILE * file
)
7001 Elf_Internal_Shdr
* sec
;
7002 Elf_Internal_Shdr
* unwsec
= NULL
;
7003 Elf_Internal_Shdr
* strsec
;
7004 unsigned long i
, unwcount
= 0, unwstart
= 0;
7005 struct ia64_unw_aux_info aux
;
7007 memset (& aux
, 0, sizeof (aux
));
7009 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7011 if (sec
->sh_type
== SHT_SYMTAB
7012 && sec
->sh_link
< elf_header
.e_shnum
)
7014 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7016 strsec
= section_headers
+ sec
->sh_link
;
7017 if (aux
.strtab
!= NULL
)
7019 error (_("Multiple auxillary string tables encountered\n"));
7022 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7025 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7027 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7032 printf (_("\nThere are no unwind sections in this file.\n"));
7034 while (unwcount
-- > 0)
7039 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7040 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7041 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7046 /* We have already counted the number of SHT_IA64_UNWIND
7047 sections so the loop above should never fail. */
7048 assert (unwsec
!= NULL
);
7051 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7053 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7055 /* We need to find which section group it is in. */
7056 struct group_list
* g
;
7058 if (section_headers_groups
== NULL
7059 || section_headers_groups
[i
] == NULL
)
7060 i
= elf_header
.e_shnum
;
7063 g
= section_headers_groups
[i
]->root
;
7065 for (; g
!= NULL
; g
= g
->next
)
7067 sec
= section_headers
+ g
->section_index
;
7069 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7074 i
= elf_header
.e_shnum
;
7077 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7079 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7080 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7081 suffix
= SECTION_NAME (unwsec
) + len
;
7082 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7084 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7085 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7090 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7091 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7092 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7093 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7095 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7096 suffix
= SECTION_NAME (unwsec
) + len
;
7097 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7099 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7100 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7104 if (i
== elf_header
.e_shnum
)
7106 printf (_("\nCould not find unwind info section for "));
7108 if (string_table
== NULL
)
7109 printf ("%d", unwsec
->sh_name
);
7111 printf ("'%s'", printable_section_name (unwsec
));
7115 aux
.info_addr
= sec
->sh_addr
;
7116 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7119 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7121 printf (_("\nUnwind section "));
7123 if (string_table
== NULL
)
7124 printf ("%d", unwsec
->sh_name
);
7126 printf ("'%s'", printable_section_name (unwsec
));
7128 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7129 (unsigned long) unwsec
->sh_offset
,
7130 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7132 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7133 && aux
.table_len
> 0)
7134 dump_ia64_unwind (& aux
);
7137 free ((char *) aux
.table
);
7139 free ((char *) aux
.info
);
7148 free ((char *) aux
.strtab
);
7151 struct hppa_unw_table_entry
7153 struct absaddr start
;
7155 unsigned int Cannot_unwind
:1; /* 0 */
7156 unsigned int Millicode
:1; /* 1 */
7157 unsigned int Millicode_save_sr0
:1; /* 2 */
7158 unsigned int Region_description
:2; /* 3..4 */
7159 unsigned int reserved1
:1; /* 5 */
7160 unsigned int Entry_SR
:1; /* 6 */
7161 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7162 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7163 unsigned int Args_stored
:1; /* 16 */
7164 unsigned int Variable_Frame
:1; /* 17 */
7165 unsigned int Separate_Package_Body
:1; /* 18 */
7166 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7167 unsigned int Stack_Overflow_Check
:1; /* 20 */
7168 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7169 unsigned int Ada_Region
:1; /* 22 */
7170 unsigned int cxx_info
:1; /* 23 */
7171 unsigned int cxx_try_catch
:1; /* 24 */
7172 unsigned int sched_entry_seq
:1; /* 25 */
7173 unsigned int reserved2
:1; /* 26 */
7174 unsigned int Save_SP
:1; /* 27 */
7175 unsigned int Save_RP
:1; /* 28 */
7176 unsigned int Save_MRP_in_frame
:1; /* 29 */
7177 unsigned int extn_ptr_defined
:1; /* 30 */
7178 unsigned int Cleanup_defined
:1; /* 31 */
7180 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7181 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7182 unsigned int Large_frame
:1; /* 2 */
7183 unsigned int Pseudo_SP_Set
:1; /* 3 */
7184 unsigned int reserved4
:1; /* 4 */
7185 unsigned int Total_frame_size
:27; /* 5..31 */
7188 struct hppa_unw_aux_info
7190 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7191 unsigned long table_len
; /* Length of unwind table. */
7192 bfd_vma seg_base
; /* Starting address of segment. */
7193 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7194 unsigned long nsyms
; /* Number of symbols. */
7195 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7196 unsigned long nfuns
; /* Number of entries in funtab. */
7197 char * strtab
; /* The string table. */
7198 unsigned long strtab_size
; /* Size of string table. */
7202 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7204 struct hppa_unw_table_entry
* tp
;
7205 unsigned long j
, nfuns
;
7207 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7208 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7209 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7210 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7212 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7214 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7217 const char * procname
;
7219 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7220 aux
->strtab_size
, tp
->start
, &procname
,
7223 fputs ("\n<", stdout
);
7227 fputs (procname
, stdout
);
7230 printf ("+%lx", (unsigned long) offset
);
7233 fputs (">: [", stdout
);
7234 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7235 fputc ('-', stdout
);
7236 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7239 #define PF(_m) if (tp->_m) printf (#_m " ");
7240 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7243 PF(Millicode_save_sr0
);
7244 /* PV(Region_description); */
7250 PF(Separate_Package_Body
);
7251 PF(Frame_Extension_Millicode
);
7252 PF(Stack_Overflow_Check
);
7253 PF(Two_Instruction_SP_Increment
);
7257 PF(sched_entry_seq
);
7260 PF(Save_MRP_in_frame
);
7261 PF(extn_ptr_defined
);
7262 PF(Cleanup_defined
);
7263 PF(MPE_XL_interrupt_marker
);
7264 PF(HP_UX_interrupt_marker
);
7267 PV(Total_frame_size
);
7278 slurp_hppa_unwind_table (FILE * file
,
7279 struct hppa_unw_aux_info
* aux
,
7280 Elf_Internal_Shdr
* sec
)
7282 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7283 Elf_Internal_Phdr
* seg
;
7284 struct hppa_unw_table_entry
* tep
;
7285 Elf_Internal_Shdr
* relsec
;
7286 Elf_Internal_Rela
* rela
;
7287 Elf_Internal_Rela
* rp
;
7288 unsigned char * table
;
7290 Elf_Internal_Sym
* sym
;
7291 const char * relname
;
7293 /* First, find the starting address of the segment that includes
7296 if (elf_header
.e_phnum
)
7298 if (! get_program_headers (file
))
7301 for (seg
= program_headers
;
7302 seg
< program_headers
+ elf_header
.e_phnum
;
7305 if (seg
->p_type
!= PT_LOAD
)
7308 if (sec
->sh_addr
>= seg
->p_vaddr
7309 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7311 aux
->seg_base
= seg
->p_vaddr
;
7317 /* Second, build the unwind table from the contents of the unwind
7319 size
= sec
->sh_size
;
7320 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7326 nentries
= size
/ unw_ent_size
;
7327 size
= unw_ent_size
* nentries
;
7329 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7330 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7332 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7334 unsigned int tmp1
, tmp2
;
7336 tep
->start
.section
= SHN_UNDEF
;
7337 tep
->end
.section
= SHN_UNDEF
;
7339 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7340 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7341 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7342 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7344 tep
->start
.offset
+= aux
->seg_base
;
7345 tep
->end
.offset
+= aux
->seg_base
;
7347 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7348 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7349 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7350 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7351 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7352 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7353 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7354 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7355 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7356 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7357 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7358 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7359 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7360 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7361 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7362 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7363 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7364 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7365 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7366 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7367 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7368 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7369 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7370 tep
->Cleanup_defined
= tmp1
& 0x1;
7372 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7373 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7374 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7375 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7376 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7377 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7381 /* Third, apply any relocations to the unwind table. */
7382 for (relsec
= section_headers
;
7383 relsec
< section_headers
+ elf_header
.e_shnum
;
7386 if (relsec
->sh_type
!= SHT_RELA
7387 || relsec
->sh_info
>= elf_header
.e_shnum
7388 || section_headers
+ relsec
->sh_info
!= sec
)
7391 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7395 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7397 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7398 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7400 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7401 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7403 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7407 i
= rp
->r_offset
/ unw_ent_size
;
7409 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7412 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7413 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7416 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7417 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7427 aux
->table_len
= nentries
;
7433 hppa_process_unwind (FILE * file
)
7435 struct hppa_unw_aux_info aux
;
7436 Elf_Internal_Shdr
* unwsec
= NULL
;
7437 Elf_Internal_Shdr
* strsec
;
7438 Elf_Internal_Shdr
* sec
;
7441 if (string_table
== NULL
)
7444 memset (& aux
, 0, sizeof (aux
));
7446 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7448 if (sec
->sh_type
== SHT_SYMTAB
7449 && sec
->sh_link
< elf_header
.e_shnum
)
7451 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7453 strsec
= section_headers
+ sec
->sh_link
;
7454 if (aux
.strtab
!= NULL
)
7456 error (_("Multiple auxillary string tables encountered\n"));
7459 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7462 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7464 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7469 printf (_("\nThere are no unwind sections in this file.\n"));
7471 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7473 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7475 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7476 printable_section_name (sec
),
7477 (unsigned long) sec
->sh_offset
,
7478 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7480 slurp_hppa_unwind_table (file
, &aux
, sec
);
7481 if (aux
.table_len
> 0)
7482 dump_hppa_unwind (&aux
);
7485 free ((char *) aux
.table
);
7493 free ((char *) aux
.strtab
);
7498 unsigned char * data
; /* The unwind data. */
7499 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7500 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7501 unsigned long nrelas
; /* The number of relocations. */
7502 unsigned int rel_type
; /* REL or RELA ? */
7503 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7506 struct arm_unw_aux_info
7508 FILE * file
; /* The file containing the unwind sections. */
7509 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7510 unsigned long nsyms
; /* Number of symbols. */
7511 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7512 unsigned long nfuns
; /* Number of these symbols. */
7513 char * strtab
; /* The file's string table. */
7514 unsigned long strtab_size
; /* Size of string table. */
7518 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7519 bfd_vma fn
, struct absaddr addr
)
7521 const char *procname
;
7524 if (addr
.section
== SHN_UNDEF
)
7527 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7528 aux
->strtab_size
, addr
, &procname
,
7531 print_vma (fn
, PREFIX_HEX
);
7535 fputs (" <", stdout
);
7536 fputs (procname
, stdout
);
7539 printf ("+0x%lx", (unsigned long) sym_offset
);
7540 fputc ('>', stdout
);
7547 arm_free_section (struct arm_section
*arm_sec
)
7549 if (arm_sec
->data
!= NULL
)
7550 free (arm_sec
->data
);
7552 if (arm_sec
->rela
!= NULL
)
7553 free (arm_sec
->rela
);
7556 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7557 cached section and install SEC instead.
7558 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7559 and return its valued in * WORDP, relocating if necessary.
7560 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7561 relocation's offset in ADDR.
7562 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7563 into the string table of the symbol associated with the reloc. If no
7564 reloc was applied store -1 there.
7565 5) Return TRUE upon success, FALSE otherwise. */
7568 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7569 struct arm_section
* arm_sec
,
7570 Elf_Internal_Shdr
* sec
,
7571 bfd_vma word_offset
,
7572 unsigned int * wordp
,
7573 struct absaddr
* addr
,
7576 Elf_Internal_Rela
*rp
;
7577 Elf_Internal_Sym
*sym
;
7578 const char * relname
;
7580 bfd_boolean wrapped
;
7582 if (sec
== NULL
|| arm_sec
== NULL
)
7585 addr
->section
= SHN_UNDEF
;
7588 if (sym_name
!= NULL
)
7589 *sym_name
= (bfd_vma
) -1;
7591 /* If necessary, update the section cache. */
7592 if (sec
!= arm_sec
->sec
)
7594 Elf_Internal_Shdr
*relsec
;
7596 arm_free_section (arm_sec
);
7599 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7600 sec
->sh_size
, _("unwind data"));
7601 arm_sec
->rela
= NULL
;
7602 arm_sec
->nrelas
= 0;
7604 for (relsec
= section_headers
;
7605 relsec
< section_headers
+ elf_header
.e_shnum
;
7608 if (relsec
->sh_info
>= elf_header
.e_shnum
7609 || section_headers
+ relsec
->sh_info
!= sec
7610 /* PR 15745: Check the section type as well. */
7611 || (relsec
->sh_type
!= SHT_REL
7612 && relsec
->sh_type
!= SHT_RELA
))
7615 arm_sec
->rel_type
= relsec
->sh_type
;
7616 if (relsec
->sh_type
== SHT_REL
)
7618 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7620 & arm_sec
->rela
, & arm_sec
->nrelas
))
7623 else /* relsec->sh_type == SHT_RELA */
7625 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7627 & arm_sec
->rela
, & arm_sec
->nrelas
))
7633 arm_sec
->next_rela
= arm_sec
->rela
;
7636 /* If there is no unwind data we can do nothing. */
7637 if (arm_sec
->data
== NULL
)
7640 /* If the offset is invalid then fail. */
7641 if (word_offset
> (sec
->sh_size
- 4)
7643 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7644 || ((bfd_signed_vma
) word_offset
) < 0)
7647 /* Get the word at the required offset. */
7648 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7650 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7651 if (arm_sec
->rela
== NULL
)
7657 /* Look through the relocs to find the one that applies to the provided offset. */
7659 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7661 bfd_vma prelval
, offset
;
7663 if (rp
->r_offset
> word_offset
&& !wrapped
)
7668 if (rp
->r_offset
> word_offset
)
7671 if (rp
->r_offset
& 3)
7673 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7674 (unsigned long) rp
->r_offset
);
7678 if (rp
->r_offset
< word_offset
)
7681 /* PR 17531: file: 027-161405-0.004 */
7682 if (aux
->symtab
== NULL
)
7685 if (arm_sec
->rel_type
== SHT_REL
)
7687 offset
= word
& 0x7fffffff;
7688 if (offset
& 0x40000000)
7689 offset
|= ~ (bfd_vma
) 0x7fffffff;
7691 else if (arm_sec
->rel_type
== SHT_RELA
)
7692 offset
= rp
->r_addend
;
7695 error (_("Unknown section relocation type %d encountered\n"),
7700 /* PR 17531 file: 027-1241568-0.004. */
7701 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7703 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7704 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7708 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7709 offset
+= sym
->st_value
;
7710 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7712 /* Check that we are processing the expected reloc type. */
7713 if (elf_header
.e_machine
== EM_ARM
)
7715 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7716 if (relname
== NULL
)
7718 warn (_("Skipping unknown ARM relocation type: %d\n"),
7719 (int) ELF32_R_TYPE (rp
->r_info
));
7723 if (streq (relname
, "R_ARM_NONE"))
7726 if (! streq (relname
, "R_ARM_PREL31"))
7728 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7732 else if (elf_header
.e_machine
== EM_TI_C6000
)
7734 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7735 if (relname
== NULL
)
7737 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7738 (int) ELF32_R_TYPE (rp
->r_info
));
7742 if (streq (relname
, "R_C6000_NONE"))
7745 if (! streq (relname
, "R_C6000_PREL31"))
7747 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7755 /* This function currently only supports ARM and TI unwinders. */
7756 warn (_("Only TI and ARM unwinders are currently supported\n"));
7760 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7761 addr
->section
= sym
->st_shndx
;
7762 addr
->offset
= offset
;
7765 * sym_name
= sym
->st_name
;
7770 arm_sec
->next_rela
= rp
;
7775 static const char *tic6x_unwind_regnames
[16] =
7777 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7778 "A14", "A13", "A12", "A11", "A10",
7779 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7783 decode_tic6x_unwind_regmask (unsigned int mask
)
7787 for (i
= 12; mask
; mask
>>= 1, i
--)
7791 fputs (tic6x_unwind_regnames
[i
], stdout
);
7793 fputs (", ", stdout
);
7799 if (remaining == 0 && more_words) \
7802 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7803 data_offset, & word, & addr, NULL)) \
7809 #define GET_OP(OP) \
7814 (OP) = word >> 24; \
7819 printf (_("[Truncated opcode]\n")); \
7822 printf ("0x%02x ", OP)
7825 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7827 unsigned int remaining
,
7828 unsigned int more_words
,
7829 bfd_vma data_offset
,
7830 Elf_Internal_Shdr
* data_sec
,
7831 struct arm_section
* data_arm_sec
)
7833 struct absaddr addr
;
7835 /* Decode the unwinding instructions. */
7838 unsigned int op
, op2
;
7847 printf (" 0x%02x ", op
);
7849 if ((op
& 0xc0) == 0x00)
7851 int offset
= ((op
& 0x3f) << 2) + 4;
7853 printf (" vsp = vsp + %d", offset
);
7855 else if ((op
& 0xc0) == 0x40)
7857 int offset
= ((op
& 0x3f) << 2) + 4;
7859 printf (" vsp = vsp - %d", offset
);
7861 else if ((op
& 0xf0) == 0x80)
7864 if (op
== 0x80 && op2
== 0)
7865 printf (_("Refuse to unwind"));
7868 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7873 for (i
= 0; i
< 12; i
++)
7874 if (mask
& (1 << i
))
7880 printf ("r%d", 4 + i
);
7885 else if ((op
& 0xf0) == 0x90)
7887 if (op
== 0x9d || op
== 0x9f)
7888 printf (_(" [Reserved]"));
7890 printf (" vsp = r%d", op
& 0x0f);
7892 else if ((op
& 0xf0) == 0xa0)
7894 int end
= 4 + (op
& 0x07);
7899 for (i
= 4; i
<= end
; i
++)
7915 else if (op
== 0xb0)
7916 printf (_(" finish"));
7917 else if (op
== 0xb1)
7920 if (op2
== 0 || (op2
& 0xf0) != 0)
7921 printf (_("[Spare]"));
7924 unsigned int mask
= op2
& 0x0f;
7929 for (i
= 0; i
< 12; i
++)
7930 if (mask
& (1 << i
))
7941 else if (op
== 0xb2)
7943 unsigned char buf
[9];
7944 unsigned int i
, len
;
7945 unsigned long offset
;
7947 for (i
= 0; i
< sizeof (buf
); i
++)
7950 if ((buf
[i
] & 0x80) == 0)
7953 if (i
== sizeof (buf
))
7954 printf (_("corrupt change to vsp"));
7957 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7958 assert (len
== i
+ 1);
7959 offset
= offset
* 4 + 0x204;
7960 printf ("vsp = vsp + %ld", offset
);
7963 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7965 unsigned int first
, last
;
7972 printf ("pop {D%d", first
);
7974 printf ("-D%d", first
+ last
);
7977 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7979 unsigned int count
= op
& 0x07;
7983 printf ("-D%d", 8 + count
);
7986 else if (op
>= 0xc0 && op
<= 0xc5)
7988 unsigned int count
= op
& 0x07;
7990 printf (" pop {wR10");
7992 printf ("-wR%d", 10 + count
);
7995 else if (op
== 0xc6)
7997 unsigned int first
, last
;
8002 printf ("pop {wR%d", first
);
8004 printf ("-wR%d", first
+ last
);
8007 else if (op
== 0xc7)
8010 if (op2
== 0 || (op2
& 0xf0) != 0)
8011 printf (_("[Spare]"));
8014 unsigned int mask
= op2
& 0x0f;
8019 for (i
= 0; i
< 4; i
++)
8020 if (mask
& (1 << i
))
8026 printf ("wCGR%d", i
);
8032 printf (_(" [unsupported opcode]"));
8038 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8040 unsigned int remaining
,
8041 unsigned int more_words
,
8042 bfd_vma data_offset
,
8043 Elf_Internal_Shdr
* data_sec
,
8044 struct arm_section
* data_arm_sec
)
8046 struct absaddr addr
;
8048 /* Decode the unwinding instructions. */
8051 unsigned int op
, op2
;
8060 printf (" 0x%02x ", op
);
8062 if ((op
& 0xc0) == 0x00)
8064 int offset
= ((op
& 0x3f) << 3) + 8;
8065 printf (" sp = sp + %d", offset
);
8067 else if ((op
& 0xc0) == 0x80)
8070 if (op
== 0x80 && op2
== 0)
8071 printf (_("Refuse to unwind"));
8074 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8076 printf ("pop compact {");
8080 decode_tic6x_unwind_regmask (mask
);
8084 else if ((op
& 0xf0) == 0xc0)
8092 unsigned int offset
;
8096 /* Scan entire instruction first so that GET_OP output is not
8097 interleaved with disassembly. */
8099 for (i
= 0; nregs
< (op
& 0xf); i
++)
8105 regpos
[nregs
].offset
= i
* 2;
8106 regpos
[nregs
].reg
= reg
;
8113 regpos
[nregs
].offset
= i
* 2 + 1;
8114 regpos
[nregs
].reg
= reg
;
8119 printf (_("pop frame {"));
8121 for (i
= i
* 2; i
> 0; i
--)
8123 if (regpos
[reg
].offset
== i
- 1)
8125 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8132 fputs (name
, stdout
);
8139 else if (op
== 0xd0)
8140 printf (" MOV FP, SP");
8141 else if (op
== 0xd1)
8142 printf (" __c6xabi_pop_rts");
8143 else if (op
== 0xd2)
8145 unsigned char buf
[9];
8146 unsigned int i
, len
;
8147 unsigned long offset
;
8149 for (i
= 0; i
< sizeof (buf
); i
++)
8152 if ((buf
[i
] & 0x80) == 0)
8155 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8156 if (i
== sizeof (buf
))
8158 printf ("<corrupt sp adjust>\n");
8159 warn (_("Corrupt stack pointer adjustment detected\n"));
8163 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8164 assert (len
== i
+ 1);
8165 offset
= offset
* 8 + 0x408;
8166 printf (_("sp = sp + %ld"), offset
);
8168 else if ((op
& 0xf0) == 0xe0)
8170 if ((op
& 0x0f) == 7)
8173 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8177 printf (_(" [unsupported opcode]"));
8184 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8188 offset
= word
& 0x7fffffff;
8189 if (offset
& 0x40000000)
8190 offset
|= ~ (bfd_vma
) 0x7fffffff;
8192 if (elf_header
.e_machine
== EM_TI_C6000
)
8195 return offset
+ where
;
8199 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8201 unsigned int remaining
,
8202 bfd_vma data_offset
,
8203 Elf_Internal_Shdr
* data_sec
,
8204 struct arm_section
* data_arm_sec
)
8207 unsigned int more_words
= 0;
8208 struct absaddr addr
;
8209 bfd_vma sym_name
= (bfd_vma
) -1;
8213 /* Fetch the first word.
8214 Note - when decoding an object file the address extracted
8215 here will always be 0. So we also pass in the sym_name
8216 parameter so that we can find the symbol associated with
8217 the personality routine. */
8218 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8219 & word
, & addr
, & sym_name
))
8225 if ((word
& 0x80000000) == 0)
8227 /* Expand prel31 for personality routine. */
8229 const char *procname
;
8231 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8232 printf (_(" Personality routine: "));
8234 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8235 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8237 procname
= aux
->strtab
+ sym_name
;
8238 print_vma (fn
, PREFIX_HEX
);
8241 fputs (" <", stdout
);
8242 fputs (procname
, stdout
);
8243 fputc ('>', stdout
);
8247 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8248 fputc ('\n', stdout
);
8250 /* The GCC personality routines use the standard compact
8251 encoding, starting with one byte giving the number of
8253 if (procname
!= NULL
8254 && (const_strneq (procname
, "__gcc_personality_v0")
8255 || const_strneq (procname
, "__gxx_personality_v0")
8256 || const_strneq (procname
, "__gcj_personality_v0")
8257 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8264 printf (_(" [Truncated data]\n"));
8267 more_words
= word
>> 24;
8277 /* ARM EHABI Section 6.3:
8279 An exception-handling table entry for the compact model looks like:
8283 1 0 index Data for personalityRoutine[index] */
8285 if (elf_header
.e_machine
== EM_ARM
8286 && (word
& 0x70000000))
8287 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8289 per_index
= (word
>> 24) & 0x7f;
8290 printf (_(" Compact model index: %d\n"), per_index
);
8297 else if (per_index
< 3)
8299 more_words
= (word
>> 16) & 0xff;
8305 switch (elf_header
.e_machine
)
8310 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8311 data_offset
, data_sec
, data_arm_sec
);
8315 warn (_("Unknown ARM compact model index encountered\n"));
8316 printf (_(" [reserved]\n"));
8323 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8324 data_offset
, data_sec
, data_arm_sec
);
8326 else if (per_index
< 5)
8328 if (((word
>> 17) & 0x7f) == 0x7f)
8329 printf (_(" Restore stack from frame pointer\n"));
8331 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8332 printf (_(" Registers restored: "));
8334 printf (" (compact) ");
8335 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8337 printf (_(" Return register: %s\n"),
8338 tic6x_unwind_regnames
[word
& 0xf]);
8341 printf (_(" [reserved (%d)]\n"), per_index
);
8345 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8346 elf_header
.e_machine
);
8349 /* Decode the descriptors. Not implemented. */
8353 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8355 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8356 unsigned int i
, exidx_len
;
8357 unsigned long j
, nfuns
;
8359 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8360 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8361 exidx_len
= exidx_sec
->sh_size
/ 8;
8363 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8364 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8365 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8366 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8368 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8370 for (i
= 0; i
< exidx_len
; i
++)
8372 unsigned int exidx_fn
, exidx_entry
;
8373 struct absaddr fn_addr
, entry_addr
;
8376 fputc ('\n', stdout
);
8378 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8379 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8380 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8381 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8384 arm_free_section (& exidx_arm_sec
);
8385 arm_free_section (& extab_arm_sec
);
8389 /* ARM EHABI, Section 5:
8390 An index table entry consists of 2 words.
8391 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8392 if (exidx_fn
& 0x80000000)
8393 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8395 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8397 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8398 fputs (": ", stdout
);
8400 if (exidx_entry
== 1)
8402 print_vma (exidx_entry
, PREFIX_HEX
);
8403 fputs (" [cantunwind]\n", stdout
);
8405 else if (exidx_entry
& 0x80000000)
8407 print_vma (exidx_entry
, PREFIX_HEX
);
8408 fputc ('\n', stdout
);
8409 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8413 bfd_vma table
, table_offset
= 0;
8414 Elf_Internal_Shdr
*table_sec
;
8416 fputs ("@", stdout
);
8417 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8418 print_vma (table
, PREFIX_HEX
);
8421 /* Locate the matching .ARM.extab. */
8422 if (entry_addr
.section
!= SHN_UNDEF
8423 && entry_addr
.section
< elf_header
.e_shnum
)
8425 table_sec
= section_headers
+ entry_addr
.section
;
8426 table_offset
= entry_addr
.offset
;
8428 if (table_offset
> table_sec
->sh_size
8429 || ((bfd_signed_vma
) table_offset
) < 0)
8431 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8432 (unsigned long) table_offset
,
8433 printable_section_name (table_sec
));
8439 table_sec
= find_section_by_address (table
);
8440 if (table_sec
!= NULL
)
8441 table_offset
= table
- table_sec
->sh_addr
;
8443 if (table_sec
== NULL
)
8445 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8446 (unsigned long) table
);
8449 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8457 arm_free_section (&exidx_arm_sec
);
8458 arm_free_section (&extab_arm_sec
);
8461 /* Used for both ARM and C6X unwinding tables. */
8464 arm_process_unwind (FILE *file
)
8466 struct arm_unw_aux_info aux
;
8467 Elf_Internal_Shdr
*unwsec
= NULL
;
8468 Elf_Internal_Shdr
*strsec
;
8469 Elf_Internal_Shdr
*sec
;
8471 unsigned int sec_type
;
8473 switch (elf_header
.e_machine
)
8476 sec_type
= SHT_ARM_EXIDX
;
8480 sec_type
= SHT_C6000_UNWIND
;
8484 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8485 elf_header
.e_machine
);
8489 if (string_table
== NULL
)
8492 memset (& aux
, 0, sizeof (aux
));
8495 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8497 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8499 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8501 strsec
= section_headers
+ sec
->sh_link
;
8503 /* PR binutils/17531 file: 011-12666-0.004. */
8504 if (aux
.strtab
!= NULL
)
8506 error (_("Multiple string tables found in file.\n"));
8509 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8510 1, strsec
->sh_size
, _("string table"));
8511 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8513 else if (sec
->sh_type
== sec_type
)
8518 printf (_("\nThere are no unwind sections in this file.\n"));
8520 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8522 if (sec
->sh_type
== sec_type
)
8524 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8525 printable_section_name (sec
),
8526 (unsigned long) sec
->sh_offset
,
8527 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8529 dump_arm_unwind (&aux
, sec
);
8536 free ((char *) aux
.strtab
);
8540 process_unwind (FILE * file
)
8542 struct unwind_handler
8545 void (* handler
)(FILE *);
8548 { EM_ARM
, arm_process_unwind
},
8549 { EM_IA_64
, ia64_process_unwind
},
8550 { EM_PARISC
, hppa_process_unwind
},
8551 { EM_TI_C6000
, arm_process_unwind
},
8559 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8560 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8562 handlers
[i
].handler (file
);
8566 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8567 get_machine_name (elf_header
.e_machine
));
8571 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8573 switch (entry
->d_tag
)
8576 if (entry
->d_un
.d_val
== 0)
8580 static const char * opts
[] =
8582 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8583 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8584 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8585 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8591 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8592 if (entry
->d_un
.d_val
& (1 << cnt
))
8594 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8600 case DT_MIPS_IVERSION
:
8601 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8602 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8606 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8607 /* Note: coded this way so that there is a single string for translation. */
8608 printf (_("<corrupt: %s>"), buf
);
8612 case DT_MIPS_TIME_STAMP
:
8616 time_t atime
= entry
->d_un
.d_val
;
8618 tmp
= gmtime (&atime
);
8619 /* PR 17531: file: 6accc532. */
8621 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8623 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8624 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8625 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8626 printf (_("Time Stamp: %s"), timebuf
);
8630 case DT_MIPS_RLD_VERSION
:
8631 case DT_MIPS_LOCAL_GOTNO
:
8632 case DT_MIPS_CONFLICTNO
:
8633 case DT_MIPS_LIBLISTNO
:
8634 case DT_MIPS_SYMTABNO
:
8635 case DT_MIPS_UNREFEXTNO
:
8636 case DT_MIPS_HIPAGENO
:
8637 case DT_MIPS_DELTA_CLASS_NO
:
8638 case DT_MIPS_DELTA_INSTANCE_NO
:
8639 case DT_MIPS_DELTA_RELOC_NO
:
8640 case DT_MIPS_DELTA_SYM_NO
:
8641 case DT_MIPS_DELTA_CLASSSYM_NO
:
8642 case DT_MIPS_COMPACT_SIZE
:
8643 print_vma (entry
->d_un
.d_ptr
, DEC
);
8647 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8653 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8655 switch (entry
->d_tag
)
8657 case DT_HP_DLD_FLAGS
:
8666 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8667 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8668 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8669 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8670 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8671 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8672 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8673 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8674 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8675 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8676 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8677 { DT_HP_GST
, "HP_GST" },
8678 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8679 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8680 { DT_HP_NODELETE
, "HP_NODELETE" },
8681 { DT_HP_GROUP
, "HP_GROUP" },
8682 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8686 bfd_vma val
= entry
->d_un
.d_val
;
8688 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8689 if (val
& flags
[cnt
].bit
)
8693 fputs (flags
[cnt
].str
, stdout
);
8695 val
^= flags
[cnt
].bit
;
8698 if (val
!= 0 || first
)
8702 print_vma (val
, HEX
);
8708 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8716 /* VMS vs Unix time offset and factor. */
8718 #define VMS_EPOCH_OFFSET 35067168000000000LL
8719 #define VMS_GRANULARITY_FACTOR 10000000
8721 /* Display a VMS time in a human readable format. */
8724 print_vms_time (bfd_int64_t vmstime
)
8729 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8730 tm
= gmtime (&unxtime
);
8731 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8732 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8733 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8738 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8740 switch (entry
->d_tag
)
8742 case DT_IA_64_PLT_RESERVE
:
8743 /* First 3 slots reserved. */
8744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8746 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8749 case DT_IA_64_VMS_LINKTIME
:
8751 print_vms_time (entry
->d_un
.d_val
);
8755 case DT_IA_64_VMS_LNKFLAGS
:
8756 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8757 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8758 printf (" CALL_DEBUG");
8759 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8760 printf (" NOP0BUFS");
8761 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8762 printf (" P0IMAGE");
8763 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8764 printf (" MKTHREADS");
8765 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8766 printf (" UPCALLS");
8767 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8769 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8770 printf (" INITIALIZE");
8771 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8773 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8774 printf (" EXE_INIT");
8775 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8776 printf (" TBK_IN_IMG");
8777 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8778 printf (" DBG_IN_IMG");
8779 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8780 printf (" TBK_IN_DSF");
8781 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8782 printf (" DBG_IN_DSF");
8783 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8784 printf (" SIGNATURES");
8785 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8786 printf (" REL_SEG_OFF");
8790 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8797 get_32bit_dynamic_section (FILE * file
)
8799 Elf32_External_Dyn
* edyn
;
8800 Elf32_External_Dyn
* ext
;
8801 Elf_Internal_Dyn
* entry
;
8803 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8804 dynamic_size
, _("dynamic section"));
8808 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8809 might not have the luxury of section headers. Look for the DT_NULL
8810 terminator to determine the number of entries. */
8811 for (ext
= edyn
, dynamic_nent
= 0;
8812 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8816 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8820 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8822 if (dynamic_section
== NULL
)
8824 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8825 (unsigned long) dynamic_nent
);
8830 for (ext
= edyn
, entry
= dynamic_section
;
8831 entry
< dynamic_section
+ dynamic_nent
;
8834 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8835 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8844 get_64bit_dynamic_section (FILE * file
)
8846 Elf64_External_Dyn
* edyn
;
8847 Elf64_External_Dyn
* ext
;
8848 Elf_Internal_Dyn
* entry
;
8850 /* Read in the data. */
8851 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8852 dynamic_size
, _("dynamic section"));
8856 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8857 might not have the luxury of section headers. Look for the DT_NULL
8858 terminator to determine the number of entries. */
8859 for (ext
= edyn
, dynamic_nent
= 0;
8860 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8861 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8865 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8869 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8871 if (dynamic_section
== NULL
)
8873 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8874 (unsigned long) dynamic_nent
);
8879 /* Convert from external to internal formats. */
8880 for (ext
= edyn
, entry
= dynamic_section
;
8881 entry
< dynamic_section
+ dynamic_nent
;
8884 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8885 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8894 print_dynamic_flags (bfd_vma flags
)
8902 flag
= flags
& - flags
;
8912 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8913 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8914 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8915 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8916 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8917 default: fputs (_("unknown"), stdout
); break;
8923 /* Parse and display the contents of the dynamic section. */
8926 process_dynamic_section (FILE * file
)
8928 Elf_Internal_Dyn
* entry
;
8930 if (dynamic_size
== 0)
8933 printf (_("\nThere is no dynamic section in this file.\n"));
8940 if (! get_32bit_dynamic_section (file
))
8943 else if (! get_64bit_dynamic_section (file
))
8946 /* Find the appropriate symbol table. */
8947 if (dynamic_symbols
== NULL
)
8949 for (entry
= dynamic_section
;
8950 entry
< dynamic_section
+ dynamic_nent
;
8953 Elf_Internal_Shdr section
;
8955 if (entry
->d_tag
!= DT_SYMTAB
)
8958 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8960 /* Since we do not know how big the symbol table is,
8961 we default to reading in the entire file (!) and
8962 processing that. This is overkill, I know, but it
8964 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8966 if (archive_file_offset
!= 0)
8967 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8970 if (fseek (file
, 0, SEEK_END
))
8971 error (_("Unable to seek to end of file!\n"));
8973 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8977 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8979 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8980 section
.sh_name
= string_table_length
;
8982 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8983 if (num_dynamic_syms
< 1)
8985 error (_("Unable to determine the number of symbols to load\n"));
8991 /* Similarly find a string table. */
8992 if (dynamic_strings
== NULL
)
8994 for (entry
= dynamic_section
;
8995 entry
< dynamic_section
+ dynamic_nent
;
8998 unsigned long offset
;
9001 if (entry
->d_tag
!= DT_STRTAB
)
9004 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9006 /* Since we do not know how big the string table is,
9007 we default to reading in the entire file (!) and
9008 processing that. This is overkill, I know, but it
9011 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9013 if (archive_file_offset
!= 0)
9014 str_tab_len
= archive_file_size
- offset
;
9017 if (fseek (file
, 0, SEEK_END
))
9018 error (_("Unable to seek to end of file\n"));
9019 str_tab_len
= ftell (file
) - offset
;
9022 if (str_tab_len
< 1)
9025 (_("Unable to determine the length of the dynamic string table\n"));
9029 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9031 _("dynamic string table"));
9032 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9037 /* And find the syminfo section if available. */
9038 if (dynamic_syminfo
== NULL
)
9040 unsigned long syminsz
= 0;
9042 for (entry
= dynamic_section
;
9043 entry
< dynamic_section
+ dynamic_nent
;
9046 if (entry
->d_tag
== DT_SYMINENT
)
9048 /* Note: these braces are necessary to avoid a syntax
9049 error from the SunOS4 C compiler. */
9050 /* PR binutils/17531: A corrupt file can trigger this test.
9051 So do not use an assert, instead generate an error message. */
9052 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9053 error (_("Bad value (%d) for SYMINENT entry\n"),
9054 (int) entry
->d_un
.d_val
);
9056 else if (entry
->d_tag
== DT_SYMINSZ
)
9057 syminsz
= entry
->d_un
.d_val
;
9058 else if (entry
->d_tag
== DT_SYMINFO
)
9059 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9063 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9065 Elf_External_Syminfo
* extsyminfo
;
9066 Elf_External_Syminfo
* extsym
;
9067 Elf_Internal_Syminfo
* syminfo
;
9069 /* There is a syminfo section. Read the data. */
9070 extsyminfo
= (Elf_External_Syminfo
*)
9071 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9072 _("symbol information"));
9076 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9077 if (dynamic_syminfo
== NULL
)
9079 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9080 (unsigned long) syminsz
);
9084 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9085 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9086 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9087 ++syminfo
, ++extsym
)
9089 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9090 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9097 if (do_dynamic
&& dynamic_addr
)
9098 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9099 dynamic_addr
, (unsigned long) dynamic_nent
);
9101 printf (_(" Tag Type Name/Value\n"));
9103 for (entry
= dynamic_section
;
9104 entry
< dynamic_section
+ dynamic_nent
;
9112 print_vma (entry
->d_tag
, FULL_HEX
);
9113 dtype
= get_dynamic_type (entry
->d_tag
);
9114 printf (" (%s)%*s", dtype
,
9115 ((is_32bit_elf
? 27 : 19)
9116 - (int) strlen (dtype
)),
9120 switch (entry
->d_tag
)
9124 print_dynamic_flags (entry
->d_un
.d_val
);
9134 switch (entry
->d_tag
)
9137 printf (_("Auxiliary library"));
9141 printf (_("Filter library"));
9145 printf (_("Configuration file"));
9149 printf (_("Dependency audit library"));
9153 printf (_("Audit library"));
9157 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9158 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9162 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
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
& DTF_1_PARINIT
)
9181 printf (" PARINIT");
9182 val
^= DTF_1_PARINIT
;
9184 if (val
& DTF_1_CONFEXP
)
9186 printf (" CONFEXP");
9187 val
^= DTF_1_CONFEXP
;
9190 printf (" %lx", val
);
9199 printf (_("Flags:"));
9201 if (entry
->d_un
.d_val
== 0)
9202 printf (_(" None\n"));
9205 unsigned long int val
= entry
->d_un
.d_val
;
9207 if (val
& DF_P1_LAZYLOAD
)
9209 printf (" LAZYLOAD");
9210 val
^= DF_P1_LAZYLOAD
;
9212 if (val
& DF_P1_GROUPPERM
)
9214 printf (" GROUPPERM");
9215 val
^= DF_P1_GROUPPERM
;
9218 printf (" %lx", val
);
9227 printf (_("Flags:"));
9228 if (entry
->d_un
.d_val
== 0)
9229 printf (_(" None\n"));
9232 unsigned long int val
= entry
->d_un
.d_val
;
9239 if (val
& DF_1_GLOBAL
)
9244 if (val
& DF_1_GROUP
)
9249 if (val
& DF_1_NODELETE
)
9251 printf (" NODELETE");
9252 val
^= DF_1_NODELETE
;
9254 if (val
& DF_1_LOADFLTR
)
9256 printf (" LOADFLTR");
9257 val
^= DF_1_LOADFLTR
;
9259 if (val
& DF_1_INITFIRST
)
9261 printf (" INITFIRST");
9262 val
^= DF_1_INITFIRST
;
9264 if (val
& DF_1_NOOPEN
)
9269 if (val
& DF_1_ORIGIN
)
9274 if (val
& DF_1_DIRECT
)
9279 if (val
& DF_1_TRANS
)
9284 if (val
& DF_1_INTERPOSE
)
9286 printf (" INTERPOSE");
9287 val
^= DF_1_INTERPOSE
;
9289 if (val
& DF_1_NODEFLIB
)
9291 printf (" NODEFLIB");
9292 val
^= DF_1_NODEFLIB
;
9294 if (val
& DF_1_NODUMP
)
9299 if (val
& DF_1_CONFALT
)
9301 printf (" CONFALT");
9302 val
^= DF_1_CONFALT
;
9304 if (val
& DF_1_ENDFILTEE
)
9306 printf (" ENDFILTEE");
9307 val
^= DF_1_ENDFILTEE
;
9309 if (val
& DF_1_DISPRELDNE
)
9311 printf (" DISPRELDNE");
9312 val
^= DF_1_DISPRELDNE
;
9314 if (val
& DF_1_DISPRELPND
)
9316 printf (" DISPRELPND");
9317 val
^= DF_1_DISPRELPND
;
9319 if (val
& DF_1_NODIRECT
)
9321 printf (" NODIRECT");
9322 val
^= DF_1_NODIRECT
;
9324 if (val
& DF_1_IGNMULDEF
)
9326 printf (" IGNMULDEF");
9327 val
^= DF_1_IGNMULDEF
;
9329 if (val
& DF_1_NOKSYMS
)
9331 printf (" NOKSYMS");
9332 val
^= DF_1_NOKSYMS
;
9334 if (val
& DF_1_NOHDR
)
9339 if (val
& DF_1_EDITED
)
9344 if (val
& DF_1_NORELOC
)
9346 printf (" NORELOC");
9347 val
^= DF_1_NORELOC
;
9349 if (val
& DF_1_SYMINTPOSE
)
9351 printf (" SYMINTPOSE");
9352 val
^= DF_1_SYMINTPOSE
;
9354 if (val
& DF_1_GLOBAUDIT
)
9356 printf (" GLOBAUDIT");
9357 val
^= DF_1_GLOBAUDIT
;
9359 if (val
& DF_1_SINGLETON
)
9361 printf (" SINGLETON");
9362 val
^= DF_1_SINGLETON
;
9364 if (val
& DF_1_STUB
)
9375 printf (" %lx", val
);
9382 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9384 puts (get_dynamic_type (entry
->d_un
.d_val
));
9404 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9410 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9411 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9417 switch (entry
->d_tag
)
9420 printf (_("Shared library: [%s]"), name
);
9422 if (streq (name
, program_interpreter
))
9423 printf (_(" program interpreter"));
9427 printf (_("Library soname: [%s]"), name
);
9431 printf (_("Library rpath: [%s]"), name
);
9435 printf (_("Library runpath: [%s]"), name
);
9439 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9444 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9457 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9461 case DT_INIT_ARRAYSZ
:
9462 case DT_FINI_ARRAYSZ
:
9463 case DT_GNU_CONFLICTSZ
:
9464 case DT_GNU_LIBLISTSZ
:
9467 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9468 printf (_(" (bytes)\n"));
9478 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9491 if (entry
->d_tag
== DT_USED
9492 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9494 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9498 printf (_("Not needed object: [%s]\n"), name
);
9503 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9509 /* The value of this entry is ignored. */
9514 case DT_GNU_PRELINKED
:
9518 time_t atime
= entry
->d_un
.d_val
;
9520 tmp
= gmtime (&atime
);
9521 /* PR 17533 file: 041-1244816-0.004. */
9523 printf (_("<corrupt time val: %lx"),
9524 (unsigned long) atime
);
9526 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9527 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9528 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9534 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9537 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9543 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9544 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9549 switch (elf_header
.e_machine
)
9552 case EM_MIPS_RS3_LE
:
9553 dynamic_section_mips_val (entry
);
9556 dynamic_section_parisc_val (entry
);
9559 dynamic_section_ia64_val (entry
);
9562 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9574 get_ver_flags (unsigned int flags
)
9576 static char buff
[32];
9583 if (flags
& VER_FLG_BASE
)
9584 strcat (buff
, "BASE ");
9586 if (flags
& VER_FLG_WEAK
)
9588 if (flags
& VER_FLG_BASE
)
9589 strcat (buff
, "| ");
9591 strcat (buff
, "WEAK ");
9594 if (flags
& VER_FLG_INFO
)
9596 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9597 strcat (buff
, "| ");
9599 strcat (buff
, "INFO ");
9602 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9603 strcat (buff
, _("| <unknown>"));
9608 /* Display the contents of the version sections. */
9611 process_version_sections (FILE * file
)
9613 Elf_Internal_Shdr
* section
;
9620 for (i
= 0, section
= section_headers
;
9621 i
< elf_header
.e_shnum
;
9624 switch (section
->sh_type
)
9626 case SHT_GNU_verdef
:
9628 Elf_External_Verdef
* edefs
;
9635 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9636 printable_section_name (section
),
9639 printf (_(" Addr: 0x"));
9640 printf_vma (section
->sh_addr
);
9641 printf (_(" Offset: %#08lx Link: %u (%s)"),
9642 (unsigned long) section
->sh_offset
, section
->sh_link
,
9643 printable_section_name_from_index (section
->sh_link
));
9645 edefs
= (Elf_External_Verdef
*)
9646 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9647 _("version definition section"));
9650 endbuf
= (char *) edefs
+ section
->sh_size
;
9652 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9655 Elf_External_Verdef
* edef
;
9656 Elf_Internal_Verdef ent
;
9657 Elf_External_Verdaux
* eaux
;
9658 Elf_Internal_Verdaux aux
;
9662 /* Check for very large indicies. */
9663 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9666 vstart
= ((char *) edefs
) + idx
;
9667 if (vstart
+ sizeof (*edef
) > endbuf
)
9670 edef
= (Elf_External_Verdef
*) vstart
;
9672 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9673 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9674 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9675 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9676 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9677 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9678 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9680 printf (_(" %#06x: Rev: %d Flags: %s"),
9681 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9683 printf (_(" Index: %d Cnt: %d "),
9684 ent
.vd_ndx
, ent
.vd_cnt
);
9686 /* Check for overflow. */
9687 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9690 vstart
+= ent
.vd_aux
;
9692 eaux
= (Elf_External_Verdaux
*) vstart
;
9694 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9695 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9697 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9698 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9700 printf (_("Name index: %ld\n"), aux
.vda_name
);
9702 isum
= idx
+ ent
.vd_aux
;
9704 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9706 /* Check for overflow. */
9707 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9710 isum
+= aux
.vda_next
;
9711 vstart
+= aux
.vda_next
;
9713 eaux
= (Elf_External_Verdaux
*) vstart
;
9714 if (vstart
+ sizeof (*eaux
) > endbuf
)
9717 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9718 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9720 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9721 printf (_(" %#06x: Parent %d: %s\n"),
9722 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9724 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9725 isum
, j
, aux
.vda_name
);
9729 printf (_(" Version def aux past end of section\n"));
9731 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9732 if (idx
+ ent
.vd_next
<= idx
)
9738 if (cnt
< section
->sh_info
)
9739 printf (_(" Version definition past end of section\n"));
9745 case SHT_GNU_verneed
:
9747 Elf_External_Verneed
* eneed
;
9754 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9755 printable_section_name (section
), section
->sh_info
);
9757 printf (_(" Addr: 0x"));
9758 printf_vma (section
->sh_addr
);
9759 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9760 (unsigned long) section
->sh_offset
, section
->sh_link
,
9761 printable_section_name_from_index (section
->sh_link
));
9763 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9764 section
->sh_offset
, 1,
9766 _("Version Needs section"));
9769 endbuf
= (char *) eneed
+ section
->sh_size
;
9771 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9773 Elf_External_Verneed
* entry
;
9774 Elf_Internal_Verneed ent
;
9779 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9782 vstart
= ((char *) eneed
) + idx
;
9783 if (vstart
+ sizeof (*entry
) > endbuf
)
9786 entry
= (Elf_External_Verneed
*) vstart
;
9788 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9789 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9790 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9791 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9792 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9794 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9796 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9797 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9799 printf (_(" File: %lx"), ent
.vn_file
);
9801 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9803 /* Check for overflow. */
9804 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9806 vstart
+= ent
.vn_aux
;
9808 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9810 Elf_External_Vernaux
* eaux
;
9811 Elf_Internal_Vernaux aux
;
9813 if (vstart
+ sizeof (*eaux
) > endbuf
)
9815 eaux
= (Elf_External_Vernaux
*) vstart
;
9817 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9818 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9819 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9820 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9821 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9823 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9824 printf (_(" %#06x: Name: %s"),
9825 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9827 printf (_(" %#06x: Name index: %lx"),
9828 isum
, aux
.vna_name
);
9830 printf (_(" Flags: %s Version: %d\n"),
9831 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9833 /* Check for overflow. */
9834 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9835 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9837 warn (_("Invalid vna_next field of %lx\n"),
9842 isum
+= aux
.vna_next
;
9843 vstart
+= aux
.vna_next
;
9847 warn (_("Missing Version Needs auxillary information\n"));
9849 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9851 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9852 cnt
= section
->sh_info
;
9858 if (cnt
< section
->sh_info
)
9859 warn (_("Missing Version Needs information\n"));
9865 case SHT_GNU_versym
:
9867 Elf_Internal_Shdr
* link_section
;
9870 unsigned char * edata
;
9871 unsigned short * data
;
9873 Elf_Internal_Sym
* symbols
;
9874 Elf_Internal_Shdr
* string_sec
;
9875 unsigned long num_syms
;
9878 if (section
->sh_link
>= elf_header
.e_shnum
)
9881 link_section
= section_headers
+ section
->sh_link
;
9882 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9884 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9889 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9890 if (symbols
== NULL
)
9893 string_sec
= section_headers
+ link_section
->sh_link
;
9895 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9896 string_sec
->sh_size
,
9897 _("version string table"));
9904 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9905 printable_section_name (section
), (unsigned long) total
);
9907 printf (_(" Addr: "));
9908 printf_vma (section
->sh_addr
);
9909 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9910 (unsigned long) section
->sh_offset
, section
->sh_link
,
9911 printable_section_name (link_section
));
9913 off
= offset_from_vma (file
,
9914 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9915 total
* sizeof (short));
9916 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9918 _("version symbol data"));
9926 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9928 for (cnt
= total
; cnt
--;)
9929 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9934 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9938 char *invalid
= _("*invalid*");
9940 printf (" %03x:", cnt
);
9942 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9943 switch (data
[cnt
+ j
])
9946 fputs (_(" 0 (*local*) "), stdout
);
9950 fputs (_(" 1 (*global*) "), stdout
);
9954 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9955 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9957 /* If this index value is greater than the size of the symbols
9958 array, break to avoid an out-of-bounds read. */
9959 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9961 warn (_("invalid index into symbol array\n"));
9966 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9968 Elf_Internal_Verneed ivn
;
9969 unsigned long offset
;
9971 offset
= offset_from_vma
9972 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9973 sizeof (Elf_External_Verneed
));
9977 Elf_Internal_Vernaux ivna
;
9978 Elf_External_Verneed evn
;
9979 Elf_External_Vernaux evna
;
9980 unsigned long a_off
;
9982 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9983 _("version need")) == NULL
)
9986 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9987 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9989 a_off
= offset
+ ivn
.vn_aux
;
9993 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9994 1, _("version need aux (2)")) == NULL
)
10001 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10002 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10005 a_off
+= ivna
.vna_next
;
10007 while (ivna
.vna_other
!= data
[cnt
+ j
]
10008 && ivna
.vna_next
!= 0);
10010 if (ivna
.vna_other
== data
[cnt
+ j
])
10012 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10014 if (ivna
.vna_name
>= string_sec
->sh_size
)
10017 name
= strtab
+ ivna
.vna_name
;
10021 offset
+= ivn
.vn_next
;
10023 while (ivn
.vn_next
);
10026 if (data
[cnt
+ j
] != 0x8001
10027 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10029 Elf_Internal_Verdef ivd
;
10030 Elf_External_Verdef evd
;
10031 unsigned long offset
;
10033 offset
= offset_from_vma
10034 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10039 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10040 _("version def")) == NULL
)
10043 /* PR 17531: file: 046-1082287-0.004. */
10044 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10049 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10050 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10053 offset
+= ivd
.vd_next
;
10055 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10056 && ivd
.vd_next
!= 0);
10058 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10060 Elf_External_Verdaux evda
;
10061 Elf_Internal_Verdaux ivda
;
10063 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10065 if (get_data (&evda
, file
,
10066 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10068 _("version def aux")) == NULL
)
10071 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10073 if (ivda
.vda_name
>= string_sec
->sh_size
)
10075 else if (name
!= NULL
&& name
!= invalid
)
10076 name
= _("*both*");
10078 name
= strtab
+ ivda
.vda_name
;
10082 nn
+= printf ("(%s%-*s",
10084 12 - (int) strlen (name
),
10088 printf ("%*c", 18 - nn
, ' ');
10106 printf (_("\nNo version information found in this file.\n"));
10111 static const char *
10112 get_symbol_binding (unsigned int binding
)
10114 static char buff
[32];
10118 case STB_LOCAL
: return "LOCAL";
10119 case STB_GLOBAL
: return "GLOBAL";
10120 case STB_WEAK
: return "WEAK";
10122 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10123 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10125 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10127 if (binding
== STB_GNU_UNIQUE
10128 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10129 /* GNU is still using the default value 0. */
10130 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10132 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10135 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10140 static const char *
10141 get_symbol_type (unsigned int type
)
10143 static char buff
[32];
10147 case STT_NOTYPE
: return "NOTYPE";
10148 case STT_OBJECT
: return "OBJECT";
10149 case STT_FUNC
: return "FUNC";
10150 case STT_SECTION
: return "SECTION";
10151 case STT_FILE
: return "FILE";
10152 case STT_COMMON
: return "COMMON";
10153 case STT_TLS
: return "TLS";
10154 case STT_RELC
: return "RELC";
10155 case STT_SRELC
: return "SRELC";
10157 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10159 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10160 return "THUMB_FUNC";
10162 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10165 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10166 return "PARISC_MILLI";
10168 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10170 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10172 if (elf_header
.e_machine
== EM_PARISC
)
10174 if (type
== STT_HP_OPAQUE
)
10175 return "HP_OPAQUE";
10176 if (type
== STT_HP_STUB
)
10180 if (type
== STT_GNU_IFUNC
10181 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10182 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10183 /* GNU is still using the default value 0. */
10184 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10187 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10190 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10195 static const char *
10196 get_symbol_visibility (unsigned int visibility
)
10198 switch (visibility
)
10200 case STV_DEFAULT
: return "DEFAULT";
10201 case STV_INTERNAL
: return "INTERNAL";
10202 case STV_HIDDEN
: return "HIDDEN";
10203 case STV_PROTECTED
: return "PROTECTED";
10205 error (_("Unrecognized visibility value: %u"), visibility
);
10206 return _("<unknown>");
10210 static const char *
10211 get_mips_symbol_other (unsigned int other
)
10221 case STO_MICROMIPS
:
10222 return "MICROMIPS";
10223 case STO_MICROMIPS
| STO_MIPS_PIC
:
10224 return "MICROMIPS, MIPS PIC";
10232 static const char *
10233 get_ia64_symbol_other (unsigned int other
)
10235 if (is_ia64_vms ())
10237 static char res
[32];
10241 /* Function types is for images and .STB files only. */
10242 switch (elf_header
.e_type
)
10246 switch (VMS_ST_FUNC_TYPE (other
))
10248 case VMS_SFT_CODE_ADDR
:
10249 strcat (res
, " CA");
10251 case VMS_SFT_SYMV_IDX
:
10252 strcat (res
, " VEC");
10255 strcat (res
, " FD");
10257 case VMS_SFT_RESERVE
:
10258 strcat (res
, " RSV");
10261 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10262 VMS_ST_FUNC_TYPE (other
));
10263 strcat (res
, " <unknown>");
10270 switch (VMS_ST_LINKAGE (other
))
10272 case VMS_STL_IGNORE
:
10273 strcat (res
, " IGN");
10275 case VMS_STL_RESERVE
:
10276 strcat (res
, " RSV");
10279 strcat (res
, " STD");
10282 strcat (res
, " LNK");
10285 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10286 VMS_ST_LINKAGE (other
));
10287 strcat (res
, " <unknown>");
10299 static const char *
10300 get_ppc64_symbol_other (unsigned int other
)
10302 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10304 static char buf
[32];
10305 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10306 PPC64_LOCAL_ENTRY_OFFSET (other
));
10312 static const char *
10313 get_symbol_other (unsigned int other
)
10315 const char * result
= NULL
;
10316 static char buff
[32];
10321 switch (elf_header
.e_machine
)
10324 result
= get_mips_symbol_other (other
);
10327 result
= get_ia64_symbol_other (other
);
10330 result
= get_ppc64_symbol_other (other
);
10339 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10343 static const char *
10344 get_symbol_index_type (unsigned int type
)
10346 static char buff
[32];
10350 case SHN_UNDEF
: return "UND";
10351 case SHN_ABS
: return "ABS";
10352 case SHN_COMMON
: return "COM";
10354 if (type
== SHN_IA_64_ANSI_COMMON
10355 && elf_header
.e_machine
== EM_IA_64
10356 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10358 else if ((elf_header
.e_machine
== EM_X86_64
10359 || elf_header
.e_machine
== EM_L1OM
10360 || elf_header
.e_machine
== EM_K1OM
)
10361 && type
== SHN_X86_64_LCOMMON
)
10362 return "LARGE_COM";
10363 else if ((type
== SHN_MIPS_SCOMMON
10364 && elf_header
.e_machine
== EM_MIPS
)
10365 || (type
== SHN_TIC6X_SCOMMON
10366 && elf_header
.e_machine
== EM_TI_C6000
))
10368 else if (type
== SHN_MIPS_SUNDEFINED
10369 && elf_header
.e_machine
== EM_MIPS
)
10371 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10372 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10373 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10374 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10375 else if (type
>= SHN_LORESERVE
)
10376 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10377 else if (type
>= elf_header
.e_shnum
)
10378 sprintf (buff
, _("bad section index[%3d]"), type
);
10380 sprintf (buff
, "%3d", type
);
10388 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10390 unsigned char * e_data
;
10393 /* If the size_t type is smaller than the bfd_size_type, eg because
10394 you are building a 32-bit tool on a 64-bit host, then make sure
10395 that when (number) is cast to (size_t) no information is lost. */
10396 if (sizeof (size_t) < sizeof (bfd_size_type
)
10397 && (bfd_size_type
) ((size_t) number
) != number
)
10399 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10400 (unsigned long long) number
, ent_size
);
10404 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10405 attempting to allocate memory when the read is bound to fail. */
10406 if (ent_size
* number
> current_file_size
)
10408 error (_("Invalid number of dynamic entries: %llu\n"),
10409 (unsigned long long) number
);
10413 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10414 if (e_data
== NULL
)
10416 error (_("Out of memory reading %llu dynamic entries\n"),
10417 (unsigned long long) number
);
10421 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10423 error (_("Unable to read in %llu bytes of dynamic data\n"),
10424 (unsigned long long) (number
* ent_size
));
10429 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10430 if (i_data
== NULL
)
10432 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10433 (unsigned long long) number
);
10439 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10447 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10449 Elf_Internal_Sym
* psym
;
10452 n
= print_vma (si
, DEC_5
);
10454 fputs (&" "[n
], stdout
);
10455 printf (" %3lu: ", hn
);
10457 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10459 printf (_("<No info available for dynamic symbol number %lu>\n"),
10460 (unsigned long) si
);
10464 psym
= dynamic_symbols
+ si
;
10465 print_vma (psym
->st_value
, LONG_HEX
);
10467 print_vma (psym
->st_size
, DEC_5
);
10469 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10470 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10471 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10472 /* Check to see if any other bits in the st_other field are set.
10473 Note - displaying this information disrupts the layout of the
10474 table being generated, but for the moment this case is very
10476 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10477 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10478 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10479 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10480 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10482 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10486 static const char *
10487 get_symbol_version_string (FILE *file
, int is_dynsym
,
10488 const char *strtab
,
10489 unsigned long int strtab_size
,
10490 unsigned int si
, Elf_Internal_Sym
*psym
,
10491 enum versioned_symbol_info
*sym_info
,
10492 unsigned short *vna_other
)
10494 unsigned char data
[2];
10495 unsigned short vers_data
;
10496 unsigned long offset
;
10499 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10502 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10503 sizeof data
+ si
* sizeof (vers_data
));
10505 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10506 sizeof (data
), 1, _("version data")) == NULL
)
10509 vers_data
= byte_get (data
, 2);
10511 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10514 /* Usually we'd only see verdef for defined symbols, and verneed for
10515 undefined symbols. However, symbols defined by the linker in
10516 .dynbss for variables copied from a shared library in order to
10517 avoid text relocations are defined yet have verneed. We could
10518 use a heuristic to detect the special case, for example, check
10519 for verneed first on symbols defined in SHT_NOBITS sections, but
10520 it is simpler and more reliable to just look for both verdef and
10521 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10523 if (psym
->st_shndx
!= SHN_UNDEF
10524 && vers_data
!= 0x8001
10525 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10527 Elf_Internal_Verdef ivd
;
10528 Elf_Internal_Verdaux ivda
;
10529 Elf_External_Verdaux evda
;
10532 off
= offset_from_vma (file
,
10533 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10534 sizeof (Elf_External_Verdef
));
10538 Elf_External_Verdef evd
;
10540 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10541 _("version def")) == NULL
)
10549 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10550 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10551 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10554 off
+= ivd
.vd_next
;
10556 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10558 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10560 off
-= ivd
.vd_next
;
10563 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10564 _("version def aux")) != NULL
)
10566 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10568 if (psym
->st_name
!= ivda
.vda_name
)
10570 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10571 ? symbol_hidden
: symbol_public
);
10572 return (ivda
.vda_name
< strtab_size
10573 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10579 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10581 Elf_External_Verneed evn
;
10582 Elf_Internal_Verneed ivn
;
10583 Elf_Internal_Vernaux ivna
;
10585 offset
= offset_from_vma (file
,
10586 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10590 unsigned long vna_off
;
10592 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10593 _("version need")) == NULL
)
10596 ivna
.vna_other
= 0;
10601 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10602 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10604 vna_off
= offset
+ ivn
.vn_aux
;
10608 Elf_External_Vernaux evna
;
10610 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10611 _("version need aux (3)")) == NULL
)
10614 ivna
.vna_other
= 0;
10619 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10620 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10621 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10624 vna_off
+= ivna
.vna_next
;
10626 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10628 if (ivna
.vna_other
== vers_data
)
10631 offset
+= ivn
.vn_next
;
10633 while (ivn
.vn_next
!= 0);
10635 if (ivna
.vna_other
== vers_data
)
10637 *sym_info
= symbol_undefined
;
10638 *vna_other
= ivna
.vna_other
;
10639 return (ivna
.vna_name
< strtab_size
10640 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10646 /* Dump the symbol table. */
10648 process_symbol_table (FILE * file
)
10650 Elf_Internal_Shdr
* section
;
10651 bfd_size_type nbuckets
= 0;
10652 bfd_size_type nchains
= 0;
10653 bfd_vma
* buckets
= NULL
;
10654 bfd_vma
* chains
= NULL
;
10655 bfd_vma ngnubuckets
= 0;
10656 bfd_vma
* gnubuckets
= NULL
;
10657 bfd_vma
* gnuchains
= NULL
;
10658 bfd_vma gnusymidx
= 0;
10659 bfd_size_type ngnuchains
= 0;
10661 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10664 if (dynamic_info
[DT_HASH
]
10666 || (do_using_dynamic
10668 && dynamic_strings
!= NULL
)))
10670 unsigned char nb
[8];
10671 unsigned char nc
[8];
10672 unsigned int hash_ent_size
= 4;
10674 if ((elf_header
.e_machine
== EM_ALPHA
10675 || elf_header
.e_machine
== EM_S390
10676 || elf_header
.e_machine
== EM_S390_OLD
)
10677 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10681 (archive_file_offset
10682 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10683 sizeof nb
+ sizeof nc
)),
10686 error (_("Unable to seek to start of dynamic information\n"));
10690 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10692 error (_("Failed to read in number of buckets\n"));
10696 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10698 error (_("Failed to read in number of chains\n"));
10702 nbuckets
= byte_get (nb
, hash_ent_size
);
10703 nchains
= byte_get (nc
, hash_ent_size
);
10705 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10706 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10709 if (buckets
== NULL
|| chains
== NULL
)
10711 if (do_using_dynamic
)
10722 if (dynamic_info_DT_GNU_HASH
10724 || (do_using_dynamic
10726 && dynamic_strings
!= NULL
)))
10728 unsigned char nb
[16];
10729 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10730 bfd_vma buckets_vma
;
10733 (archive_file_offset
10734 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10738 error (_("Unable to seek to start of dynamic information\n"));
10742 if (fread (nb
, 16, 1, file
) != 1)
10744 error (_("Failed to read in number of buckets\n"));
10748 ngnubuckets
= byte_get (nb
, 4);
10749 gnusymidx
= byte_get (nb
+ 4, 4);
10750 bitmaskwords
= byte_get (nb
+ 8, 4);
10751 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10753 buckets_vma
+= bitmaskwords
* 4;
10755 buckets_vma
+= bitmaskwords
* 8;
10758 (archive_file_offset
10759 + offset_from_vma (file
, buckets_vma
, 4)),
10762 error (_("Unable to seek to start of dynamic information\n"));
10766 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10768 if (gnubuckets
== NULL
)
10771 for (i
= 0; i
< ngnubuckets
; i
++)
10772 if (gnubuckets
[i
] != 0)
10774 if (gnubuckets
[i
] < gnusymidx
)
10777 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10778 maxchain
= gnubuckets
[i
];
10781 if (maxchain
== 0xffffffff)
10784 maxchain
-= gnusymidx
;
10787 (archive_file_offset
10788 + offset_from_vma (file
, buckets_vma
10789 + 4 * (ngnubuckets
+ maxchain
), 4)),
10792 error (_("Unable to seek to start of dynamic information\n"));
10798 if (fread (nb
, 4, 1, file
) != 1)
10800 error (_("Failed to determine last chain length\n"));
10804 if (maxchain
+ 1 == 0)
10809 while ((byte_get (nb
, 4) & 1) == 0);
10812 (archive_file_offset
10813 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10816 error (_("Unable to seek to start of dynamic information\n"));
10820 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10821 ngnuchains
= maxchain
;
10824 if (gnuchains
== NULL
)
10829 if (do_using_dynamic
)
10834 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10836 && do_using_dynamic
10837 && dynamic_strings
!= NULL
10838 && dynamic_symbols
!= NULL
)
10842 if (dynamic_info
[DT_HASH
])
10846 printf (_("\nSymbol table for image:\n"));
10848 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10850 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10852 for (hn
= 0; hn
< nbuckets
; hn
++)
10857 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10858 print_dynamic_symbol (si
, hn
);
10862 if (dynamic_info_DT_GNU_HASH
)
10864 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10866 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10868 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10870 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10871 if (gnubuckets
[hn
] != 0)
10873 bfd_vma si
= gnubuckets
[hn
];
10874 bfd_vma off
= si
- gnusymidx
;
10878 print_dynamic_symbol (si
, hn
);
10881 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10885 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10886 && section_headers
!= NULL
)
10890 for (i
= 0, section
= section_headers
;
10891 i
< elf_header
.e_shnum
;
10895 char * strtab
= NULL
;
10896 unsigned long int strtab_size
= 0;
10897 Elf_Internal_Sym
* symtab
;
10898 Elf_Internal_Sym
* psym
;
10899 unsigned long num_syms
;
10901 if ((section
->sh_type
!= SHT_SYMTAB
10902 && section
->sh_type
!= SHT_DYNSYM
)
10904 && section
->sh_type
== SHT_SYMTAB
))
10907 if (section
->sh_entsize
== 0)
10909 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10910 printable_section_name (section
));
10914 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10915 printable_section_name (section
),
10916 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10919 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10921 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10923 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10924 if (symtab
== NULL
)
10927 if (section
->sh_link
== elf_header
.e_shstrndx
)
10929 strtab
= string_table
;
10930 strtab_size
= string_table_length
;
10932 else if (section
->sh_link
< elf_header
.e_shnum
)
10934 Elf_Internal_Shdr
* string_sec
;
10936 string_sec
= section_headers
+ section
->sh_link
;
10938 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10939 1, string_sec
->sh_size
,
10940 _("string table"));
10941 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10944 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10946 const char *version_string
;
10947 enum versioned_symbol_info sym_info
;
10948 unsigned short vna_other
;
10950 printf ("%6d: ", si
);
10951 print_vma (psym
->st_value
, LONG_HEX
);
10953 print_vma (psym
->st_size
, DEC_5
);
10954 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10955 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10956 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10957 /* Check to see if any other bits in the st_other field are set.
10958 Note - displaying this information disrupts the layout of the
10959 table being generated, but for the moment this case is very rare. */
10960 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10961 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10962 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10963 print_symbol (25, psym
->st_name
< strtab_size
10964 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10967 = get_symbol_version_string (file
,
10968 section
->sh_type
== SHT_DYNSYM
,
10969 strtab
, strtab_size
, si
,
10970 psym
, &sym_info
, &vna_other
);
10971 if (version_string
)
10973 if (sym_info
== symbol_undefined
)
10974 printf ("@%s (%d)", version_string
, vna_other
);
10976 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10984 if (strtab
!= string_table
)
10990 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10992 if (do_histogram
&& buckets
!= NULL
)
10994 unsigned long * lengths
;
10995 unsigned long * counts
;
10998 unsigned long maxlength
= 0;
10999 unsigned long nzero_counts
= 0;
11000 unsigned long nsyms
= 0;
11001 unsigned long chained
;
11003 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11004 (unsigned long) nbuckets
);
11006 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11007 if (lengths
== NULL
)
11009 error (_("Out of memory allocating space for histogram buckets\n"));
11013 printf (_(" Length Number %% of total Coverage\n"));
11014 for (hn
= 0; hn
< nbuckets
; ++hn
)
11016 for (si
= buckets
[hn
], chained
= 0;
11017 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11018 si
= chains
[si
], ++chained
)
11021 if (maxlength
< ++lengths
[hn
])
11025 /* PR binutils/17531: A corrupt binary could contain broken
11026 histogram data. Do not go into an infinite loop trying
11028 if (chained
> nchains
)
11030 error (_("histogram chain is corrupt\n"));
11035 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11036 if (counts
== NULL
)
11039 error (_("Out of memory allocating space for histogram counts\n"));
11043 for (hn
= 0; hn
< nbuckets
; ++hn
)
11044 ++counts
[lengths
[hn
]];
11049 printf (" 0 %-10lu (%5.1f%%)\n",
11050 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11051 for (i
= 1; i
<= maxlength
; ++i
)
11053 nzero_counts
+= counts
[i
] * i
;
11054 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11055 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11056 (nzero_counts
* 100.0) / nsyms
);
11064 if (buckets
!= NULL
)
11070 if (do_histogram
&& gnubuckets
!= NULL
)
11072 unsigned long * lengths
;
11073 unsigned long * counts
;
11075 unsigned long maxlength
= 0;
11076 unsigned long nzero_counts
= 0;
11077 unsigned long nsyms
= 0;
11079 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11080 (unsigned long) ngnubuckets
);
11082 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11083 if (lengths
== NULL
)
11085 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11089 printf (_(" Length Number %% of total Coverage\n"));
11091 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11092 if (gnubuckets
[hn
] != 0)
11094 bfd_vma off
, length
= 1;
11096 for (off
= gnubuckets
[hn
] - gnusymidx
;
11097 /* PR 17531 file: 010-77222-0.004. */
11098 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11101 lengths
[hn
] = length
;
11102 if (length
> maxlength
)
11103 maxlength
= length
;
11107 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11108 if (counts
== NULL
)
11111 error (_("Out of memory allocating space for gnu histogram counts\n"));
11115 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11116 ++counts
[lengths
[hn
]];
11118 if (ngnubuckets
> 0)
11121 printf (" 0 %-10lu (%5.1f%%)\n",
11122 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11123 for (j
= 1; j
<= maxlength
; ++j
)
11125 nzero_counts
+= counts
[j
] * j
;
11126 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11127 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11128 (nzero_counts
* 100.0) / nsyms
);
11142 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11146 if (dynamic_syminfo
== NULL
11148 /* No syminfo, this is ok. */
11151 /* There better should be a dynamic symbol section. */
11152 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11156 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11157 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11159 printf (_(" Num: Name BoundTo Flags\n"));
11160 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11162 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11164 printf ("%4d: ", i
);
11165 if (i
>= num_dynamic_syms
)
11166 printf (_("<corrupt index>"));
11167 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11168 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11170 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11173 switch (dynamic_syminfo
[i
].si_boundto
)
11175 case SYMINFO_BT_SELF
:
11176 fputs ("SELF ", stdout
);
11178 case SYMINFO_BT_PARENT
:
11179 fputs ("PARENT ", stdout
);
11182 if (dynamic_syminfo
[i
].si_boundto
> 0
11183 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11184 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11186 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11190 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11194 if (flags
& SYMINFO_FLG_DIRECT
)
11195 printf (" DIRECT");
11196 if (flags
& SYMINFO_FLG_PASSTHRU
)
11197 printf (" PASSTHRU");
11198 if (flags
& SYMINFO_FLG_COPY
)
11200 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11201 printf (" LAZYLOAD");
11209 /* Check to see if the given reloc needs to be handled in a target specific
11210 manner. If so then process the reloc and return TRUE otherwise return
11214 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11215 unsigned char * start
,
11216 Elf_Internal_Sym
* symtab
)
11218 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11220 switch (elf_header
.e_machine
)
11223 case EM_MSP430_OLD
:
11225 static Elf_Internal_Sym
* saved_sym
= NULL
;
11227 switch (reloc_type
)
11229 case 10: /* R_MSP430_SYM_DIFF */
11230 if (uses_msp430x_relocs ())
11232 case 21: /* R_MSP430X_SYM_DIFF */
11233 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11236 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11237 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11238 goto handle_sym_diff
;
11240 case 5: /* R_MSP430_16_BYTE */
11241 case 9: /* R_MSP430_8 */
11242 if (uses_msp430x_relocs ())
11244 goto handle_sym_diff
;
11246 case 2: /* R_MSP430_ABS16 */
11247 case 15: /* R_MSP430X_ABS16 */
11248 if (! uses_msp430x_relocs ())
11250 goto handle_sym_diff
;
11253 if (saved_sym
!= NULL
)
11257 value
= reloc
->r_addend
11258 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11259 - saved_sym
->st_value
);
11261 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11269 if (saved_sym
!= NULL
)
11270 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11277 case EM_CYGNUS_MN10300
:
11279 static Elf_Internal_Sym
* saved_sym
= NULL
;
11281 switch (reloc_type
)
11283 case 34: /* R_MN10300_ALIGN */
11285 case 33: /* R_MN10300_SYM_DIFF */
11286 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11288 case 1: /* R_MN10300_32 */
11289 case 2: /* R_MN10300_16 */
11290 if (saved_sym
!= NULL
)
11294 value
= reloc
->r_addend
11295 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11296 - saved_sym
->st_value
);
11298 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11305 if (saved_sym
!= NULL
)
11306 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11314 static bfd_vma saved_sym1
= 0;
11315 static bfd_vma saved_sym2
= 0;
11316 static bfd_vma value
;
11318 switch (reloc_type
)
11320 case 0x80: /* R_RL78_SYM. */
11321 saved_sym1
= saved_sym2
;
11322 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11323 saved_sym2
+= reloc
->r_addend
;
11326 case 0x83: /* R_RL78_OPsub. */
11327 value
= saved_sym1
- saved_sym2
;
11328 saved_sym2
= saved_sym1
= 0;
11332 case 0x41: /* R_RL78_ABS32. */
11333 byte_put (start
+ reloc
->r_offset
, value
, 4);
11337 case 0x43: /* R_RL78_ABS16. */
11338 byte_put (start
+ reloc
->r_offset
, value
, 2);
11352 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11353 DWARF debug sections. This is a target specific test. Note - we do not
11354 go through the whole including-target-headers-multiple-times route, (as
11355 we have already done with <elf/h8.h>) because this would become very
11356 messy and even then this function would have to contain target specific
11357 information (the names of the relocs instead of their numeric values).
11358 FIXME: This is not the correct way to solve this problem. The proper way
11359 is to have target specific reloc sizing and typing functions created by
11360 the reloc-macros.h header, in the same way that it already creates the
11361 reloc naming functions. */
11364 is_32bit_abs_reloc (unsigned int reloc_type
)
11366 switch (elf_header
.e_machine
)
11370 return reloc_type
== 1; /* R_386_32. */
11372 return reloc_type
== 1; /* R_68K_32. */
11374 return reloc_type
== 1; /* R_860_32. */
11376 return reloc_type
== 2; /* R_960_32. */
11378 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11380 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11382 return reloc_type
== 1; /* R_ARC_32. */
11383 case EM_ARC_COMPACT
:
11384 case EM_ARC_COMPACT2
:
11385 return reloc_type
== 4; /* R_ARC_32. */
11387 return reloc_type
== 2; /* R_ARM_ABS32 */
11390 return reloc_type
== 1;
11391 case EM_ADAPTEVA_EPIPHANY
:
11392 return reloc_type
== 3;
11394 return reloc_type
== 0x12; /* R_byte4_data. */
11396 return reloc_type
== 3; /* R_CRIS_32. */
11398 return reloc_type
== 3; /* R_CR16_NUM32. */
11400 return reloc_type
== 15; /* R_CRX_NUM32. */
11401 case EM_CYGNUS_FRV
:
11402 return reloc_type
== 1;
11403 case EM_CYGNUS_D10V
:
11405 return reloc_type
== 6; /* R_D10V_32. */
11406 case EM_CYGNUS_D30V
:
11408 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11410 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11411 case EM_CYGNUS_FR30
:
11413 return reloc_type
== 3; /* R_FR30_32. */
11415 return reloc_type
== 1; /* R_FT32_32. */
11419 return reloc_type
== 1; /* R_H8_DIR32. */
11421 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11422 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11425 return reloc_type
== 2; /* R_IP2K_32. */
11427 return reloc_type
== 2; /* R_IQ2000_32. */
11428 case EM_LATTICEMICO32
:
11429 return reloc_type
== 3; /* R_LM32_32. */
11432 return reloc_type
== 3; /* R_M32C_32. */
11434 return reloc_type
== 34; /* R_M32R_32_RELA. */
11437 return reloc_type
== 6; /* R_M68HC11_32. */
11439 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11440 case EM_CYGNUS_MEP
:
11441 return reloc_type
== 4; /* R_MEP_32. */
11443 return reloc_type
== 2; /* R_METAG_ADDR32. */
11444 case EM_MICROBLAZE
:
11445 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11447 return reloc_type
== 2; /* R_MIPS_32. */
11449 return reloc_type
== 4; /* R_MMIX_32. */
11450 case EM_CYGNUS_MN10200
:
11452 return reloc_type
== 1; /* R_MN10200_32. */
11453 case EM_CYGNUS_MN10300
:
11455 return reloc_type
== 1; /* R_MN10300_32. */
11457 return reloc_type
== 1; /* R_MOXIE_32. */
11458 case EM_MSP430_OLD
:
11460 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11462 return reloc_type
== 2; /* R_MT_32. */
11464 return reloc_type
== 20; /* R_NDS32_RELA. */
11465 case EM_ALTERA_NIOS2
:
11466 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11468 return reloc_type
== 1; /* R_NIOS_32. */
11470 return reloc_type
== 1; /* R_OR1K_32. */
11472 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11473 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11476 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11478 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11480 return reloc_type
== 1; /* R_PPC_ADDR32. */
11482 return reloc_type
== 1; /* R_RL78_DIR32. */
11484 return reloc_type
== 1; /* R_RX_DIR32. */
11486 return reloc_type
== 1; /* R_I370_ADDR31. */
11489 return reloc_type
== 4; /* R_S390_32. */
11491 return reloc_type
== 8; /* R_SCORE_ABS32. */
11493 return reloc_type
== 1; /* R_SH_DIR32. */
11494 case EM_SPARC32PLUS
:
11497 return reloc_type
== 3 /* R_SPARC_32. */
11498 || reloc_type
== 23; /* R_SPARC_UA32. */
11500 return reloc_type
== 6; /* R_SPU_ADDR32 */
11502 return reloc_type
== 1; /* R_C6000_ABS32. */
11504 return reloc_type
== 2; /* R_TILEGX_32. */
11506 return reloc_type
== 1; /* R_TILEPRO_32. */
11507 case EM_CYGNUS_V850
:
11509 return reloc_type
== 6; /* R_V850_ABS32. */
11511 return reloc_type
== 0x33; /* R_V810_WORD. */
11513 return reloc_type
== 1; /* R_VAX_32. */
11515 return reloc_type
== 3; /* R_VISIUM_32. */
11519 return reloc_type
== 10; /* R_X86_64_32. */
11522 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11524 return reloc_type
== 4; /* R_XGATE_32. */
11526 return reloc_type
== 1; /* R_XSTROMY16_32. */
11527 case EM_XTENSA_OLD
:
11529 return reloc_type
== 1; /* R_XTENSA_32. */
11532 static unsigned int prev_warn
= 0;
11534 /* Avoid repeating the same warning multiple times. */
11535 if (prev_warn
!= elf_header
.e_machine
)
11536 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11537 elf_header
.e_machine
);
11538 prev_warn
= elf_header
.e_machine
;
11544 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11545 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11548 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11550 switch (elf_header
.e_machine
)
11554 return reloc_type
== 2; /* R_386_PC32. */
11556 return reloc_type
== 4; /* R_68K_PC32. */
11558 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11559 case EM_ADAPTEVA_EPIPHANY
:
11560 return reloc_type
== 6;
11562 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11564 return reloc_type
== 3; /* R_ARM_REL32 */
11565 case EM_MICROBLAZE
:
11566 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11568 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11570 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11572 return reloc_type
== 26; /* R_PPC_REL32. */
11574 return reloc_type
== 26; /* R_PPC64_REL32. */
11577 return reloc_type
== 5; /* R_390_PC32. */
11579 return reloc_type
== 2; /* R_SH_REL32. */
11580 case EM_SPARC32PLUS
:
11583 return reloc_type
== 6; /* R_SPARC_DISP32. */
11585 return reloc_type
== 13; /* R_SPU_REL32. */
11587 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11589 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11591 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11595 return reloc_type
== 2; /* R_X86_64_PC32. */
11596 case EM_XTENSA_OLD
:
11598 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11600 /* Do not abort or issue an error message here. Not all targets use
11601 pc-relative 32-bit relocs in their DWARF debug information and we
11602 have already tested for target coverage in is_32bit_abs_reloc. A
11603 more helpful warning message will be generated by apply_relocations
11604 anyway, so just return. */
11609 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11610 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11613 is_64bit_abs_reloc (unsigned int reloc_type
)
11615 switch (elf_header
.e_machine
)
11618 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11620 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11622 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11624 return reloc_type
== 80; /* R_PARISC_DIR64. */
11626 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11627 case EM_SPARC32PLUS
:
11630 return reloc_type
== 54; /* R_SPARC_UA64. */
11634 return reloc_type
== 1; /* R_X86_64_64. */
11637 return reloc_type
== 22; /* R_S390_64. */
11639 return reloc_type
== 1; /* R_TILEGX_64. */
11641 return reloc_type
== 18; /* R_MIPS_64. */
11647 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11648 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11651 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11653 switch (elf_header
.e_machine
)
11656 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11658 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11660 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11662 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11664 return reloc_type
== 44; /* R_PPC64_REL64. */
11665 case EM_SPARC32PLUS
:
11668 return reloc_type
== 46; /* R_SPARC_DISP64. */
11672 return reloc_type
== 24; /* R_X86_64_PC64. */
11675 return reloc_type
== 23; /* R_S390_PC64. */
11677 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11683 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11684 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11687 is_24bit_abs_reloc (unsigned int reloc_type
)
11689 switch (elf_header
.e_machine
)
11691 case EM_CYGNUS_MN10200
:
11693 return reloc_type
== 4; /* R_MN10200_24. */
11699 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11700 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11703 is_16bit_abs_reloc (unsigned int reloc_type
)
11705 switch (elf_header
.e_machine
)
11708 case EM_ARC_COMPACT
:
11709 case EM_ARC_COMPACT2
:
11710 return reloc_type
== 2; /* R_ARC_16. */
11713 return reloc_type
== 4; /* R_AVR_16. */
11714 case EM_ADAPTEVA_EPIPHANY
:
11715 return reloc_type
== 5;
11716 case EM_CYGNUS_D10V
:
11718 return reloc_type
== 3; /* R_D10V_16. */
11722 return reloc_type
== R_H8_DIR16
;
11725 return reloc_type
== 1; /* R_IP2K_16. */
11728 return reloc_type
== 1; /* R_M32C_16 */
11730 if (uses_msp430x_relocs ())
11731 return reloc_type
== 2; /* R_MSP430_ABS16. */
11732 case EM_MSP430_OLD
:
11733 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11735 return reloc_type
== 19; /* R_NDS32_RELA. */
11736 case EM_ALTERA_NIOS2
:
11737 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11739 return reloc_type
== 9; /* R_NIOS_16. */
11741 return reloc_type
== 2; /* R_OR1K_16. */
11743 return reloc_type
== 2; /* R_C6000_ABS16. */
11746 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11747 case EM_CYGNUS_MN10200
:
11749 return reloc_type
== 2; /* R_MN10200_16. */
11750 case EM_CYGNUS_MN10300
:
11752 return reloc_type
== 2; /* R_MN10300_16. */
11754 return reloc_type
== 2; /* R_VISIUM_16. */
11756 return reloc_type
== 3; /* R_XGATE_16. */
11762 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11763 relocation entries (possibly formerly used for SHT_GROUP sections). */
11766 is_none_reloc (unsigned int reloc_type
)
11768 switch (elf_header
.e_machine
)
11770 case EM_68K
: /* R_68K_NONE. */
11771 case EM_386
: /* R_386_NONE. */
11772 case EM_SPARC32PLUS
:
11774 case EM_SPARC
: /* R_SPARC_NONE. */
11775 case EM_MIPS
: /* R_MIPS_NONE. */
11776 case EM_PARISC
: /* R_PARISC_NONE. */
11777 case EM_ALPHA
: /* R_ALPHA_NONE. */
11778 case EM_ADAPTEVA_EPIPHANY
:
11779 case EM_PPC
: /* R_PPC_NONE. */
11780 case EM_PPC64
: /* R_PPC64_NONE. */
11781 case EM_ARC
: /* R_ARC_NONE. */
11782 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11783 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11784 case EM_ARM
: /* R_ARM_NONE. */
11785 case EM_IA_64
: /* R_IA64_NONE. */
11786 case EM_SH
: /* R_SH_NONE. */
11788 case EM_S390
: /* R_390_NONE. */
11789 case EM_CRIS
: /* R_CRIS_NONE. */
11790 case EM_X86_64
: /* R_X86_64_NONE. */
11791 case EM_L1OM
: /* R_X86_64_NONE. */
11792 case EM_K1OM
: /* R_X86_64_NONE. */
11793 case EM_MN10300
: /* R_MN10300_NONE. */
11794 case EM_FT32
: /* R_FT32_NONE. */
11795 case EM_MOXIE
: /* R_MOXIE_NONE. */
11796 case EM_M32R
: /* R_M32R_NONE. */
11797 case EM_TI_C6000
:/* R_C6000_NONE. */
11798 case EM_TILEGX
: /* R_TILEGX_NONE. */
11799 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11801 case EM_C166
: /* R_XC16X_NONE. */
11802 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11803 case EM_NIOS32
: /* R_NIOS_NONE. */
11804 case EM_OR1K
: /* R_OR1K_NONE. */
11805 return reloc_type
== 0;
11807 return reloc_type
== 0 || reloc_type
== 256;
11809 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11810 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11811 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11812 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11813 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11814 case EM_XTENSA_OLD
:
11816 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11817 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11818 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11819 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11821 return reloc_type
== 3; /* R_METAG_NONE. */
11826 /* Returns TRUE if there is a relocation against
11827 section NAME at OFFSET bytes. */
11830 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11832 Elf_Internal_Rela
* relocs
;
11833 Elf_Internal_Rela
* rp
;
11835 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11838 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11840 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11841 if (rp
->r_offset
== offset
)
11847 /* Apply relocations to a section.
11848 Note: So far support has been added only for those relocations
11849 which can be found in debug sections.
11850 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11851 loaded relocs. It is then the caller's responsibility to free them.
11852 FIXME: Add support for more relocations ? */
11855 apply_relocations (void * file
,
11856 const Elf_Internal_Shdr
* section
,
11857 unsigned char * start
,
11858 bfd_size_type size
,
11859 void ** relocs_return
,
11860 unsigned long * num_relocs_return
)
11862 Elf_Internal_Shdr
* relsec
;
11863 unsigned char * end
= start
+ size
;
11865 if (relocs_return
!= NULL
)
11867 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11868 * num_relocs_return
= 0;
11871 if (elf_header
.e_type
!= ET_REL
)
11874 /* Find the reloc section associated with the section. */
11875 for (relsec
= section_headers
;
11876 relsec
< section_headers
+ elf_header
.e_shnum
;
11879 bfd_boolean is_rela
;
11880 unsigned long num_relocs
;
11881 Elf_Internal_Rela
* relocs
;
11882 Elf_Internal_Rela
* rp
;
11883 Elf_Internal_Shdr
* symsec
;
11884 Elf_Internal_Sym
* symtab
;
11885 unsigned long num_syms
;
11886 Elf_Internal_Sym
* sym
;
11888 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11889 || relsec
->sh_info
>= elf_header
.e_shnum
11890 || section_headers
+ relsec
->sh_info
!= section
11891 || relsec
->sh_size
== 0
11892 || relsec
->sh_link
>= elf_header
.e_shnum
)
11895 is_rela
= relsec
->sh_type
== SHT_RELA
;
11899 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11900 relsec
->sh_size
, & relocs
, & num_relocs
))
11905 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11906 relsec
->sh_size
, & relocs
, & num_relocs
))
11910 /* SH uses RELA but uses in place value instead of the addend field. */
11911 if (elf_header
.e_machine
== EM_SH
)
11914 symsec
= section_headers
+ relsec
->sh_link
;
11915 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11917 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11920 unsigned int reloc_type
;
11921 unsigned int reloc_size
;
11922 unsigned char * rloc
;
11923 unsigned long sym_index
;
11925 reloc_type
= get_reloc_type (rp
->r_info
);
11927 if (target_specific_reloc_handling (rp
, start
, symtab
))
11929 else if (is_none_reloc (reloc_type
))
11931 else if (is_32bit_abs_reloc (reloc_type
)
11932 || is_32bit_pcrel_reloc (reloc_type
))
11934 else if (is_64bit_abs_reloc (reloc_type
)
11935 || is_64bit_pcrel_reloc (reloc_type
))
11937 else if (is_24bit_abs_reloc (reloc_type
))
11939 else if (is_16bit_abs_reloc (reloc_type
))
11943 static unsigned int prev_reloc
= 0;
11944 if (reloc_type
!= prev_reloc
)
11945 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11946 reloc_type
, printable_section_name (section
));
11947 prev_reloc
= reloc_type
;
11951 rloc
= start
+ rp
->r_offset
;
11952 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11954 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11955 (unsigned long) rp
->r_offset
,
11956 printable_section_name (section
));
11960 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11961 if (sym_index
>= num_syms
)
11963 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11964 sym_index
, printable_section_name (section
));
11967 sym
= symtab
+ sym_index
;
11969 /* If the reloc has a symbol associated with it,
11970 make sure that it is of an appropriate type.
11972 Relocations against symbols without type can happen.
11973 Gcc -feliminate-dwarf2-dups may generate symbols
11974 without type for debug info.
11976 Icc generates relocations against function symbols
11977 instead of local labels.
11979 Relocations against object symbols can happen, eg when
11980 referencing a global array. For an example of this see
11981 the _clz.o binary in libgcc.a. */
11983 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11985 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11986 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11987 (long int)(rp
- relocs
),
11988 printable_section_name (relsec
));
11994 addend
+= rp
->r_addend
;
11995 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11996 partial_inplace. */
11998 || (elf_header
.e_machine
== EM_XTENSA
11999 && reloc_type
== 1)
12000 || ((elf_header
.e_machine
== EM_PJ
12001 || elf_header
.e_machine
== EM_PJ_OLD
)
12002 && reloc_type
== 1)
12003 || ((elf_header
.e_machine
== EM_D30V
12004 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12005 && reloc_type
== 12))
12006 addend
+= byte_get (rloc
, reloc_size
);
12008 if (is_32bit_pcrel_reloc (reloc_type
)
12009 || is_64bit_pcrel_reloc (reloc_type
))
12011 /* On HPPA, all pc-relative relocations are biased by 8. */
12012 if (elf_header
.e_machine
== EM_PARISC
)
12014 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12018 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12025 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12026 * num_relocs_return
= num_relocs
;
12035 #ifdef SUPPORT_DISASSEMBLY
12037 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12039 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12041 /* FIXME: XXX -- to be done --- XXX */
12047 /* Reads in the contents of SECTION from FILE, returning a pointer
12048 to a malloc'ed buffer or NULL if something went wrong. */
12051 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12053 bfd_size_type num_bytes
;
12055 num_bytes
= section
->sh_size
;
12057 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12059 printf (_("\nSection '%s' has no data to dump.\n"),
12060 printable_section_name (section
));
12064 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12065 _("section contents"));
12068 /* Uncompresses a section that was compressed using zlib, in place. */
12071 uncompress_section_contents (unsigned char **buffer
,
12072 dwarf_size_type uncompressed_size
,
12073 dwarf_size_type
*size
)
12075 dwarf_size_type compressed_size
= *size
;
12076 unsigned char * compressed_buffer
= *buffer
;
12077 unsigned char * uncompressed_buffer
;
12081 /* It is possible the section consists of several compressed
12082 buffers concatenated together, so we uncompress in a loop. */
12083 /* PR 18313: The state field in the z_stream structure is supposed
12084 to be invisible to the user (ie us), but some compilers will
12085 still complain about it being used without initialisation. So
12086 we first zero the entire z_stream structure and then set the fields
12088 memset (& strm
, 0, sizeof strm
);
12089 strm
.avail_in
= compressed_size
;
12090 strm
.next_in
= (Bytef
*) compressed_buffer
;
12091 strm
.avail_out
= uncompressed_size
;
12092 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12094 rc
= inflateInit (& strm
);
12095 while (strm
.avail_in
> 0)
12099 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12100 + (uncompressed_size
- strm
.avail_out
));
12101 rc
= inflate (&strm
, Z_FINISH
);
12102 if (rc
!= Z_STREAM_END
)
12104 rc
= inflateReset (& strm
);
12106 rc
= inflateEnd (& strm
);
12108 || strm
.avail_out
!= 0)
12111 *buffer
= uncompressed_buffer
;
12112 *size
= uncompressed_size
;
12116 free (uncompressed_buffer
);
12117 /* Indicate decompression failure. */
12123 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12125 Elf_Internal_Shdr
* relsec
;
12126 bfd_size_type num_bytes
;
12127 unsigned char * data
;
12128 unsigned char * end
;
12129 unsigned char * real_start
;
12130 unsigned char * start
;
12131 bfd_boolean some_strings_shown
;
12133 real_start
= start
= (unsigned char *) get_section_contents (section
,
12137 num_bytes
= section
->sh_size
;
12139 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12141 if (decompress_dumps
)
12143 dwarf_size_type new_size
= num_bytes
;
12144 dwarf_size_type uncompressed_size
= 0;
12146 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12148 Elf_Internal_Chdr chdr
;
12149 unsigned int compression_header_size
12150 = get_compression_header (& chdr
, (unsigned char *) start
);
12152 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12154 warn (_("section '%s' has unsupported compress type: %d\n"),
12155 printable_section_name (section
), chdr
.ch_type
);
12158 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12160 warn (_("compressed section '%s' is corrupted\n"),
12161 printable_section_name (section
));
12164 uncompressed_size
= chdr
.ch_size
;
12165 start
+= compression_header_size
;
12166 new_size
-= compression_header_size
;
12168 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12170 /* Read the zlib header. In this case, it should be "ZLIB"
12171 followed by the uncompressed section size, 8 bytes in
12172 big-endian order. */
12173 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12174 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12175 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12176 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12177 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12178 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12179 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12180 uncompressed_size
+= start
[11];
12185 if (uncompressed_size
12186 && uncompress_section_contents (& start
,
12187 uncompressed_size
, & new_size
))
12188 num_bytes
= new_size
;
12191 /* If the section being dumped has relocations against it the user might
12192 be expecting these relocations to have been applied. Check for this
12193 case and issue a warning message in order to avoid confusion.
12194 FIXME: Maybe we ought to have an option that dumps a section with
12195 relocs applied ? */
12196 for (relsec
= section_headers
;
12197 relsec
< section_headers
+ elf_header
.e_shnum
;
12200 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12201 || relsec
->sh_info
>= elf_header
.e_shnum
12202 || section_headers
+ relsec
->sh_info
!= section
12203 || relsec
->sh_size
== 0
12204 || relsec
->sh_link
>= elf_header
.e_shnum
)
12207 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12212 end
= start
+ num_bytes
;
12213 some_strings_shown
= FALSE
;
12217 while (!ISPRINT (* data
))
12218 if (++ data
>= end
)
12223 size_t maxlen
= end
- data
;
12226 /* PR 11128: Use two separate invocations in order to work
12227 around bugs in the Solaris 8 implementation of printf. */
12228 printf (" [%6tx] ", data
- start
);
12230 printf (" [%6Ix] ", (size_t) (data
- start
));
12234 print_symbol ((int) maxlen
, (const char *) data
);
12236 data
+= strnlen ((const char *) data
, maxlen
);
12240 printf (_("<corrupt>\n"));
12243 some_strings_shown
= TRUE
;
12247 if (! some_strings_shown
)
12248 printf (_(" No strings found in this section."));
12256 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12258 bfd_boolean relocate
)
12260 Elf_Internal_Shdr
* relsec
;
12261 bfd_size_type bytes
;
12262 bfd_size_type section_size
;
12264 unsigned char * data
;
12265 unsigned char * real_start
;
12266 unsigned char * start
;
12268 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12271 section_size
= section
->sh_size
;
12273 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12275 if (decompress_dumps
)
12277 dwarf_size_type new_size
= section_size
;
12278 dwarf_size_type uncompressed_size
= 0;
12280 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12282 Elf_Internal_Chdr chdr
;
12283 unsigned int compression_header_size
12284 = get_compression_header (& chdr
, start
);
12286 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12288 warn (_("section '%s' has unsupported compress type: %d\n"),
12289 printable_section_name (section
), chdr
.ch_type
);
12292 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12294 warn (_("compressed section '%s' is corrupted\n"),
12295 printable_section_name (section
));
12298 uncompressed_size
= chdr
.ch_size
;
12299 start
+= compression_header_size
;
12300 new_size
-= compression_header_size
;
12302 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12304 /* Read the zlib header. In this case, it should be "ZLIB"
12305 followed by the uncompressed section size, 8 bytes in
12306 big-endian order. */
12307 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12308 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12309 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12310 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12311 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12312 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12313 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12314 uncompressed_size
+= start
[11];
12319 if (uncompressed_size
12320 && uncompress_section_contents (& start
, uncompressed_size
,
12322 section_size
= new_size
;
12327 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12331 /* If the section being dumped has relocations against it the user might
12332 be expecting these relocations to have been applied. Check for this
12333 case and issue a warning message in order to avoid confusion.
12334 FIXME: Maybe we ought to have an option that dumps a section with
12335 relocs applied ? */
12336 for (relsec
= section_headers
;
12337 relsec
< section_headers
+ elf_header
.e_shnum
;
12340 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12341 || relsec
->sh_info
>= elf_header
.e_shnum
12342 || section_headers
+ relsec
->sh_info
!= section
12343 || relsec
->sh_size
== 0
12344 || relsec
->sh_link
>= elf_header
.e_shnum
)
12347 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12352 addr
= section
->sh_addr
;
12353 bytes
= section_size
;
12362 lbytes
= (bytes
> 16 ? 16 : bytes
);
12364 printf (" 0x%8.8lx ", (unsigned long) addr
);
12366 for (j
= 0; j
< 16; j
++)
12369 printf ("%2.2x", data
[j
]);
12377 for (j
= 0; j
< lbytes
; j
++)
12380 if (k
>= ' ' && k
< 0x7f)
12399 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12400 const Elf_Internal_Shdr
* sec
, void * file
)
12402 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12405 /* If it is already loaded, do nothing. */
12406 if (section
->start
!= NULL
)
12409 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12410 section
->address
= sec
->sh_addr
;
12411 section
->user_data
= NULL
;
12412 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12414 sec
->sh_size
, buf
);
12415 if (section
->start
== NULL
)
12419 unsigned char *start
= section
->start
;
12420 dwarf_size_type size
= sec
->sh_size
;
12421 dwarf_size_type uncompressed_size
= 0;
12423 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12425 Elf_Internal_Chdr chdr
;
12426 unsigned int compression_header_size
12427 = get_compression_header (&chdr
, start
);
12428 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12430 warn (_("section '%s' has unsupported compress type: %d\n"),
12431 section
->name
, chdr
.ch_type
);
12434 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12436 warn (_("compressed section '%s' is corrupted\n"),
12440 uncompressed_size
= chdr
.ch_size
;
12441 start
+= compression_header_size
;
12442 size
-= compression_header_size
;
12444 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12446 /* Read the zlib header. In this case, it should be "ZLIB"
12447 followed by the uncompressed section size, 8 bytes in
12448 big-endian order. */
12449 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12450 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12451 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12452 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12453 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12454 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12455 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12456 uncompressed_size
+= start
[11];
12461 if (uncompressed_size
12462 && uncompress_section_contents (&start
, uncompressed_size
,
12465 /* Free the compressed buffer, update the section buffer
12466 and the section size if uncompress is successful. */
12467 free (section
->start
);
12468 section
->start
= start
;
12470 section
->size
= size
;
12473 if (section
->start
== NULL
)
12476 if (debug_displays
[debug
].relocate
)
12477 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12478 & section
->reloc_info
, & section
->num_relocs
);
12481 section
->reloc_info
= NULL
;
12482 section
->num_relocs
= 0;
12488 /* If this is not NULL, load_debug_section will only look for sections
12489 within the list of sections given here. */
12490 unsigned int *section_subset
= NULL
;
12493 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12495 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12496 Elf_Internal_Shdr
* sec
;
12498 /* Locate the debug section. */
12499 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12501 section
->name
= section
->uncompressed_name
;
12504 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12506 section
->name
= section
->compressed_name
;
12511 /* If we're loading from a subset of sections, and we've loaded
12512 a section matching this name before, it's likely that it's a
12514 if (section_subset
!= NULL
)
12515 free_debug_section (debug
);
12517 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12521 free_debug_section (enum dwarf_section_display_enum debug
)
12523 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12525 if (section
->start
== NULL
)
12528 free ((char *) section
->start
);
12529 section
->start
= NULL
;
12530 section
->address
= 0;
12535 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12537 char * name
= SECTION_NAME (section
);
12538 const char * print_name
= printable_section_name (section
);
12539 bfd_size_type length
;
12543 length
= section
->sh_size
;
12546 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12549 if (section
->sh_type
== SHT_NOBITS
)
12551 /* There is no point in dumping the contents of a debugging section
12552 which has the NOBITS type - the bits in the file will be random.
12553 This can happen when a file containing a .eh_frame section is
12554 stripped with the --only-keep-debug command line option. */
12555 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12560 if (const_strneq (name
, ".gnu.linkonce.wi."))
12561 name
= ".debug_info";
12563 /* See if we know how to display the contents of this section. */
12564 for (i
= 0; i
< max
; i
++)
12565 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12566 || (i
== line
&& const_strneq (name
, ".debug_line."))
12567 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12569 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12570 int secondary
= (section
!= find_section (name
));
12573 free_debug_section ((enum dwarf_section_display_enum
) i
);
12575 if (i
== line
&& const_strneq (name
, ".debug_line."))
12577 else if (streq (sec
->uncompressed_name
, name
))
12578 sec
->name
= sec
->uncompressed_name
;
12580 sec
->name
= sec
->compressed_name
;
12581 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12584 /* If this debug section is part of a CU/TU set in a .dwp file,
12585 restrict load_debug_section to the sections in that set. */
12586 section_subset
= find_cu_tu_set (file
, shndx
);
12588 result
&= debug_displays
[i
].display (sec
, file
);
12590 section_subset
= NULL
;
12592 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12593 free_debug_section ((enum dwarf_section_display_enum
) i
);
12601 printf (_("Unrecognized debug section: %s\n"), print_name
);
12608 /* Set DUMP_SECTS for all sections where dumps were requested
12609 based on section name. */
12612 initialise_dumps_byname (void)
12614 struct dump_list_entry
* cur
;
12616 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12621 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12622 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12624 request_dump_bynumber (i
, cur
->type
);
12629 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12635 process_section_contents (FILE * file
)
12637 Elf_Internal_Shdr
* section
;
12643 initialise_dumps_byname ();
12645 for (i
= 0, section
= section_headers
;
12646 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12649 #ifdef SUPPORT_DISASSEMBLY
12650 if (dump_sects
[i
] & DISASS_DUMP
)
12651 disassemble_section (section
, file
);
12653 if (dump_sects
[i
] & HEX_DUMP
)
12654 dump_section_as_bytes (section
, file
, FALSE
);
12656 if (dump_sects
[i
] & RELOC_DUMP
)
12657 dump_section_as_bytes (section
, file
, TRUE
);
12659 if (dump_sects
[i
] & STRING_DUMP
)
12660 dump_section_as_strings (section
, file
);
12662 if (dump_sects
[i
] & DEBUG_DUMP
)
12663 display_debug_section (i
, section
, file
);
12666 /* Check to see if the user requested a
12667 dump of a section that does not exist. */
12668 while (i
++ < num_dump_sects
)
12670 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12674 process_mips_fpe_exception (int mask
)
12679 if (mask
& OEX_FPU_INEX
)
12680 fputs ("INEX", stdout
), first
= 0;
12681 if (mask
& OEX_FPU_UFLO
)
12682 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12683 if (mask
& OEX_FPU_OFLO
)
12684 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12685 if (mask
& OEX_FPU_DIV0
)
12686 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12687 if (mask
& OEX_FPU_INVAL
)
12688 printf ("%sINVAL", first
? "" : "|");
12691 fputs ("0", stdout
);
12694 /* Display's the value of TAG at location P. If TAG is
12695 greater than 0 it is assumed to be an unknown tag, and
12696 a message is printed to this effect. Otherwise it is
12697 assumed that a message has already been printed.
12699 If the bottom bit of TAG is set it assumed to have a
12700 string value, otherwise it is assumed to have an integer
12703 Returns an updated P pointing to the first unread byte
12704 beyond the end of TAG's value.
12706 Reads at or beyond END will not be made. */
12708 static unsigned char *
12709 display_tag_value (int tag
,
12711 const unsigned char * const end
)
12716 printf (" Tag_unknown_%d: ", tag
);
12720 warn (_("<corrupt tag>\n"));
12724 /* PR 17531 file: 027-19978-0.004. */
12725 size_t maxlen
= (end
- p
) - 1;
12730 print_symbol ((int) maxlen
, (const char *) p
);
12731 p
+= strnlen ((char *) p
, maxlen
) + 1;
12735 printf (_("<corrupt string tag>"));
12736 p
= (unsigned char *) end
;
12744 val
= read_uleb128 (p
, &len
, end
);
12746 printf ("%ld (0x%lx)\n", val
, val
);
12753 /* ARM EABI attributes section. */
12758 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12760 const char ** table
;
12761 } arm_attr_public_tag
;
12763 static const char * arm_attr_tag_CPU_arch
[] =
12764 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12765 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12767 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12768 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12769 {"No", "Thumb-1", "Thumb-2", "Yes"};
12770 static const char * arm_attr_tag_FP_arch
[] =
12771 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12772 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12773 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12774 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12775 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12776 static const char * arm_attr_tag_PCS_config
[] =
12777 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12778 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12779 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12780 {"V6", "SB", "TLS", "Unused"};
12781 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12782 {"Absolute", "PC-relative", "SB-relative", "None"};
12783 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12784 {"Absolute", "PC-relative", "None"};
12785 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12786 {"None", "direct", "GOT-indirect"};
12787 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12788 {"None", "??? 1", "2", "??? 3", "4"};
12789 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12790 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12791 {"Unused", "Needed", "Sign only"};
12792 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12793 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12794 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12795 {"Unused", "Finite", "RTABI", "IEEE 754"};
12796 static const char * arm_attr_tag_ABI_enum_size
[] =
12797 {"Unused", "small", "int", "forced to int"};
12798 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12799 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12800 static const char * arm_attr_tag_ABI_VFP_args
[] =
12801 {"AAPCS", "VFP registers", "custom", "compatible"};
12802 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12803 {"AAPCS", "WMMX registers", "custom"};
12804 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12805 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12806 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12807 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12808 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12809 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12810 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12811 static const char * arm_attr_tag_FP_HP_extension
[] =
12812 {"Not Allowed", "Allowed"};
12813 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12814 {"None", "IEEE 754", "Alternative Format"};
12815 static const char * arm_attr_tag_MPextension_use
[] =
12816 {"Not Allowed", "Allowed"};
12817 static const char * arm_attr_tag_DIV_use
[] =
12818 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12819 "Allowed in v7-A with integer division extension"};
12820 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12821 static const char * arm_attr_tag_Virtualization_use
[] =
12822 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12823 "TrustZone and Virtualization Extensions"};
12824 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12825 {"Not Allowed", "Allowed"};
12827 #define LOOKUP(id, name) \
12828 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12829 static arm_attr_public_tag arm_attr_public_tags
[] =
12831 {4, "CPU_raw_name", 1, NULL
},
12832 {5, "CPU_name", 1, NULL
},
12833 LOOKUP(6, CPU_arch
),
12834 {7, "CPU_arch_profile", 0, NULL
},
12835 LOOKUP(8, ARM_ISA_use
),
12836 LOOKUP(9, THUMB_ISA_use
),
12837 LOOKUP(10, FP_arch
),
12838 LOOKUP(11, WMMX_arch
),
12839 LOOKUP(12, Advanced_SIMD_arch
),
12840 LOOKUP(13, PCS_config
),
12841 LOOKUP(14, ABI_PCS_R9_use
),
12842 LOOKUP(15, ABI_PCS_RW_data
),
12843 LOOKUP(16, ABI_PCS_RO_data
),
12844 LOOKUP(17, ABI_PCS_GOT_use
),
12845 LOOKUP(18, ABI_PCS_wchar_t
),
12846 LOOKUP(19, ABI_FP_rounding
),
12847 LOOKUP(20, ABI_FP_denormal
),
12848 LOOKUP(21, ABI_FP_exceptions
),
12849 LOOKUP(22, ABI_FP_user_exceptions
),
12850 LOOKUP(23, ABI_FP_number_model
),
12851 {24, "ABI_align_needed", 0, NULL
},
12852 {25, "ABI_align_preserved", 0, NULL
},
12853 LOOKUP(26, ABI_enum_size
),
12854 LOOKUP(27, ABI_HardFP_use
),
12855 LOOKUP(28, ABI_VFP_args
),
12856 LOOKUP(29, ABI_WMMX_args
),
12857 LOOKUP(30, ABI_optimization_goals
),
12858 LOOKUP(31, ABI_FP_optimization_goals
),
12859 {32, "compatibility", 0, NULL
},
12860 LOOKUP(34, CPU_unaligned_access
),
12861 LOOKUP(36, FP_HP_extension
),
12862 LOOKUP(38, ABI_FP_16bit_format
),
12863 LOOKUP(42, MPextension_use
),
12864 LOOKUP(44, DIV_use
),
12865 {64, "nodefaults", 0, NULL
},
12866 {65, "also_compatible_with", 0, NULL
},
12867 LOOKUP(66, T2EE_use
),
12868 {67, "conformance", 1, NULL
},
12869 LOOKUP(68, Virtualization_use
),
12870 LOOKUP(70, MPextension_use_legacy
)
12874 static unsigned char *
12875 display_arm_attribute (unsigned char * p
,
12876 const unsigned char * const end
)
12881 arm_attr_public_tag
* attr
;
12885 tag
= read_uleb128 (p
, &len
, end
);
12888 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12890 if (arm_attr_public_tags
[i
].tag
== tag
)
12892 attr
= &arm_attr_public_tags
[i
];
12899 printf (" Tag_%s: ", attr
->name
);
12900 switch (attr
->type
)
12905 case 7: /* Tag_CPU_arch_profile. */
12906 val
= read_uleb128 (p
, &len
, end
);
12910 case 0: printf (_("None\n")); break;
12911 case 'A': printf (_("Application\n")); break;
12912 case 'R': printf (_("Realtime\n")); break;
12913 case 'M': printf (_("Microcontroller\n")); break;
12914 case 'S': printf (_("Application or Realtime\n")); break;
12915 default: printf ("??? (%d)\n", val
); break;
12919 case 24: /* Tag_align_needed. */
12920 val
= read_uleb128 (p
, &len
, end
);
12924 case 0: printf (_("None\n")); break;
12925 case 1: printf (_("8-byte\n")); break;
12926 case 2: printf (_("4-byte\n")); break;
12927 case 3: printf ("??? 3\n"); break;
12930 printf (_("8-byte and up to %d-byte extended\n"),
12933 printf ("??? (%d)\n", val
);
12938 case 25: /* Tag_align_preserved. */
12939 val
= read_uleb128 (p
, &len
, end
);
12943 case 0: printf (_("None\n")); break;
12944 case 1: printf (_("8-byte, except leaf SP\n")); break;
12945 case 2: printf (_("8-byte\n")); break;
12946 case 3: printf ("??? 3\n"); break;
12949 printf (_("8-byte and up to %d-byte extended\n"),
12952 printf ("??? (%d)\n", val
);
12957 case 32: /* Tag_compatibility. */
12959 val
= read_uleb128 (p
, &len
, end
);
12961 printf (_("flag = %d, vendor = "), val
);
12964 size_t maxlen
= (end
- p
) - 1;
12966 print_symbol ((int) maxlen
, (const char *) p
);
12967 p
+= strnlen ((char *) p
, maxlen
) + 1;
12971 printf (_("<corrupt>"));
12972 p
= (unsigned char *) end
;
12978 case 64: /* Tag_nodefaults. */
12979 /* PR 17531: file: 001-505008-0.01. */
12982 printf (_("True\n"));
12985 case 65: /* Tag_also_compatible_with. */
12986 val
= read_uleb128 (p
, &len
, end
);
12988 if (val
== 6 /* Tag_CPU_arch. */)
12990 val
= read_uleb128 (p
, &len
, end
);
12992 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12993 printf ("??? (%d)\n", val
);
12995 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12999 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13004 printf (_("<unknown: %d>\n"), tag
);
13010 return display_tag_value (-1, p
, end
);
13012 return display_tag_value (0, p
, end
);
13015 assert (attr
->type
& 0x80);
13016 val
= read_uleb128 (p
, &len
, end
);
13018 type
= attr
->type
& 0x7f;
13020 printf ("??? (%d)\n", val
);
13022 printf ("%s\n", attr
->table
[val
]);
13027 return display_tag_value (tag
, p
, end
);
13030 static unsigned char *
13031 display_gnu_attribute (unsigned char * p
,
13032 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13033 const unsigned char * const end
)
13039 tag
= read_uleb128 (p
, &len
, end
);
13042 /* Tag_compatibility is the only generic GNU attribute defined at
13046 val
= read_uleb128 (p
, &len
, end
);
13049 printf (_("flag = %d, vendor = "), val
);
13052 printf (_("<corrupt>\n"));
13053 warn (_("corrupt vendor attribute\n"));
13059 size_t maxlen
= (end
- p
) - 1;
13061 print_symbol ((int) maxlen
, (const char *) p
);
13062 p
+= strnlen ((char *) p
, maxlen
) + 1;
13066 printf (_("<corrupt>"));
13067 p
= (unsigned char *) end
;
13074 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13075 return display_proc_gnu_attribute (p
, tag
, end
);
13077 return display_tag_value (tag
, p
, end
);
13080 static unsigned char *
13081 display_power_gnu_attribute (unsigned char * p
,
13083 const unsigned char * const end
)
13088 if (tag
== Tag_GNU_Power_ABI_FP
)
13090 val
= read_uleb128 (p
, &len
, end
);
13092 printf (" Tag_GNU_Power_ABI_FP: ");
13097 printf (_("Hard or soft float\n"));
13100 printf (_("Hard float\n"));
13103 printf (_("Soft float\n"));
13106 printf (_("Single-precision hard float\n"));
13109 printf ("??? (%d)\n", val
);
13115 if (tag
== Tag_GNU_Power_ABI_Vector
)
13117 val
= read_uleb128 (p
, &len
, end
);
13119 printf (" Tag_GNU_Power_ABI_Vector: ");
13123 printf (_("Any\n"));
13126 printf (_("Generic\n"));
13129 printf ("AltiVec\n");
13135 printf ("??? (%d)\n", val
);
13141 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13145 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13149 val
= read_uleb128 (p
, &len
, end
);
13151 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13155 printf (_("Any\n"));
13158 printf ("r3/r4\n");
13161 printf (_("Memory\n"));
13164 printf ("??? (%d)\n", val
);
13170 return display_tag_value (tag
& 1, p
, end
);
13173 static unsigned char *
13174 display_s390_gnu_attribute (unsigned char * p
,
13176 const unsigned char * const end
)
13181 if (tag
== Tag_GNU_S390_ABI_Vector
)
13183 val
= read_uleb128 (p
, &len
, end
);
13185 printf (" Tag_GNU_S390_ABI_Vector: ");
13190 printf (_("any\n"));
13193 printf (_("software\n"));
13196 printf (_("hardware\n"));
13199 printf ("??? (%d)\n", val
);
13205 return display_tag_value (tag
& 1, p
, end
);
13209 display_sparc_hwcaps (int mask
)
13215 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13216 fputs ("mul32", stdout
), first
= 0;
13217 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13218 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13219 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13220 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13221 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13222 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13223 if (mask
& ELF_SPARC_HWCAP_POPC
)
13224 printf ("%spopc", first
? "" : "|"), first
= 0;
13225 if (mask
& ELF_SPARC_HWCAP_VIS
)
13226 printf ("%svis", first
? "" : "|"), first
= 0;
13227 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13228 printf ("%svis2", first
? "" : "|"), first
= 0;
13229 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13230 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13231 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13232 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13233 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13234 printf ("%svis3", first
? "" : "|"), first
= 0;
13235 if (mask
& ELF_SPARC_HWCAP_HPC
)
13236 printf ("%shpc", first
? "" : "|"), first
= 0;
13237 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13238 printf ("%srandom", first
? "" : "|"), first
= 0;
13239 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13240 printf ("%strans", first
? "" : "|"), first
= 0;
13241 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13242 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13243 if (mask
& ELF_SPARC_HWCAP_IMA
)
13244 printf ("%sima", first
? "" : "|"), first
= 0;
13245 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13246 printf ("%scspare", first
? "" : "|"), first
= 0;
13249 fputc ('0', stdout
);
13250 fputc ('\n', stdout
);
13254 display_sparc_hwcaps2 (int mask
)
13260 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13261 fputs ("fjathplus", stdout
), first
= 0;
13262 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13263 printf ("%svis3b", first
? "" : "|"), first
= 0;
13264 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13265 printf ("%sadp", first
? "" : "|"), first
= 0;
13266 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13267 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13268 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13269 printf ("%smwait", first
? "" : "|"), first
= 0;
13270 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13271 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13272 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13273 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13274 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13275 printf ("%snsec", first
? "" : "|"), first
= 0;
13276 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13277 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13278 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13279 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13280 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13281 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13284 fputc ('0', stdout
);
13285 fputc ('\n', stdout
);
13288 static unsigned char *
13289 display_sparc_gnu_attribute (unsigned char * p
,
13291 const unsigned char * const end
)
13296 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13298 val
= read_uleb128 (p
, &len
, end
);
13300 printf (" Tag_GNU_Sparc_HWCAPS: ");
13301 display_sparc_hwcaps (val
);
13304 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13306 val
= read_uleb128 (p
, &len
, end
);
13308 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13309 display_sparc_hwcaps2 (val
);
13313 return display_tag_value (tag
, p
, end
);
13317 print_mips_fp_abi_value (int val
)
13321 case Val_GNU_MIPS_ABI_FP_ANY
:
13322 printf (_("Hard or soft float\n"));
13324 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13325 printf (_("Hard float (double precision)\n"));
13327 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13328 printf (_("Hard float (single precision)\n"));
13330 case Val_GNU_MIPS_ABI_FP_SOFT
:
13331 printf (_("Soft float\n"));
13333 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13334 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13336 case Val_GNU_MIPS_ABI_FP_XX
:
13337 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13339 case Val_GNU_MIPS_ABI_FP_64
:
13340 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13342 case Val_GNU_MIPS_ABI_FP_64A
:
13343 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13345 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13346 printf (_("NaN 2008 compatibility\n"));
13349 printf ("??? (%d)\n", val
);
13354 static unsigned char *
13355 display_mips_gnu_attribute (unsigned char * p
,
13357 const unsigned char * const end
)
13359 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13364 val
= read_uleb128 (p
, &len
, end
);
13366 printf (" Tag_GNU_MIPS_ABI_FP: ");
13368 print_mips_fp_abi_value (val
);
13373 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13378 val
= read_uleb128 (p
, &len
, end
);
13380 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13384 case Val_GNU_MIPS_ABI_MSA_ANY
:
13385 printf (_("Any MSA or not\n"));
13387 case Val_GNU_MIPS_ABI_MSA_128
:
13388 printf (_("128-bit MSA\n"));
13391 printf ("??? (%d)\n", val
);
13397 return display_tag_value (tag
& 1, p
, end
);
13400 static unsigned char *
13401 display_tic6x_attribute (unsigned char * p
,
13402 const unsigned char * const end
)
13408 tag
= read_uleb128 (p
, &len
, end
);
13414 val
= read_uleb128 (p
, &len
, end
);
13416 printf (" Tag_ISA: ");
13420 case C6XABI_Tag_ISA_none
:
13421 printf (_("None\n"));
13423 case C6XABI_Tag_ISA_C62X
:
13426 case C6XABI_Tag_ISA_C67X
:
13429 case C6XABI_Tag_ISA_C67XP
:
13430 printf ("C67x+\n");
13432 case C6XABI_Tag_ISA_C64X
:
13435 case C6XABI_Tag_ISA_C64XP
:
13436 printf ("C64x+\n");
13438 case C6XABI_Tag_ISA_C674X
:
13439 printf ("C674x\n");
13442 printf ("??? (%d)\n", val
);
13447 case Tag_ABI_wchar_t
:
13448 val
= read_uleb128 (p
, &len
, end
);
13450 printf (" Tag_ABI_wchar_t: ");
13454 printf (_("Not used\n"));
13457 printf (_("2 bytes\n"));
13460 printf (_("4 bytes\n"));
13463 printf ("??? (%d)\n", val
);
13468 case Tag_ABI_stack_align_needed
:
13469 val
= read_uleb128 (p
, &len
, end
);
13471 printf (" Tag_ABI_stack_align_needed: ");
13475 printf (_("8-byte\n"));
13478 printf (_("16-byte\n"));
13481 printf ("??? (%d)\n", val
);
13486 case Tag_ABI_stack_align_preserved
:
13487 val
= read_uleb128 (p
, &len
, end
);
13489 printf (" Tag_ABI_stack_align_preserved: ");
13493 printf (_("8-byte\n"));
13496 printf (_("16-byte\n"));
13499 printf ("??? (%d)\n", val
);
13505 val
= read_uleb128 (p
, &len
, end
);
13507 printf (" Tag_ABI_DSBT: ");
13511 printf (_("DSBT addressing not used\n"));
13514 printf (_("DSBT addressing used\n"));
13517 printf ("??? (%d)\n", val
);
13523 val
= read_uleb128 (p
, &len
, end
);
13525 printf (" Tag_ABI_PID: ");
13529 printf (_("Data addressing position-dependent\n"));
13532 printf (_("Data addressing position-independent, GOT near DP\n"));
13535 printf (_("Data addressing position-independent, GOT far from DP\n"));
13538 printf ("??? (%d)\n", val
);
13544 val
= read_uleb128 (p
, &len
, end
);
13546 printf (" Tag_ABI_PIC: ");
13550 printf (_("Code addressing position-dependent\n"));
13553 printf (_("Code addressing position-independent\n"));
13556 printf ("??? (%d)\n", val
);
13561 case Tag_ABI_array_object_alignment
:
13562 val
= read_uleb128 (p
, &len
, end
);
13564 printf (" Tag_ABI_array_object_alignment: ");
13568 printf (_("8-byte\n"));
13571 printf (_("4-byte\n"));
13574 printf (_("16-byte\n"));
13577 printf ("??? (%d)\n", val
);
13582 case Tag_ABI_array_object_align_expected
:
13583 val
= read_uleb128 (p
, &len
, end
);
13585 printf (" Tag_ABI_array_object_align_expected: ");
13589 printf (_("8-byte\n"));
13592 printf (_("4-byte\n"));
13595 printf (_("16-byte\n"));
13598 printf ("??? (%d)\n", val
);
13603 case Tag_ABI_compatibility
:
13605 val
= read_uleb128 (p
, &len
, end
);
13607 printf (" Tag_ABI_compatibility: ");
13608 printf (_("flag = %d, vendor = "), val
);
13611 size_t maxlen
= (end
- p
) - 1;
13613 print_symbol ((int) maxlen
, (const char *) p
);
13614 p
+= strnlen ((char *) p
, maxlen
) + 1;
13618 printf (_("<corrupt>"));
13619 p
= (unsigned char *) end
;
13625 case Tag_ABI_conformance
:
13627 printf (" Tag_ABI_conformance: \"");
13630 size_t maxlen
= (end
- p
) - 1;
13632 print_symbol ((int) maxlen
, (const char *) p
);
13633 p
+= strnlen ((char *) p
, maxlen
) + 1;
13637 printf (_("<corrupt>"));
13638 p
= (unsigned char *) end
;
13645 return display_tag_value (tag
, p
, end
);
13649 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13651 unsigned long addr
= 0;
13652 size_t bytes
= end
- p
;
13659 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13661 printf (" 0x%8.8lx ", addr
);
13663 for (j
= 0; j
< 16; j
++)
13666 printf ("%2.2x", p
[j
]);
13674 for (j
= 0; j
< lbytes
; j
++)
13677 if (k
>= ' ' && k
< 0x7f)
13693 static unsigned char *
13694 display_msp430x_attribute (unsigned char * p
,
13695 const unsigned char * const end
)
13701 tag
= read_uleb128 (p
, & len
, end
);
13706 case OFBA_MSPABI_Tag_ISA
:
13707 val
= read_uleb128 (p
, &len
, end
);
13709 printf (" Tag_ISA: ");
13712 case 0: printf (_("None\n")); break;
13713 case 1: printf (_("MSP430\n")); break;
13714 case 2: printf (_("MSP430X\n")); break;
13715 default: printf ("??? (%d)\n", val
); break;
13719 case OFBA_MSPABI_Tag_Code_Model
:
13720 val
= read_uleb128 (p
, &len
, end
);
13722 printf (" Tag_Code_Model: ");
13725 case 0: printf (_("None\n")); break;
13726 case 1: printf (_("Small\n")); break;
13727 case 2: printf (_("Large\n")); break;
13728 default: printf ("??? (%d)\n", val
); break;
13732 case OFBA_MSPABI_Tag_Data_Model
:
13733 val
= read_uleb128 (p
, &len
, end
);
13735 printf (" Tag_Data_Model: ");
13738 case 0: printf (_("None\n")); break;
13739 case 1: printf (_("Small\n")); break;
13740 case 2: printf (_("Large\n")); break;
13741 case 3: printf (_("Restricted Large\n")); break;
13742 default: printf ("??? (%d)\n", val
); break;
13747 printf (_(" <unknown tag %d>: "), tag
);
13754 size_t maxlen
= (end
- p
) - 1;
13756 print_symbol ((int) maxlen
, (const char *) p
);
13757 p
+= strnlen ((char *) p
, maxlen
) + 1;
13761 printf (_("<corrupt>"));
13762 p
= (unsigned char *) end
;
13768 val
= read_uleb128 (p
, &len
, end
);
13770 printf ("%d (0x%x)\n", val
, val
);
13780 process_attributes (FILE * file
,
13781 const char * public_name
,
13782 unsigned int proc_type
,
13783 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13784 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13786 Elf_Internal_Shdr
* sect
;
13789 /* Find the section header so that we get the size. */
13790 for (i
= 0, sect
= section_headers
;
13791 i
< elf_header
.e_shnum
;
13794 unsigned char * contents
;
13797 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13800 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13801 sect
->sh_size
, _("attributes"));
13802 if (contents
== NULL
)
13808 bfd_vma section_len
;
13810 section_len
= sect
->sh_size
- 1;
13813 while (section_len
> 0)
13816 unsigned int namelen
;
13817 bfd_boolean public_section
;
13818 bfd_boolean gnu_section
;
13820 if (section_len
<= 4)
13822 error (_("Tag section ends prematurely\n"));
13825 attr_len
= byte_get (p
, 4);
13828 if (attr_len
> section_len
)
13830 error (_("Bad attribute length (%u > %u)\n"),
13831 (unsigned) attr_len
, (unsigned) section_len
);
13832 attr_len
= section_len
;
13834 /* PR 17531: file: 001-101425-0.004 */
13835 else if (attr_len
< 5)
13837 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13841 section_len
-= attr_len
;
13844 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13845 if (namelen
== 0 || namelen
>= attr_len
)
13847 error (_("Corrupt attribute section name\n"));
13851 printf (_("Attribute Section: "));
13852 print_symbol (INT_MAX
, (const char *) p
);
13855 if (public_name
&& streq ((char *) p
, public_name
))
13856 public_section
= TRUE
;
13858 public_section
= FALSE
;
13860 if (streq ((char *) p
, "gnu"))
13861 gnu_section
= TRUE
;
13863 gnu_section
= FALSE
;
13866 attr_len
-= namelen
;
13868 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13873 unsigned char * end
;
13875 /* PR binutils/17531: Safe handling of corrupt files. */
13878 error (_("Unused bytes at end of section\n"));
13884 size
= byte_get (p
, 4);
13885 if (size
> attr_len
)
13887 error (_("Bad subsection length (%u > %u)\n"),
13888 (unsigned) size
, (unsigned) attr_len
);
13891 /* PR binutils/17531: Safe handling of corrupt files. */
13894 error (_("Bad subsection length (%u < 6)\n"),
13901 end
= p
+ size
- 1;
13902 assert (end
<= contents
+ sect
->sh_size
);
13908 printf (_("File Attributes\n"));
13911 printf (_("Section Attributes:"));
13914 printf (_("Symbol Attributes:"));
13920 val
= read_uleb128 (p
, &j
, end
);
13924 printf (" %d", val
);
13929 printf (_("Unknown tag: %d\n"), tag
);
13930 public_section
= FALSE
;
13934 if (public_section
&& display_pub_attribute
!= NULL
)
13937 p
= display_pub_attribute (p
, end
);
13940 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13943 p
= display_gnu_attribute (p
,
13944 display_proc_gnu_attribute
,
13950 printf (_(" Unknown attribute:\n"));
13951 display_raw_attribute (p
, end
);
13960 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13968 process_arm_specific (FILE * file
)
13970 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13971 display_arm_attribute
, NULL
);
13975 process_power_specific (FILE * file
)
13977 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13978 display_power_gnu_attribute
);
13982 process_s390_specific (FILE * file
)
13984 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13985 display_s390_gnu_attribute
);
13989 process_sparc_specific (FILE * file
)
13991 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13992 display_sparc_gnu_attribute
);
13996 process_tic6x_specific (FILE * file
)
13998 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13999 display_tic6x_attribute
, NULL
);
14003 process_msp430x_specific (FILE * file
)
14005 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14006 display_msp430x_attribute
, NULL
);
14009 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14010 Print the Address, Access and Initial fields of an entry at VMA ADDR
14011 and return the VMA of the next entry, or -1 if there was a problem.
14012 Does not read from DATA_END or beyond. */
14015 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14016 unsigned char * data_end
)
14019 print_vma (addr
, LONG_HEX
);
14021 if (addr
< pltgot
+ 0xfff0)
14022 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14024 printf ("%10s", "");
14027 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14031 unsigned char * from
= data
+ addr
- pltgot
;
14033 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14035 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14036 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14037 return (bfd_vma
) -1;
14041 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14042 print_vma (entry
, LONG_HEX
);
14045 return addr
+ (is_32bit_elf
? 4 : 8);
14048 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14049 PLTGOT. Print the Address and Initial fields of an entry at VMA
14050 ADDR and return the VMA of the next entry. */
14053 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14056 print_vma (addr
, LONG_HEX
);
14059 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14064 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14065 print_vma (entry
, LONG_HEX
);
14067 return addr
+ (is_32bit_elf
? 4 : 8);
14071 print_mips_ases (unsigned int mask
)
14073 if (mask
& AFL_ASE_DSP
)
14074 fputs ("\n\tDSP ASE", stdout
);
14075 if (mask
& AFL_ASE_DSPR2
)
14076 fputs ("\n\tDSP R2 ASE", stdout
);
14077 if (mask
& AFL_ASE_EVA
)
14078 fputs ("\n\tEnhanced VA Scheme", stdout
);
14079 if (mask
& AFL_ASE_MCU
)
14080 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14081 if (mask
& AFL_ASE_MDMX
)
14082 fputs ("\n\tMDMX ASE", stdout
);
14083 if (mask
& AFL_ASE_MIPS3D
)
14084 fputs ("\n\tMIPS-3D ASE", stdout
);
14085 if (mask
& AFL_ASE_MT
)
14086 fputs ("\n\tMT ASE", stdout
);
14087 if (mask
& AFL_ASE_SMARTMIPS
)
14088 fputs ("\n\tSmartMIPS ASE", stdout
);
14089 if (mask
& AFL_ASE_VIRT
)
14090 fputs ("\n\tVZ ASE", stdout
);
14091 if (mask
& AFL_ASE_MSA
)
14092 fputs ("\n\tMSA ASE", stdout
);
14093 if (mask
& AFL_ASE_MIPS16
)
14094 fputs ("\n\tMIPS16 ASE", stdout
);
14095 if (mask
& AFL_ASE_MICROMIPS
)
14096 fputs ("\n\tMICROMIPS ASE", stdout
);
14097 if (mask
& AFL_ASE_XPA
)
14098 fputs ("\n\tXPA ASE", stdout
);
14100 fprintf (stdout
, "\n\t%s", _("None"));
14101 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14102 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14106 print_mips_isa_ext (unsigned int isa_ext
)
14111 fputs (_("None"), stdout
);
14114 fputs ("RMI XLR", stdout
);
14116 case AFL_EXT_OCTEON3
:
14117 fputs ("Cavium Networks Octeon3", stdout
);
14119 case AFL_EXT_OCTEON2
:
14120 fputs ("Cavium Networks Octeon2", stdout
);
14122 case AFL_EXT_OCTEONP
:
14123 fputs ("Cavium Networks OcteonP", stdout
);
14125 case AFL_EXT_LOONGSON_3A
:
14126 fputs ("Loongson 3A", stdout
);
14128 case AFL_EXT_OCTEON
:
14129 fputs ("Cavium Networks Octeon", stdout
);
14132 fputs ("Toshiba R5900", stdout
);
14135 fputs ("MIPS R4650", stdout
);
14138 fputs ("LSI R4010", stdout
);
14141 fputs ("NEC VR4100", stdout
);
14144 fputs ("Toshiba R3900", stdout
);
14146 case AFL_EXT_10000
:
14147 fputs ("MIPS R10000", stdout
);
14150 fputs ("Broadcom SB-1", stdout
);
14153 fputs ("NEC VR4111/VR4181", stdout
);
14156 fputs ("NEC VR4120", stdout
);
14159 fputs ("NEC VR5400", stdout
);
14162 fputs ("NEC VR5500", stdout
);
14164 case AFL_EXT_LOONGSON_2E
:
14165 fputs ("ST Microelectronics Loongson 2E", stdout
);
14167 case AFL_EXT_LOONGSON_2F
:
14168 fputs ("ST Microelectronics Loongson 2F", stdout
);
14171 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14176 get_mips_reg_size (int reg_size
)
14178 return (reg_size
== AFL_REG_NONE
) ? 0
14179 : (reg_size
== AFL_REG_32
) ? 32
14180 : (reg_size
== AFL_REG_64
) ? 64
14181 : (reg_size
== AFL_REG_128
) ? 128
14186 process_mips_specific (FILE * file
)
14188 Elf_Internal_Dyn
* entry
;
14189 Elf_Internal_Shdr
*sect
= NULL
;
14190 size_t liblist_offset
= 0;
14191 size_t liblistno
= 0;
14192 size_t conflictsno
= 0;
14193 size_t options_offset
= 0;
14194 size_t conflicts_offset
= 0;
14195 size_t pltrelsz
= 0;
14197 bfd_vma pltgot
= 0;
14198 bfd_vma mips_pltgot
= 0;
14199 bfd_vma jmprel
= 0;
14200 bfd_vma local_gotno
= 0;
14201 bfd_vma gotsym
= 0;
14202 bfd_vma symtabno
= 0;
14204 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14205 display_mips_gnu_attribute
);
14207 sect
= find_section (".MIPS.abiflags");
14211 Elf_External_ABIFlags_v0
*abiflags_ext
;
14212 Elf_Internal_ABIFlags_v0 abiflags_in
;
14214 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14215 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14218 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14219 sect
->sh_size
, _("MIPS ABI Flags section"));
14222 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14223 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14224 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14225 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14226 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14227 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14228 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14229 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14230 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14231 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14232 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14234 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14235 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14236 if (abiflags_in
.isa_rev
> 1)
14237 printf ("r%d", abiflags_in
.isa_rev
);
14238 printf ("\nGPR size: %d",
14239 get_mips_reg_size (abiflags_in
.gpr_size
));
14240 printf ("\nCPR1 size: %d",
14241 get_mips_reg_size (abiflags_in
.cpr1_size
));
14242 printf ("\nCPR2 size: %d",
14243 get_mips_reg_size (abiflags_in
.cpr2_size
));
14244 fputs ("\nFP ABI: ", stdout
);
14245 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14246 fputs ("ISA Extension: ", stdout
);
14247 print_mips_isa_ext (abiflags_in
.isa_ext
);
14248 fputs ("\nASEs:", stdout
);
14249 print_mips_ases (abiflags_in
.ases
);
14250 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14251 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14252 fputc ('\n', stdout
);
14253 free (abiflags_ext
);
14258 /* We have a lot of special sections. Thanks SGI! */
14259 if (dynamic_section
== NULL
)
14260 /* No information available. */
14263 for (entry
= dynamic_section
;
14264 /* PR 17531 file: 012-50589-0.004. */
14265 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14267 switch (entry
->d_tag
)
14269 case DT_MIPS_LIBLIST
:
14271 = offset_from_vma (file
, entry
->d_un
.d_val
,
14272 liblistno
* sizeof (Elf32_External_Lib
));
14274 case DT_MIPS_LIBLISTNO
:
14275 liblistno
= entry
->d_un
.d_val
;
14277 case DT_MIPS_OPTIONS
:
14278 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14280 case DT_MIPS_CONFLICT
:
14282 = offset_from_vma (file
, entry
->d_un
.d_val
,
14283 conflictsno
* sizeof (Elf32_External_Conflict
));
14285 case DT_MIPS_CONFLICTNO
:
14286 conflictsno
= entry
->d_un
.d_val
;
14289 pltgot
= entry
->d_un
.d_ptr
;
14291 case DT_MIPS_LOCAL_GOTNO
:
14292 local_gotno
= entry
->d_un
.d_val
;
14294 case DT_MIPS_GOTSYM
:
14295 gotsym
= entry
->d_un
.d_val
;
14297 case DT_MIPS_SYMTABNO
:
14298 symtabno
= entry
->d_un
.d_val
;
14300 case DT_MIPS_PLTGOT
:
14301 mips_pltgot
= entry
->d_un
.d_ptr
;
14304 pltrel
= entry
->d_un
.d_val
;
14307 pltrelsz
= entry
->d_un
.d_val
;
14310 jmprel
= entry
->d_un
.d_ptr
;
14316 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14318 Elf32_External_Lib
* elib
;
14321 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14323 sizeof (Elf32_External_Lib
),
14324 _("liblist section data"));
14327 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14328 (unsigned long) liblistno
);
14329 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14332 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14339 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14340 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14341 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14342 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14343 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14345 tmp
= gmtime (&atime
);
14346 snprintf (timebuf
, sizeof (timebuf
),
14347 "%04u-%02u-%02uT%02u:%02u:%02u",
14348 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14349 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14351 printf ("%3lu: ", (unsigned long) cnt
);
14352 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14353 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14355 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14356 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14357 liblist
.l_version
);
14359 if (liblist
.l_flags
== 0)
14363 static const struct
14370 { " EXACT_MATCH", LL_EXACT_MATCH
},
14371 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14372 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14373 { " EXPORTS", LL_EXPORTS
},
14374 { " DELAY_LOAD", LL_DELAY_LOAD
},
14375 { " DELTA", LL_DELTA
}
14377 int flags
= liblist
.l_flags
;
14380 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14381 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14383 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14384 flags
^= l_flags_vals
[fcnt
].bit
;
14387 printf (" %#x", (unsigned int) flags
);
14397 if (options_offset
!= 0)
14399 Elf_External_Options
* eopt
;
14400 Elf_Internal_Options
* iopt
;
14401 Elf_Internal_Options
* option
;
14404 sect
= section_headers
;
14406 /* Find the section header so that we get the size. */
14407 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14408 /* PR 17533 file: 012-277276-0.004. */
14411 error (_("No MIPS_OPTIONS header found\n"));
14415 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14416 sect
->sh_size
, _("options"));
14419 iopt
= (Elf_Internal_Options
*)
14420 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14423 error (_("Out of memory allocatinf space for MIPS options\n"));
14430 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14432 Elf_External_Options
* eoption
;
14434 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14436 option
->kind
= BYTE_GET (eoption
->kind
);
14437 option
->size
= BYTE_GET (eoption
->size
);
14438 option
->section
= BYTE_GET (eoption
->section
);
14439 option
->info
= BYTE_GET (eoption
->info
);
14441 /* PR 17531: file: ffa0fa3b. */
14442 if (option
->size
< sizeof (* eopt
)
14443 || offset
+ option
->size
> sect
->sh_size
)
14445 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14448 offset
+= option
->size
;
14454 printf (_("\nSection '%s' contains %d entries:\n"),
14455 printable_section_name (sect
), cnt
);
14464 switch (option
->kind
)
14467 /* This shouldn't happen. */
14468 printf (" NULL %d %lx", option
->section
, option
->info
);
14471 printf (" REGINFO ");
14472 if (elf_header
.e_machine
== EM_MIPS
)
14475 Elf32_External_RegInfo
* ereg
;
14476 Elf32_RegInfo reginfo
;
14478 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14479 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14480 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14481 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14482 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14483 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14484 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14486 printf ("GPR %08lx GP 0x%lx\n",
14487 reginfo
.ri_gprmask
,
14488 (unsigned long) reginfo
.ri_gp_value
);
14489 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14490 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14491 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14496 Elf64_External_RegInfo
* ereg
;
14497 Elf64_Internal_RegInfo reginfo
;
14499 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14500 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14501 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14502 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14503 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14504 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14505 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14507 printf ("GPR %08lx GP 0x",
14508 reginfo
.ri_gprmask
);
14509 printf_vma (reginfo
.ri_gp_value
);
14512 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14513 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14514 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14518 case ODK_EXCEPTIONS
:
14519 fputs (" EXCEPTIONS fpe_min(", stdout
);
14520 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14521 fputs (") fpe_max(", stdout
);
14522 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14523 fputs (")", stdout
);
14525 if (option
->info
& OEX_PAGE0
)
14526 fputs (" PAGE0", stdout
);
14527 if (option
->info
& OEX_SMM
)
14528 fputs (" SMM", stdout
);
14529 if (option
->info
& OEX_FPDBUG
)
14530 fputs (" FPDBUG", stdout
);
14531 if (option
->info
& OEX_DISMISS
)
14532 fputs (" DISMISS", stdout
);
14535 fputs (" PAD ", stdout
);
14536 if (option
->info
& OPAD_PREFIX
)
14537 fputs (" PREFIX", stdout
);
14538 if (option
->info
& OPAD_POSTFIX
)
14539 fputs (" POSTFIX", stdout
);
14540 if (option
->info
& OPAD_SYMBOL
)
14541 fputs (" SYMBOL", stdout
);
14544 fputs (" HWPATCH ", stdout
);
14545 if (option
->info
& OHW_R4KEOP
)
14546 fputs (" R4KEOP", stdout
);
14547 if (option
->info
& OHW_R8KPFETCH
)
14548 fputs (" R8KPFETCH", stdout
);
14549 if (option
->info
& OHW_R5KEOP
)
14550 fputs (" R5KEOP", stdout
);
14551 if (option
->info
& OHW_R5KCVTL
)
14552 fputs (" R5KCVTL", stdout
);
14555 fputs (" FILL ", stdout
);
14556 /* XXX Print content of info word? */
14559 fputs (" TAGS ", stdout
);
14560 /* XXX Print content of info word? */
14563 fputs (" HWAND ", stdout
);
14564 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14565 fputs (" R4KEOP_CHECKED", stdout
);
14566 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14567 fputs (" R4KEOP_CLEAN", stdout
);
14570 fputs (" HWOR ", stdout
);
14571 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14572 fputs (" R4KEOP_CHECKED", stdout
);
14573 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14574 fputs (" R4KEOP_CLEAN", stdout
);
14577 printf (" GP_GROUP %#06lx self-contained %#06lx",
14578 option
->info
& OGP_GROUP
,
14579 (option
->info
& OGP_SELF
) >> 16);
14582 printf (" IDENT %#06lx self-contained %#06lx",
14583 option
->info
& OGP_GROUP
,
14584 (option
->info
& OGP_SELF
) >> 16);
14587 /* This shouldn't happen. */
14588 printf (" %3d ??? %d %lx",
14589 option
->kind
, option
->section
, option
->info
);
14593 len
= sizeof (* eopt
);
14594 while (len
< option
->size
)
14596 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14598 if (ISPRINT (datum
))
14599 printf ("%c", datum
);
14601 printf ("\\%03o", datum
);
14604 fputs ("\n", stdout
);
14606 offset
+= option
->size
;
14614 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14616 Elf32_Conflict
* iconf
;
14619 if (dynamic_symbols
== NULL
)
14621 error (_("conflict list found without a dynamic symbol table\n"));
14625 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14628 error (_("Out of memory allocating space for dynamic conflicts\n"));
14634 Elf32_External_Conflict
* econf32
;
14636 econf32
= (Elf32_External_Conflict
*)
14637 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14638 sizeof (* econf32
), _("conflict"));
14642 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14643 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14649 Elf64_External_Conflict
* econf64
;
14651 econf64
= (Elf64_External_Conflict
*)
14652 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14653 sizeof (* econf64
), _("conflict"));
14657 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14658 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14663 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14664 (unsigned long) conflictsno
);
14665 puts (_(" Num: Index Value Name"));
14667 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14669 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14671 if (iconf
[cnt
] >= num_dynamic_syms
)
14672 printf (_("<corrupt symbol index>"));
14675 Elf_Internal_Sym
* psym
;
14677 psym
= & dynamic_symbols
[iconf
[cnt
]];
14678 print_vma (psym
->st_value
, FULL_HEX
);
14680 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14681 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14683 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14691 if (pltgot
!= 0 && local_gotno
!= 0)
14693 bfd_vma ent
, local_end
, global_end
;
14695 unsigned char * data
;
14696 unsigned char * data_end
;
14700 addr_size
= (is_32bit_elf
? 4 : 8);
14701 local_end
= pltgot
+ local_gotno
* addr_size
;
14703 /* PR binutils/17533 file: 012-111227-0.004 */
14704 if (symtabno
< gotsym
)
14706 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14707 (unsigned long) gotsym
, (unsigned long) symtabno
);
14711 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14712 /* PR 17531: file: 54c91a34. */
14713 if (global_end
< local_end
)
14715 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14719 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14720 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14721 global_end
- pltgot
, 1,
14722 _("Global Offset Table data"));
14725 data_end
= data
+ (global_end
- pltgot
);
14727 printf (_("\nPrimary GOT:\n"));
14728 printf (_(" Canonical gp value: "));
14729 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14732 printf (_(" Reserved entries:\n"));
14733 printf (_(" %*s %10s %*s Purpose\n"),
14734 addr_size
* 2, _("Address"), _("Access"),
14735 addr_size
* 2, _("Initial"));
14736 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14737 printf (_(" Lazy resolver\n"));
14738 if (ent
== (bfd_vma
) -1)
14739 goto got_print_fail
;
14741 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14742 >> (addr_size
* 8 - 1)) != 0)
14744 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14745 printf (_(" Module pointer (GNU extension)\n"));
14746 if (ent
== (bfd_vma
) -1)
14747 goto got_print_fail
;
14751 if (ent
< local_end
)
14753 printf (_(" Local entries:\n"));
14754 printf (" %*s %10s %*s\n",
14755 addr_size
* 2, _("Address"), _("Access"),
14756 addr_size
* 2, _("Initial"));
14757 while (ent
< local_end
)
14759 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14761 if (ent
== (bfd_vma
) -1)
14762 goto got_print_fail
;
14767 if (gotsym
< symtabno
)
14771 printf (_(" Global entries:\n"));
14772 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14773 addr_size
* 2, _("Address"),
14775 addr_size
* 2, _("Initial"),
14776 addr_size
* 2, _("Sym.Val."),
14778 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14779 _("Ndx"), _("Name"));
14781 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14783 for (i
= gotsym
; i
< symtabno
; i
++)
14785 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14788 if (dynamic_symbols
== NULL
)
14789 printf (_("<no dynamic symbols>"));
14790 else if (i
< num_dynamic_syms
)
14792 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14794 print_vma (psym
->st_value
, LONG_HEX
);
14795 printf (" %-7s %3s ",
14796 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14797 get_symbol_index_type (psym
->st_shndx
));
14799 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14800 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14802 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14805 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14806 (unsigned long) i
);
14809 if (ent
== (bfd_vma
) -1)
14820 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14823 size_t offset
, rel_offset
;
14824 unsigned long count
, i
;
14825 unsigned char * data
;
14826 int addr_size
, sym_width
;
14827 Elf_Internal_Rela
* rels
;
14829 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14830 if (pltrel
== DT_RELA
)
14832 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14837 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14842 addr_size
= (is_32bit_elf
? 4 : 8);
14843 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14845 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14846 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14847 1, _("Procedure Linkage Table data"));
14851 printf ("\nPLT GOT:\n\n");
14852 printf (_(" Reserved entries:\n"));
14853 printf (_(" %*s %*s Purpose\n"),
14854 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14855 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14856 printf (_(" PLT lazy resolver\n"));
14857 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14858 printf (_(" Module pointer\n"));
14861 printf (_(" Entries:\n"));
14862 printf (" %*s %*s %*s %-7s %3s %s\n",
14863 addr_size
* 2, _("Address"),
14864 addr_size
* 2, _("Initial"),
14865 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14866 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14867 for (i
= 0; i
< count
; i
++)
14869 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14871 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14874 if (idx
>= num_dynamic_syms
)
14875 printf (_("<corrupt symbol index: %lu>"), idx
);
14878 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14880 print_vma (psym
->st_value
, LONG_HEX
);
14881 printf (" %-7s %3s ",
14882 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14883 get_symbol_index_type (psym
->st_shndx
));
14884 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14885 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14887 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14902 process_nds32_specific (FILE * file
)
14904 Elf_Internal_Shdr
*sect
= NULL
;
14906 sect
= find_section (".nds32_e_flags");
14909 unsigned int *flag
;
14911 printf ("\nNDS32 elf flags section:\n");
14912 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14913 sect
->sh_size
, _("NDS32 elf flags section"));
14915 switch ((*flag
) & 0x3)
14918 printf ("(VEC_SIZE):\tNo entry.\n");
14921 printf ("(VEC_SIZE):\t4 bytes\n");
14924 printf ("(VEC_SIZE):\t16 bytes\n");
14927 printf ("(VEC_SIZE):\treserved\n");
14936 process_gnu_liblist (FILE * file
)
14938 Elf_Internal_Shdr
* section
;
14939 Elf_Internal_Shdr
* string_sec
;
14940 Elf32_External_Lib
* elib
;
14942 size_t strtab_size
;
14949 for (i
= 0, section
= section_headers
;
14950 i
< elf_header
.e_shnum
;
14953 switch (section
->sh_type
)
14955 case SHT_GNU_LIBLIST
:
14956 if (section
->sh_link
>= elf_header
.e_shnum
)
14959 elib
= (Elf32_External_Lib
*)
14960 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14961 _("liblist section data"));
14965 string_sec
= section_headers
+ section
->sh_link
;
14967 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14968 string_sec
->sh_size
,
14969 _("liblist string table"));
14971 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14977 strtab_size
= string_sec
->sh_size
;
14979 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14980 printable_section_name (section
),
14981 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14983 puts (_(" Library Time Stamp Checksum Version Flags"));
14985 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14993 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14994 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14995 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14996 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14997 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14999 tmp
= gmtime (&atime
);
15000 snprintf (timebuf
, sizeof (timebuf
),
15001 "%04u-%02u-%02uT%02u:%02u:%02u",
15002 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15003 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15005 printf ("%3lu: ", (unsigned long) cnt
);
15007 printf ("%-20s", liblist
.l_name
< strtab_size
15008 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15010 printf ("%-20.20s", liblist
.l_name
< strtab_size
15011 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15012 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15013 liblist
.l_version
, liblist
.l_flags
);
15024 static const char *
15025 get_note_type (unsigned e_type
)
15027 static char buff
[64];
15029 if (elf_header
.e_type
== ET_CORE
)
15033 return _("NT_AUXV (auxiliary vector)");
15035 return _("NT_PRSTATUS (prstatus structure)");
15037 return _("NT_FPREGSET (floating point registers)");
15039 return _("NT_PRPSINFO (prpsinfo structure)");
15040 case NT_TASKSTRUCT
:
15041 return _("NT_TASKSTRUCT (task structure)");
15043 return _("NT_PRXFPREG (user_xfpregs structure)");
15045 return _("NT_PPC_VMX (ppc Altivec registers)");
15047 return _("NT_PPC_VSX (ppc VSX registers)");
15049 return _("NT_386_TLS (x86 TLS information)");
15050 case NT_386_IOPERM
:
15051 return _("NT_386_IOPERM (x86 I/O permissions)");
15052 case NT_X86_XSTATE
:
15053 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15054 case NT_S390_HIGH_GPRS
:
15055 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15056 case NT_S390_TIMER
:
15057 return _("NT_S390_TIMER (s390 timer register)");
15058 case NT_S390_TODCMP
:
15059 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15060 case NT_S390_TODPREG
:
15061 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15063 return _("NT_S390_CTRS (s390 control registers)");
15064 case NT_S390_PREFIX
:
15065 return _("NT_S390_PREFIX (s390 prefix register)");
15066 case NT_S390_LAST_BREAK
:
15067 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15068 case NT_S390_SYSTEM_CALL
:
15069 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15071 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15072 case NT_S390_VXRS_LOW
:
15073 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15074 case NT_S390_VXRS_HIGH
:
15075 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15077 return _("NT_ARM_VFP (arm VFP registers)");
15079 return _("NT_ARM_TLS (AArch TLS registers)");
15080 case NT_ARM_HW_BREAK
:
15081 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15082 case NT_ARM_HW_WATCH
:
15083 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15085 return _("NT_PSTATUS (pstatus structure)");
15087 return _("NT_FPREGS (floating point registers)");
15089 return _("NT_PSINFO (psinfo structure)");
15091 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15093 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15094 case NT_WIN32PSTATUS
:
15095 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15097 return _("NT_SIGINFO (siginfo_t data)");
15099 return _("NT_FILE (mapped files)");
15107 return _("NT_VERSION (version)");
15109 return _("NT_ARCH (architecture)");
15114 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15119 print_core_note (Elf_Internal_Note
*pnote
)
15121 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15122 bfd_vma count
, page_size
;
15123 unsigned char *descdata
, *filenames
, *descend
;
15125 if (pnote
->type
!= NT_FILE
)
15131 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15132 /* Still "successful". */
15137 if (pnote
->descsz
< 2 * addr_size
)
15139 printf (_(" Malformed note - too short for header\n"));
15143 descdata
= (unsigned char *) pnote
->descdata
;
15144 descend
= descdata
+ pnote
->descsz
;
15146 if (descdata
[pnote
->descsz
- 1] != '\0')
15148 printf (_(" Malformed note - does not end with \\0\n"));
15152 count
= byte_get (descdata
, addr_size
);
15153 descdata
+= addr_size
;
15155 page_size
= byte_get (descdata
, addr_size
);
15156 descdata
+= addr_size
;
15158 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15160 printf (_(" Malformed note - too short for supplied file count\n"));
15164 printf (_(" Page size: "));
15165 print_vma (page_size
, DEC
);
15168 printf (_(" %*s%*s%*s\n"),
15169 (int) (2 + 2 * addr_size
), _("Start"),
15170 (int) (4 + 2 * addr_size
), _("End"),
15171 (int) (4 + 2 * addr_size
), _("Page Offset"));
15172 filenames
= descdata
+ count
* 3 * addr_size
;
15173 while (count
-- > 0)
15175 bfd_vma start
, end
, file_ofs
;
15177 if (filenames
== descend
)
15179 printf (_(" Malformed note - filenames end too early\n"));
15183 start
= byte_get (descdata
, addr_size
);
15184 descdata
+= addr_size
;
15185 end
= byte_get (descdata
, addr_size
);
15186 descdata
+= addr_size
;
15187 file_ofs
= byte_get (descdata
, addr_size
);
15188 descdata
+= addr_size
;
15191 print_vma (start
, FULL_HEX
);
15193 print_vma (end
, FULL_HEX
);
15195 print_vma (file_ofs
, FULL_HEX
);
15196 printf ("\n %s\n", filenames
);
15198 filenames
+= 1 + strlen ((char *) filenames
);
15204 static const char *
15205 get_gnu_elf_note_type (unsigned e_type
)
15207 static char buff
[64];
15211 case NT_GNU_ABI_TAG
:
15212 return _("NT_GNU_ABI_TAG (ABI version tag)");
15214 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15215 case NT_GNU_BUILD_ID
:
15216 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15217 case NT_GNU_GOLD_VERSION
:
15218 return _("NT_GNU_GOLD_VERSION (gold version)");
15223 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15228 print_gnu_note (Elf_Internal_Note
*pnote
)
15230 switch (pnote
->type
)
15232 case NT_GNU_BUILD_ID
:
15236 printf (_(" Build ID: "));
15237 for (i
= 0; i
< pnote
->descsz
; ++i
)
15238 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15243 case NT_GNU_ABI_TAG
:
15245 unsigned long os
, major
, minor
, subminor
;
15246 const char *osname
;
15248 /* PR 17531: file: 030-599401-0.004. */
15249 if (pnote
->descsz
< 16)
15251 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15255 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15256 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15257 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15258 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15262 case GNU_ABI_TAG_LINUX
:
15265 case GNU_ABI_TAG_HURD
:
15268 case GNU_ABI_TAG_SOLARIS
:
15269 osname
= "Solaris";
15271 case GNU_ABI_TAG_FREEBSD
:
15272 osname
= "FreeBSD";
15274 case GNU_ABI_TAG_NETBSD
:
15277 case GNU_ABI_TAG_SYLLABLE
:
15278 osname
= "Syllable";
15280 case GNU_ABI_TAG_NACL
:
15284 osname
= "Unknown";
15288 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15289 major
, minor
, subminor
);
15293 case NT_GNU_GOLD_VERSION
:
15297 printf (_(" Version: "));
15298 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15299 printf ("%c", pnote
->descdata
[i
]);
15308 static const char *
15309 get_v850_elf_note_type (enum v850_notes n_type
)
15311 static char buff
[64];
15315 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15316 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15317 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15318 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15319 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15320 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15322 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15328 print_v850_note (Elf_Internal_Note
* pnote
)
15332 if (pnote
->descsz
!= 4)
15334 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15338 printf (_("not set\n"));
15342 switch (pnote
->type
)
15344 case V850_NOTE_ALIGNMENT
:
15347 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15348 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15352 case V850_NOTE_DATA_SIZE
:
15355 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15356 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15360 case V850_NOTE_FPU_INFO
:
15363 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15364 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15368 case V850_NOTE_MMU_INFO
:
15369 case V850_NOTE_CACHE_INFO
:
15370 case V850_NOTE_SIMD_INFO
:
15371 if (val
== EF_RH850_SIMD
)
15373 printf (_("yes\n"));
15379 /* An 'unknown note type' message will already have been displayed. */
15383 printf (_("unknown value: %x\n"), val
);
15388 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15390 unsigned int version
;
15392 switch (pnote
->type
)
15394 case NT_NETBSD_IDENT
:
15395 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15396 if ((version
/ 10000) % 100)
15397 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15398 version
, version
/ 100000000, (version
/ 1000000) % 100,
15399 (version
/ 10000) % 100 > 26 ? "Z" : "",
15400 'A' + (version
/ 10000) % 26);
15402 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15403 version
, version
/ 100000000, (version
/ 1000000) % 100,
15404 (version
/ 100) % 100);
15407 case NT_NETBSD_MARCH
:
15408 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15416 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15421 static const char *
15422 get_freebsd_elfcore_note_type (unsigned e_type
)
15426 case NT_FREEBSD_THRMISC
:
15427 return _("NT_THRMISC (thrmisc structure)");
15428 case NT_FREEBSD_PROCSTAT_PROC
:
15429 return _("NT_PROCSTAT_PROC (proc data)");
15430 case NT_FREEBSD_PROCSTAT_FILES
:
15431 return _("NT_PROCSTAT_FILES (files data)");
15432 case NT_FREEBSD_PROCSTAT_VMMAP
:
15433 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15434 case NT_FREEBSD_PROCSTAT_GROUPS
:
15435 return _("NT_PROCSTAT_GROUPS (groups data)");
15436 case NT_FREEBSD_PROCSTAT_UMASK
:
15437 return _("NT_PROCSTAT_UMASK (umask data)");
15438 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15439 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15440 case NT_FREEBSD_PROCSTAT_OSREL
:
15441 return _("NT_PROCSTAT_OSREL (osreldate data)");
15442 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15443 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15444 case NT_FREEBSD_PROCSTAT_AUXV
:
15445 return _("NT_PROCSTAT_AUXV (auxv data)");
15447 return get_note_type (e_type
);
15450 static const char *
15451 get_netbsd_elfcore_note_type (unsigned e_type
)
15453 static char buff
[64];
15455 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15457 /* NetBSD core "procinfo" structure. */
15458 return _("NetBSD procinfo structure");
15461 /* As of Jan 2002 there are no other machine-independent notes
15462 defined for NetBSD core files. If the note type is less
15463 than the start of the machine-dependent note types, we don't
15466 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15468 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15472 switch (elf_header
.e_machine
)
15474 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15475 and PT_GETFPREGS == mach+2. */
15480 case EM_SPARC32PLUS
:
15484 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15485 return _("PT_GETREGS (reg structure)");
15486 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15487 return _("PT_GETFPREGS (fpreg structure)");
15493 /* On all other arch's, PT_GETREGS == mach+1 and
15494 PT_GETFPREGS == mach+3. */
15498 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15499 return _("PT_GETREGS (reg structure)");
15500 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15501 return _("PT_GETFPREGS (fpreg structure)");
15507 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15508 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15512 static const char *
15513 get_stapsdt_note_type (unsigned e_type
)
15515 static char buff
[64];
15520 return _("NT_STAPSDT (SystemTap probe descriptors)");
15526 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15531 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15533 int addr_size
= is_32bit_elf
? 4 : 8;
15534 char *data
= pnote
->descdata
;
15535 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15536 bfd_vma pc
, base_addr
, semaphore
;
15537 char *provider
, *probe
, *arg_fmt
;
15539 pc
= byte_get ((unsigned char *) data
, addr_size
);
15541 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15543 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15547 data
+= strlen (data
) + 1;
15549 data
+= strlen (data
) + 1;
15551 data
+= strlen (data
) + 1;
15553 printf (_(" Provider: %s\n"), provider
);
15554 printf (_(" Name: %s\n"), probe
);
15555 printf (_(" Location: "));
15556 print_vma (pc
, FULL_HEX
);
15557 printf (_(", Base: "));
15558 print_vma (base_addr
, FULL_HEX
);
15559 printf (_(", Semaphore: "));
15560 print_vma (semaphore
, FULL_HEX
);
15562 printf (_(" Arguments: %s\n"), arg_fmt
);
15564 return data
== data_end
;
15567 static const char *
15568 get_ia64_vms_note_type (unsigned e_type
)
15570 static char buff
[64];
15575 return _("NT_VMS_MHD (module header)");
15577 return _("NT_VMS_LNM (language name)");
15579 return _("NT_VMS_SRC (source files)");
15581 return "NT_VMS_TITLE";
15583 return _("NT_VMS_EIDC (consistency check)");
15584 case NT_VMS_FPMODE
:
15585 return _("NT_VMS_FPMODE (FP mode)");
15586 case NT_VMS_LINKTIME
:
15587 return "NT_VMS_LINKTIME";
15588 case NT_VMS_IMGNAM
:
15589 return _("NT_VMS_IMGNAM (image name)");
15591 return _("NT_VMS_IMGID (image id)");
15592 case NT_VMS_LINKID
:
15593 return _("NT_VMS_LINKID (link id)");
15594 case NT_VMS_IMGBID
:
15595 return _("NT_VMS_IMGBID (build id)");
15596 case NT_VMS_GSTNAM
:
15597 return _("NT_VMS_GSTNAM (sym table name)");
15598 case NT_VMS_ORIG_DYN
:
15599 return "NT_VMS_ORIG_DYN";
15600 case NT_VMS_PATCHTIME
:
15601 return "NT_VMS_PATCHTIME";
15603 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15609 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15611 switch (pnote
->type
)
15614 if (pnote
->descsz
> 36)
15616 size_t l
= strlen (pnote
->descdata
+ 34);
15617 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15618 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15619 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15620 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15623 printf (_(" Invalid size\n"));
15626 printf (_(" Language: %s\n"), pnote
->descdata
);
15629 case NT_VMS_FPMODE
:
15630 printf (_(" Floating Point mode: "));
15631 printf ("0x%016" BFD_VMA_FMT
"x\n",
15632 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15634 case NT_VMS_LINKTIME
:
15635 printf (_(" Link time: "));
15637 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15640 case NT_VMS_PATCHTIME
:
15641 printf (_(" Patch time: "));
15643 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15646 case NT_VMS_ORIG_DYN
:
15647 printf (_(" Major id: %u, minor id: %u\n"),
15648 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15649 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15650 printf (_(" Last modified : "));
15652 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15653 printf (_("\n Link flags : "));
15654 printf ("0x%016" BFD_VMA_FMT
"x\n",
15655 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15656 printf (_(" Header flags: 0x%08x\n"),
15657 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15658 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15661 case NT_VMS_IMGNAM
:
15662 printf (_(" Image name: %s\n"), pnote
->descdata
);
15664 case NT_VMS_GSTNAM
:
15665 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15668 printf (_(" Image id: %s\n"), pnote
->descdata
);
15670 case NT_VMS_LINKID
:
15671 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15679 /* Note that by the ELF standard, the name field is already null byte
15680 terminated, and namesz includes the terminating null byte.
15681 I.E. the value of namesz for the name "FSF" is 4.
15683 If the value of namesz is zero, there is no name present. */
15685 process_note (Elf_Internal_Note
* pnote
)
15687 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15690 if (pnote
->namesz
== 0)
15691 /* If there is no note name, then use the default set of
15692 note type strings. */
15693 nt
= get_note_type (pnote
->type
);
15695 else if (const_strneq (pnote
->namedata
, "GNU"))
15696 /* GNU-specific object file notes. */
15697 nt
= get_gnu_elf_note_type (pnote
->type
);
15699 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
15700 /* FreeBSD-specific core file notes. */
15701 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
15703 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15704 /* NetBSD-specific core file notes. */
15705 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15707 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15708 /* NetBSD-specific core file notes. */
15709 return process_netbsd_elf_note (pnote
);
15711 else if (strneq (pnote
->namedata
, "SPU/", 4))
15713 /* SPU-specific core file notes. */
15714 nt
= pnote
->namedata
+ 4;
15718 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15719 /* VMS/ia64-specific file notes. */
15720 nt
= get_ia64_vms_note_type (pnote
->type
);
15722 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15723 nt
= get_stapsdt_note_type (pnote
->type
);
15726 /* Don't recognize this note name; just use the default set of
15727 note type strings. */
15728 nt
= get_note_type (pnote
->type
);
15730 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15732 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15733 return print_ia64_vms_note (pnote
);
15734 else if (const_strneq (pnote
->namedata
, "GNU"))
15735 return print_gnu_note (pnote
);
15736 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15737 return print_stapsdt_note (pnote
);
15738 else if (const_strneq (pnote
->namedata
, "CORE"))
15739 return print_core_note (pnote
);
15746 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15748 Elf_External_Note
* pnotes
;
15749 Elf_External_Note
* external
;
15756 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15758 if (pnotes
== NULL
)
15763 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15764 (unsigned long) offset
, (unsigned long) length
);
15765 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15767 end
= (char *) pnotes
+ length
;
15768 while ((char *) external
< end
)
15770 Elf_Internal_Note inote
;
15773 char * temp
= NULL
;
15774 size_t data_remaining
= end
- (char *) external
;
15776 if (!is_ia64_vms ())
15778 /* PR binutils/15191
15779 Make sure that there is enough data to read. */
15780 min_notesz
= offsetof (Elf_External_Note
, name
);
15781 if (data_remaining
< min_notesz
)
15783 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15784 (int) data_remaining
);
15787 inote
.type
= BYTE_GET (external
->type
);
15788 inote
.namesz
= BYTE_GET (external
->namesz
);
15789 inote
.namedata
= external
->name
;
15790 inote
.descsz
= BYTE_GET (external
->descsz
);
15791 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15792 /* PR 17531: file: 3443835e. */
15793 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15795 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15796 inote
.descdata
= inote
.namedata
;
15800 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15801 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15805 Elf64_External_VMS_Note
*vms_external
;
15807 /* PR binutils/15191
15808 Make sure that there is enough data to read. */
15809 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15810 if (data_remaining
< min_notesz
)
15812 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15813 (int) data_remaining
);
15817 vms_external
= (Elf64_External_VMS_Note
*) external
;
15818 inote
.type
= BYTE_GET (vms_external
->type
);
15819 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15820 inote
.namedata
= vms_external
->name
;
15821 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15822 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15823 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15824 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15827 if (inote
.descdata
< (char *) external
+ min_notesz
15828 || next
< (char *) external
+ min_notesz
15829 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15830 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15831 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15832 || data_remaining
< (size_t)(next
- (char *) external
))
15834 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15835 (unsigned long) ((char *) external
- (char *) pnotes
));
15836 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15837 inote
.type
, inote
.namesz
, inote
.descsz
);
15841 external
= (Elf_External_Note
*) next
;
15843 /* Verify that name is null terminated. It appears that at least
15844 one version of Linux (RedHat 6.0) generates corefiles that don't
15845 comply with the ELF spec by failing to include the null byte in
15847 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15849 temp
= (char *) malloc (inote
.namesz
+ 1);
15852 error (_("Out of memory allocating space for inote name\n"));
15857 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15858 temp
[inote
.namesz
] = 0;
15860 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15861 inote
.namedata
= temp
;
15864 res
&= process_note (& inote
);
15879 process_corefile_note_segments (FILE * file
)
15881 Elf_Internal_Phdr
* segment
;
15885 if (! get_program_headers (file
))
15888 for (i
= 0, segment
= program_headers
;
15889 i
< elf_header
.e_phnum
;
15892 if (segment
->p_type
== PT_NOTE
)
15893 res
&= process_corefile_note_segment (file
,
15894 (bfd_vma
) segment
->p_offset
,
15895 (bfd_vma
) segment
->p_filesz
);
15902 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15904 Elf_External_Note
* pnotes
;
15905 Elf_External_Note
* external
;
15912 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15914 if (pnotes
== NULL
)
15918 end
= (char*) pnotes
+ length
;
15920 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15921 (unsigned long) offset
, (unsigned long) length
);
15923 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15925 Elf_External_Note
* next
;
15926 Elf_Internal_Note inote
;
15928 inote
.type
= BYTE_GET (external
->type
);
15929 inote
.namesz
= BYTE_GET (external
->namesz
);
15930 inote
.namedata
= external
->name
;
15931 inote
.descsz
= BYTE_GET (external
->descsz
);
15932 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15933 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15935 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15937 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15938 inote
.descdata
= inote
.namedata
;
15942 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15944 if ( ((char *) next
> end
)
15945 || ((char *) next
< (char *) pnotes
))
15947 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15948 (unsigned long) ((char *) external
- (char *) pnotes
));
15949 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15950 inote
.type
, inote
.namesz
, inote
.descsz
);
15956 /* Prevent out-of-bounds indexing. */
15957 if ( inote
.namedata
+ inote
.namesz
> end
15958 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15960 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15961 (unsigned long) ((char *) external
- (char *) pnotes
));
15962 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15963 inote
.type
, inote
.namesz
, inote
.descsz
);
15967 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15969 if (! print_v850_note (& inote
))
15972 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15973 inote
.namesz
, inote
.descsz
);
15983 process_note_sections (FILE * file
)
15985 Elf_Internal_Shdr
* section
;
15990 for (i
= 0, section
= section_headers
;
15991 i
< elf_header
.e_shnum
&& section
!= NULL
;
15994 if (section
->sh_type
== SHT_NOTE
)
15996 res
&= process_corefile_note_segment (file
,
15997 (bfd_vma
) section
->sh_offset
,
15998 (bfd_vma
) section
->sh_size
);
16002 if (( elf_header
.e_machine
== EM_V800
16003 || elf_header
.e_machine
== EM_V850
16004 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16005 && section
->sh_type
== SHT_RENESAS_INFO
)
16007 res
&= process_v850_notes (file
,
16008 (bfd_vma
) section
->sh_offset
,
16009 (bfd_vma
) section
->sh_size
);
16015 /* Try processing NOTE segments instead. */
16016 return process_corefile_note_segments (file
);
16022 process_notes (FILE * file
)
16024 /* If we have not been asked to display the notes then do nothing. */
16028 if (elf_header
.e_type
!= ET_CORE
)
16029 return process_note_sections (file
);
16031 /* No program headers means no NOTE segment. */
16032 if (elf_header
.e_phnum
> 0)
16033 return process_corefile_note_segments (file
);
16035 printf (_("No note segments present in the core file.\n"));
16040 process_arch_specific (FILE * file
)
16045 switch (elf_header
.e_machine
)
16048 return process_arm_specific (file
);
16050 case EM_MIPS_RS3_LE
:
16051 return process_mips_specific (file
);
16054 return process_nds32_specific (file
);
16057 return process_power_specific (file
);
16061 return process_s390_specific (file
);
16064 case EM_SPARC32PLUS
:
16066 return process_sparc_specific (file
);
16069 return process_tic6x_specific (file
);
16072 return process_msp430x_specific (file
);
16080 get_file_header (FILE * file
)
16082 /* Read in the identity array. */
16083 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16086 /* Determine how to read the rest of the header. */
16087 switch (elf_header
.e_ident
[EI_DATA
])
16089 default: /* fall through */
16090 case ELFDATANONE
: /* fall through */
16092 byte_get
= byte_get_little_endian
;
16093 byte_put
= byte_put_little_endian
;
16096 byte_get
= byte_get_big_endian
;
16097 byte_put
= byte_put_big_endian
;
16101 /* For now we only support 32 bit and 64 bit ELF files. */
16102 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16104 /* Read in the rest of the header. */
16107 Elf32_External_Ehdr ehdr32
;
16109 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16112 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16113 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16114 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16115 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16116 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16117 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16118 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16119 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16120 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16121 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16122 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16123 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16124 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16128 Elf64_External_Ehdr ehdr64
;
16130 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16131 we will not be able to cope with the 64bit data found in
16132 64 ELF files. Detect this now and abort before we start
16133 overwriting things. */
16134 if (sizeof (bfd_vma
) < 8)
16136 error (_("This instance of readelf has been built without support for a\n\
16137 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16141 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16144 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16145 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16146 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16147 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16148 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16149 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16150 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16151 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16152 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16153 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16154 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16155 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16156 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16159 if (elf_header
.e_shoff
)
16161 /* There may be some extensions in the first section header. Don't
16162 bomb if we can't read it. */
16164 get_32bit_section_headers (file
, TRUE
);
16166 get_64bit_section_headers (file
, TRUE
);
16172 /* Process one ELF object file according to the command line options.
16173 This file may actually be stored in an archive. The file is
16174 positioned at the start of the ELF object. */
16177 process_object (char * file_name
, FILE * file
)
16181 if (! get_file_header (file
))
16183 error (_("%s: Failed to read file header\n"), file_name
);
16187 /* Initialise per file variables. */
16188 for (i
= ARRAY_SIZE (version_info
); i
--;)
16189 version_info
[i
] = 0;
16191 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16192 dynamic_info
[i
] = 0;
16193 dynamic_info_DT_GNU_HASH
= 0;
16195 /* Process the file. */
16197 printf (_("\nFile: %s\n"), file_name
);
16199 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16200 Note we do this even if cmdline_dump_sects is empty because we
16201 must make sure that the dump_sets array is zeroed out before each
16202 object file is processed. */
16203 if (num_dump_sects
> num_cmdline_dump_sects
)
16204 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16206 if (num_cmdline_dump_sects
> 0)
16208 if (num_dump_sects
== 0)
16209 /* A sneaky way of allocating the dump_sects array. */
16210 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16212 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16213 memcpy (dump_sects
, cmdline_dump_sects
,
16214 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16217 if (! process_file_header ())
16220 if (! process_section_headers (file
))
16222 /* Without loaded section headers we cannot process lots of
16224 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16226 if (! do_using_dynamic
)
16227 do_syms
= do_dyn_syms
= do_reloc
= 0;
16230 if (! process_section_groups (file
))
16232 /* Without loaded section groups we cannot process unwind. */
16236 if (process_program_headers (file
))
16237 process_dynamic_section (file
);
16239 process_relocs (file
);
16241 process_unwind (file
);
16243 process_symbol_table (file
);
16245 process_syminfo (file
);
16247 process_version_sections (file
);
16249 process_section_contents (file
);
16251 process_notes (file
);
16253 process_gnu_liblist (file
);
16255 process_arch_specific (file
);
16257 if (program_headers
)
16259 free (program_headers
);
16260 program_headers
= NULL
;
16263 if (section_headers
)
16265 free (section_headers
);
16266 section_headers
= NULL
;
16271 free (string_table
);
16272 string_table
= NULL
;
16273 string_table_length
= 0;
16276 if (dynamic_strings
)
16278 free (dynamic_strings
);
16279 dynamic_strings
= NULL
;
16280 dynamic_strings_length
= 0;
16283 if (dynamic_symbols
)
16285 free (dynamic_symbols
);
16286 dynamic_symbols
= NULL
;
16287 num_dynamic_syms
= 0;
16290 if (dynamic_syminfo
)
16292 free (dynamic_syminfo
);
16293 dynamic_syminfo
= NULL
;
16296 if (dynamic_section
)
16298 free (dynamic_section
);
16299 dynamic_section
= NULL
;
16302 if (section_headers_groups
)
16304 free (section_headers_groups
);
16305 section_headers_groups
= NULL
;
16308 if (section_groups
)
16310 struct group_list
* g
;
16311 struct group_list
* next
;
16313 for (i
= 0; i
< group_count
; i
++)
16315 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16322 free (section_groups
);
16323 section_groups
= NULL
;
16326 free_debug_memory ();
16331 /* Process an ELF archive.
16332 On entry the file is positioned just after the ARMAG string. */
16335 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16337 struct archive_info arch
;
16338 struct archive_info nested_arch
;
16344 /* The ARCH structure is used to hold information about this archive. */
16345 arch
.file_name
= NULL
;
16347 arch
.index_array
= NULL
;
16348 arch
.sym_table
= NULL
;
16349 arch
.longnames
= NULL
;
16351 /* The NESTED_ARCH structure is used as a single-item cache of information
16352 about a nested archive (when members of a thin archive reside within
16353 another regular archive file). */
16354 nested_arch
.file_name
= NULL
;
16355 nested_arch
.file
= NULL
;
16356 nested_arch
.index_array
= NULL
;
16357 nested_arch
.sym_table
= NULL
;
16358 nested_arch
.longnames
= NULL
;
16360 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16366 if (do_archive_index
)
16368 if (arch
.sym_table
== NULL
)
16369 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16372 unsigned long i
, l
;
16373 unsigned long current_pos
;
16375 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16376 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16377 current_pos
= ftell (file
);
16379 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16381 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16383 char * member_name
;
16385 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16387 if (member_name
!= NULL
)
16389 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16391 if (qualified_name
!= NULL
)
16393 printf (_("Contents of binary %s at offset "), qualified_name
);
16394 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16396 free (qualified_name
);
16401 if (l
>= arch
.sym_size
)
16403 error (_("%s: end of the symbol table reached before the end of the index\n"),
16407 /* PR 17531: file: 0b6630b2. */
16408 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16409 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16412 if (arch
.uses_64bit_indicies
)
16417 if (l
< arch
.sym_size
)
16418 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16419 file_name
, arch
.sym_size
- l
);
16421 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16423 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16429 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16430 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16431 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16432 && !do_section_groups
&& !do_dyn_syms
)
16434 ret
= 0; /* Archive index only. */
16445 char * qualified_name
;
16447 /* Read the next archive header. */
16448 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16450 error (_("%s: failed to seek to next archive header\n"), file_name
);
16453 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16454 if (got
!= sizeof arch
.arhdr
)
16458 error (_("%s: failed to read archive header\n"), file_name
);
16462 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16464 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16469 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16471 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16472 if (archive_file_size
& 01)
16473 ++archive_file_size
;
16475 name
= get_archive_member_name (&arch
, &nested_arch
);
16478 error (_("%s: bad archive file name\n"), file_name
);
16482 namelen
= strlen (name
);
16484 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16485 if (qualified_name
== NULL
)
16487 error (_("%s: bad archive file name\n"), file_name
);
16492 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16494 /* This is a proxy for an external member of a thin archive. */
16495 FILE * member_file
;
16496 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16497 if (member_file_name
== NULL
)
16503 member_file
= fopen (member_file_name
, "rb");
16504 if (member_file
== NULL
)
16506 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16507 free (member_file_name
);
16512 archive_file_offset
= arch
.nested_member_origin
;
16514 ret
|= process_object (qualified_name
, member_file
);
16516 fclose (member_file
);
16517 free (member_file_name
);
16519 else if (is_thin_archive
)
16521 /* PR 15140: Allow for corrupt thin archives. */
16522 if (nested_arch
.file
== NULL
)
16524 error (_("%s: contains corrupt thin archive: %s\n"),
16530 /* This is a proxy for a member of a nested archive. */
16531 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16533 /* The nested archive file will have been opened and setup by
16534 get_archive_member_name. */
16535 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16537 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16542 ret
|= process_object (qualified_name
, nested_arch
.file
);
16546 archive_file_offset
= arch
.next_arhdr_offset
;
16547 arch
.next_arhdr_offset
+= archive_file_size
;
16549 ret
|= process_object (qualified_name
, file
);
16552 if (dump_sects
!= NULL
)
16556 num_dump_sects
= 0;
16559 free (qualified_name
);
16563 if (nested_arch
.file
!= NULL
)
16564 fclose (nested_arch
.file
);
16565 release_archive (&nested_arch
);
16566 release_archive (&arch
);
16572 process_file (char * file_name
)
16575 struct stat statbuf
;
16576 char armag
[SARMAG
];
16579 if (stat (file_name
, &statbuf
) < 0)
16581 if (errno
== ENOENT
)
16582 error (_("'%s': No such file\n"), file_name
);
16584 error (_("Could not locate '%s'. System error message: %s\n"),
16585 file_name
, strerror (errno
));
16589 if (! S_ISREG (statbuf
.st_mode
))
16591 error (_("'%s' is not an ordinary file\n"), file_name
);
16595 file
= fopen (file_name
, "rb");
16598 error (_("Input file '%s' is not readable.\n"), file_name
);
16602 if (fread (armag
, SARMAG
, 1, file
) != 1)
16604 error (_("%s: Failed to read file's magic number\n"), file_name
);
16609 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16611 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16612 ret
= process_archive (file_name
, file
, FALSE
);
16613 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16614 ret
= process_archive (file_name
, file
, TRUE
);
16617 if (do_archive_index
)
16618 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16622 archive_file_size
= archive_file_offset
= 0;
16623 ret
= process_object (file_name
, file
);
16628 current_file_size
= 0;
16632 #ifdef SUPPORT_DISASSEMBLY
16633 /* Needed by the i386 disassembler. For extra credit, someone could
16634 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16638 print_address (unsigned int addr
, FILE * outfile
)
16640 fprintf (outfile
,"0x%8.8x", addr
);
16643 /* Needed by the i386 disassembler. */
16645 db_task_printsym (unsigned int addr
)
16647 print_address (addr
, stderr
);
16652 main (int argc
, char ** argv
)
16656 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16657 setlocale (LC_MESSAGES
, "");
16659 #if defined (HAVE_SETLOCALE)
16660 setlocale (LC_CTYPE
, "");
16662 bindtextdomain (PACKAGE
, LOCALEDIR
);
16663 textdomain (PACKAGE
);
16665 expandargv (&argc
, &argv
);
16667 parse_args (argc
, argv
);
16669 if (num_dump_sects
> 0)
16671 /* Make a copy of the dump_sects array. */
16672 cmdline_dump_sects
= (dump_type
*)
16673 malloc (num_dump_sects
* sizeof (* dump_sects
));
16674 if (cmdline_dump_sects
== NULL
)
16675 error (_("Out of memory allocating dump request table.\n"));
16678 memcpy (cmdline_dump_sects
, dump_sects
,
16679 num_dump_sects
* sizeof (* dump_sects
));
16680 num_cmdline_dump_sects
= num_dump_sects
;
16684 if (optind
< (argc
- 1))
16686 else if (optind
>= argc
)
16688 warn (_("Nothing to do.\n"));
16693 while (optind
< argc
)
16694 err
|= process_file (argv
[optind
++]);
16696 if (dump_sects
!= NULL
)
16698 if (cmdline_dump_sects
!= NULL
)
16699 free (cmdline_dump_sects
);