1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name
= "readelf";
168 static unsigned long archive_file_offset
;
169 static unsigned long archive_file_size
;
170 static bfd_size_type current_file_size
;
171 static unsigned long dynamic_addr
;
172 static bfd_size_type dynamic_size
;
173 static size_t dynamic_nent
;
174 static char * dynamic_strings
;
175 static unsigned long dynamic_strings_length
;
176 static char * string_table
;
177 static unsigned long string_table_length
;
178 static unsigned long num_dynamic_syms
;
179 static Elf_Internal_Sym
* dynamic_symbols
;
180 static Elf_Internal_Syminfo
* dynamic_syminfo
;
181 static unsigned long dynamic_syminfo_offset
;
182 static unsigned int dynamic_syminfo_nent
;
183 static char program_interpreter
[PATH_MAX
];
184 static bfd_vma dynamic_info
[DT_ENCODING
];
185 static bfd_vma dynamic_info_DT_GNU_HASH
;
186 static bfd_vma version_info
[16];
187 static Elf_Internal_Ehdr elf_header
;
188 static Elf_Internal_Shdr
* section_headers
;
189 static Elf_Internal_Phdr
* program_headers
;
190 static Elf_Internal_Dyn
* dynamic_section
;
191 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
192 static int show_name
;
193 static int do_dynamic
;
195 static int do_dyn_syms
;
197 static int do_sections
;
198 static int do_section_groups
;
199 static int do_section_details
;
200 static int do_segments
;
201 static int do_unwind
;
202 static int do_using_dynamic
;
203 static int do_header
;
205 static int do_version
;
206 static int do_histogram
;
207 static int do_debugging
;
210 static int do_archive_index
;
211 static int is_32bit_elf
;
215 struct group_list
* next
;
216 unsigned int section_index
;
221 struct group_list
* root
;
222 unsigned int group_index
;
225 static size_t group_count
;
226 static struct group
* section_groups
;
227 static struct group
** section_headers_groups
;
230 /* Flag bits indicating particular types of dump. */
231 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
232 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
237 typedef unsigned char dump_type
;
239 /* A linked list of the section names for which dumps were requested. */
240 struct dump_list_entry
244 struct dump_list_entry
* next
;
246 static struct dump_list_entry
* dump_sects_byname
;
248 /* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250 static dump_type
* cmdline_dump_sects
= NULL
;
251 static unsigned int num_cmdline_dump_sects
= 0;
253 /* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
258 static dump_type
* dump_sects
= NULL
;
259 static unsigned int num_dump_sects
= 0;
262 /* How to print a vma value. */
263 typedef enum print_mode
275 /* Versioned symbol info. */
276 enum versioned_symbol_info
283 static const char *get_symbol_version_string
284 (FILE *file
, int is_dynsym
, const char *strtab
,
285 unsigned long int strtab_size
, unsigned int si
,
286 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
287 unsigned short *vna_other
);
291 #define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
295 : string_table + (X)->sh_name))
297 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
299 #define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 #define REMOVE_ARCH_BITS(ADDR) \
311 if (elf_header.e_machine == EM_ARM) \
316 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
321 and REASON is not NULL then emit an error message using REASON as part of the
325 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
326 bfd_size_type nmemb
, const char * reason
)
329 bfd_size_type amt
= size
* nmemb
;
331 if (size
== 0 || nmemb
== 0)
334 /* If the size_t type is smaller than the bfd_size_type, eg because
335 you are building a 32-bit tool on a 64-bit host, then make sure
336 that when the sizes are cast to (size_t) no information is lost. */
337 if (sizeof (size_t) < sizeof (bfd_size_type
)
338 && ( (bfd_size_type
) ((size_t) size
) != size
339 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
342 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
343 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
347 /* Check for size overflow. */
351 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
352 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
356 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
357 attempting to allocate memory when the read is bound to fail. */
358 if (amt
> current_file_size
359 || offset
+ archive_file_offset
+ amt
> current_file_size
)
362 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
363 (unsigned long long) amt
, reason
);
367 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
370 error (_("Unable to seek to 0x%lx for %s\n"),
371 (unsigned long) archive_file_offset
+ offset
, reason
);
378 /* Check for overflow. */
379 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
380 /* + 1 so that we can '\0' terminate invalid string table sections. */
381 mvar
= malloc ((size_t) amt
+ 1);
386 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
387 (unsigned long long) amt
, reason
);
391 ((char *) mvar
)[amt
] = '\0';
394 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
397 error (_("Unable to read in 0x%llx bytes of %s\n"),
398 (unsigned long long) amt
, reason
);
407 /* Print a VMA value. */
410 print_vma (bfd_vma vma
, print_mode mode
)
423 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
430 return printf ("%5" BFD_VMA_FMT
"d", vma
);
438 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
441 return printf ("%" BFD_VMA_FMT
"d", vma
);
444 return printf ("%" BFD_VMA_FMT
"u", vma
);
449 /* Display a symbol on stdout. Handles the display of control characters and
450 multibye characters (assuming the host environment supports them).
452 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
454 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
455 padding as necessary.
457 Returns the number of emitted characters. */
460 print_symbol (int width
, const char *symbol
)
462 bfd_boolean extra_padding
= FALSE
;
464 #ifdef HAVE_MBSTATE_T
471 /* Keep the width positive. This also helps. */
473 extra_padding
= TRUE
;
478 /* Set the remaining width to a very large value.
479 This simplifies the code below. */
480 width_remaining
= INT_MAX
;
482 width_remaining
= width
;
484 #ifdef HAVE_MBSTATE_T
485 /* Initialise the multibyte conversion state. */
486 memset (& state
, 0, sizeof (state
));
489 while (width_remaining
)
492 const char c
= *symbol
++;
497 /* Do not print control characters directly as they can affect terminal
498 settings. Such characters usually appear in the names generated
499 by the assembler for local labels. */
502 if (width_remaining
< 2)
505 printf ("^%c", c
+ 0x40);
506 width_remaining
-= 2;
509 else if (ISPRINT (c
))
517 #ifdef HAVE_MBSTATE_T
520 /* Let printf do the hard work of displaying multibyte characters. */
521 printf ("%.1s", symbol
- 1);
525 #ifdef HAVE_MBSTATE_T
526 /* Try to find out how many bytes made up the character that was
527 just printed. Advance the symbol pointer past the bytes that
529 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
533 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
538 if (extra_padding
&& num_printed
< width
)
540 /* Fill in the remaining spaces. */
541 printf ("%-*s", width
- num_printed
, " ");
548 /* Returns a pointer to a static buffer containing a printable version of
549 the given section's name. Like print_symbol, except that it does not try
550 to print multibyte characters, it just interprets them as hex values. */
553 printable_section_name (Elf_Internal_Shdr
* sec
)
555 #define MAX_PRINT_SEC_NAME_LEN 128
556 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
557 const char * name
= SECTION_NAME (sec
);
558 char * buf
= sec_name_buf
;
560 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
562 while ((c
= * name
++) != 0)
573 else if (ISPRINT (c
))
580 static char hex
[17] = "0123456789ABCDEF";
585 * buf
++ = hex
[(c
& 0xf0) >> 4];
586 * buf
++ = hex
[c
& 0x0f];
600 printable_section_name_from_index (unsigned long ndx
)
602 if (ndx
>= elf_header
.e_shnum
)
603 return _("<corrupt>");
605 return printable_section_name (section_headers
+ ndx
);
608 /* Return a pointer to section NAME, or NULL if no such section exists. */
610 static Elf_Internal_Shdr
*
611 find_section (const char * name
)
615 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
616 if (streq (SECTION_NAME (section_headers
+ i
), name
))
617 return section_headers
+ i
;
622 /* Return a pointer to a section containing ADDR, or NULL if no such
625 static Elf_Internal_Shdr
*
626 find_section_by_address (bfd_vma addr
)
630 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
632 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
633 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
640 static Elf_Internal_Shdr
*
641 find_section_by_type (unsigned int type
)
645 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
647 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
648 if (sec
->sh_type
== type
)
655 /* Return a pointer to section NAME, or NULL if no such section exists,
656 restricted to the list of sections given in SET. */
658 static Elf_Internal_Shdr
*
659 find_section_in_set (const char * name
, unsigned int * set
)
665 while ((i
= *set
++) > 0)
666 if (streq (SECTION_NAME (section_headers
+ i
), name
))
667 return section_headers
+ i
;
670 return find_section (name
);
673 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
676 static inline unsigned long
677 read_uleb128 (unsigned char *data
,
678 unsigned int *length_return
,
679 const unsigned char * const end
)
681 return read_leb128 (data
, length_return
, FALSE
, end
);
684 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
685 This OS has so many departures from the ELF standard that we test it at
691 return elf_header
.e_machine
== EM_IA_64
692 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
695 /* Guess the relocation size commonly used by the specific machines. */
698 guess_is_rela (unsigned int e_machine
)
702 /* Targets that use REL relocations. */
717 /* Targets that use RELA relocations. */
721 case EM_ADAPTEVA_EPIPHANY
:
723 case EM_ALTERA_NIOS2
:
743 case EM_LATTICEMICO32
:
752 case EM_CYGNUS_MN10200
:
754 case EM_CYGNUS_MN10300
:
788 case EM_MICROBLAZE_OLD
:
809 warn (_("Don't know about relocations on this machine architecture\n"));
815 slurp_rela_relocs (FILE * file
,
816 unsigned long rel_offset
,
817 unsigned long rel_size
,
818 Elf_Internal_Rela
** relasp
,
819 unsigned long * nrelasp
)
821 Elf_Internal_Rela
* relas
;
827 Elf32_External_Rela
* erelas
;
829 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
830 rel_size
, _("32-bit relocation data"));
834 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
836 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
837 sizeof (Elf_Internal_Rela
));
842 error (_("out of memory parsing relocs\n"));
846 for (i
= 0; i
< nrelas
; i
++)
848 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
849 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
850 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
857 Elf64_External_Rela
* erelas
;
859 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
860 rel_size
, _("64-bit relocation data"));
864 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
866 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
867 sizeof (Elf_Internal_Rela
));
872 error (_("out of memory parsing relocs\n"));
876 for (i
= 0; i
< nrelas
; i
++)
878 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
879 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
880 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
882 /* The #ifdef BFD64 below is to prevent a compile time
883 warning. We know that if we do not have a 64 bit data
884 type that we will never execute this code anyway. */
886 if (elf_header
.e_machine
== EM_MIPS
887 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
889 /* In little-endian objects, r_info isn't really a
890 64-bit little-endian value: it has a 32-bit
891 little-endian symbol index followed by four
892 individual byte fields. Reorder INFO
894 bfd_vma inf
= relas
[i
].r_info
;
895 inf
= (((inf
& 0xffffffff) << 32)
896 | ((inf
>> 56) & 0xff)
897 | ((inf
>> 40) & 0xff00)
898 | ((inf
>> 24) & 0xff0000)
899 | ((inf
>> 8) & 0xff000000));
900 relas
[i
].r_info
= inf
;
913 slurp_rel_relocs (FILE * file
,
914 unsigned long rel_offset
,
915 unsigned long rel_size
,
916 Elf_Internal_Rela
** relsp
,
917 unsigned long * nrelsp
)
919 Elf_Internal_Rela
* rels
;
925 Elf32_External_Rel
* erels
;
927 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
928 rel_size
, _("32-bit relocation data"));
932 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
934 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
939 error (_("out of memory parsing relocs\n"));
943 for (i
= 0; i
< nrels
; i
++)
945 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
946 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
947 rels
[i
].r_addend
= 0;
954 Elf64_External_Rel
* erels
;
956 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
957 rel_size
, _("64-bit relocation data"));
961 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
963 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
968 error (_("out of memory parsing relocs\n"));
972 for (i
= 0; i
< nrels
; i
++)
974 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
975 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
976 rels
[i
].r_addend
= 0;
978 /* The #ifdef BFD64 below is to prevent a compile time
979 warning. We know that if we do not have a 64 bit data
980 type that we will never execute this code anyway. */
982 if (elf_header
.e_machine
== EM_MIPS
983 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
985 /* In little-endian objects, r_info isn't really a
986 64-bit little-endian value: it has a 32-bit
987 little-endian symbol index followed by four
988 individual byte fields. Reorder INFO
990 bfd_vma inf
= rels
[i
].r_info
;
991 inf
= (((inf
& 0xffffffff) << 32)
992 | ((inf
>> 56) & 0xff)
993 | ((inf
>> 40) & 0xff00)
994 | ((inf
>> 24) & 0xff0000)
995 | ((inf
>> 8) & 0xff000000));
996 rels
[i
].r_info
= inf
;
1008 /* Returns the reloc type extracted from the reloc info field. */
1011 get_reloc_type (bfd_vma reloc_info
)
1014 return ELF32_R_TYPE (reloc_info
);
1016 switch (elf_header
.e_machine
)
1019 /* Note: We assume that reloc_info has already been adjusted for us. */
1020 return ELF64_MIPS_R_TYPE (reloc_info
);
1023 return ELF64_R_TYPE_ID (reloc_info
);
1026 return ELF64_R_TYPE (reloc_info
);
1030 /* Return the symbol index extracted from the reloc info field. */
1033 get_reloc_symindex (bfd_vma reloc_info
)
1035 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1038 static inline bfd_boolean
1039 uses_msp430x_relocs (void)
1042 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1043 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1044 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1045 /* TI compiler uses ELFOSABI_NONE. */
1046 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1049 /* Display the contents of the relocation data found at the specified
1053 dump_relocations (FILE * file
,
1054 unsigned long rel_offset
,
1055 unsigned long rel_size
,
1056 Elf_Internal_Sym
* symtab
,
1057 unsigned long nsyms
,
1059 unsigned long strtablen
,
1064 Elf_Internal_Rela
* rels
;
1066 if (is_rela
== UNKNOWN
)
1067 is_rela
= guess_is_rela (elf_header
.e_machine
);
1071 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1076 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1085 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1087 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1092 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1094 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1102 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1104 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1109 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1111 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1115 for (i
= 0; i
< rel_size
; i
++)
1120 bfd_vma symtab_index
;
1123 offset
= rels
[i
].r_offset
;
1124 inf
= rels
[i
].r_info
;
1126 type
= get_reloc_type (inf
);
1127 symtab_index
= get_reloc_symindex (inf
);
1131 printf ("%8.8lx %8.8lx ",
1132 (unsigned long) offset
& 0xffffffff,
1133 (unsigned long) inf
& 0xffffffff);
1137 #if BFD_HOST_64BIT_LONG
1139 ? "%16.16lx %16.16lx "
1140 : "%12.12lx %12.12lx ",
1142 #elif BFD_HOST_64BIT_LONG_LONG
1145 ? "%16.16llx %16.16llx "
1146 : "%12.12llx %12.12llx ",
1150 ? "%16.16I64x %16.16I64x "
1151 : "%12.12I64x %12.12I64x ",
1156 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1157 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1158 _bfd_int64_high (offset
),
1159 _bfd_int64_low (offset
),
1160 _bfd_int64_high (inf
),
1161 _bfd_int64_low (inf
));
1165 switch (elf_header
.e_machine
)
1172 rtype
= elf_aarch64_reloc_type (type
);
1176 case EM_CYGNUS_M32R
:
1177 rtype
= elf_m32r_reloc_type (type
);
1182 rtype
= elf_i386_reloc_type (type
);
1187 rtype
= elf_m68hc11_reloc_type (type
);
1191 rtype
= elf_m68k_reloc_type (type
);
1195 rtype
= elf_i960_reloc_type (type
);
1200 rtype
= elf_avr_reloc_type (type
);
1203 case EM_OLD_SPARCV9
:
1204 case EM_SPARC32PLUS
:
1207 rtype
= elf_sparc_reloc_type (type
);
1211 rtype
= elf_spu_reloc_type (type
);
1215 rtype
= v800_reloc_type (type
);
1218 case EM_CYGNUS_V850
:
1219 rtype
= v850_reloc_type (type
);
1223 case EM_CYGNUS_D10V
:
1224 rtype
= elf_d10v_reloc_type (type
);
1228 case EM_CYGNUS_D30V
:
1229 rtype
= elf_d30v_reloc_type (type
);
1233 rtype
= elf_dlx_reloc_type (type
);
1237 rtype
= elf_sh_reloc_type (type
);
1241 case EM_CYGNUS_MN10300
:
1242 rtype
= elf_mn10300_reloc_type (type
);
1246 case EM_CYGNUS_MN10200
:
1247 rtype
= elf_mn10200_reloc_type (type
);
1251 case EM_CYGNUS_FR30
:
1252 rtype
= elf_fr30_reloc_type (type
);
1256 rtype
= elf_frv_reloc_type (type
);
1260 rtype
= elf_ft32_reloc_type (type
);
1264 rtype
= elf_mcore_reloc_type (type
);
1268 rtype
= elf_mmix_reloc_type (type
);
1272 rtype
= elf_moxie_reloc_type (type
);
1276 if (uses_msp430x_relocs ())
1278 rtype
= elf_msp430x_reloc_type (type
);
1282 rtype
= elf_msp430_reloc_type (type
);
1286 rtype
= elf_nds32_reloc_type (type
);
1290 rtype
= elf_ppc_reloc_type (type
);
1294 rtype
= elf_ppc64_reloc_type (type
);
1298 case EM_MIPS_RS3_LE
:
1299 rtype
= elf_mips_reloc_type (type
);
1303 rtype
= elf_alpha_reloc_type (type
);
1307 rtype
= elf_arm_reloc_type (type
);
1311 rtype
= elf_arc_reloc_type (type
);
1315 rtype
= elf_hppa_reloc_type (type
);
1321 rtype
= elf_h8_reloc_type (type
);
1325 rtype
= elf_or1k_reloc_type (type
);
1330 rtype
= elf_pj_reloc_type (type
);
1333 rtype
= elf_ia64_reloc_type (type
);
1337 rtype
= elf_cris_reloc_type (type
);
1341 rtype
= elf_i860_reloc_type (type
);
1347 rtype
= elf_x86_64_reloc_type (type
);
1351 rtype
= i370_reloc_type (type
);
1356 rtype
= elf_s390_reloc_type (type
);
1360 rtype
= elf_score_reloc_type (type
);
1364 rtype
= elf_xstormy16_reloc_type (type
);
1368 rtype
= elf_crx_reloc_type (type
);
1372 rtype
= elf_vax_reloc_type (type
);
1376 rtype
= elf_visium_reloc_type (type
);
1379 case EM_ADAPTEVA_EPIPHANY
:
1380 rtype
= elf_epiphany_reloc_type (type
);
1385 rtype
= elf_ip2k_reloc_type (type
);
1389 rtype
= elf_iq2000_reloc_type (type
);
1394 rtype
= elf_xtensa_reloc_type (type
);
1397 case EM_LATTICEMICO32
:
1398 rtype
= elf_lm32_reloc_type (type
);
1403 rtype
= elf_m32c_reloc_type (type
);
1407 rtype
= elf_mt_reloc_type (type
);
1411 rtype
= elf_bfin_reloc_type (type
);
1415 rtype
= elf_mep_reloc_type (type
);
1419 rtype
= elf_cr16_reloc_type (type
);
1423 case EM_MICROBLAZE_OLD
:
1424 rtype
= elf_microblaze_reloc_type (type
);
1428 rtype
= elf_rl78_reloc_type (type
);
1432 rtype
= elf_rx_reloc_type (type
);
1436 rtype
= elf_metag_reloc_type (type
);
1441 rtype
= elf_xc16x_reloc_type (type
);
1445 rtype
= elf_tic6x_reloc_type (type
);
1449 rtype
= elf_tilegx_reloc_type (type
);
1453 rtype
= elf_tilepro_reloc_type (type
);
1457 rtype
= elf_xgate_reloc_type (type
);
1460 case EM_ALTERA_NIOS2
:
1461 rtype
= elf_nios2_reloc_type (type
);
1466 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1468 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1470 if (elf_header
.e_machine
== EM_ALPHA
1472 && streq (rtype
, "R_ALPHA_LITUSE")
1475 switch (rels
[i
].r_addend
)
1477 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1478 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1479 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1480 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1481 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1482 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1483 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1484 default: rtype
= NULL
;
1487 printf (" (%s)", rtype
);
1491 printf (_("<unknown addend: %lx>"),
1492 (unsigned long) rels
[i
].r_addend
);
1495 else if (symtab_index
)
1497 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1498 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1501 Elf_Internal_Sym
* psym
;
1502 const char * version_string
;
1503 enum versioned_symbol_info sym_info
;
1504 unsigned short vna_other
;
1506 psym
= symtab
+ symtab_index
;
1509 = get_symbol_version_string (file
, is_dynsym
,
1518 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1522 unsigned int width
= is_32bit_elf
? 8 : 14;
1524 /* Relocations against GNU_IFUNC symbols do not use the value
1525 of the symbol as the address to relocate against. Instead
1526 they invoke the function named by the symbol and use its
1527 result as the address for relocation.
1529 To indicate this to the user, do not display the value of
1530 the symbol in the "Symbols's Value" field. Instead show
1531 its name followed by () as a hint that the symbol is
1535 || psym
->st_name
== 0
1536 || psym
->st_name
>= strtablen
)
1539 name
= strtab
+ psym
->st_name
;
1541 len
= print_symbol (width
, name
);
1543 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1545 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1549 print_vma (psym
->st_value
, LONG_HEX
);
1551 printf (is_32bit_elf
? " " : " ");
1554 if (psym
->st_name
== 0)
1556 const char * sec_name
= "<null>";
1559 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1561 if (psym
->st_shndx
< elf_header
.e_shnum
)
1562 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1563 else if (psym
->st_shndx
== SHN_ABS
)
1565 else if (psym
->st_shndx
== SHN_COMMON
)
1566 sec_name
= "COMMON";
1567 else if ((elf_header
.e_machine
== EM_MIPS
1568 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1569 || (elf_header
.e_machine
== EM_TI_C6000
1570 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1571 sec_name
= "SCOMMON";
1572 else if (elf_header
.e_machine
== EM_MIPS
1573 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1574 sec_name
= "SUNDEF";
1575 else if ((elf_header
.e_machine
== EM_X86_64
1576 || elf_header
.e_machine
== EM_L1OM
1577 || elf_header
.e_machine
== EM_K1OM
)
1578 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1579 sec_name
= "LARGE_COMMON";
1580 else if (elf_header
.e_machine
== EM_IA_64
1581 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1582 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1583 sec_name
= "ANSI_COM";
1584 else if (is_ia64_vms ()
1585 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1586 sec_name
= "VMS_SYMVEC";
1589 sprintf (name_buf
, "<section 0x%x>",
1590 (unsigned int) psym
->st_shndx
);
1591 sec_name
= name_buf
;
1594 print_symbol (22, sec_name
);
1596 else if (strtab
== NULL
)
1597 printf (_("<string table index: %3ld>"), psym
->st_name
);
1598 else if (psym
->st_name
>= strtablen
)
1599 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1602 print_symbol (22, strtab
+ psym
->st_name
);
1604 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1610 bfd_signed_vma off
= rels
[i
].r_addend
;
1612 /* PR 17531: file: 2e63226f. */
1613 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1614 printf (" + %" BFD_VMA_FMT
"x", off
);
1616 printf (" - %" BFD_VMA_FMT
"x", - off
);
1618 printf (" + %" BFD_VMA_FMT
"x", off
);
1624 bfd_signed_vma off
= rels
[i
].r_addend
;
1626 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1627 /* PR 17531: file: 2e63226f. */
1628 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1629 printf ("%" BFD_VMA_FMT
"x", off
);
1631 printf ("-%" BFD_VMA_FMT
"x", - off
);
1633 printf ("%" BFD_VMA_FMT
"x", off
);
1636 if (elf_header
.e_machine
== EM_SPARCV9
1638 && streq (rtype
, "R_SPARC_OLO10"))
1639 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1644 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1646 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1647 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1648 const char * rtype2
= elf_mips_reloc_type (type2
);
1649 const char * rtype3
= elf_mips_reloc_type (type3
);
1651 printf (" Type2: ");
1654 printf (_("unrecognized: %-7lx"),
1655 (unsigned long) type2
& 0xffffffff);
1657 printf ("%-17.17s", rtype2
);
1659 printf ("\n Type3: ");
1662 printf (_("unrecognized: %-7lx"),
1663 (unsigned long) type3
& 0xffffffff);
1665 printf ("%-17.17s", rtype3
);
1676 get_mips_dynamic_type (unsigned long type
)
1680 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1681 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1682 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1683 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1684 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1685 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1686 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1687 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1688 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1689 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1690 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1691 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1692 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1693 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1694 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1695 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1696 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1697 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1698 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1699 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1700 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1701 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1702 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1703 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1704 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1705 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1706 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1707 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1708 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1709 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1710 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1711 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1712 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1713 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1714 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1715 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1716 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1717 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1718 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1719 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1720 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1721 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1722 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1723 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1724 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1731 get_sparc64_dynamic_type (unsigned long type
)
1735 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1742 get_ppc_dynamic_type (unsigned long type
)
1746 case DT_PPC_GOT
: return "PPC_GOT";
1747 case DT_PPC_OPT
: return "PPC_OPT";
1754 get_ppc64_dynamic_type (unsigned long type
)
1758 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1759 case DT_PPC64_OPD
: return "PPC64_OPD";
1760 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1761 case DT_PPC64_OPT
: return "PPC64_OPT";
1768 get_parisc_dynamic_type (unsigned long type
)
1772 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1773 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1774 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1775 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1776 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1777 case DT_HP_PREINIT
: return "HP_PREINIT";
1778 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1779 case DT_HP_NEEDED
: return "HP_NEEDED";
1780 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1781 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1782 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1783 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1784 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1785 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1786 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1787 case DT_HP_FILTERED
: return "HP_FILTERED";
1788 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1789 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1790 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1791 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1792 case DT_PLT
: return "PLT";
1793 case DT_PLT_SIZE
: return "PLT_SIZE";
1794 case DT_DLT
: return "DLT";
1795 case DT_DLT_SIZE
: return "DLT_SIZE";
1802 get_ia64_dynamic_type (unsigned long type
)
1806 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1807 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1808 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1809 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1810 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1811 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1812 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1813 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1814 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1815 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1816 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1817 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1818 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1819 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1820 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1821 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1822 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1823 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1824 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1825 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1826 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1827 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1828 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1829 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1830 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1831 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1832 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1833 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1834 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1835 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1836 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1843 get_alpha_dynamic_type (unsigned long type
)
1847 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1854 get_score_dynamic_type (unsigned long type
)
1858 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1859 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1860 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1861 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1862 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1863 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1870 get_tic6x_dynamic_type (unsigned long type
)
1874 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1875 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1876 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1877 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1878 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1879 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1886 get_nios2_dynamic_type (unsigned long type
)
1890 case DT_NIOS2_GP
: return "NIOS2_GP";
1897 get_dynamic_type (unsigned long type
)
1899 static char buff
[64];
1903 case DT_NULL
: return "NULL";
1904 case DT_NEEDED
: return "NEEDED";
1905 case DT_PLTRELSZ
: return "PLTRELSZ";
1906 case DT_PLTGOT
: return "PLTGOT";
1907 case DT_HASH
: return "HASH";
1908 case DT_STRTAB
: return "STRTAB";
1909 case DT_SYMTAB
: return "SYMTAB";
1910 case DT_RELA
: return "RELA";
1911 case DT_RELASZ
: return "RELASZ";
1912 case DT_RELAENT
: return "RELAENT";
1913 case DT_STRSZ
: return "STRSZ";
1914 case DT_SYMENT
: return "SYMENT";
1915 case DT_INIT
: return "INIT";
1916 case DT_FINI
: return "FINI";
1917 case DT_SONAME
: return "SONAME";
1918 case DT_RPATH
: return "RPATH";
1919 case DT_SYMBOLIC
: return "SYMBOLIC";
1920 case DT_REL
: return "REL";
1921 case DT_RELSZ
: return "RELSZ";
1922 case DT_RELENT
: return "RELENT";
1923 case DT_PLTREL
: return "PLTREL";
1924 case DT_DEBUG
: return "DEBUG";
1925 case DT_TEXTREL
: return "TEXTREL";
1926 case DT_JMPREL
: return "JMPREL";
1927 case DT_BIND_NOW
: return "BIND_NOW";
1928 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1929 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1930 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1931 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1932 case DT_RUNPATH
: return "RUNPATH";
1933 case DT_FLAGS
: return "FLAGS";
1935 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1936 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1938 case DT_CHECKSUM
: return "CHECKSUM";
1939 case DT_PLTPADSZ
: return "PLTPADSZ";
1940 case DT_MOVEENT
: return "MOVEENT";
1941 case DT_MOVESZ
: return "MOVESZ";
1942 case DT_FEATURE
: return "FEATURE";
1943 case DT_POSFLAG_1
: return "POSFLAG_1";
1944 case DT_SYMINSZ
: return "SYMINSZ";
1945 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1947 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1948 case DT_CONFIG
: return "CONFIG";
1949 case DT_DEPAUDIT
: return "DEPAUDIT";
1950 case DT_AUDIT
: return "AUDIT";
1951 case DT_PLTPAD
: return "PLTPAD";
1952 case DT_MOVETAB
: return "MOVETAB";
1953 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1955 case DT_VERSYM
: return "VERSYM";
1957 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1958 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1959 case DT_RELACOUNT
: return "RELACOUNT";
1960 case DT_RELCOUNT
: return "RELCOUNT";
1961 case DT_FLAGS_1
: return "FLAGS_1";
1962 case DT_VERDEF
: return "VERDEF";
1963 case DT_VERDEFNUM
: return "VERDEFNUM";
1964 case DT_VERNEED
: return "VERNEED";
1965 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1967 case DT_AUXILIARY
: return "AUXILIARY";
1968 case DT_USED
: return "USED";
1969 case DT_FILTER
: return "FILTER";
1971 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1972 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1973 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1974 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1975 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1976 case DT_GNU_HASH
: return "GNU_HASH";
1979 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1981 const char * result
;
1983 switch (elf_header
.e_machine
)
1986 case EM_MIPS_RS3_LE
:
1987 result
= get_mips_dynamic_type (type
);
1990 result
= get_sparc64_dynamic_type (type
);
1993 result
= get_ppc_dynamic_type (type
);
1996 result
= get_ppc64_dynamic_type (type
);
1999 result
= get_ia64_dynamic_type (type
);
2002 result
= get_alpha_dynamic_type (type
);
2005 result
= get_score_dynamic_type (type
);
2008 result
= get_tic6x_dynamic_type (type
);
2010 case EM_ALTERA_NIOS2
:
2011 result
= get_nios2_dynamic_type (type
);
2021 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2023 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2024 || (elf_header
.e_machine
== EM_PARISC
2025 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2027 const char * result
;
2029 switch (elf_header
.e_machine
)
2032 result
= get_parisc_dynamic_type (type
);
2035 result
= get_ia64_dynamic_type (type
);
2045 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2049 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2056 get_file_type (unsigned e_type
)
2058 static char buff
[32];
2062 case ET_NONE
: return _("NONE (None)");
2063 case ET_REL
: return _("REL (Relocatable file)");
2064 case ET_EXEC
: return _("EXEC (Executable file)");
2065 case ET_DYN
: return _("DYN (Shared object file)");
2066 case ET_CORE
: return _("CORE (Core file)");
2069 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2070 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2071 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2072 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2074 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2080 get_machine_name (unsigned e_machine
)
2082 static char buff
[64]; /* XXX */
2086 case EM_NONE
: return _("None");
2087 case EM_AARCH64
: return "AArch64";
2088 case EM_M32
: return "WE32100";
2089 case EM_SPARC
: return "Sparc";
2090 case EM_SPU
: return "SPU";
2091 case EM_386
: return "Intel 80386";
2092 case EM_68K
: return "MC68000";
2093 case EM_88K
: return "MC88000";
2094 case EM_486
: return "Intel 80486";
2095 case EM_860
: return "Intel 80860";
2096 case EM_MIPS
: return "MIPS R3000";
2097 case EM_S370
: return "IBM System/370";
2098 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2099 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2100 case EM_PARISC
: return "HPPA";
2101 case EM_PPC_OLD
: return "Power PC (old)";
2102 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2103 case EM_960
: return "Intel 90860";
2104 case EM_PPC
: return "PowerPC";
2105 case EM_PPC64
: return "PowerPC64";
2106 case EM_FR20
: return "Fujitsu FR20";
2107 case EM_FT32
: return "FTDI FT32";
2108 case EM_RH32
: return "TRW RH32";
2109 case EM_MCORE
: return "MCORE";
2110 case EM_ARM
: return "ARM";
2111 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2112 case EM_SH
: return "Renesas / SuperH SH";
2113 case EM_SPARCV9
: return "Sparc v9";
2114 case EM_TRICORE
: return "Siemens Tricore";
2115 case EM_ARC
: return "ARC";
2116 case EM_H8_300
: return "Renesas H8/300";
2117 case EM_H8_300H
: return "Renesas H8/300H";
2118 case EM_H8S
: return "Renesas H8S";
2119 case EM_H8_500
: return "Renesas H8/500";
2120 case EM_IA_64
: return "Intel IA-64";
2121 case EM_MIPS_X
: return "Stanford MIPS-X";
2122 case EM_COLDFIRE
: return "Motorola Coldfire";
2123 case EM_ALPHA
: return "Alpha";
2124 case EM_CYGNUS_D10V
:
2125 case EM_D10V
: return "d10v";
2126 case EM_CYGNUS_D30V
:
2127 case EM_D30V
: return "d30v";
2128 case EM_CYGNUS_M32R
:
2129 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2130 case EM_CYGNUS_V850
:
2131 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2132 case EM_V850
: return "Renesas V850";
2133 case EM_CYGNUS_MN10300
:
2134 case EM_MN10300
: return "mn10300";
2135 case EM_CYGNUS_MN10200
:
2136 case EM_MN10200
: return "mn10200";
2137 case EM_MOXIE
: return "Moxie";
2138 case EM_CYGNUS_FR30
:
2139 case EM_FR30
: return "Fujitsu FR30";
2140 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2142 case EM_PJ
: return "picoJava";
2143 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2144 case EM_PCP
: return "Siemens PCP";
2145 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2146 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2147 case EM_STARCORE
: return "Motorola Star*Core processor";
2148 case EM_ME16
: return "Toyota ME16 processor";
2149 case EM_ST100
: return "STMicroelectronics ST100 processor";
2150 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2151 case EM_PDSP
: return "Sony DSP processor";
2152 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2153 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2154 case EM_FX66
: return "Siemens FX66 microcontroller";
2155 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2156 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2157 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2158 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2159 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2160 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2161 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2162 case EM_SVX
: return "Silicon Graphics SVx";
2163 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2164 case EM_VAX
: return "Digital VAX";
2165 case EM_VISIUM
: return "CDS VISIUMcore processor";
2167 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2168 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2169 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2170 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2171 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2172 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2173 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2174 case EM_PRISM
: return "Vitesse Prism";
2175 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2176 case EM_L1OM
: return "Intel L1OM";
2177 case EM_K1OM
: return "Intel K1OM";
2179 case EM_S390
: return "IBM S/390";
2180 case EM_SCORE
: return "SUNPLUS S+Core";
2181 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2182 case EM_OR1K
: return "OpenRISC 1000";
2183 case EM_ARC_A5
: return "ARC International ARCompact processor";
2184 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2185 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2186 case EM_DLX
: return "OpenDLX";
2188 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2189 case EM_IQ2000
: return "Vitesse IQ2000";
2191 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2192 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2193 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2194 case EM_NS32K
: return "National Semiconductor 32000 series";
2195 case EM_TPC
: return "Tenor Network TPC processor";
2196 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2197 case EM_MAX
: return "MAX Processor";
2198 case EM_CR
: return "National Semiconductor CompactRISC";
2199 case EM_F2MC16
: return "Fujitsu F2MC16";
2200 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2201 case EM_LATTICEMICO32
: return "Lattice Mico32";
2203 case EM_M32C
: return "Renesas M32c";
2204 case EM_MT
: return "Morpho Techologies MT processor";
2205 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2206 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2207 case EM_SEP
: return "Sharp embedded microprocessor";
2208 case EM_ARCA
: return "Arca RISC microprocessor";
2209 case EM_UNICORE
: return "Unicore";
2210 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2211 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2212 case EM_NIOS32
: return "Altera Nios";
2213 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2215 case EM_XC16X
: return "Infineon Technologies xc16x";
2216 case EM_M16C
: return "Renesas M16C series microprocessors";
2217 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2218 case EM_CE
: return "Freescale Communication Engine RISC core";
2219 case EM_TSK3000
: return "Altium TSK3000 core";
2220 case EM_RS08
: return "Freescale RS08 embedded processor";
2221 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2222 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2223 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2224 case EM_SE_C17
: return "Seiko Epson C17 family";
2225 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2226 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2227 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2228 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2229 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2230 case EM_R32C
: return "Renesas R32C series microprocessors";
2231 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2232 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2233 case EM_8051
: return "Intel 8051 and variants";
2234 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2235 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2236 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2237 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2238 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2239 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2240 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2241 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2244 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2245 case EM_RL78
: return "Renesas RL78";
2246 case EM_RX
: return "Renesas RX";
2247 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2248 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2249 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2250 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2251 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2252 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2253 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2254 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2255 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2256 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2257 case EM_CUDA
: return "NVIDIA CUDA architecture";
2258 case EM_XGATE
: return "Motorola XGATE embedded processor";
2260 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2266 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2271 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2272 e_flags
&= ~ EF_ARM_EABIMASK
;
2274 /* Handle "generic" ARM flags. */
2275 if (e_flags
& EF_ARM_RELEXEC
)
2277 strcat (buf
, ", relocatable executable");
2278 e_flags
&= ~ EF_ARM_RELEXEC
;
2281 /* Now handle EABI specific flags. */
2285 strcat (buf
, ", <unrecognized EABI>");
2290 case EF_ARM_EABI_VER1
:
2291 strcat (buf
, ", Version1 EABI");
2296 /* Process flags one bit at a time. */
2297 flag
= e_flags
& - e_flags
;
2302 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2303 strcat (buf
, ", sorted symbol tables");
2313 case EF_ARM_EABI_VER2
:
2314 strcat (buf
, ", Version2 EABI");
2319 /* Process flags one bit at a time. */
2320 flag
= e_flags
& - e_flags
;
2325 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2326 strcat (buf
, ", sorted symbol tables");
2329 case EF_ARM_DYNSYMSUSESEGIDX
:
2330 strcat (buf
, ", dynamic symbols use segment index");
2333 case EF_ARM_MAPSYMSFIRST
:
2334 strcat (buf
, ", mapping symbols precede others");
2344 case EF_ARM_EABI_VER3
:
2345 strcat (buf
, ", Version3 EABI");
2348 case EF_ARM_EABI_VER4
:
2349 strcat (buf
, ", Version4 EABI");
2354 /* Process flags one bit at a time. */
2355 flag
= e_flags
& - e_flags
;
2361 strcat (buf
, ", BE8");
2365 strcat (buf
, ", LE8");
2376 case EF_ARM_EABI_VER5
:
2377 strcat (buf
, ", Version5 EABI");
2382 /* Process flags one bit at a time. */
2383 flag
= e_flags
& - e_flags
;
2389 strcat (buf
, ", BE8");
2393 strcat (buf
, ", LE8");
2396 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2397 strcat (buf
, ", soft-float ABI");
2400 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2401 strcat (buf
, ", hard-float ABI");
2411 case EF_ARM_EABI_UNKNOWN
:
2412 strcat (buf
, ", GNU EABI");
2417 /* Process flags one bit at a time. */
2418 flag
= e_flags
& - e_flags
;
2423 case EF_ARM_INTERWORK
:
2424 strcat (buf
, ", interworking enabled");
2427 case EF_ARM_APCS_26
:
2428 strcat (buf
, ", uses APCS/26");
2431 case EF_ARM_APCS_FLOAT
:
2432 strcat (buf
, ", uses APCS/float");
2436 strcat (buf
, ", position independent");
2440 strcat (buf
, ", 8 bit structure alignment");
2443 case EF_ARM_NEW_ABI
:
2444 strcat (buf
, ", uses new ABI");
2447 case EF_ARM_OLD_ABI
:
2448 strcat (buf
, ", uses old ABI");
2451 case EF_ARM_SOFT_FLOAT
:
2452 strcat (buf
, ", software FP");
2455 case EF_ARM_VFP_FLOAT
:
2456 strcat (buf
, ", VFP");
2459 case EF_ARM_MAVERICK_FLOAT
:
2460 strcat (buf
, ", Maverick FP");
2471 strcat (buf
,_(", <unknown>"));
2475 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2477 --size
; /* Leave space for null terminator. */
2479 switch (e_flags
& EF_AVR_MACH
)
2481 case E_AVR_MACH_AVR1
:
2482 strncat (buf
, ", avr:1", size
);
2484 case E_AVR_MACH_AVR2
:
2485 strncat (buf
, ", avr:2", size
);
2487 case E_AVR_MACH_AVR25
:
2488 strncat (buf
, ", avr:25", size
);
2490 case E_AVR_MACH_AVR3
:
2491 strncat (buf
, ", avr:3", size
);
2493 case E_AVR_MACH_AVR31
:
2494 strncat (buf
, ", avr:31", size
);
2496 case E_AVR_MACH_AVR35
:
2497 strncat (buf
, ", avr:35", size
);
2499 case E_AVR_MACH_AVR4
:
2500 strncat (buf
, ", avr:4", size
);
2502 case E_AVR_MACH_AVR5
:
2503 strncat (buf
, ", avr:5", size
);
2505 case E_AVR_MACH_AVR51
:
2506 strncat (buf
, ", avr:51", size
);
2508 case E_AVR_MACH_AVR6
:
2509 strncat (buf
, ", avr:6", size
);
2511 case E_AVR_MACH_AVRTINY
:
2512 strncat (buf
, ", avr:100", size
);
2514 case E_AVR_MACH_XMEGA1
:
2515 strncat (buf
, ", avr:101", size
);
2517 case E_AVR_MACH_XMEGA2
:
2518 strncat (buf
, ", avr:102", size
);
2520 case E_AVR_MACH_XMEGA3
:
2521 strncat (buf
, ", avr:103", size
);
2523 case E_AVR_MACH_XMEGA4
:
2524 strncat (buf
, ", avr:104", size
);
2526 case E_AVR_MACH_XMEGA5
:
2527 strncat (buf
, ", avr:105", size
);
2529 case E_AVR_MACH_XMEGA6
:
2530 strncat (buf
, ", avr:106", size
);
2532 case E_AVR_MACH_XMEGA7
:
2533 strncat (buf
, ", avr:107", size
);
2536 strncat (buf
, ", avr:<unknown>", size
);
2540 size
-= strlen (buf
);
2541 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2542 strncat (buf
, ", link-relax", size
);
2546 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2555 static const char *ABI_STRINGS
[] =
2557 "ABI v0", /* use r5 as return register; only used in N1213HC */
2558 "ABI v1", /* use r0 as return register */
2559 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2560 "ABI v2fp", /* for FPU */
2564 static const char *VER_STRINGS
[] =
2566 "Andes ELF V1.3 or older",
2570 static const char *ARCH_STRINGS
[] =
2579 abi
= EF_NDS_ABI
& e_flags
;
2580 arch
= EF_NDS_ARCH
& e_flags
;
2581 config
= EF_NDS_INST
& e_flags
;
2582 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2584 memset (buf
, 0, size
);
2591 case E_NDS_ABI_V2FP
:
2592 case E_NDS_ABI_AABI
:
2593 case E_NDS_ABI_V2FP_PLUS
:
2594 /* In case there are holes in the array. */
2595 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2599 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2605 case E_NDS32_ELF_VER_1_2
:
2606 case E_NDS32_ELF_VER_1_3
:
2607 case E_NDS32_ELF_VER_1_4
:
2608 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2612 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2616 if (E_NDS_ABI_V0
== abi
)
2618 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2619 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2620 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2621 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2627 case E_NDS_ARCH_STAR_V1_0
:
2628 case E_NDS_ARCH_STAR_V2_0
:
2629 case E_NDS_ARCH_STAR_V3_0
:
2630 case E_NDS_ARCH_STAR_V3_M
:
2631 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2635 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2636 /* ARCH version determines how the e_flags are interpreted.
2637 If it is unknown, we cannot proceed. */
2641 /* Newer ABI; Now handle architecture specific flags. */
2642 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2644 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2645 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2647 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2648 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2650 if (config
& E_NDS32_HAS_DIV_INST
)
2651 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2653 if (config
& E_NDS32_HAS_16BIT_INST
)
2654 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2658 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2660 if (version
<= E_NDS32_ELF_VER_1_3
)
2661 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2663 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2666 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2667 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2669 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2670 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2672 if (config
& E_NDS32_HAS_16BIT_INST
)
2674 if (version
<= E_NDS32_ELF_VER_1_3
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2677 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2681 if (config
& E_NDS32_HAS_EXT_INST
)
2682 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2684 if (config
& E_NDS32_HAS_EXT2_INST
)
2685 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2687 if (config
& E_NDS32_HAS_FPU_INST
)
2690 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2693 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2696 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2699 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2702 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2707 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2709 case E_NDS32_FPU_REG_8SP_4DP
:
2710 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2712 case E_NDS32_FPU_REG_16SP_8DP
:
2713 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2715 case E_NDS32_FPU_REG_32SP_16DP
:
2716 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2718 case E_NDS32_FPU_REG_32SP_32DP
:
2719 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2724 if (config
& E_NDS32_HAS_AUDIO_INST
)
2725 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2727 if (config
& E_NDS32_HAS_STRING_INST
)
2728 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2730 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2731 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2733 if (config
& E_NDS32_HAS_VIDEO_INST
)
2735 if (version
<= E_NDS32_ELF_VER_1_3
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2738 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2741 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2742 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2744 if (config
& E_NDS32_HAS_L2C_INST
)
2745 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2749 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2751 static char buf
[1024];
2763 decode_ARM_machine_flags (e_flags
, buf
);
2767 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2771 if (e_flags
& EF_BFIN_PIC
)
2772 strcat (buf
, ", PIC");
2774 if (e_flags
& EF_BFIN_FDPIC
)
2775 strcat (buf
, ", FDPIC");
2777 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2778 strcat (buf
, ", code in L1");
2780 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2781 strcat (buf
, ", data in L1");
2786 switch (e_flags
& EF_FRV_CPU_MASK
)
2788 case EF_FRV_CPU_GENERIC
:
2792 strcat (buf
, ", fr???");
2795 case EF_FRV_CPU_FR300
:
2796 strcat (buf
, ", fr300");
2799 case EF_FRV_CPU_FR400
:
2800 strcat (buf
, ", fr400");
2802 case EF_FRV_CPU_FR405
:
2803 strcat (buf
, ", fr405");
2806 case EF_FRV_CPU_FR450
:
2807 strcat (buf
, ", fr450");
2810 case EF_FRV_CPU_FR500
:
2811 strcat (buf
, ", fr500");
2813 case EF_FRV_CPU_FR550
:
2814 strcat (buf
, ", fr550");
2817 case EF_FRV_CPU_SIMPLE
:
2818 strcat (buf
, ", simple");
2820 case EF_FRV_CPU_TOMCAT
:
2821 strcat (buf
, ", tomcat");
2827 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2828 strcat (buf
, ", m68000");
2829 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2830 strcat (buf
, ", cpu32");
2831 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2832 strcat (buf
, ", fido_a");
2835 char const * isa
= _("unknown");
2836 char const * mac
= _("unknown mac");
2837 char const * additional
= NULL
;
2839 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2841 case EF_M68K_CF_ISA_A_NODIV
:
2843 additional
= ", nodiv";
2845 case EF_M68K_CF_ISA_A
:
2848 case EF_M68K_CF_ISA_A_PLUS
:
2851 case EF_M68K_CF_ISA_B_NOUSP
:
2853 additional
= ", nousp";
2855 case EF_M68K_CF_ISA_B
:
2858 case EF_M68K_CF_ISA_C
:
2861 case EF_M68K_CF_ISA_C_NODIV
:
2863 additional
= ", nodiv";
2866 strcat (buf
, ", cf, isa ");
2869 strcat (buf
, additional
);
2870 if (e_flags
& EF_M68K_CF_FLOAT
)
2871 strcat (buf
, ", float");
2872 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2877 case EF_M68K_CF_MAC
:
2880 case EF_M68K_CF_EMAC
:
2883 case EF_M68K_CF_EMAC_B
:
2896 if (e_flags
& EF_PPC_EMB
)
2897 strcat (buf
, ", emb");
2899 if (e_flags
& EF_PPC_RELOCATABLE
)
2900 strcat (buf
, _(", relocatable"));
2902 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2903 strcat (buf
, _(", relocatable-lib"));
2907 if (e_flags
& EF_PPC64_ABI
)
2909 char abi
[] = ", abiv0";
2911 abi
[6] += e_flags
& EF_PPC64_ABI
;
2917 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2918 strcat (buf
, ", RH850 ABI");
2920 if (e_flags
& EF_V800_850E3
)
2921 strcat (buf
, ", V3 architecture");
2923 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2924 strcat (buf
, ", FPU not used");
2926 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2927 strcat (buf
, ", regmode: COMMON");
2929 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2930 strcat (buf
, ", r4 not used");
2932 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2933 strcat (buf
, ", r30 not used");
2935 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2936 strcat (buf
, ", r5 not used");
2938 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2939 strcat (buf
, ", r2 not used");
2941 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2943 switch (e_flags
& - e_flags
)
2945 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2946 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2947 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2948 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2949 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2950 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2951 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2952 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2953 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2954 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2955 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2956 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2963 case EM_CYGNUS_V850
:
2964 switch (e_flags
& EF_V850_ARCH
)
2966 case E_V850E3V5_ARCH
:
2967 strcat (buf
, ", v850e3v5");
2969 case E_V850E2V3_ARCH
:
2970 strcat (buf
, ", v850e2v3");
2973 strcat (buf
, ", v850e2");
2976 strcat (buf
, ", v850e1");
2979 strcat (buf
, ", v850e");
2982 strcat (buf
, ", v850");
2985 strcat (buf
, _(", unknown v850 architecture variant"));
2991 case EM_CYGNUS_M32R
:
2992 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2993 strcat (buf
, ", m32r");
2997 case EM_MIPS_RS3_LE
:
2998 if (e_flags
& EF_MIPS_NOREORDER
)
2999 strcat (buf
, ", noreorder");
3001 if (e_flags
& EF_MIPS_PIC
)
3002 strcat (buf
, ", pic");
3004 if (e_flags
& EF_MIPS_CPIC
)
3005 strcat (buf
, ", cpic");
3007 if (e_flags
& EF_MIPS_UCODE
)
3008 strcat (buf
, ", ugen_reserved");
3010 if (e_flags
& EF_MIPS_ABI2
)
3011 strcat (buf
, ", abi2");
3013 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3014 strcat (buf
, ", odk first");
3016 if (e_flags
& EF_MIPS_32BITMODE
)
3017 strcat (buf
, ", 32bitmode");
3019 if (e_flags
& EF_MIPS_NAN2008
)
3020 strcat (buf
, ", nan2008");
3022 if (e_flags
& EF_MIPS_FP64
)
3023 strcat (buf
, ", fp64");
3025 switch ((e_flags
& EF_MIPS_MACH
))
3027 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3028 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3029 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3030 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3031 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3032 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3033 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3034 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3035 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3036 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3037 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3038 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3039 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3040 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3041 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3042 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3043 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3045 /* We simply ignore the field in this case to avoid confusion:
3046 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3049 default: strcat (buf
, _(", unknown CPU")); break;
3052 switch ((e_flags
& EF_MIPS_ABI
))
3054 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3055 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3056 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3057 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3059 /* We simply ignore the field in this case to avoid confusion:
3060 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3061 This means it is likely to be an o32 file, but not for
3064 default: strcat (buf
, _(", unknown ABI")); break;
3067 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3068 strcat (buf
, ", mdmx");
3070 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3071 strcat (buf
, ", mips16");
3073 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3074 strcat (buf
, ", micromips");
3076 switch ((e_flags
& EF_MIPS_ARCH
))
3078 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3079 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3080 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3081 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3082 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3083 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3084 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3085 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3086 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3087 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3088 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3089 default: strcat (buf
, _(", unknown ISA")); break;
3094 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3098 switch ((e_flags
& EF_SH_MACH_MASK
))
3100 case EF_SH1
: strcat (buf
, ", sh1"); break;
3101 case EF_SH2
: strcat (buf
, ", sh2"); break;
3102 case EF_SH3
: strcat (buf
, ", sh3"); break;
3103 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3104 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3105 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3106 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3107 case EF_SH4
: strcat (buf
, ", sh4"); break;
3108 case EF_SH5
: strcat (buf
, ", sh5"); break;
3109 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3110 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3111 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3112 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3113 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3114 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3115 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3116 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3117 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3118 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3119 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3120 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3121 default: strcat (buf
, _(", unknown ISA")); break;
3124 if (e_flags
& EF_SH_PIC
)
3125 strcat (buf
, ", pic");
3127 if (e_flags
& EF_SH_FDPIC
)
3128 strcat (buf
, ", fdpic");
3132 if (e_flags
& EF_OR1K_NODELAY
)
3133 strcat (buf
, ", no delay");
3137 if (e_flags
& EF_SPARC_32PLUS
)
3138 strcat (buf
, ", v8+");
3140 if (e_flags
& EF_SPARC_SUN_US1
)
3141 strcat (buf
, ", ultrasparcI");
3143 if (e_flags
& EF_SPARC_SUN_US3
)
3144 strcat (buf
, ", ultrasparcIII");
3146 if (e_flags
& EF_SPARC_HAL_R1
)
3147 strcat (buf
, ", halr1");
3149 if (e_flags
& EF_SPARC_LEDATA
)
3150 strcat (buf
, ", ledata");
3152 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3153 strcat (buf
, ", tso");
3155 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3156 strcat (buf
, ", pso");
3158 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3159 strcat (buf
, ", rmo");
3163 switch (e_flags
& EF_PARISC_ARCH
)
3165 case EFA_PARISC_1_0
:
3166 strcpy (buf
, ", PA-RISC 1.0");
3168 case EFA_PARISC_1_1
:
3169 strcpy (buf
, ", PA-RISC 1.1");
3171 case EFA_PARISC_2_0
:
3172 strcpy (buf
, ", PA-RISC 2.0");
3177 if (e_flags
& EF_PARISC_TRAPNIL
)
3178 strcat (buf
, ", trapnil");
3179 if (e_flags
& EF_PARISC_EXT
)
3180 strcat (buf
, ", ext");
3181 if (e_flags
& EF_PARISC_LSB
)
3182 strcat (buf
, ", lsb");
3183 if (e_flags
& EF_PARISC_WIDE
)
3184 strcat (buf
, ", wide");
3185 if (e_flags
& EF_PARISC_NO_KABP
)
3186 strcat (buf
, ", no kabp");
3187 if (e_flags
& EF_PARISC_LAZYSWAP
)
3188 strcat (buf
, ", lazyswap");
3193 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3194 strcat (buf
, ", new calling convention");
3196 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3197 strcat (buf
, ", gnu calling convention");
3201 if ((e_flags
& EF_IA_64_ABI64
))
3202 strcat (buf
, ", 64-bit");
3204 strcat (buf
, ", 32-bit");
3205 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3206 strcat (buf
, ", reduced fp model");
3207 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3208 strcat (buf
, ", no function descriptors, constant gp");
3209 else if ((e_flags
& EF_IA_64_CONS_GP
))
3210 strcat (buf
, ", constant gp");
3211 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3212 strcat (buf
, ", absolute");
3213 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3215 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3216 strcat (buf
, ", vms_linkages");
3217 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3219 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3221 case EF_IA_64_VMS_COMCOD_WARNING
:
3222 strcat (buf
, ", warning");
3224 case EF_IA_64_VMS_COMCOD_ERROR
:
3225 strcat (buf
, ", error");
3227 case EF_IA_64_VMS_COMCOD_ABORT
:
3228 strcat (buf
, ", abort");
3231 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3232 e_flags
& EF_IA_64_VMS_COMCOD
);
3233 strcat (buf
, ", <unknown>");
3239 if ((e_flags
& EF_VAX_NONPIC
))
3240 strcat (buf
, ", non-PIC");
3241 if ((e_flags
& EF_VAX_DFLOAT
))
3242 strcat (buf
, ", D-Float");
3243 if ((e_flags
& EF_VAX_GFLOAT
))
3244 strcat (buf
, ", G-Float");
3248 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3249 strcat (buf
, ", mcm");
3250 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3251 strcat (buf
, ", mcm24");
3252 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3253 strcat (buf
, ", gr6");
3257 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3259 case E_FLAG_RL78_ANY_CPU
: break;
3260 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3261 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3262 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3264 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3265 strcat (buf
, ", 64-bit doubles");
3269 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3270 strcat (buf
, ", 64-bit doubles");
3271 if (e_flags
& E_FLAG_RX_DSP
)
3272 strcat (buf
, ", dsp");
3273 if (e_flags
& E_FLAG_RX_PID
)
3274 strcat (buf
, ", pid");
3275 if (e_flags
& E_FLAG_RX_ABI
)
3276 strcat (buf
, ", RX ABI");
3280 if (e_flags
& EF_S390_HIGH_GPRS
)
3281 strcat (buf
, ", highgprs");
3285 if ((e_flags
& EF_C6000_REL
))
3286 strcat (buf
, ", relocatable module");
3290 strcat (buf
, _(": architecture variant: "));
3291 switch (e_flags
& EF_MSP430_MACH
)
3293 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3294 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3295 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3296 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3297 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3298 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3299 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3300 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3301 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3302 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3303 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3304 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3305 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3306 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3307 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3309 strcat (buf
, _(": unknown")); break;
3312 if (e_flags
& ~ EF_MSP430_MACH
)
3313 strcat (buf
, _(": unknown extra flag bits also present"));
3321 get_osabi_name (unsigned int osabi
)
3323 static char buff
[32];
3327 case ELFOSABI_NONE
: return "UNIX - System V";
3328 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3329 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3330 case ELFOSABI_GNU
: return "UNIX - GNU";
3331 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3332 case ELFOSABI_AIX
: return "UNIX - AIX";
3333 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3334 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3335 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3336 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3337 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3338 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3339 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3340 case ELFOSABI_AROS
: return "AROS";
3341 case ELFOSABI_FENIXOS
: return "FenixOS";
3344 switch (elf_header
.e_machine
)
3349 case ELFOSABI_ARM
: return "ARM";
3360 case ELFOSABI_STANDALONE
: return _("Standalone App");
3369 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3370 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3379 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3385 get_aarch64_segment_type (unsigned long type
)
3389 case PT_AARCH64_ARCHEXT
:
3390 return "AARCH64_ARCHEXT";
3399 get_arm_segment_type (unsigned long type
)
3413 get_mips_segment_type (unsigned long type
)
3417 case PT_MIPS_REGINFO
:
3419 case PT_MIPS_RTPROC
:
3421 case PT_MIPS_OPTIONS
:
3423 case PT_MIPS_ABIFLAGS
:
3433 get_parisc_segment_type (unsigned long type
)
3437 case PT_HP_TLS
: return "HP_TLS";
3438 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3439 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3440 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3441 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3442 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3443 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3444 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3445 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3446 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3447 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3448 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3449 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3450 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3451 case PT_HP_STACK
: return "HP_STACK";
3452 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3453 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3454 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3455 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3464 get_ia64_segment_type (unsigned long type
)
3468 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3469 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3470 case PT_HP_TLS
: return "HP_TLS";
3471 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3472 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3473 case PT_IA_64_HP_STACK
: return "HP_STACK";
3482 get_tic6x_segment_type (unsigned long type
)
3486 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3495 get_segment_type (unsigned long p_type
)
3497 static char buff
[32];
3501 case PT_NULL
: return "NULL";
3502 case PT_LOAD
: return "LOAD";
3503 case PT_DYNAMIC
: return "DYNAMIC";
3504 case PT_INTERP
: return "INTERP";
3505 case PT_NOTE
: return "NOTE";
3506 case PT_SHLIB
: return "SHLIB";
3507 case PT_PHDR
: return "PHDR";
3508 case PT_TLS
: return "TLS";
3510 case PT_GNU_EH_FRAME
:
3511 return "GNU_EH_FRAME";
3512 case PT_GNU_STACK
: return "GNU_STACK";
3513 case PT_GNU_RELRO
: return "GNU_RELRO";
3516 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3518 const char * result
;
3520 switch (elf_header
.e_machine
)
3523 result
= get_aarch64_segment_type (p_type
);
3526 result
= get_arm_segment_type (p_type
);
3529 case EM_MIPS_RS3_LE
:
3530 result
= get_mips_segment_type (p_type
);
3533 result
= get_parisc_segment_type (p_type
);
3536 result
= get_ia64_segment_type (p_type
);
3539 result
= get_tic6x_segment_type (p_type
);
3549 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3551 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3553 const char * result
;
3555 switch (elf_header
.e_machine
)
3558 result
= get_parisc_segment_type (p_type
);
3561 result
= get_ia64_segment_type (p_type
);
3571 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3574 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3581 get_mips_section_type_name (unsigned int sh_type
)
3585 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3586 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3587 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3588 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3589 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3590 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3591 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3592 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3593 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3594 case SHT_MIPS_RELD
: return "MIPS_RELD";
3595 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3596 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3597 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3598 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3599 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3600 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3601 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3602 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3603 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3604 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3605 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3606 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3607 case SHT_MIPS_LINE
: return "MIPS_LINE";
3608 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3609 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3610 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3611 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3612 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3613 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3614 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3615 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3616 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3617 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3618 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3619 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3620 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3621 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3622 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3623 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3624 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3632 get_parisc_section_type_name (unsigned int sh_type
)
3636 case SHT_PARISC_EXT
: return "PARISC_EXT";
3637 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3638 case SHT_PARISC_DOC
: return "PARISC_DOC";
3639 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3640 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3641 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3642 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3650 get_ia64_section_type_name (unsigned int sh_type
)
3652 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3653 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3654 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3658 case SHT_IA_64_EXT
: return "IA_64_EXT";
3659 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3660 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3661 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3662 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3663 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3664 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3665 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3666 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3667 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3675 get_x86_64_section_type_name (unsigned int sh_type
)
3679 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3687 get_aarch64_section_type_name (unsigned int sh_type
)
3691 case SHT_AARCH64_ATTRIBUTES
:
3692 return "AARCH64_ATTRIBUTES";
3700 get_arm_section_type_name (unsigned int sh_type
)
3704 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3705 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3706 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3707 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3708 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3716 get_tic6x_section_type_name (unsigned int sh_type
)
3720 case SHT_C6000_UNWIND
:
3721 return "C6000_UNWIND";
3722 case SHT_C6000_PREEMPTMAP
:
3723 return "C6000_PREEMPTMAP";
3724 case SHT_C6000_ATTRIBUTES
:
3725 return "C6000_ATTRIBUTES";
3730 case SHT_TI_HANDLER
:
3731 return "TI_HANDLER";
3732 case SHT_TI_INITINFO
:
3733 return "TI_INITINFO";
3734 case SHT_TI_PHATTRS
:
3735 return "TI_PHATTRS";
3743 get_msp430x_section_type_name (unsigned int sh_type
)
3747 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3748 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3749 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3750 default: return NULL
;
3755 get_v850_section_type_name (unsigned int sh_type
)
3759 case SHT_V850_SCOMMON
: return "V850 Small Common";
3760 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3761 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3762 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3763 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3764 default: return NULL
;
3769 get_section_type_name (unsigned int sh_type
)
3771 static char buff
[32];
3775 case SHT_NULL
: return "NULL";
3776 case SHT_PROGBITS
: return "PROGBITS";
3777 case SHT_SYMTAB
: return "SYMTAB";
3778 case SHT_STRTAB
: return "STRTAB";
3779 case SHT_RELA
: return "RELA";
3780 case SHT_HASH
: return "HASH";
3781 case SHT_DYNAMIC
: return "DYNAMIC";
3782 case SHT_NOTE
: return "NOTE";
3783 case SHT_NOBITS
: return "NOBITS";
3784 case SHT_REL
: return "REL";
3785 case SHT_SHLIB
: return "SHLIB";
3786 case SHT_DYNSYM
: return "DYNSYM";
3787 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3788 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3789 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3790 case SHT_GNU_HASH
: return "GNU_HASH";
3791 case SHT_GROUP
: return "GROUP";
3792 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3793 case SHT_GNU_verdef
: return "VERDEF";
3794 case SHT_GNU_verneed
: return "VERNEED";
3795 case SHT_GNU_versym
: return "VERSYM";
3796 case 0x6ffffff0: return "VERSYM";
3797 case 0x6ffffffc: return "VERDEF";
3798 case 0x7ffffffd: return "AUXILIARY";
3799 case 0x7fffffff: return "FILTER";
3800 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3803 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3805 const char * result
;
3807 switch (elf_header
.e_machine
)
3810 case EM_MIPS_RS3_LE
:
3811 result
= get_mips_section_type_name (sh_type
);
3814 result
= get_parisc_section_type_name (sh_type
);
3817 result
= get_ia64_section_type_name (sh_type
);
3822 result
= get_x86_64_section_type_name (sh_type
);
3825 result
= get_aarch64_section_type_name (sh_type
);
3828 result
= get_arm_section_type_name (sh_type
);
3831 result
= get_tic6x_section_type_name (sh_type
);
3834 result
= get_msp430x_section_type_name (sh_type
);
3838 case EM_CYGNUS_V850
:
3839 result
= get_v850_section_type_name (sh_type
);
3849 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3851 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3853 const char * result
;
3855 switch (elf_header
.e_machine
)
3858 result
= get_ia64_section_type_name (sh_type
);
3868 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3870 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3872 switch (elf_header
.e_machine
)
3876 case EM_CYGNUS_V850
:
3877 return get_v850_section_type_name (sh_type
);
3882 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3885 /* This message is probably going to be displayed in a 15
3886 character wide field, so put the hex value first. */
3887 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3893 #define OPTION_DEBUG_DUMP 512
3894 #define OPTION_DYN_SYMS 513
3895 #define OPTION_DWARF_DEPTH 514
3896 #define OPTION_DWARF_START 515
3897 #define OPTION_DWARF_CHECK 516
3899 static struct option options
[] =
3901 {"all", no_argument
, 0, 'a'},
3902 {"file-header", no_argument
, 0, 'h'},
3903 {"program-headers", no_argument
, 0, 'l'},
3904 {"headers", no_argument
, 0, 'e'},
3905 {"histogram", no_argument
, 0, 'I'},
3906 {"segments", no_argument
, 0, 'l'},
3907 {"sections", no_argument
, 0, 'S'},
3908 {"section-headers", no_argument
, 0, 'S'},
3909 {"section-groups", no_argument
, 0, 'g'},
3910 {"section-details", no_argument
, 0, 't'},
3911 {"full-section-name",no_argument
, 0, 'N'},
3912 {"symbols", no_argument
, 0, 's'},
3913 {"syms", no_argument
, 0, 's'},
3914 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3915 {"relocs", no_argument
, 0, 'r'},
3916 {"notes", no_argument
, 0, 'n'},
3917 {"dynamic", no_argument
, 0, 'd'},
3918 {"arch-specific", no_argument
, 0, 'A'},
3919 {"version-info", no_argument
, 0, 'V'},
3920 {"use-dynamic", no_argument
, 0, 'D'},
3921 {"unwind", no_argument
, 0, 'u'},
3922 {"archive-index", no_argument
, 0, 'c'},
3923 {"hex-dump", required_argument
, 0, 'x'},
3924 {"relocated-dump", required_argument
, 0, 'R'},
3925 {"string-dump", required_argument
, 0, 'p'},
3926 #ifdef SUPPORT_DISASSEMBLY
3927 {"instruction-dump", required_argument
, 0, 'i'},
3929 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3931 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3932 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3933 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3935 {"version", no_argument
, 0, 'v'},
3936 {"wide", no_argument
, 0, 'W'},
3937 {"help", no_argument
, 0, 'H'},
3938 {0, no_argument
, 0, 0}
3942 usage (FILE * stream
)
3944 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3945 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3946 fprintf (stream
, _(" Options are:\n\
3947 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3948 -h --file-header Display the ELF file header\n\
3949 -l --program-headers Display the program headers\n\
3950 --segments An alias for --program-headers\n\
3951 -S --section-headers Display the sections' header\n\
3952 --sections An alias for --section-headers\n\
3953 -g --section-groups Display the section groups\n\
3954 -t --section-details Display the section details\n\
3955 -e --headers Equivalent to: -h -l -S\n\
3956 -s --syms Display the symbol table\n\
3957 --symbols An alias for --syms\n\
3958 --dyn-syms Display the dynamic symbol table\n\
3959 -n --notes Display the core notes (if present)\n\
3960 -r --relocs Display the relocations (if present)\n\
3961 -u --unwind Display the unwind info (if present)\n\
3962 -d --dynamic Display the dynamic section (if present)\n\
3963 -V --version-info Display the version sections (if present)\n\
3964 -A --arch-specific Display architecture specific information (if any)\n\
3965 -c --archive-index Display the symbol/file index in an archive\n\
3966 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3967 -x --hex-dump=<number|name>\n\
3968 Dump the contents of section <number|name> as bytes\n\
3969 -p --string-dump=<number|name>\n\
3970 Dump the contents of section <number|name> as strings\n\
3971 -R --relocated-dump=<number|name>\n\
3972 Dump the contents of section <number|name> as relocated bytes\n\
3973 -w[lLiaprmfFsoRt] or\n\
3974 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3975 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3976 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3978 Display the contents of DWARF2 debug sections\n"));
3979 fprintf (stream
, _("\
3980 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3981 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3983 #ifdef SUPPORT_DISASSEMBLY
3984 fprintf (stream
, _("\
3985 -i --instruction-dump=<number|name>\n\
3986 Disassemble the contents of section <number|name>\n"));
3988 fprintf (stream
, _("\
3989 -I --histogram Display histogram of bucket list lengths\n\
3990 -W --wide Allow output width to exceed 80 characters\n\
3991 @<file> Read options from <file>\n\
3992 -H --help Display this information\n\
3993 -v --version Display the version number of readelf\n"));
3995 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3996 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3998 exit (stream
== stdout
? 0 : 1);
4001 /* Record the fact that the user wants the contents of section number
4002 SECTION to be displayed using the method(s) encoded as flags bits
4003 in TYPE. Note, TYPE can be zero if we are creating the array for
4007 request_dump_bynumber (unsigned int section
, dump_type type
)
4009 if (section
>= num_dump_sects
)
4011 dump_type
* new_dump_sects
;
4013 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4014 sizeof (* dump_sects
));
4016 if (new_dump_sects
== NULL
)
4017 error (_("Out of memory allocating dump request table.\n"));
4020 /* Copy current flag settings. */
4021 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4025 dump_sects
= new_dump_sects
;
4026 num_dump_sects
= section
+ 1;
4031 dump_sects
[section
] |= type
;
4036 /* Request a dump by section name. */
4039 request_dump_byname (const char * section
, dump_type type
)
4041 struct dump_list_entry
* new_request
;
4043 new_request
= (struct dump_list_entry
*)
4044 malloc (sizeof (struct dump_list_entry
));
4046 error (_("Out of memory allocating dump request table.\n"));
4048 new_request
->name
= strdup (section
);
4049 if (!new_request
->name
)
4050 error (_("Out of memory allocating dump request table.\n"));
4052 new_request
->type
= type
;
4054 new_request
->next
= dump_sects_byname
;
4055 dump_sects_byname
= new_request
;
4059 request_dump (dump_type type
)
4065 section
= strtoul (optarg
, & cp
, 0);
4067 if (! *cp
&& section
>= 0)
4068 request_dump_bynumber (section
, type
);
4070 request_dump_byname (optarg
, type
);
4075 parse_args (int argc
, char ** argv
)
4082 while ((c
= getopt_long
4083 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4101 do_section_groups
++;
4109 do_section_groups
++;
4114 do_section_details
++;
4158 request_dump (HEX_DUMP
);
4161 request_dump (STRING_DUMP
);
4164 request_dump (RELOC_DUMP
);
4171 dwarf_select_sections_all ();
4176 dwarf_select_sections_by_letters (optarg
);
4179 case OPTION_DEBUG_DUMP
:
4186 dwarf_select_sections_by_names (optarg
);
4189 case OPTION_DWARF_DEPTH
:
4193 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4196 case OPTION_DWARF_START
:
4200 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4203 case OPTION_DWARF_CHECK
:
4206 case OPTION_DYN_SYMS
:
4209 #ifdef SUPPORT_DISASSEMBLY
4211 request_dump (DISASS_DUMP
);
4215 print_version (program_name
);
4224 /* xgettext:c-format */
4225 error (_("Invalid option '-%c'\n"), c
);
4232 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4233 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4234 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4235 && !do_section_groups
&& !do_archive_index
4241 get_elf_class (unsigned int elf_class
)
4243 static char buff
[32];
4247 case ELFCLASSNONE
: return _("none");
4248 case ELFCLASS32
: return "ELF32";
4249 case ELFCLASS64
: return "ELF64";
4251 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4257 get_data_encoding (unsigned int encoding
)
4259 static char buff
[32];
4263 case ELFDATANONE
: return _("none");
4264 case ELFDATA2LSB
: return _("2's complement, little endian");
4265 case ELFDATA2MSB
: return _("2's complement, big endian");
4267 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4272 /* Decode the data held in 'elf_header'. */
4275 process_file_header (void)
4277 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4278 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4279 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4280 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4283 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4287 init_dwarf_regnames (elf_header
.e_machine
);
4293 printf (_("ELF Header:\n"));
4294 printf (_(" Magic: "));
4295 for (i
= 0; i
< EI_NIDENT
; i
++)
4296 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4298 printf (_(" Class: %s\n"),
4299 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4300 printf (_(" Data: %s\n"),
4301 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4302 printf (_(" Version: %d %s\n"),
4303 elf_header
.e_ident
[EI_VERSION
],
4304 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4306 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4307 ? _("<unknown: %lx>")
4309 printf (_(" OS/ABI: %s\n"),
4310 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4311 printf (_(" ABI Version: %d\n"),
4312 elf_header
.e_ident
[EI_ABIVERSION
]);
4313 printf (_(" Type: %s\n"),
4314 get_file_type (elf_header
.e_type
));
4315 printf (_(" Machine: %s\n"),
4316 get_machine_name (elf_header
.e_machine
));
4317 printf (_(" Version: 0x%lx\n"),
4318 (unsigned long) elf_header
.e_version
);
4320 printf (_(" Entry point address: "));
4321 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4322 printf (_("\n Start of program headers: "));
4323 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4324 printf (_(" (bytes into file)\n Start of section headers: "));
4325 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4326 printf (_(" (bytes into file)\n"));
4328 printf (_(" Flags: 0x%lx%s\n"),
4329 (unsigned long) elf_header
.e_flags
,
4330 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4331 printf (_(" Size of this header: %ld (bytes)\n"),
4332 (long) elf_header
.e_ehsize
);
4333 printf (_(" Size of program headers: %ld (bytes)\n"),
4334 (long) elf_header
.e_phentsize
);
4335 printf (_(" Number of program headers: %ld"),
4336 (long) elf_header
.e_phnum
);
4337 if (section_headers
!= NULL
4338 && elf_header
.e_phnum
== PN_XNUM
4339 && section_headers
[0].sh_info
!= 0)
4340 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4341 putc ('\n', stdout
);
4342 printf (_(" Size of section headers: %ld (bytes)\n"),
4343 (long) elf_header
.e_shentsize
);
4344 printf (_(" Number of section headers: %ld"),
4345 (long) elf_header
.e_shnum
);
4346 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4347 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4348 putc ('\n', stdout
);
4349 printf (_(" Section header string table index: %ld"),
4350 (long) elf_header
.e_shstrndx
);
4351 if (section_headers
!= NULL
4352 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4353 printf (" (%u)", section_headers
[0].sh_link
);
4354 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4355 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4356 printf (_(" <corrupt: out of range>"));
4357 putc ('\n', stdout
);
4360 if (section_headers
!= NULL
)
4362 if (elf_header
.e_phnum
== PN_XNUM
4363 && section_headers
[0].sh_info
!= 0)
4364 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4365 if (elf_header
.e_shnum
== SHN_UNDEF
)
4366 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4367 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4368 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4369 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4370 elf_header
.e_shstrndx
= SHN_UNDEF
;
4371 free (section_headers
);
4372 section_headers
= NULL
;
4379 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4381 Elf32_External_Phdr
* phdrs
;
4382 Elf32_External_Phdr
* external
;
4383 Elf_Internal_Phdr
* internal
;
4385 unsigned int size
= elf_header
.e_phentsize
;
4386 unsigned int num
= elf_header
.e_phnum
;
4388 /* PR binutils/17531: Cope with unexpected section header sizes. */
4389 if (size
== 0 || num
== 0)
4391 if (size
< sizeof * phdrs
)
4393 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4396 if (size
> sizeof * phdrs
)
4397 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4399 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4400 size
, num
, _("program headers"));
4404 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4405 i
< elf_header
.e_phnum
;
4406 i
++, internal
++, external
++)
4408 internal
->p_type
= BYTE_GET (external
->p_type
);
4409 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4410 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4411 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4412 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4413 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4414 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4415 internal
->p_align
= BYTE_GET (external
->p_align
);
4423 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4425 Elf64_External_Phdr
* phdrs
;
4426 Elf64_External_Phdr
* external
;
4427 Elf_Internal_Phdr
* internal
;
4429 unsigned int size
= elf_header
.e_phentsize
;
4430 unsigned int num
= elf_header
.e_phnum
;
4432 /* PR binutils/17531: Cope with unexpected section header sizes. */
4433 if (size
== 0 || num
== 0)
4435 if (size
< sizeof * phdrs
)
4437 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4440 if (size
> sizeof * phdrs
)
4441 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4443 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4444 size
, num
, _("program headers"));
4448 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4449 i
< elf_header
.e_phnum
;
4450 i
++, internal
++, external
++)
4452 internal
->p_type
= BYTE_GET (external
->p_type
);
4453 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4454 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4455 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4456 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4457 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4458 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4459 internal
->p_align
= BYTE_GET (external
->p_align
);
4466 /* Returns 1 if the program headers were read into `program_headers'. */
4469 get_program_headers (FILE * file
)
4471 Elf_Internal_Phdr
* phdrs
;
4473 /* Check cache of prior read. */
4474 if (program_headers
!= NULL
)
4477 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4478 sizeof (Elf_Internal_Phdr
));
4482 error (_("Out of memory reading %u program headers\n"),
4483 elf_header
.e_phnum
);
4488 ? get_32bit_program_headers (file
, phdrs
)
4489 : get_64bit_program_headers (file
, phdrs
))
4491 program_headers
= phdrs
;
4499 /* Returns 1 if the program headers were loaded. */
4502 process_program_headers (FILE * file
)
4504 Elf_Internal_Phdr
* segment
;
4507 if (elf_header
.e_phnum
== 0)
4509 /* PR binutils/12467. */
4510 if (elf_header
.e_phoff
!= 0)
4511 warn (_("possibly corrupt ELF header - it has a non-zero program"
4512 " header offset, but no program headers\n"));
4513 else if (do_segments
)
4514 printf (_("\nThere are no program headers in this file.\n"));
4518 if (do_segments
&& !do_header
)
4520 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4521 printf (_("Entry point "));
4522 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4523 printf (_("\nThere are %d program headers, starting at offset "),
4524 elf_header
.e_phnum
);
4525 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4529 if (! get_program_headers (file
))
4534 if (elf_header
.e_phnum
> 1)
4535 printf (_("\nProgram Headers:\n"));
4537 printf (_("\nProgram Headers:\n"));
4541 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4544 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4548 (_(" Type Offset VirtAddr PhysAddr\n"));
4550 (_(" FileSiz MemSiz Flags Align\n"));
4557 for (i
= 0, segment
= program_headers
;
4558 i
< elf_header
.e_phnum
;
4563 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4567 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4568 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4569 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4570 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4571 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4573 (segment
->p_flags
& PF_R
? 'R' : ' '),
4574 (segment
->p_flags
& PF_W
? 'W' : ' '),
4575 (segment
->p_flags
& PF_X
? 'E' : ' '));
4576 printf ("%#lx", (unsigned long) segment
->p_align
);
4580 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4581 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4584 print_vma (segment
->p_offset
, FULL_HEX
);
4588 print_vma (segment
->p_vaddr
, FULL_HEX
);
4590 print_vma (segment
->p_paddr
, FULL_HEX
);
4593 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4594 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4597 print_vma (segment
->p_filesz
, FULL_HEX
);
4601 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4602 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4605 print_vma (segment
->p_memsz
, FULL_HEX
);
4609 (segment
->p_flags
& PF_R
? 'R' : ' '),
4610 (segment
->p_flags
& PF_W
? 'W' : ' '),
4611 (segment
->p_flags
& PF_X
? 'E' : ' '));
4613 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4614 printf ("%#lx", (unsigned long) segment
->p_align
);
4617 print_vma (segment
->p_align
, PREFIX_HEX
);
4622 print_vma (segment
->p_offset
, FULL_HEX
);
4624 print_vma (segment
->p_vaddr
, FULL_HEX
);
4626 print_vma (segment
->p_paddr
, FULL_HEX
);
4628 print_vma (segment
->p_filesz
, FULL_HEX
);
4630 print_vma (segment
->p_memsz
, FULL_HEX
);
4632 (segment
->p_flags
& PF_R
? 'R' : ' '),
4633 (segment
->p_flags
& PF_W
? 'W' : ' '),
4634 (segment
->p_flags
& PF_X
? 'E' : ' '));
4635 print_vma (segment
->p_align
, HEX
);
4640 putc ('\n', stdout
);
4642 switch (segment
->p_type
)
4646 error (_("more than one dynamic segment\n"));
4648 /* By default, assume that the .dynamic section is the first
4649 section in the DYNAMIC segment. */
4650 dynamic_addr
= segment
->p_offset
;
4651 dynamic_size
= segment
->p_filesz
;
4652 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4653 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4655 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4656 dynamic_addr
= dynamic_size
= 0;
4659 /* Try to locate the .dynamic section. If there is
4660 a section header table, we can easily locate it. */
4661 if (section_headers
!= NULL
)
4663 Elf_Internal_Shdr
* sec
;
4665 sec
= find_section (".dynamic");
4666 if (sec
== NULL
|| sec
->sh_size
== 0)
4668 /* A corresponding .dynamic section is expected, but on
4669 IA-64/OpenVMS it is OK for it to be missing. */
4670 if (!is_ia64_vms ())
4671 error (_("no .dynamic section in the dynamic segment\n"));
4675 if (sec
->sh_type
== SHT_NOBITS
)
4681 dynamic_addr
= sec
->sh_offset
;
4682 dynamic_size
= sec
->sh_size
;
4684 if (dynamic_addr
< segment
->p_offset
4685 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4686 warn (_("the .dynamic section is not contained"
4687 " within the dynamic segment\n"));
4688 else if (dynamic_addr
> segment
->p_offset
)
4689 warn (_("the .dynamic section is not the first section"
4690 " in the dynamic segment.\n"));
4695 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4697 error (_("Unable to find program interpreter name\n"));
4701 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4703 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4704 error (_("Internal error: failed to create format string to display program interpreter\n"));
4706 program_interpreter
[0] = 0;
4707 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4708 error (_("Unable to read program interpreter name\n"));
4711 printf (_(" [Requesting program interpreter: %s]\n"),
4712 program_interpreter
);
4718 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4720 printf (_("\n Section to Segment mapping:\n"));
4721 printf (_(" Segment Sections...\n"));
4723 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4726 Elf_Internal_Shdr
* section
;
4728 segment
= program_headers
+ i
;
4729 section
= section_headers
+ 1;
4731 printf (" %2.2d ", i
);
4733 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4735 if (!ELF_TBSS_SPECIAL (section
, segment
)
4736 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4737 printf ("%s ", printable_section_name (section
));
4748 /* Find the file offset corresponding to VMA by using the program headers. */
4751 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4753 Elf_Internal_Phdr
* seg
;
4755 if (! get_program_headers (file
))
4757 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4761 for (seg
= program_headers
;
4762 seg
< program_headers
+ elf_header
.e_phnum
;
4765 if (seg
->p_type
!= PT_LOAD
)
4768 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4769 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4770 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4773 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4774 (unsigned long) vma
);
4779 /* Allocate memory and load the sections headers into the global pointer
4780 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4781 generate any error messages if the load fails. */
4784 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4786 Elf32_External_Shdr
* shdrs
;
4787 Elf_Internal_Shdr
* internal
;
4789 unsigned int size
= elf_header
.e_shentsize
;
4790 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4792 /* PR binutils/17531: Cope with unexpected section header sizes. */
4793 if (size
== 0 || num
== 0)
4795 if (size
< sizeof * shdrs
)
4798 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4801 if (!probe
&& size
> sizeof * shdrs
)
4802 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4804 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4806 probe
? NULL
: _("section headers"));
4810 if (section_headers
!= NULL
)
4811 free (section_headers
);
4812 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4813 sizeof (Elf_Internal_Shdr
));
4814 if (section_headers
== NULL
)
4817 error (_("Out of memory reading %u section headers\n"), num
);
4821 for (i
= 0, internal
= section_headers
;
4825 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4826 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4827 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4828 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4829 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4830 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4831 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4832 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4833 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4834 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4842 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4844 Elf64_External_Shdr
* shdrs
;
4845 Elf_Internal_Shdr
* internal
;
4847 unsigned int size
= elf_header
.e_shentsize
;
4848 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4850 /* PR binutils/17531: Cope with unexpected section header sizes. */
4851 if (size
== 0 || num
== 0)
4853 if (size
< sizeof * shdrs
)
4856 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4859 if (! probe
&& size
> sizeof * shdrs
)
4860 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4862 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4864 probe
? NULL
: _("section headers"));
4868 if (section_headers
!= NULL
)
4869 free (section_headers
);
4870 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4871 sizeof (Elf_Internal_Shdr
));
4872 if (section_headers
== NULL
)
4875 error (_("Out of memory reading %u section headers\n"), num
);
4879 for (i
= 0, internal
= section_headers
;
4883 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4884 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4885 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4886 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4887 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4888 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4889 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4890 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4891 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4892 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4899 static Elf_Internal_Sym
*
4900 get_32bit_elf_symbols (FILE * file
,
4901 Elf_Internal_Shdr
* section
,
4902 unsigned long * num_syms_return
)
4904 unsigned long number
= 0;
4905 Elf32_External_Sym
* esyms
= NULL
;
4906 Elf_External_Sym_Shndx
* shndx
= NULL
;
4907 Elf_Internal_Sym
* isyms
= NULL
;
4908 Elf_Internal_Sym
* psym
;
4911 if (section
->sh_size
== 0)
4913 if (num_syms_return
!= NULL
)
4914 * num_syms_return
= 0;
4918 /* Run some sanity checks first. */
4919 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4921 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4922 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4926 if (section
->sh_size
> current_file_size
)
4928 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4929 printable_section_name (section
), (unsigned long) section
->sh_size
);
4933 number
= section
->sh_size
/ section
->sh_entsize
;
4935 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4937 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4938 (unsigned long) section
->sh_size
,
4939 printable_section_name (section
),
4940 (unsigned long) section
->sh_entsize
);
4944 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4945 section
->sh_size
, _("symbols"));
4950 if (symtab_shndx_hdr
!= NULL
4951 && (symtab_shndx_hdr
->sh_link
4952 == (unsigned long) (section
- section_headers
)))
4954 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4955 symtab_shndx_hdr
->sh_offset
,
4956 1, symtab_shndx_hdr
->sh_size
,
4957 _("symbol table section indicies"));
4960 /* PR17531: file: heap-buffer-overflow */
4961 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4963 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4964 printable_section_name (symtab_shndx_hdr
),
4965 (unsigned long) symtab_shndx_hdr
->sh_size
,
4966 (unsigned long) section
->sh_size
);
4971 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4975 error (_("Out of memory reading %lu symbols\n"),
4976 (unsigned long) number
);
4980 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4982 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4983 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4984 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4985 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4986 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4988 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4989 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4990 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4991 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4992 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5001 if (num_syms_return
!= NULL
)
5002 * num_syms_return
= isyms
== NULL
? 0 : number
;
5007 static Elf_Internal_Sym
*
5008 get_64bit_elf_symbols (FILE * file
,
5009 Elf_Internal_Shdr
* section
,
5010 unsigned long * num_syms_return
)
5012 unsigned long number
= 0;
5013 Elf64_External_Sym
* esyms
= NULL
;
5014 Elf_External_Sym_Shndx
* shndx
= NULL
;
5015 Elf_Internal_Sym
* isyms
= NULL
;
5016 Elf_Internal_Sym
* psym
;
5019 if (section
->sh_size
== 0)
5021 if (num_syms_return
!= NULL
)
5022 * num_syms_return
= 0;
5026 /* Run some sanity checks first. */
5027 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5029 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5030 printable_section_name (section
),
5031 (unsigned long) section
->sh_entsize
);
5035 if (section
->sh_size
> current_file_size
)
5037 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5038 printable_section_name (section
),
5039 (unsigned long) section
->sh_size
);
5043 number
= section
->sh_size
/ section
->sh_entsize
;
5045 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5047 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5048 (unsigned long) section
->sh_size
,
5049 printable_section_name (section
),
5050 (unsigned long) section
->sh_entsize
);
5054 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5055 section
->sh_size
, _("symbols"));
5059 if (symtab_shndx_hdr
!= NULL
5060 && (symtab_shndx_hdr
->sh_link
5061 == (unsigned long) (section
- section_headers
)))
5063 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5064 symtab_shndx_hdr
->sh_offset
,
5065 1, symtab_shndx_hdr
->sh_size
,
5066 _("symbol table section indicies"));
5069 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5071 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5072 printable_section_name (symtab_shndx_hdr
),
5073 (unsigned long) symtab_shndx_hdr
->sh_size
,
5074 (unsigned long) section
->sh_size
);
5079 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5083 error (_("Out of memory reading %lu symbols\n"),
5084 (unsigned long) number
);
5088 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5090 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5091 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5092 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5093 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5095 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5097 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5098 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5099 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5101 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5102 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5111 if (num_syms_return
!= NULL
)
5112 * num_syms_return
= isyms
== NULL
? 0 : number
;
5118 get_elf_section_flags (bfd_vma sh_flags
)
5120 static char buff
[1024];
5122 int field_size
= is_32bit_elf
? 8 : 16;
5124 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5125 bfd_vma os_flags
= 0;
5126 bfd_vma proc_flags
= 0;
5127 bfd_vma unknown_flags
= 0;
5135 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5136 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5137 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5138 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5139 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5140 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5141 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5142 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5143 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5144 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5145 /* IA-64 specific. */
5146 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5147 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5148 /* IA-64 OpenVMS specific. */
5149 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5150 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5151 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5152 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5153 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5154 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5156 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5157 /* SPARC specific. */
5158 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5159 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5162 if (do_section_details
)
5164 sprintf (buff
, "[%*.*lx]: ",
5165 field_size
, field_size
, (unsigned long) sh_flags
);
5166 p
+= field_size
+ 4;
5173 flag
= sh_flags
& - sh_flags
;
5176 if (do_section_details
)
5180 case SHF_WRITE
: sindex
= 0; break;
5181 case SHF_ALLOC
: sindex
= 1; break;
5182 case SHF_EXECINSTR
: sindex
= 2; break;
5183 case SHF_MERGE
: sindex
= 3; break;
5184 case SHF_STRINGS
: sindex
= 4; break;
5185 case SHF_INFO_LINK
: sindex
= 5; break;
5186 case SHF_LINK_ORDER
: sindex
= 6; break;
5187 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5188 case SHF_GROUP
: sindex
= 8; break;
5189 case SHF_TLS
: sindex
= 9; break;
5190 case SHF_EXCLUDE
: sindex
= 18; break;
5191 case SHF_COMPRESSED
: sindex
= 20; break;
5195 switch (elf_header
.e_machine
)
5198 if (flag
== SHF_IA_64_SHORT
)
5200 else if (flag
== SHF_IA_64_NORECOV
)
5203 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5206 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5207 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5208 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5209 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5210 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5211 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5222 case EM_OLD_SPARCV9
:
5223 case EM_SPARC32PLUS
:
5226 if (flag
== SHF_ORDERED
)
5236 if (p
!= buff
+ field_size
+ 4)
5238 if (size
< (10 + 2))
5240 warn (_("Internal error: not enough buffer room for section flag info"));
5241 return _("<unknown>");
5248 size
-= flags
[sindex
].len
;
5249 p
= stpcpy (p
, flags
[sindex
].str
);
5251 else if (flag
& SHF_MASKOS
)
5253 else if (flag
& SHF_MASKPROC
)
5256 unknown_flags
|= flag
;
5262 case SHF_WRITE
: *p
= 'W'; break;
5263 case SHF_ALLOC
: *p
= 'A'; break;
5264 case SHF_EXECINSTR
: *p
= 'X'; break;
5265 case SHF_MERGE
: *p
= 'M'; break;
5266 case SHF_STRINGS
: *p
= 'S'; break;
5267 case SHF_INFO_LINK
: *p
= 'I'; break;
5268 case SHF_LINK_ORDER
: *p
= 'L'; break;
5269 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5270 case SHF_GROUP
: *p
= 'G'; break;
5271 case SHF_TLS
: *p
= 'T'; break;
5272 case SHF_EXCLUDE
: *p
= 'E'; break;
5273 case SHF_COMPRESSED
: *p
= 'C'; break;
5276 if ((elf_header
.e_machine
== EM_X86_64
5277 || elf_header
.e_machine
== EM_L1OM
5278 || elf_header
.e_machine
== EM_K1OM
)
5279 && flag
== SHF_X86_64_LARGE
)
5281 else if (flag
& SHF_MASKOS
)
5284 sh_flags
&= ~ SHF_MASKOS
;
5286 else if (flag
& SHF_MASKPROC
)
5289 sh_flags
&= ~ SHF_MASKPROC
;
5299 if (do_section_details
)
5303 size
-= 5 + field_size
;
5304 if (p
!= buff
+ field_size
+ 4)
5308 warn (_("Internal error: not enough buffer room for section flag info"));
5309 return _("<unknown>");
5315 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5316 (unsigned long) os_flags
);
5317 p
+= 5 + field_size
;
5321 size
-= 7 + field_size
;
5322 if (p
!= buff
+ field_size
+ 4)
5326 warn (_("Internal error: not enough buffer room for section flag info"));
5327 return _("<unknown>");
5333 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5334 (unsigned long) proc_flags
);
5335 p
+= 7 + field_size
;
5339 size
-= 10 + field_size
;
5340 if (p
!= buff
+ field_size
+ 4)
5344 warn (_("Internal error: not enough buffer room for section flag info"));
5345 return _("<unknown>");
5351 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5352 (unsigned long) unknown_flags
);
5353 p
+= 10 + field_size
;
5362 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5366 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5367 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5368 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5369 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5370 return sizeof (*echdr
);
5374 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5375 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5376 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5377 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5378 return sizeof (*echdr
);
5383 process_section_headers (FILE * file
)
5385 Elf_Internal_Shdr
* section
;
5388 section_headers
= NULL
;
5390 if (elf_header
.e_shnum
== 0)
5392 /* PR binutils/12467. */
5393 if (elf_header
.e_shoff
!= 0)
5394 warn (_("possibly corrupt ELF file header - it has a non-zero"
5395 " section header offset, but no section headers\n"));
5396 else if (do_sections
)
5397 printf (_("\nThere are no sections in this file.\n"));
5402 if (do_sections
&& !do_header
)
5403 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5404 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5408 if (! get_32bit_section_headers (file
, FALSE
))
5411 else if (! get_64bit_section_headers (file
, FALSE
))
5414 /* Read in the string table, so that we have names to display. */
5415 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5416 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5418 section
= section_headers
+ elf_header
.e_shstrndx
;
5420 if (section
->sh_size
!= 0)
5422 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5423 1, section
->sh_size
,
5426 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5430 /* Scan the sections for the dynamic symbol table
5431 and dynamic string table and debug sections. */
5432 dynamic_symbols
= NULL
;
5433 dynamic_strings
= NULL
;
5434 dynamic_syminfo
= NULL
;
5435 symtab_shndx_hdr
= NULL
;
5437 eh_addr_size
= is_32bit_elf
? 4 : 8;
5438 switch (elf_header
.e_machine
)
5441 case EM_MIPS_RS3_LE
:
5442 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5443 FDE addresses. However, the ABI also has a semi-official ILP32
5444 variant for which the normal FDE address size rules apply.
5446 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5447 section, where XX is the size of longs in bits. Unfortunately,
5448 earlier compilers provided no way of distinguishing ILP32 objects
5449 from LP64 objects, so if there's any doubt, we should assume that
5450 the official LP64 form is being used. */
5451 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5452 && find_section (".gcc_compiled_long32") == NULL
)
5458 switch (elf_header
.e_flags
& EF_H8_MACH
)
5460 case E_H8_MACH_H8300
:
5461 case E_H8_MACH_H8300HN
:
5462 case E_H8_MACH_H8300SN
:
5463 case E_H8_MACH_H8300SXN
:
5466 case E_H8_MACH_H8300H
:
5467 case E_H8_MACH_H8300S
:
5468 case E_H8_MACH_H8300SX
:
5476 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5478 case EF_M32C_CPU_M16C
:
5485 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5488 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5489 if (section->sh_entsize != expected_entsize) \
5492 sprintf_vma (buf, section->sh_entsize); \
5493 /* Note: coded this way so that there is a single string for \
5495 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5496 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5497 (unsigned) expected_entsize); \
5498 section->sh_entsize = expected_entsize; \
5503 #define CHECK_ENTSIZE(section, i, type) \
5504 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5505 sizeof (Elf64_External_##type))
5507 for (i
= 0, section
= section_headers
;
5508 i
< elf_header
.e_shnum
;
5511 char * name
= SECTION_NAME (section
);
5513 if (section
->sh_type
== SHT_DYNSYM
)
5515 if (dynamic_symbols
!= NULL
)
5517 error (_("File contains multiple dynamic symbol tables\n"));
5521 CHECK_ENTSIZE (section
, i
, Sym
);
5522 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5524 else if (section
->sh_type
== SHT_STRTAB
5525 && streq (name
, ".dynstr"))
5527 if (dynamic_strings
!= NULL
)
5529 error (_("File contains multiple dynamic string tables\n"));
5533 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5534 1, section
->sh_size
,
5535 _("dynamic strings"));
5536 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5538 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5540 if (symtab_shndx_hdr
!= NULL
)
5542 error (_("File contains multiple symtab shndx tables\n"));
5545 symtab_shndx_hdr
= section
;
5547 else if (section
->sh_type
== SHT_SYMTAB
)
5548 CHECK_ENTSIZE (section
, i
, Sym
);
5549 else if (section
->sh_type
== SHT_GROUP
)
5550 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5551 else if (section
->sh_type
== SHT_REL
)
5552 CHECK_ENTSIZE (section
, i
, Rel
);
5553 else if (section
->sh_type
== SHT_RELA
)
5554 CHECK_ENTSIZE (section
, i
, Rela
);
5555 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5556 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5557 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5558 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5559 || do_debug_addr
|| do_debug_cu_index
)
5560 && (const_strneq (name
, ".debug_")
5561 || const_strneq (name
, ".zdebug_")))
5564 name
+= sizeof (".zdebug_") - 1;
5566 name
+= sizeof (".debug_") - 1;
5569 || (do_debug_info
&& const_strneq (name
, "info"))
5570 || (do_debug_info
&& const_strneq (name
, "types"))
5571 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5572 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5573 || (do_debug_lines
&& const_strneq (name
, "line."))
5574 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5575 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5576 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5577 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5578 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5579 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5580 || (do_debug_frames
&& const_strneq (name
, "frame"))
5581 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5582 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5583 || (do_debug_str
&& const_strneq (name
, "str"))
5584 || (do_debug_loc
&& const_strneq (name
, "loc"))
5585 || (do_debug_addr
&& const_strneq (name
, "addr"))
5586 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5587 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5589 request_dump_bynumber (i
, DEBUG_DUMP
);
5591 /* Linkonce section to be combined with .debug_info at link time. */
5592 else if ((do_debugging
|| do_debug_info
)
5593 && const_strneq (name
, ".gnu.linkonce.wi."))
5594 request_dump_bynumber (i
, DEBUG_DUMP
);
5595 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5596 request_dump_bynumber (i
, DEBUG_DUMP
);
5597 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5598 request_dump_bynumber (i
, DEBUG_DUMP
);
5599 /* Trace sections for Itanium VMS. */
5600 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5601 || do_trace_aranges
)
5602 && const_strneq (name
, ".trace_"))
5604 name
+= sizeof (".trace_") - 1;
5607 || (do_trace_info
&& streq (name
, "info"))
5608 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5609 || (do_trace_aranges
&& streq (name
, "aranges"))
5611 request_dump_bynumber (i
, DEBUG_DUMP
);
5618 if (elf_header
.e_shnum
> 1)
5619 printf (_("\nSection Headers:\n"));
5621 printf (_("\nSection Header:\n"));
5625 if (do_section_details
)
5627 printf (_(" [Nr] Name\n"));
5628 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5632 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5636 if (do_section_details
)
5638 printf (_(" [Nr] Name\n"));
5639 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5643 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5647 if (do_section_details
)
5649 printf (_(" [Nr] Name\n"));
5650 printf (_(" Type Address Offset Link\n"));
5651 printf (_(" Size EntSize Info Align\n"));
5655 printf (_(" [Nr] Name Type Address Offset\n"));
5656 printf (_(" Size EntSize Flags Link Info Align\n"));
5660 if (do_section_details
)
5661 printf (_(" Flags\n"));
5663 for (i
= 0, section
= section_headers
;
5664 i
< elf_header
.e_shnum
;
5667 printf (" [%2u] ", i
);
5668 if (do_section_details
)
5669 printf ("%s\n ", printable_section_name (section
));
5671 print_symbol (-17, SECTION_NAME (section
));
5673 printf (do_wide
? " %-15s " : " %-15.15s ",
5674 get_section_type_name (section
->sh_type
));
5678 const char * link_too_big
= NULL
;
5680 print_vma (section
->sh_addr
, LONG_HEX
);
5682 printf ( " %6.6lx %6.6lx %2.2lx",
5683 (unsigned long) section
->sh_offset
,
5684 (unsigned long) section
->sh_size
,
5685 (unsigned long) section
->sh_entsize
);
5687 if (do_section_details
)
5688 fputs (" ", stdout
);
5690 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5692 if (section
->sh_link
>= elf_header
.e_shnum
)
5695 /* The sh_link value is out of range. Normally this indicates
5696 an error but it can have special values in Solaris binaries. */
5697 switch (elf_header
.e_machine
)
5704 case EM_OLD_SPARCV9
:
5705 case EM_SPARC32PLUS
:
5708 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5709 link_too_big
= "BEFORE";
5710 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5711 link_too_big
= "AFTER";
5718 if (do_section_details
)
5720 if (link_too_big
!= NULL
&& * link_too_big
)
5721 printf ("<%s> ", link_too_big
);
5723 printf ("%2u ", section
->sh_link
);
5724 printf ("%3u %2lu\n", section
->sh_info
,
5725 (unsigned long) section
->sh_addralign
);
5728 printf ("%2u %3u %2lu\n",
5731 (unsigned long) section
->sh_addralign
);
5733 if (link_too_big
&& ! * link_too_big
)
5734 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5735 i
, section
->sh_link
);
5739 print_vma (section
->sh_addr
, LONG_HEX
);
5741 if ((long) section
->sh_offset
== section
->sh_offset
)
5742 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5746 print_vma (section
->sh_offset
, LONG_HEX
);
5749 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5750 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5754 print_vma (section
->sh_size
, LONG_HEX
);
5757 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5758 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5762 print_vma (section
->sh_entsize
, LONG_HEX
);
5765 if (do_section_details
)
5766 fputs (" ", stdout
);
5768 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5770 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5772 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5773 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5776 print_vma (section
->sh_addralign
, DEC
);
5780 else if (do_section_details
)
5782 printf (" %-15.15s ",
5783 get_section_type_name (section
->sh_type
));
5784 print_vma (section
->sh_addr
, LONG_HEX
);
5785 if ((long) section
->sh_offset
== section
->sh_offset
)
5786 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5790 print_vma (section
->sh_offset
, LONG_HEX
);
5792 printf (" %u\n ", section
->sh_link
);
5793 print_vma (section
->sh_size
, LONG_HEX
);
5795 print_vma (section
->sh_entsize
, LONG_HEX
);
5797 printf (" %-16u %lu\n",
5799 (unsigned long) section
->sh_addralign
);
5804 print_vma (section
->sh_addr
, LONG_HEX
);
5805 if ((long) section
->sh_offset
== section
->sh_offset
)
5806 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5810 print_vma (section
->sh_offset
, LONG_HEX
);
5813 print_vma (section
->sh_size
, LONG_HEX
);
5815 print_vma (section
->sh_entsize
, LONG_HEX
);
5817 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5819 printf (" %2u %3u %lu\n",
5822 (unsigned long) section
->sh_addralign
);
5825 if (do_section_details
)
5827 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5828 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5830 /* Minimum section size is 12 bytes for 32-bit compression
5831 header + 12 bytes for compressed data header. */
5832 unsigned char buf
[24];
5833 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5834 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5835 sizeof (buf
), _("compression header")))
5837 Elf_Internal_Chdr chdr
;
5838 get_compression_header (&chdr
, buf
);
5839 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5842 printf (_(" [<unknown>: 0x%x], "),
5844 print_vma (chdr
.ch_size
, LONG_HEX
);
5845 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
5851 if (!do_section_details
)
5853 if (elf_header
.e_machine
== EM_X86_64
5854 || elf_header
.e_machine
== EM_L1OM
5855 || elf_header
.e_machine
== EM_K1OM
)
5856 printf (_("Key to Flags:\n\
5857 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5858 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5859 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5861 printf (_("Key to Flags:\n\
5862 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5863 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5864 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5871 get_group_flags (unsigned int flags
)
5873 static char buff
[32];
5883 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5890 process_section_groups (FILE * file
)
5892 Elf_Internal_Shdr
* section
;
5894 struct group
* group
;
5895 Elf_Internal_Shdr
* symtab_sec
;
5896 Elf_Internal_Shdr
* strtab_sec
;
5897 Elf_Internal_Sym
* symtab
;
5898 unsigned long num_syms
;
5902 /* Don't process section groups unless needed. */
5903 if (!do_unwind
&& !do_section_groups
)
5906 if (elf_header
.e_shnum
== 0)
5908 if (do_section_groups
)
5909 printf (_("\nThere are no sections to group in this file.\n"));
5914 if (section_headers
== NULL
)
5916 error (_("Section headers are not available!\n"));
5917 /* PR 13622: This can happen with a corrupt ELF header. */
5921 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5922 sizeof (struct group
*));
5924 if (section_headers_groups
== NULL
)
5926 error (_("Out of memory reading %u section group headers\n"),
5927 elf_header
.e_shnum
);
5931 /* Scan the sections for the group section. */
5933 for (i
= 0, section
= section_headers
;
5934 i
< elf_header
.e_shnum
;
5936 if (section
->sh_type
== SHT_GROUP
)
5939 if (group_count
== 0)
5941 if (do_section_groups
)
5942 printf (_("\nThere are no section groups in this file.\n"));
5947 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5949 if (section_groups
== NULL
)
5951 error (_("Out of memory reading %lu groups\n"),
5952 (unsigned long) group_count
);
5962 for (i
= 0, section
= section_headers
, group
= section_groups
;
5963 i
< elf_header
.e_shnum
;
5966 if (section
->sh_type
== SHT_GROUP
)
5968 const char * name
= printable_section_name (section
);
5969 const char * group_name
;
5970 unsigned char * start
;
5971 unsigned char * indices
;
5972 unsigned int entry
, j
, size
;
5973 Elf_Internal_Shdr
* sec
;
5974 Elf_Internal_Sym
* sym
;
5976 /* Get the symbol table. */
5977 if (section
->sh_link
>= elf_header
.e_shnum
5978 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5981 error (_("Bad sh_link in group section `%s'\n"), name
);
5985 if (symtab_sec
!= sec
)
5990 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5995 error (_("Corrupt header in group section `%s'\n"), name
);
5999 if (section
->sh_info
>= num_syms
)
6001 error (_("Bad sh_info in group section `%s'\n"), name
);
6005 sym
= symtab
+ section
->sh_info
;
6007 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6009 if (sym
->st_shndx
== 0
6010 || sym
->st_shndx
>= elf_header
.e_shnum
)
6012 error (_("Bad sh_info in group section `%s'\n"), name
);
6016 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6025 /* Get the string table. */
6026 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6035 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6041 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6042 1, strtab_sec
->sh_size
,
6044 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6046 group_name
= sym
->st_name
< strtab_size
6047 ? strtab
+ sym
->st_name
: _("<corrupt>");
6050 /* PR 17531: file: loop. */
6051 if (section
->sh_entsize
> section
->sh_size
)
6053 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6054 printable_section_name (section
),
6055 (unsigned long) section
->sh_entsize
,
6056 (unsigned long) section
->sh_size
);
6060 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6061 1, section
->sh_size
,
6067 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6068 entry
= byte_get (indices
, 4);
6071 if (do_section_groups
)
6073 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6074 get_group_flags (entry
), i
, name
, group_name
, size
);
6076 printf (_(" [Index] Name\n"));
6079 group
->group_index
= i
;
6081 for (j
= 0; j
< size
; j
++)
6083 struct group_list
* g
;
6085 entry
= byte_get (indices
, 4);
6088 if (entry
>= elf_header
.e_shnum
)
6090 static unsigned num_group_errors
= 0;
6092 if (num_group_errors
++ < 10)
6094 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6095 entry
, i
, elf_header
.e_shnum
- 1);
6096 if (num_group_errors
== 10)
6097 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6102 if (section_headers_groups
[entry
] != NULL
)
6106 static unsigned num_errs
= 0;
6108 if (num_errs
++ < 10)
6110 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6112 section_headers_groups
[entry
]->group_index
);
6114 warn (_("Further error messages about already contained group sections suppressed\n"));
6120 /* Intel C/C++ compiler may put section 0 in a
6121 section group. We just warn it the first time
6122 and ignore it afterwards. */
6123 static int warned
= 0;
6126 error (_("section 0 in group section [%5u]\n"),
6127 section_headers_groups
[entry
]->group_index
);
6133 section_headers_groups
[entry
] = group
;
6135 if (do_section_groups
)
6137 sec
= section_headers
+ entry
;
6138 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6141 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6142 g
->section_index
= entry
;
6143 g
->next
= group
->root
;
6161 /* Data used to display dynamic fixups. */
6163 struct ia64_vms_dynfixup
6165 bfd_vma needed_ident
; /* Library ident number. */
6166 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6167 bfd_vma fixup_needed
; /* Index of the library. */
6168 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6169 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6172 /* Data used to display dynamic relocations. */
6174 struct ia64_vms_dynimgrela
6176 bfd_vma img_rela_cnt
; /* Number of relocations. */
6177 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6180 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6184 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6185 const char *strtab
, unsigned int strtab_sz
)
6187 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6189 const char *lib_name
;
6191 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6192 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6193 _("dynamic section image fixups"));
6197 if (fixup
->needed
< strtab_sz
)
6198 lib_name
= strtab
+ fixup
->needed
;
6201 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6202 (unsigned long) fixup
->needed
);
6205 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6206 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6208 (_("Seg Offset Type SymVec DataType\n"));
6210 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6215 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6216 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6217 type
= BYTE_GET (imfs
[i
].type
);
6218 rtype
= elf_ia64_reloc_type (type
);
6220 printf (" 0x%08x ", type
);
6222 printf (" %-32s ", rtype
);
6223 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6224 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6230 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6233 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6235 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6238 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6239 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6240 _("dynamic section image relocations"));
6244 printf (_("\nImage relocs\n"));
6246 (_("Seg Offset Type Addend Seg Sym Off\n"));
6248 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6253 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6254 printf ("%08" BFD_VMA_FMT
"x ",
6255 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6256 type
= BYTE_GET (imrs
[i
].type
);
6257 rtype
= elf_ia64_reloc_type (type
);
6259 printf ("0x%08x ", type
);
6261 printf ("%-31s ", rtype
);
6262 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6263 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6264 printf ("%08" BFD_VMA_FMT
"x\n",
6265 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6271 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6274 process_ia64_vms_dynamic_relocs (FILE *file
)
6276 struct ia64_vms_dynfixup fixup
;
6277 struct ia64_vms_dynimgrela imgrela
;
6278 Elf_Internal_Dyn
*entry
;
6280 bfd_vma strtab_off
= 0;
6281 bfd_vma strtab_sz
= 0;
6282 char *strtab
= NULL
;
6284 memset (&fixup
, 0, sizeof (fixup
));
6285 memset (&imgrela
, 0, sizeof (imgrela
));
6287 /* Note: the order of the entries is specified by the OpenVMS specs. */
6288 for (entry
= dynamic_section
;
6289 entry
< dynamic_section
+ dynamic_nent
;
6292 switch (entry
->d_tag
)
6294 case DT_IA_64_VMS_STRTAB_OFFSET
:
6295 strtab_off
= entry
->d_un
.d_val
;
6298 strtab_sz
= entry
->d_un
.d_val
;
6300 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6301 1, strtab_sz
, _("dynamic string section"));
6304 case DT_IA_64_VMS_NEEDED_IDENT
:
6305 fixup
.needed_ident
= entry
->d_un
.d_val
;
6308 fixup
.needed
= entry
->d_un
.d_val
;
6310 case DT_IA_64_VMS_FIXUP_NEEDED
:
6311 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6313 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6314 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6316 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6317 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6319 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6322 case DT_IA_64_VMS_IMG_RELA_CNT
:
6323 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6325 case DT_IA_64_VMS_IMG_RELA_OFF
:
6326 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6328 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6348 } dynamic_relocations
[] =
6350 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6351 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6352 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6355 /* Process the reloc section. */
6358 process_relocs (FILE * file
)
6360 unsigned long rel_size
;
6361 unsigned long rel_offset
;
6367 if (do_using_dynamic
)
6371 int has_dynamic_reloc
;
6374 has_dynamic_reloc
= 0;
6376 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6378 is_rela
= dynamic_relocations
[i
].rela
;
6379 name
= dynamic_relocations
[i
].name
;
6380 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6381 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6383 has_dynamic_reloc
|= rel_size
;
6385 if (is_rela
== UNKNOWN
)
6387 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6388 switch (dynamic_info
[DT_PLTREL
])
6402 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6403 name
, rel_offset
, rel_size
);
6405 dump_relocations (file
,
6406 offset_from_vma (file
, rel_offset
, rel_size
),
6408 dynamic_symbols
, num_dynamic_syms
,
6409 dynamic_strings
, dynamic_strings_length
,
6415 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6417 if (! has_dynamic_reloc
)
6418 printf (_("\nThere are no dynamic relocations in this file.\n"));
6422 Elf_Internal_Shdr
* section
;
6426 for (i
= 0, section
= section_headers
;
6427 i
< elf_header
.e_shnum
;
6430 if ( section
->sh_type
!= SHT_RELA
6431 && section
->sh_type
!= SHT_REL
)
6434 rel_offset
= section
->sh_offset
;
6435 rel_size
= section
->sh_size
;
6439 Elf_Internal_Shdr
* strsec
;
6442 printf (_("\nRelocation section "));
6444 if (string_table
== NULL
)
6445 printf ("%d", section
->sh_name
);
6447 printf ("'%s'", printable_section_name (section
));
6449 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6450 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6452 is_rela
= section
->sh_type
== SHT_RELA
;
6454 if (section
->sh_link
!= 0
6455 && section
->sh_link
< elf_header
.e_shnum
)
6457 Elf_Internal_Shdr
* symsec
;
6458 Elf_Internal_Sym
* symtab
;
6459 unsigned long nsyms
;
6460 unsigned long strtablen
= 0;
6461 char * strtab
= NULL
;
6463 symsec
= section_headers
+ section
->sh_link
;
6464 if (symsec
->sh_type
!= SHT_SYMTAB
6465 && symsec
->sh_type
!= SHT_DYNSYM
)
6468 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6473 if (symsec
->sh_link
!= 0
6474 && symsec
->sh_link
< elf_header
.e_shnum
)
6476 strsec
= section_headers
+ symsec
->sh_link
;
6478 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6481 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6484 dump_relocations (file
, rel_offset
, rel_size
,
6485 symtab
, nsyms
, strtab
, strtablen
,
6487 symsec
->sh_type
== SHT_DYNSYM
);
6493 dump_relocations (file
, rel_offset
, rel_size
,
6494 NULL
, 0, NULL
, 0, is_rela
, 0);
6501 printf (_("\nThere are no relocations in this file.\n"));
6507 /* An absolute address consists of a section and an offset. If the
6508 section is NULL, the offset itself is the address, otherwise, the
6509 address equals to LOAD_ADDRESS(section) + offset. */
6513 unsigned short section
;
6517 #define ABSADDR(a) \
6519 ? section_headers [(a).section].sh_addr + (a).offset \
6522 /* Find the nearest symbol at or below ADDR. Returns the symbol
6523 name, if found, and the offset from the symbol to ADDR. */
6526 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6527 unsigned long nsyms
,
6528 const char * strtab
,
6529 unsigned long strtab_size
,
6530 struct absaddr addr
,
6531 const char ** symname
,
6534 bfd_vma dist
= 0x100000;
6535 Elf_Internal_Sym
* sym
;
6536 Elf_Internal_Sym
* beg
;
6537 Elf_Internal_Sym
* end
;
6538 Elf_Internal_Sym
* best
= NULL
;
6540 REMOVE_ARCH_BITS (addr
.offset
);
6542 end
= symtab
+ nsyms
;
6548 sym
= beg
+ (end
- beg
) / 2;
6550 value
= sym
->st_value
;
6551 REMOVE_ARCH_BITS (value
);
6553 if (sym
->st_name
!= 0
6554 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6555 && addr
.offset
>= value
6556 && addr
.offset
- value
< dist
)
6559 dist
= addr
.offset
- value
;
6564 if (addr
.offset
< value
)
6572 *symname
= (best
->st_name
>= strtab_size
6573 ? _("<corrupt>") : strtab
+ best
->st_name
);
6579 *offset
= addr
.offset
;
6583 symcmp (const void *p
, const void *q
)
6585 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6586 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6588 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6591 /* Process the unwind section. */
6593 #include "unwind-ia64.h"
6595 struct ia64_unw_table_entry
6597 struct absaddr start
;
6599 struct absaddr info
;
6602 struct ia64_unw_aux_info
6604 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6605 unsigned long table_len
; /* Length of unwind table. */
6606 unsigned char * info
; /* Unwind info. */
6607 unsigned long info_size
; /* Size of unwind info. */
6608 bfd_vma info_addr
; /* Starting address of unwind info. */
6609 bfd_vma seg_base
; /* Starting address of segment. */
6610 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6611 unsigned long nsyms
; /* Number of symbols. */
6612 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6613 unsigned long nfuns
; /* Number of entries in funtab. */
6614 char * strtab
; /* The string table. */
6615 unsigned long strtab_size
; /* Size of string table. */
6619 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6621 struct ia64_unw_table_entry
* tp
;
6622 unsigned long j
, nfuns
;
6625 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6626 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6627 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6628 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6630 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6632 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6636 const unsigned char * dp
;
6637 const unsigned char * head
;
6638 const unsigned char * end
;
6639 const char * procname
;
6641 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6642 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6644 fputs ("\n<", stdout
);
6648 fputs (procname
, stdout
);
6651 printf ("+%lx", (unsigned long) offset
);
6654 fputs (">: [", stdout
);
6655 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6656 fputc ('-', stdout
);
6657 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6658 printf ("], info at +0x%lx\n",
6659 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6661 /* PR 17531: file: 86232b32. */
6662 if (aux
->info
== NULL
)
6665 /* PR 17531: file: 0997b4d1. */
6666 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6668 warn (_("Invalid offset %lx in table entry %ld\n"),
6669 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6673 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6674 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6676 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6677 (unsigned) UNW_VER (stamp
),
6678 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6679 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6680 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6681 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6683 if (UNW_VER (stamp
) != 1)
6685 printf (_("\tUnknown version.\n"));
6690 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6691 /* PR 17531: file: 16ceda89. */
6692 if (end
> aux
->info
+ aux
->info_size
)
6693 end
= aux
->info
+ aux
->info_size
;
6694 for (dp
= head
+ 8; dp
< end
;)
6695 dp
= unw_decode (dp
, in_body
, & in_body
);
6702 slurp_ia64_unwind_table (FILE * file
,
6703 struct ia64_unw_aux_info
* aux
,
6704 Elf_Internal_Shdr
* sec
)
6706 unsigned long size
, nrelas
, i
;
6707 Elf_Internal_Phdr
* seg
;
6708 struct ia64_unw_table_entry
* tep
;
6709 Elf_Internal_Shdr
* relsec
;
6710 Elf_Internal_Rela
* rela
;
6711 Elf_Internal_Rela
* rp
;
6712 unsigned char * table
;
6714 Elf_Internal_Sym
* sym
;
6715 const char * relname
;
6719 /* First, find the starting address of the segment that includes
6722 if (elf_header
.e_phnum
)
6724 if (! get_program_headers (file
))
6727 for (seg
= program_headers
;
6728 seg
< program_headers
+ elf_header
.e_phnum
;
6731 if (seg
->p_type
!= PT_LOAD
)
6734 if (sec
->sh_addr
>= seg
->p_vaddr
6735 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6737 aux
->seg_base
= seg
->p_vaddr
;
6743 /* Second, build the unwind table from the contents of the unwind section: */
6744 size
= sec
->sh_size
;
6745 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6750 aux
->table_len
= size
/ (3 * eh_addr_size
);
6751 aux
->table
= (struct ia64_unw_table_entry
*)
6752 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6755 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6757 tep
->start
.section
= SHN_UNDEF
;
6758 tep
->end
.section
= SHN_UNDEF
;
6759 tep
->info
.section
= SHN_UNDEF
;
6760 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6761 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6762 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6763 tep
->start
.offset
+= aux
->seg_base
;
6764 tep
->end
.offset
+= aux
->seg_base
;
6765 tep
->info
.offset
+= aux
->seg_base
;
6769 /* Third, apply any relocations to the unwind table: */
6770 for (relsec
= section_headers
;
6771 relsec
< section_headers
+ elf_header
.e_shnum
;
6774 if (relsec
->sh_type
!= SHT_RELA
6775 || relsec
->sh_info
>= elf_header
.e_shnum
6776 || section_headers
+ relsec
->sh_info
!= sec
)
6779 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6788 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6790 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6791 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6793 /* PR 17531: file: 9fa67536. */
6794 if (relname
== NULL
)
6796 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6800 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6802 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6806 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6808 /* PR 17531: file: 5bc8d9bf. */
6809 if (i
>= aux
->table_len
)
6811 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6815 switch (rp
->r_offset
/ eh_addr_size
% 3)
6818 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6819 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6822 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6823 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6826 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6827 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6841 ia64_process_unwind (FILE * file
)
6843 Elf_Internal_Shdr
* sec
;
6844 Elf_Internal_Shdr
* unwsec
= NULL
;
6845 Elf_Internal_Shdr
* strsec
;
6846 unsigned long i
, unwcount
= 0, unwstart
= 0;
6847 struct ia64_unw_aux_info aux
;
6849 memset (& aux
, 0, sizeof (aux
));
6851 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6853 if (sec
->sh_type
== SHT_SYMTAB
6854 && sec
->sh_link
< elf_header
.e_shnum
)
6856 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6858 strsec
= section_headers
+ sec
->sh_link
;
6859 if (aux
.strtab
!= NULL
)
6861 error (_("Multiple auxillary string tables encountered\n"));
6864 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6867 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6869 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6874 printf (_("\nThere are no unwind sections in this file.\n"));
6876 while (unwcount
-- > 0)
6881 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6882 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6883 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6888 /* We have already counted the number of SHT_IA64_UNWIND
6889 sections so the loop above should never fail. */
6890 assert (unwsec
!= NULL
);
6893 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6895 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6897 /* We need to find which section group it is in. */
6898 struct group_list
* g
;
6900 if (section_headers_groups
== NULL
6901 || section_headers_groups
[i
] == NULL
)
6902 i
= elf_header
.e_shnum
;
6905 g
= section_headers_groups
[i
]->root
;
6907 for (; g
!= NULL
; g
= g
->next
)
6909 sec
= section_headers
+ g
->section_index
;
6911 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6916 i
= elf_header
.e_shnum
;
6919 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6921 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6922 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6923 suffix
= SECTION_NAME (unwsec
) + len
;
6924 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6926 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6927 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6932 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6933 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6934 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6935 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6937 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6938 suffix
= SECTION_NAME (unwsec
) + len
;
6939 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6941 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6942 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6946 if (i
== elf_header
.e_shnum
)
6948 printf (_("\nCould not find unwind info section for "));
6950 if (string_table
== NULL
)
6951 printf ("%d", unwsec
->sh_name
);
6953 printf ("'%s'", printable_section_name (unwsec
));
6957 aux
.info_addr
= sec
->sh_addr
;
6958 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6961 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6963 printf (_("\nUnwind section "));
6965 if (string_table
== NULL
)
6966 printf ("%d", unwsec
->sh_name
);
6968 printf ("'%s'", printable_section_name (unwsec
));
6970 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6971 (unsigned long) unwsec
->sh_offset
,
6972 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6974 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
6975 && aux
.table_len
> 0)
6976 dump_ia64_unwind (& aux
);
6979 free ((char *) aux
.table
);
6981 free ((char *) aux
.info
);
6990 free ((char *) aux
.strtab
);
6993 struct hppa_unw_table_entry
6995 struct absaddr start
;
6997 unsigned int Cannot_unwind
:1; /* 0 */
6998 unsigned int Millicode
:1; /* 1 */
6999 unsigned int Millicode_save_sr0
:1; /* 2 */
7000 unsigned int Region_description
:2; /* 3..4 */
7001 unsigned int reserved1
:1; /* 5 */
7002 unsigned int Entry_SR
:1; /* 6 */
7003 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7004 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7005 unsigned int Args_stored
:1; /* 16 */
7006 unsigned int Variable_Frame
:1; /* 17 */
7007 unsigned int Separate_Package_Body
:1; /* 18 */
7008 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7009 unsigned int Stack_Overflow_Check
:1; /* 20 */
7010 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7011 unsigned int Ada_Region
:1; /* 22 */
7012 unsigned int cxx_info
:1; /* 23 */
7013 unsigned int cxx_try_catch
:1; /* 24 */
7014 unsigned int sched_entry_seq
:1; /* 25 */
7015 unsigned int reserved2
:1; /* 26 */
7016 unsigned int Save_SP
:1; /* 27 */
7017 unsigned int Save_RP
:1; /* 28 */
7018 unsigned int Save_MRP_in_frame
:1; /* 29 */
7019 unsigned int extn_ptr_defined
:1; /* 30 */
7020 unsigned int Cleanup_defined
:1; /* 31 */
7022 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7023 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7024 unsigned int Large_frame
:1; /* 2 */
7025 unsigned int Pseudo_SP_Set
:1; /* 3 */
7026 unsigned int reserved4
:1; /* 4 */
7027 unsigned int Total_frame_size
:27; /* 5..31 */
7030 struct hppa_unw_aux_info
7032 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7033 unsigned long table_len
; /* Length of unwind table. */
7034 bfd_vma seg_base
; /* Starting address of segment. */
7035 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7036 unsigned long nsyms
; /* Number of symbols. */
7037 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7038 unsigned long nfuns
; /* Number of entries in funtab. */
7039 char * strtab
; /* The string table. */
7040 unsigned long strtab_size
; /* Size of string table. */
7044 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7046 struct hppa_unw_table_entry
* tp
;
7047 unsigned long j
, nfuns
;
7049 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7050 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7051 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7052 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7054 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7056 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7059 const char * procname
;
7061 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7062 aux
->strtab_size
, tp
->start
, &procname
,
7065 fputs ("\n<", stdout
);
7069 fputs (procname
, stdout
);
7072 printf ("+%lx", (unsigned long) offset
);
7075 fputs (">: [", stdout
);
7076 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7077 fputc ('-', stdout
);
7078 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7081 #define PF(_m) if (tp->_m) printf (#_m " ");
7082 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7085 PF(Millicode_save_sr0
);
7086 /* PV(Region_description); */
7092 PF(Separate_Package_Body
);
7093 PF(Frame_Extension_Millicode
);
7094 PF(Stack_Overflow_Check
);
7095 PF(Two_Instruction_SP_Increment
);
7099 PF(sched_entry_seq
);
7102 PF(Save_MRP_in_frame
);
7103 PF(extn_ptr_defined
);
7104 PF(Cleanup_defined
);
7105 PF(MPE_XL_interrupt_marker
);
7106 PF(HP_UX_interrupt_marker
);
7109 PV(Total_frame_size
);
7120 slurp_hppa_unwind_table (FILE * file
,
7121 struct hppa_unw_aux_info
* aux
,
7122 Elf_Internal_Shdr
* sec
)
7124 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7125 Elf_Internal_Phdr
* seg
;
7126 struct hppa_unw_table_entry
* tep
;
7127 Elf_Internal_Shdr
* relsec
;
7128 Elf_Internal_Rela
* rela
;
7129 Elf_Internal_Rela
* rp
;
7130 unsigned char * table
;
7132 Elf_Internal_Sym
* sym
;
7133 const char * relname
;
7135 /* First, find the starting address of the segment that includes
7138 if (elf_header
.e_phnum
)
7140 if (! get_program_headers (file
))
7143 for (seg
= program_headers
;
7144 seg
< program_headers
+ elf_header
.e_phnum
;
7147 if (seg
->p_type
!= PT_LOAD
)
7150 if (sec
->sh_addr
>= seg
->p_vaddr
7151 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7153 aux
->seg_base
= seg
->p_vaddr
;
7159 /* Second, build the unwind table from the contents of the unwind
7161 size
= sec
->sh_size
;
7162 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7168 nentries
= size
/ unw_ent_size
;
7169 size
= unw_ent_size
* nentries
;
7171 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7172 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7174 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7176 unsigned int tmp1
, tmp2
;
7178 tep
->start
.section
= SHN_UNDEF
;
7179 tep
->end
.section
= SHN_UNDEF
;
7181 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7182 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7183 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7184 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7186 tep
->start
.offset
+= aux
->seg_base
;
7187 tep
->end
.offset
+= aux
->seg_base
;
7189 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7190 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7191 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7192 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7193 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7194 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7195 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7196 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7197 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7198 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7199 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7200 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7201 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7202 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7203 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7204 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7205 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7206 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7207 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7208 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7209 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7210 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7211 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7212 tep
->Cleanup_defined
= tmp1
& 0x1;
7214 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7215 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7216 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7217 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7218 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7219 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7223 /* Third, apply any relocations to the unwind table. */
7224 for (relsec
= section_headers
;
7225 relsec
< section_headers
+ elf_header
.e_shnum
;
7228 if (relsec
->sh_type
!= SHT_RELA
7229 || relsec
->sh_info
>= elf_header
.e_shnum
7230 || section_headers
+ relsec
->sh_info
!= sec
)
7233 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7237 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7239 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7240 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7242 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7243 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7245 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7249 i
= rp
->r_offset
/ unw_ent_size
;
7251 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7254 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7255 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7258 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7259 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7269 aux
->table_len
= nentries
;
7275 hppa_process_unwind (FILE * file
)
7277 struct hppa_unw_aux_info aux
;
7278 Elf_Internal_Shdr
* unwsec
= NULL
;
7279 Elf_Internal_Shdr
* strsec
;
7280 Elf_Internal_Shdr
* sec
;
7283 if (string_table
== NULL
)
7286 memset (& aux
, 0, sizeof (aux
));
7288 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7290 if (sec
->sh_type
== SHT_SYMTAB
7291 && sec
->sh_link
< elf_header
.e_shnum
)
7293 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7295 strsec
= section_headers
+ sec
->sh_link
;
7296 if (aux
.strtab
!= NULL
)
7298 error (_("Multiple auxillary string tables encountered\n"));
7301 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7304 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7306 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7311 printf (_("\nThere are no unwind sections in this file.\n"));
7313 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7315 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7317 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7318 printable_section_name (sec
),
7319 (unsigned long) sec
->sh_offset
,
7320 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7322 slurp_hppa_unwind_table (file
, &aux
, sec
);
7323 if (aux
.table_len
> 0)
7324 dump_hppa_unwind (&aux
);
7327 free ((char *) aux
.table
);
7335 free ((char *) aux
.strtab
);
7340 unsigned char * data
; /* The unwind data. */
7341 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7342 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7343 unsigned long nrelas
; /* The number of relocations. */
7344 unsigned int rel_type
; /* REL or RELA ? */
7345 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7348 struct arm_unw_aux_info
7350 FILE * file
; /* The file containing the unwind sections. */
7351 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7352 unsigned long nsyms
; /* Number of symbols. */
7353 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7354 unsigned long nfuns
; /* Number of these symbols. */
7355 char * strtab
; /* The file's string table. */
7356 unsigned long strtab_size
; /* Size of string table. */
7360 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7361 bfd_vma fn
, struct absaddr addr
)
7363 const char *procname
;
7366 if (addr
.section
== SHN_UNDEF
)
7369 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7370 aux
->strtab_size
, addr
, &procname
,
7373 print_vma (fn
, PREFIX_HEX
);
7377 fputs (" <", stdout
);
7378 fputs (procname
, stdout
);
7381 printf ("+0x%lx", (unsigned long) sym_offset
);
7382 fputc ('>', stdout
);
7389 arm_free_section (struct arm_section
*arm_sec
)
7391 if (arm_sec
->data
!= NULL
)
7392 free (arm_sec
->data
);
7394 if (arm_sec
->rela
!= NULL
)
7395 free (arm_sec
->rela
);
7398 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7399 cached section and install SEC instead.
7400 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7401 and return its valued in * WORDP, relocating if necessary.
7402 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7403 relocation's offset in ADDR.
7404 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7405 into the string table of the symbol associated with the reloc. If no
7406 reloc was applied store -1 there.
7407 5) Return TRUE upon success, FALSE otherwise. */
7410 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7411 struct arm_section
* arm_sec
,
7412 Elf_Internal_Shdr
* sec
,
7413 bfd_vma word_offset
,
7414 unsigned int * wordp
,
7415 struct absaddr
* addr
,
7418 Elf_Internal_Rela
*rp
;
7419 Elf_Internal_Sym
*sym
;
7420 const char * relname
;
7422 bfd_boolean wrapped
;
7424 if (sec
== NULL
|| arm_sec
== NULL
)
7427 addr
->section
= SHN_UNDEF
;
7430 if (sym_name
!= NULL
)
7431 *sym_name
= (bfd_vma
) -1;
7433 /* If necessary, update the section cache. */
7434 if (sec
!= arm_sec
->sec
)
7436 Elf_Internal_Shdr
*relsec
;
7438 arm_free_section (arm_sec
);
7441 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7442 sec
->sh_size
, _("unwind data"));
7443 arm_sec
->rela
= NULL
;
7444 arm_sec
->nrelas
= 0;
7446 for (relsec
= section_headers
;
7447 relsec
< section_headers
+ elf_header
.e_shnum
;
7450 if (relsec
->sh_info
>= elf_header
.e_shnum
7451 || section_headers
+ relsec
->sh_info
!= sec
7452 /* PR 15745: Check the section type as well. */
7453 || (relsec
->sh_type
!= SHT_REL
7454 && relsec
->sh_type
!= SHT_RELA
))
7457 arm_sec
->rel_type
= relsec
->sh_type
;
7458 if (relsec
->sh_type
== SHT_REL
)
7460 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7462 & arm_sec
->rela
, & arm_sec
->nrelas
))
7465 else /* relsec->sh_type == SHT_RELA */
7467 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7469 & arm_sec
->rela
, & arm_sec
->nrelas
))
7475 arm_sec
->next_rela
= arm_sec
->rela
;
7478 /* If there is no unwind data we can do nothing. */
7479 if (arm_sec
->data
== NULL
)
7482 /* If the offset is invalid then fail. */
7483 if (word_offset
> sec
->sh_size
- 4)
7486 /* Get the word at the required offset. */
7487 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7489 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7490 if (arm_sec
->rela
== NULL
)
7496 /* Look through the relocs to find the one that applies to the provided offset. */
7498 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7500 bfd_vma prelval
, offset
;
7502 if (rp
->r_offset
> word_offset
&& !wrapped
)
7507 if (rp
->r_offset
> word_offset
)
7510 if (rp
->r_offset
& 3)
7512 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7513 (unsigned long) rp
->r_offset
);
7517 if (rp
->r_offset
< word_offset
)
7520 /* PR 17531: file: 027-161405-0.004 */
7521 if (aux
->symtab
== NULL
)
7524 if (arm_sec
->rel_type
== SHT_REL
)
7526 offset
= word
& 0x7fffffff;
7527 if (offset
& 0x40000000)
7528 offset
|= ~ (bfd_vma
) 0x7fffffff;
7530 else if (arm_sec
->rel_type
== SHT_RELA
)
7531 offset
= rp
->r_addend
;
7534 error (_("Unknown section relocation type %d encountered\n"),
7539 /* PR 17531 file: 027-1241568-0.004. */
7540 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7542 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7543 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7547 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7548 offset
+= sym
->st_value
;
7549 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7551 /* Check that we are processing the expected reloc type. */
7552 if (elf_header
.e_machine
== EM_ARM
)
7554 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7555 if (relname
== NULL
)
7557 warn (_("Skipping unknown ARM relocation type: %d\n"),
7558 (int) ELF32_R_TYPE (rp
->r_info
));
7562 if (streq (relname
, "R_ARM_NONE"))
7565 if (! streq (relname
, "R_ARM_PREL31"))
7567 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7571 else if (elf_header
.e_machine
== EM_TI_C6000
)
7573 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7574 if (relname
== NULL
)
7576 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7577 (int) ELF32_R_TYPE (rp
->r_info
));
7581 if (streq (relname
, "R_C6000_NONE"))
7584 if (! streq (relname
, "R_C6000_PREL31"))
7586 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7594 /* This function currently only supports ARM and TI unwinders. */
7595 warn (_("Only TI and ARM unwinders are currently supported\n"));
7599 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7600 addr
->section
= sym
->st_shndx
;
7601 addr
->offset
= offset
;
7604 * sym_name
= sym
->st_name
;
7609 arm_sec
->next_rela
= rp
;
7614 static const char *tic6x_unwind_regnames
[16] =
7616 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7617 "A14", "A13", "A12", "A11", "A10",
7618 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7622 decode_tic6x_unwind_regmask (unsigned int mask
)
7626 for (i
= 12; mask
; mask
>>= 1, i
--)
7630 fputs (tic6x_unwind_regnames
[i
], stdout
);
7632 fputs (", ", stdout
);
7638 if (remaining == 0 && more_words) \
7641 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7642 data_offset, & word, & addr, NULL)) \
7648 #define GET_OP(OP) \
7653 (OP) = word >> 24; \
7658 printf (_("[Truncated opcode]\n")); \
7661 printf ("0x%02x ", OP)
7664 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7666 unsigned int remaining
,
7667 unsigned int more_words
,
7668 bfd_vma data_offset
,
7669 Elf_Internal_Shdr
* data_sec
,
7670 struct arm_section
* data_arm_sec
)
7672 struct absaddr addr
;
7674 /* Decode the unwinding instructions. */
7677 unsigned int op
, op2
;
7686 printf (" 0x%02x ", op
);
7688 if ((op
& 0xc0) == 0x00)
7690 int offset
= ((op
& 0x3f) << 2) + 4;
7692 printf (" vsp = vsp + %d", offset
);
7694 else if ((op
& 0xc0) == 0x40)
7696 int offset
= ((op
& 0x3f) << 2) + 4;
7698 printf (" vsp = vsp - %d", offset
);
7700 else if ((op
& 0xf0) == 0x80)
7703 if (op
== 0x80 && op2
== 0)
7704 printf (_("Refuse to unwind"));
7707 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7712 for (i
= 0; i
< 12; i
++)
7713 if (mask
& (1 << i
))
7719 printf ("r%d", 4 + i
);
7724 else if ((op
& 0xf0) == 0x90)
7726 if (op
== 0x9d || op
== 0x9f)
7727 printf (_(" [Reserved]"));
7729 printf (" vsp = r%d", op
& 0x0f);
7731 else if ((op
& 0xf0) == 0xa0)
7733 int end
= 4 + (op
& 0x07);
7738 for (i
= 4; i
<= end
; i
++)
7754 else if (op
== 0xb0)
7755 printf (_(" finish"));
7756 else if (op
== 0xb1)
7759 if (op2
== 0 || (op2
& 0xf0) != 0)
7760 printf (_("[Spare]"));
7763 unsigned int mask
= op2
& 0x0f;
7768 for (i
= 0; i
< 12; i
++)
7769 if (mask
& (1 << i
))
7780 else if (op
== 0xb2)
7782 unsigned char buf
[9];
7783 unsigned int i
, len
;
7784 unsigned long offset
;
7786 for (i
= 0; i
< sizeof (buf
); i
++)
7789 if ((buf
[i
] & 0x80) == 0)
7792 if (i
== sizeof (buf
))
7793 printf (_("corrupt change to vsp"));
7796 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7797 assert (len
== i
+ 1);
7798 offset
= offset
* 4 + 0x204;
7799 printf ("vsp = vsp + %ld", offset
);
7802 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7804 unsigned int first
, last
;
7811 printf ("pop {D%d", first
);
7813 printf ("-D%d", first
+ last
);
7816 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7818 unsigned int count
= op
& 0x07;
7822 printf ("-D%d", 8 + count
);
7825 else if (op
>= 0xc0 && op
<= 0xc5)
7827 unsigned int count
= op
& 0x07;
7829 printf (" pop {wR10");
7831 printf ("-wR%d", 10 + count
);
7834 else if (op
== 0xc6)
7836 unsigned int first
, last
;
7841 printf ("pop {wR%d", first
);
7843 printf ("-wR%d", first
+ last
);
7846 else if (op
== 0xc7)
7849 if (op2
== 0 || (op2
& 0xf0) != 0)
7850 printf (_("[Spare]"));
7853 unsigned int mask
= op2
& 0x0f;
7858 for (i
= 0; i
< 4; i
++)
7859 if (mask
& (1 << i
))
7865 printf ("wCGR%d", i
);
7871 printf (_(" [unsupported opcode]"));
7877 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7879 unsigned int remaining
,
7880 unsigned int more_words
,
7881 bfd_vma data_offset
,
7882 Elf_Internal_Shdr
* data_sec
,
7883 struct arm_section
* data_arm_sec
)
7885 struct absaddr addr
;
7887 /* Decode the unwinding instructions. */
7890 unsigned int op
, op2
;
7899 printf (" 0x%02x ", op
);
7901 if ((op
& 0xc0) == 0x00)
7903 int offset
= ((op
& 0x3f) << 3) + 8;
7904 printf (" sp = sp + %d", offset
);
7906 else if ((op
& 0xc0) == 0x80)
7909 if (op
== 0x80 && op2
== 0)
7910 printf (_("Refuse to unwind"));
7913 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7915 printf ("pop compact {");
7919 decode_tic6x_unwind_regmask (mask
);
7923 else if ((op
& 0xf0) == 0xc0)
7931 unsigned int offset
;
7935 /* Scan entire instruction first so that GET_OP output is not
7936 interleaved with disassembly. */
7938 for (i
= 0; nregs
< (op
& 0xf); i
++)
7944 regpos
[nregs
].offset
= i
* 2;
7945 regpos
[nregs
].reg
= reg
;
7952 regpos
[nregs
].offset
= i
* 2 + 1;
7953 regpos
[nregs
].reg
= reg
;
7958 printf (_("pop frame {"));
7960 for (i
= i
* 2; i
> 0; i
--)
7962 if (regpos
[reg
].offset
== i
- 1)
7964 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7971 fputs (name
, stdout
);
7978 else if (op
== 0xd0)
7979 printf (" MOV FP, SP");
7980 else if (op
== 0xd1)
7981 printf (" __c6xabi_pop_rts");
7982 else if (op
== 0xd2)
7984 unsigned char buf
[9];
7985 unsigned int i
, len
;
7986 unsigned long offset
;
7988 for (i
= 0; i
< sizeof (buf
); i
++)
7991 if ((buf
[i
] & 0x80) == 0)
7994 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7995 if (i
== sizeof (buf
))
7997 printf ("<corrupt sp adjust>\n");
7998 warn (_("Corrupt stack pointer adjustment detected\n"));
8002 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8003 assert (len
== i
+ 1);
8004 offset
= offset
* 8 + 0x408;
8005 printf (_("sp = sp + %ld"), offset
);
8007 else if ((op
& 0xf0) == 0xe0)
8009 if ((op
& 0x0f) == 7)
8012 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8016 printf (_(" [unsupported opcode]"));
8023 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8027 offset
= word
& 0x7fffffff;
8028 if (offset
& 0x40000000)
8029 offset
|= ~ (bfd_vma
) 0x7fffffff;
8031 if (elf_header
.e_machine
== EM_TI_C6000
)
8034 return offset
+ where
;
8038 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8040 unsigned int remaining
,
8041 bfd_vma data_offset
,
8042 Elf_Internal_Shdr
* data_sec
,
8043 struct arm_section
* data_arm_sec
)
8046 unsigned int more_words
= 0;
8047 struct absaddr addr
;
8048 bfd_vma sym_name
= (bfd_vma
) -1;
8052 /* Fetch the first word.
8053 Note - when decoding an object file the address extracted
8054 here will always be 0. So we also pass in the sym_name
8055 parameter so that we can find the symbol associated with
8056 the personality routine. */
8057 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8058 & word
, & addr
, & sym_name
))
8064 if ((word
& 0x80000000) == 0)
8066 /* Expand prel31 for personality routine. */
8068 const char *procname
;
8070 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8071 printf (_(" Personality routine: "));
8073 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8074 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8076 procname
= aux
->strtab
+ sym_name
;
8077 print_vma (fn
, PREFIX_HEX
);
8080 fputs (" <", stdout
);
8081 fputs (procname
, stdout
);
8082 fputc ('>', stdout
);
8086 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8087 fputc ('\n', stdout
);
8089 /* The GCC personality routines use the standard compact
8090 encoding, starting with one byte giving the number of
8092 if (procname
!= NULL
8093 && (const_strneq (procname
, "__gcc_personality_v0")
8094 || const_strneq (procname
, "__gxx_personality_v0")
8095 || const_strneq (procname
, "__gcj_personality_v0")
8096 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8103 printf (_(" [Truncated data]\n"));
8106 more_words
= word
>> 24;
8116 /* ARM EHABI Section 6.3:
8118 An exception-handling table entry for the compact model looks like:
8122 1 0 index Data for personalityRoutine[index] */
8124 if (elf_header
.e_machine
== EM_ARM
8125 && (word
& 0x70000000))
8126 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8128 per_index
= (word
>> 24) & 0x7f;
8129 printf (_(" Compact model index: %d\n"), per_index
);
8136 else if (per_index
< 3)
8138 more_words
= (word
>> 16) & 0xff;
8144 switch (elf_header
.e_machine
)
8149 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8150 data_offset
, data_sec
, data_arm_sec
);
8154 warn (_("Unknown ARM compact model index encountered\n"));
8155 printf (_(" [reserved]\n"));
8162 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8163 data_offset
, data_sec
, data_arm_sec
);
8165 else if (per_index
< 5)
8167 if (((word
>> 17) & 0x7f) == 0x7f)
8168 printf (_(" Restore stack from frame pointer\n"));
8170 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8171 printf (_(" Registers restored: "));
8173 printf (" (compact) ");
8174 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8176 printf (_(" Return register: %s\n"),
8177 tic6x_unwind_regnames
[word
& 0xf]);
8180 printf (_(" [reserved (%d)]\n"), per_index
);
8184 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8185 elf_header
.e_machine
);
8188 /* Decode the descriptors. Not implemented. */
8192 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8194 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8195 unsigned int i
, exidx_len
;
8196 unsigned long j
, nfuns
;
8198 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8199 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8200 exidx_len
= exidx_sec
->sh_size
/ 8;
8202 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8203 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8204 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8205 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8207 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8209 for (i
= 0; i
< exidx_len
; i
++)
8211 unsigned int exidx_fn
, exidx_entry
;
8212 struct absaddr fn_addr
, entry_addr
;
8215 fputc ('\n', stdout
);
8217 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8218 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8219 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8220 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8223 arm_free_section (& exidx_arm_sec
);
8224 arm_free_section (& extab_arm_sec
);
8228 /* ARM EHABI, Section 5:
8229 An index table entry consists of 2 words.
8230 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8231 if (exidx_fn
& 0x80000000)
8232 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8234 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8236 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8237 fputs (": ", stdout
);
8239 if (exidx_entry
== 1)
8241 print_vma (exidx_entry
, PREFIX_HEX
);
8242 fputs (" [cantunwind]\n", stdout
);
8244 else if (exidx_entry
& 0x80000000)
8246 print_vma (exidx_entry
, PREFIX_HEX
);
8247 fputc ('\n', stdout
);
8248 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8252 bfd_vma table
, table_offset
= 0;
8253 Elf_Internal_Shdr
*table_sec
;
8255 fputs ("@", stdout
);
8256 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8257 print_vma (table
, PREFIX_HEX
);
8260 /* Locate the matching .ARM.extab. */
8261 if (entry_addr
.section
!= SHN_UNDEF
8262 && entry_addr
.section
< elf_header
.e_shnum
)
8264 table_sec
= section_headers
+ entry_addr
.section
;
8265 table_offset
= entry_addr
.offset
;
8269 table_sec
= find_section_by_address (table
);
8270 if (table_sec
!= NULL
)
8271 table_offset
= table
- table_sec
->sh_addr
;
8273 if (table_sec
== NULL
)
8275 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8276 (unsigned long) table
);
8279 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8287 arm_free_section (&exidx_arm_sec
);
8288 arm_free_section (&extab_arm_sec
);
8291 /* Used for both ARM and C6X unwinding tables. */
8294 arm_process_unwind (FILE *file
)
8296 struct arm_unw_aux_info aux
;
8297 Elf_Internal_Shdr
*unwsec
= NULL
;
8298 Elf_Internal_Shdr
*strsec
;
8299 Elf_Internal_Shdr
*sec
;
8301 unsigned int sec_type
;
8303 switch (elf_header
.e_machine
)
8306 sec_type
= SHT_ARM_EXIDX
;
8310 sec_type
= SHT_C6000_UNWIND
;
8314 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8315 elf_header
.e_machine
);
8319 if (string_table
== NULL
)
8322 memset (& aux
, 0, sizeof (aux
));
8325 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8327 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8329 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8331 strsec
= section_headers
+ sec
->sh_link
;
8333 /* PR binutils/17531 file: 011-12666-0.004. */
8334 if (aux
.strtab
!= NULL
)
8336 error (_("Multiple string tables found in file.\n"));
8339 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8340 1, strsec
->sh_size
, _("string table"));
8341 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8343 else if (sec
->sh_type
== sec_type
)
8348 printf (_("\nThere are no unwind sections in this file.\n"));
8350 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8352 if (sec
->sh_type
== sec_type
)
8354 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8355 printable_section_name (sec
),
8356 (unsigned long) sec
->sh_offset
,
8357 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8359 dump_arm_unwind (&aux
, sec
);
8366 free ((char *) aux
.strtab
);
8370 process_unwind (FILE * file
)
8372 struct unwind_handler
8375 void (* handler
)(FILE *);
8378 { EM_ARM
, arm_process_unwind
},
8379 { EM_IA_64
, ia64_process_unwind
},
8380 { EM_PARISC
, hppa_process_unwind
},
8381 { EM_TI_C6000
, arm_process_unwind
},
8389 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8390 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8392 handlers
[i
].handler (file
);
8396 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8397 get_machine_name (elf_header
.e_machine
));
8401 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8403 switch (entry
->d_tag
)
8406 if (entry
->d_un
.d_val
== 0)
8410 static const char * opts
[] =
8412 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8413 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8414 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8415 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8421 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8422 if (entry
->d_un
.d_val
& (1 << cnt
))
8424 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8430 case DT_MIPS_IVERSION
:
8431 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8432 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8436 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8437 /* Note: coded this way so that there is a single string for translation. */
8438 printf (_("<corrupt: %s>"), buf
);
8442 case DT_MIPS_TIME_STAMP
:
8446 time_t atime
= entry
->d_un
.d_val
;
8448 tmp
= gmtime (&atime
);
8449 /* PR 17531: file: 6accc532. */
8451 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8453 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8454 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8455 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8456 printf (_("Time Stamp: %s"), timebuf
);
8460 case DT_MIPS_RLD_VERSION
:
8461 case DT_MIPS_LOCAL_GOTNO
:
8462 case DT_MIPS_CONFLICTNO
:
8463 case DT_MIPS_LIBLISTNO
:
8464 case DT_MIPS_SYMTABNO
:
8465 case DT_MIPS_UNREFEXTNO
:
8466 case DT_MIPS_HIPAGENO
:
8467 case DT_MIPS_DELTA_CLASS_NO
:
8468 case DT_MIPS_DELTA_INSTANCE_NO
:
8469 case DT_MIPS_DELTA_RELOC_NO
:
8470 case DT_MIPS_DELTA_SYM_NO
:
8471 case DT_MIPS_DELTA_CLASSSYM_NO
:
8472 case DT_MIPS_COMPACT_SIZE
:
8473 print_vma (entry
->d_un
.d_ptr
, DEC
);
8477 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8483 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8485 switch (entry
->d_tag
)
8487 case DT_HP_DLD_FLAGS
:
8496 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8497 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8498 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8499 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8500 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8501 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8502 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8503 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8504 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8505 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8506 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8507 { DT_HP_GST
, "HP_GST" },
8508 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8509 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8510 { DT_HP_NODELETE
, "HP_NODELETE" },
8511 { DT_HP_GROUP
, "HP_GROUP" },
8512 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8516 bfd_vma val
= entry
->d_un
.d_val
;
8518 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8519 if (val
& flags
[cnt
].bit
)
8523 fputs (flags
[cnt
].str
, stdout
);
8525 val
^= flags
[cnt
].bit
;
8528 if (val
!= 0 || first
)
8532 print_vma (val
, HEX
);
8538 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8546 /* VMS vs Unix time offset and factor. */
8548 #define VMS_EPOCH_OFFSET 35067168000000000LL
8549 #define VMS_GRANULARITY_FACTOR 10000000
8551 /* Display a VMS time in a human readable format. */
8554 print_vms_time (bfd_int64_t vmstime
)
8559 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8560 tm
= gmtime (&unxtime
);
8561 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8562 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8563 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8568 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8570 switch (entry
->d_tag
)
8572 case DT_IA_64_PLT_RESERVE
:
8573 /* First 3 slots reserved. */
8574 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8576 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8579 case DT_IA_64_VMS_LINKTIME
:
8581 print_vms_time (entry
->d_un
.d_val
);
8585 case DT_IA_64_VMS_LNKFLAGS
:
8586 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8587 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8588 printf (" CALL_DEBUG");
8589 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8590 printf (" NOP0BUFS");
8591 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8592 printf (" P0IMAGE");
8593 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8594 printf (" MKTHREADS");
8595 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8596 printf (" UPCALLS");
8597 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8599 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8600 printf (" INITIALIZE");
8601 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8603 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8604 printf (" EXE_INIT");
8605 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8606 printf (" TBK_IN_IMG");
8607 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8608 printf (" DBG_IN_IMG");
8609 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8610 printf (" TBK_IN_DSF");
8611 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8612 printf (" DBG_IN_DSF");
8613 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8614 printf (" SIGNATURES");
8615 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8616 printf (" REL_SEG_OFF");
8620 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8627 get_32bit_dynamic_section (FILE * file
)
8629 Elf32_External_Dyn
* edyn
;
8630 Elf32_External_Dyn
* ext
;
8631 Elf_Internal_Dyn
* entry
;
8633 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8634 dynamic_size
, _("dynamic section"));
8638 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8639 might not have the luxury of section headers. Look for the DT_NULL
8640 terminator to determine the number of entries. */
8641 for (ext
= edyn
, dynamic_nent
= 0;
8642 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8646 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8650 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8652 if (dynamic_section
== NULL
)
8654 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8655 (unsigned long) dynamic_nent
);
8660 for (ext
= edyn
, entry
= dynamic_section
;
8661 entry
< dynamic_section
+ dynamic_nent
;
8664 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8665 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8674 get_64bit_dynamic_section (FILE * file
)
8676 Elf64_External_Dyn
* edyn
;
8677 Elf64_External_Dyn
* ext
;
8678 Elf_Internal_Dyn
* entry
;
8680 /* Read in the data. */
8681 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8682 dynamic_size
, _("dynamic section"));
8686 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8687 might not have the luxury of section headers. Look for the DT_NULL
8688 terminator to determine the number of entries. */
8689 for (ext
= edyn
, dynamic_nent
= 0;
8690 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8691 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8695 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8699 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8701 if (dynamic_section
== NULL
)
8703 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8704 (unsigned long) dynamic_nent
);
8709 /* Convert from external to internal formats. */
8710 for (ext
= edyn
, entry
= dynamic_section
;
8711 entry
< dynamic_section
+ dynamic_nent
;
8714 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8715 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8724 print_dynamic_flags (bfd_vma flags
)
8732 flag
= flags
& - flags
;
8742 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8743 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8744 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8745 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8746 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8747 default: fputs (_("unknown"), stdout
); break;
8753 /* Parse and display the contents of the dynamic section. */
8756 process_dynamic_section (FILE * file
)
8758 Elf_Internal_Dyn
* entry
;
8760 if (dynamic_size
== 0)
8763 printf (_("\nThere is no dynamic section in this file.\n"));
8770 if (! get_32bit_dynamic_section (file
))
8773 else if (! get_64bit_dynamic_section (file
))
8776 /* Find the appropriate symbol table. */
8777 if (dynamic_symbols
== NULL
)
8779 for (entry
= dynamic_section
;
8780 entry
< dynamic_section
+ dynamic_nent
;
8783 Elf_Internal_Shdr section
;
8785 if (entry
->d_tag
!= DT_SYMTAB
)
8788 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8790 /* Since we do not know how big the symbol table is,
8791 we default to reading in the entire file (!) and
8792 processing that. This is overkill, I know, but it
8794 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8796 if (archive_file_offset
!= 0)
8797 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8800 if (fseek (file
, 0, SEEK_END
))
8801 error (_("Unable to seek to end of file!\n"));
8803 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8807 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8809 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8810 section
.sh_name
= string_table_length
;
8812 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8813 if (num_dynamic_syms
< 1)
8815 error (_("Unable to determine the number of symbols to load\n"));
8821 /* Similarly find a string table. */
8822 if (dynamic_strings
== NULL
)
8824 for (entry
= dynamic_section
;
8825 entry
< dynamic_section
+ dynamic_nent
;
8828 unsigned long offset
;
8831 if (entry
->d_tag
!= DT_STRTAB
)
8834 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8836 /* Since we do not know how big the string table is,
8837 we default to reading in the entire file (!) and
8838 processing that. This is overkill, I know, but it
8841 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8843 if (archive_file_offset
!= 0)
8844 str_tab_len
= archive_file_size
- offset
;
8847 if (fseek (file
, 0, SEEK_END
))
8848 error (_("Unable to seek to end of file\n"));
8849 str_tab_len
= ftell (file
) - offset
;
8852 if (str_tab_len
< 1)
8855 (_("Unable to determine the length of the dynamic string table\n"));
8859 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8861 _("dynamic string table"));
8862 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8867 /* And find the syminfo section if available. */
8868 if (dynamic_syminfo
== NULL
)
8870 unsigned long syminsz
= 0;
8872 for (entry
= dynamic_section
;
8873 entry
< dynamic_section
+ dynamic_nent
;
8876 if (entry
->d_tag
== DT_SYMINENT
)
8878 /* Note: these braces are necessary to avoid a syntax
8879 error from the SunOS4 C compiler. */
8880 /* PR binutils/17531: A corrupt file can trigger this test.
8881 So do not use an assert, instead generate an error message. */
8882 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8883 error (_("Bad value (%d) for SYMINENT entry\n"),
8884 (int) entry
->d_un
.d_val
);
8886 else if (entry
->d_tag
== DT_SYMINSZ
)
8887 syminsz
= entry
->d_un
.d_val
;
8888 else if (entry
->d_tag
== DT_SYMINFO
)
8889 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8893 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8895 Elf_External_Syminfo
* extsyminfo
;
8896 Elf_External_Syminfo
* extsym
;
8897 Elf_Internal_Syminfo
* syminfo
;
8899 /* There is a syminfo section. Read the data. */
8900 extsyminfo
= (Elf_External_Syminfo
*)
8901 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8902 _("symbol information"));
8906 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8907 if (dynamic_syminfo
== NULL
)
8909 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8910 (unsigned long) syminsz
);
8914 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8915 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8916 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8917 ++syminfo
, ++extsym
)
8919 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8920 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8927 if (do_dynamic
&& dynamic_addr
)
8928 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8929 dynamic_addr
, (unsigned long) dynamic_nent
);
8931 printf (_(" Tag Type Name/Value\n"));
8933 for (entry
= dynamic_section
;
8934 entry
< dynamic_section
+ dynamic_nent
;
8942 print_vma (entry
->d_tag
, FULL_HEX
);
8943 dtype
= get_dynamic_type (entry
->d_tag
);
8944 printf (" (%s)%*s", dtype
,
8945 ((is_32bit_elf
? 27 : 19)
8946 - (int) strlen (dtype
)),
8950 switch (entry
->d_tag
)
8954 print_dynamic_flags (entry
->d_un
.d_val
);
8964 switch (entry
->d_tag
)
8967 printf (_("Auxiliary library"));
8971 printf (_("Filter library"));
8975 printf (_("Configuration file"));
8979 printf (_("Dependency audit library"));
8983 printf (_("Audit library"));
8987 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8988 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8992 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9001 printf (_("Flags:"));
9003 if (entry
->d_un
.d_val
== 0)
9004 printf (_(" None\n"));
9007 unsigned long int val
= entry
->d_un
.d_val
;
9009 if (val
& DTF_1_PARINIT
)
9011 printf (" PARINIT");
9012 val
^= DTF_1_PARINIT
;
9014 if (val
& DTF_1_CONFEXP
)
9016 printf (" CONFEXP");
9017 val
^= DTF_1_CONFEXP
;
9020 printf (" %lx", val
);
9029 printf (_("Flags:"));
9031 if (entry
->d_un
.d_val
== 0)
9032 printf (_(" None\n"));
9035 unsigned long int val
= entry
->d_un
.d_val
;
9037 if (val
& DF_P1_LAZYLOAD
)
9039 printf (" LAZYLOAD");
9040 val
^= DF_P1_LAZYLOAD
;
9042 if (val
& DF_P1_GROUPPERM
)
9044 printf (" GROUPPERM");
9045 val
^= DF_P1_GROUPPERM
;
9048 printf (" %lx", val
);
9057 printf (_("Flags:"));
9058 if (entry
->d_un
.d_val
== 0)
9059 printf (_(" None\n"));
9062 unsigned long int val
= entry
->d_un
.d_val
;
9069 if (val
& DF_1_GLOBAL
)
9074 if (val
& DF_1_GROUP
)
9079 if (val
& DF_1_NODELETE
)
9081 printf (" NODELETE");
9082 val
^= DF_1_NODELETE
;
9084 if (val
& DF_1_LOADFLTR
)
9086 printf (" LOADFLTR");
9087 val
^= DF_1_LOADFLTR
;
9089 if (val
& DF_1_INITFIRST
)
9091 printf (" INITFIRST");
9092 val
^= DF_1_INITFIRST
;
9094 if (val
& DF_1_NOOPEN
)
9099 if (val
& DF_1_ORIGIN
)
9104 if (val
& DF_1_DIRECT
)
9109 if (val
& DF_1_TRANS
)
9114 if (val
& DF_1_INTERPOSE
)
9116 printf (" INTERPOSE");
9117 val
^= DF_1_INTERPOSE
;
9119 if (val
& DF_1_NODEFLIB
)
9121 printf (" NODEFLIB");
9122 val
^= DF_1_NODEFLIB
;
9124 if (val
& DF_1_NODUMP
)
9129 if (val
& DF_1_CONFALT
)
9131 printf (" CONFALT");
9132 val
^= DF_1_CONFALT
;
9134 if (val
& DF_1_ENDFILTEE
)
9136 printf (" ENDFILTEE");
9137 val
^= DF_1_ENDFILTEE
;
9139 if (val
& DF_1_DISPRELDNE
)
9141 printf (" DISPRELDNE");
9142 val
^= DF_1_DISPRELDNE
;
9144 if (val
& DF_1_DISPRELPND
)
9146 printf (" DISPRELPND");
9147 val
^= DF_1_DISPRELPND
;
9149 if (val
& DF_1_NODIRECT
)
9151 printf (" NODIRECT");
9152 val
^= DF_1_NODIRECT
;
9154 if (val
& DF_1_IGNMULDEF
)
9156 printf (" IGNMULDEF");
9157 val
^= DF_1_IGNMULDEF
;
9159 if (val
& DF_1_NOKSYMS
)
9161 printf (" NOKSYMS");
9162 val
^= DF_1_NOKSYMS
;
9164 if (val
& DF_1_NOHDR
)
9169 if (val
& DF_1_EDITED
)
9174 if (val
& DF_1_NORELOC
)
9176 printf (" NORELOC");
9177 val
^= DF_1_NORELOC
;
9179 if (val
& DF_1_SYMINTPOSE
)
9181 printf (" SYMINTPOSE");
9182 val
^= DF_1_SYMINTPOSE
;
9184 if (val
& DF_1_GLOBAUDIT
)
9186 printf (" GLOBAUDIT");
9187 val
^= DF_1_GLOBAUDIT
;
9189 if (val
& DF_1_SINGLETON
)
9191 printf (" SINGLETON");
9192 val
^= DF_1_SINGLETON
;
9195 printf (" %lx", val
);
9202 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9204 puts (get_dynamic_type (entry
->d_un
.d_val
));
9224 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9230 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9231 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9237 switch (entry
->d_tag
)
9240 printf (_("Shared library: [%s]"), name
);
9242 if (streq (name
, program_interpreter
))
9243 printf (_(" program interpreter"));
9247 printf (_("Library soname: [%s]"), name
);
9251 printf (_("Library rpath: [%s]"), name
);
9255 printf (_("Library runpath: [%s]"), name
);
9259 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9264 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9277 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9281 case DT_INIT_ARRAYSZ
:
9282 case DT_FINI_ARRAYSZ
:
9283 case DT_GNU_CONFLICTSZ
:
9284 case DT_GNU_LIBLISTSZ
:
9287 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9288 printf (_(" (bytes)\n"));
9298 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9311 if (entry
->d_tag
== DT_USED
9312 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9314 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9318 printf (_("Not needed object: [%s]\n"), name
);
9323 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9329 /* The value of this entry is ignored. */
9334 case DT_GNU_PRELINKED
:
9338 time_t atime
= entry
->d_un
.d_val
;
9340 tmp
= gmtime (&atime
);
9341 /* PR 17533 file: 041-1244816-0.004. */
9343 printf (_("<corrupt time val: %lx"),
9344 (unsigned long) atime
);
9346 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9347 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9348 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9354 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9357 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9363 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9364 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9369 switch (elf_header
.e_machine
)
9372 case EM_MIPS_RS3_LE
:
9373 dynamic_section_mips_val (entry
);
9376 dynamic_section_parisc_val (entry
);
9379 dynamic_section_ia64_val (entry
);
9382 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9394 get_ver_flags (unsigned int flags
)
9396 static char buff
[32];
9403 if (flags
& VER_FLG_BASE
)
9404 strcat (buff
, "BASE ");
9406 if (flags
& VER_FLG_WEAK
)
9408 if (flags
& VER_FLG_BASE
)
9409 strcat (buff
, "| ");
9411 strcat (buff
, "WEAK ");
9414 if (flags
& VER_FLG_INFO
)
9416 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9417 strcat (buff
, "| ");
9419 strcat (buff
, "INFO ");
9422 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9423 strcat (buff
, _("| <unknown>"));
9428 /* Display the contents of the version sections. */
9431 process_version_sections (FILE * file
)
9433 Elf_Internal_Shdr
* section
;
9440 for (i
= 0, section
= section_headers
;
9441 i
< elf_header
.e_shnum
;
9444 switch (section
->sh_type
)
9446 case SHT_GNU_verdef
:
9448 Elf_External_Verdef
* edefs
;
9455 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9456 printable_section_name (section
),
9459 printf (_(" Addr: 0x"));
9460 printf_vma (section
->sh_addr
);
9461 printf (_(" Offset: %#08lx Link: %u (%s)"),
9462 (unsigned long) section
->sh_offset
, section
->sh_link
,
9463 printable_section_name_from_index (section
->sh_link
));
9465 edefs
= (Elf_External_Verdef
*)
9466 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9467 _("version definition section"));
9470 endbuf
= (char *) edefs
+ section
->sh_size
;
9472 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9475 Elf_External_Verdef
* edef
;
9476 Elf_Internal_Verdef ent
;
9477 Elf_External_Verdaux
* eaux
;
9478 Elf_Internal_Verdaux aux
;
9482 /* Check for very large indicies. */
9483 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9486 vstart
= ((char *) edefs
) + idx
;
9487 if (vstart
+ sizeof (*edef
) > endbuf
)
9490 edef
= (Elf_External_Verdef
*) vstart
;
9492 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9493 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9494 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9495 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9496 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9497 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9498 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9500 printf (_(" %#06x: Rev: %d Flags: %s"),
9501 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9503 printf (_(" Index: %d Cnt: %d "),
9504 ent
.vd_ndx
, ent
.vd_cnt
);
9506 /* Check for overflow. */
9507 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9510 vstart
+= ent
.vd_aux
;
9512 eaux
= (Elf_External_Verdaux
*) vstart
;
9514 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9515 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9517 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9518 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9520 printf (_("Name index: %ld\n"), aux
.vda_name
);
9522 isum
= idx
+ ent
.vd_aux
;
9524 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9526 /* Check for overflow. */
9527 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9530 isum
+= aux
.vda_next
;
9531 vstart
+= aux
.vda_next
;
9533 eaux
= (Elf_External_Verdaux
*) vstart
;
9534 if (vstart
+ sizeof (*eaux
) > endbuf
)
9537 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9538 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9540 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9541 printf (_(" %#06x: Parent %d: %s\n"),
9542 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9544 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9545 isum
, j
, aux
.vda_name
);
9549 printf (_(" Version def aux past end of section\n"));
9551 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9552 if (idx
+ ent
.vd_next
<= idx
)
9558 if (cnt
< section
->sh_info
)
9559 printf (_(" Version definition past end of section\n"));
9565 case SHT_GNU_verneed
:
9567 Elf_External_Verneed
* eneed
;
9574 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9575 printable_section_name (section
), section
->sh_info
);
9577 printf (_(" Addr: 0x"));
9578 printf_vma (section
->sh_addr
);
9579 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9580 (unsigned long) section
->sh_offset
, section
->sh_link
,
9581 printable_section_name_from_index (section
->sh_link
));
9583 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9584 section
->sh_offset
, 1,
9586 _("Version Needs section"));
9589 endbuf
= (char *) eneed
+ section
->sh_size
;
9591 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9593 Elf_External_Verneed
* entry
;
9594 Elf_Internal_Verneed ent
;
9599 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9602 vstart
= ((char *) eneed
) + idx
;
9603 if (vstart
+ sizeof (*entry
) > endbuf
)
9606 entry
= (Elf_External_Verneed
*) vstart
;
9608 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9609 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9610 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9611 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9612 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9614 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9616 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9617 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9619 printf (_(" File: %lx"), ent
.vn_file
);
9621 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9623 /* Check for overflow. */
9624 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9626 vstart
+= ent
.vn_aux
;
9628 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9630 Elf_External_Vernaux
* eaux
;
9631 Elf_Internal_Vernaux aux
;
9633 if (vstart
+ sizeof (*eaux
) > endbuf
)
9635 eaux
= (Elf_External_Vernaux
*) vstart
;
9637 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9638 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9639 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9640 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9641 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9643 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9644 printf (_(" %#06x: Name: %s"),
9645 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9647 printf (_(" %#06x: Name index: %lx"),
9648 isum
, aux
.vna_name
);
9650 printf (_(" Flags: %s Version: %d\n"),
9651 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9653 /* Check for overflow. */
9654 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9655 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9657 warn (_("Invalid vna_next field of %lx\n"),
9662 isum
+= aux
.vna_next
;
9663 vstart
+= aux
.vna_next
;
9667 warn (_("Missing Version Needs auxillary information\n"));
9669 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9671 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9672 cnt
= section
->sh_info
;
9678 if (cnt
< section
->sh_info
)
9679 warn (_("Missing Version Needs information\n"));
9685 case SHT_GNU_versym
:
9687 Elf_Internal_Shdr
* link_section
;
9690 unsigned char * edata
;
9691 unsigned short * data
;
9693 Elf_Internal_Sym
* symbols
;
9694 Elf_Internal_Shdr
* string_sec
;
9695 unsigned long num_syms
;
9698 if (section
->sh_link
>= elf_header
.e_shnum
)
9701 link_section
= section_headers
+ section
->sh_link
;
9702 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9704 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9709 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9710 if (symbols
== NULL
)
9713 string_sec
= section_headers
+ link_section
->sh_link
;
9715 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9716 string_sec
->sh_size
,
9717 _("version string table"));
9724 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9725 printable_section_name (section
), (unsigned long) total
);
9727 printf (_(" Addr: "));
9728 printf_vma (section
->sh_addr
);
9729 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9730 (unsigned long) section
->sh_offset
, section
->sh_link
,
9731 printable_section_name (link_section
));
9733 off
= offset_from_vma (file
,
9734 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9735 total
* sizeof (short));
9736 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9738 _("version symbol data"));
9746 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9748 for (cnt
= total
; cnt
--;)
9749 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9754 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9757 int check_def
, check_need
;
9760 printf (" %03x:", cnt
);
9762 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9763 switch (data
[cnt
+ j
])
9766 fputs (_(" 0 (*local*) "), stdout
);
9770 fputs (_(" 1 (*global*) "), stdout
);
9774 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9775 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9777 /* If this index value is greater than the size of the symbols
9778 array, break to avoid an out-of-bounds read. */
9779 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9781 warn (_("invalid index into symbol array\n"));
9787 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9788 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9791 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9798 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9800 Elf_Internal_Verneed ivn
;
9801 unsigned long offset
;
9803 offset
= offset_from_vma
9804 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9805 sizeof (Elf_External_Verneed
));
9809 Elf_Internal_Vernaux ivna
;
9810 Elf_External_Verneed evn
;
9811 Elf_External_Vernaux evna
;
9812 unsigned long a_off
;
9814 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9815 _("version need")) == NULL
)
9818 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9819 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9821 a_off
= offset
+ ivn
.vn_aux
;
9825 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9826 1, _("version need aux (2)")) == NULL
)
9833 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9834 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9837 a_off
+= ivna
.vna_next
;
9839 while (ivna
.vna_other
!= data
[cnt
+ j
]
9840 && ivna
.vna_next
!= 0);
9842 if (ivna
.vna_other
== data
[cnt
+ j
])
9844 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9846 if (ivna
.vna_name
>= string_sec
->sh_size
)
9847 name
= _("*invalid*");
9849 name
= strtab
+ ivna
.vna_name
;
9850 nn
+= printf ("(%s%-*s",
9852 12 - (int) strlen (name
),
9858 offset
+= ivn
.vn_next
;
9860 while (ivn
.vn_next
);
9863 if (check_def
&& data
[cnt
+ j
] != 0x8001
9864 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9866 Elf_Internal_Verdef ivd
;
9867 Elf_External_Verdef evd
;
9868 unsigned long offset
;
9870 offset
= offset_from_vma
9871 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9876 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9877 _("version def")) == NULL
)
9880 /* PR 17531: file: 046-1082287-0.004. */
9881 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9886 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9887 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9890 offset
+= ivd
.vd_next
;
9892 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9893 && ivd
.vd_next
!= 0);
9895 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9897 Elf_External_Verdaux evda
;
9898 Elf_Internal_Verdaux ivda
;
9900 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9902 if (get_data (&evda
, file
,
9903 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9905 _("version def aux")) == NULL
)
9908 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9910 if (ivda
.vda_name
>= string_sec
->sh_size
)
9911 name
= _("*invalid*");
9913 name
= strtab
+ ivda
.vda_name
;
9914 nn
+= printf ("(%s%-*s",
9916 12 - (int) strlen (name
),
9922 printf ("%*c", 18 - nn
, ' ');
9940 printf (_("\nNo version information found in this file.\n"));
9946 get_symbol_binding (unsigned int binding
)
9948 static char buff
[32];
9952 case STB_LOCAL
: return "LOCAL";
9953 case STB_GLOBAL
: return "GLOBAL";
9954 case STB_WEAK
: return "WEAK";
9956 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9957 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9959 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9961 if (binding
== STB_GNU_UNIQUE
9962 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9963 /* GNU is still using the default value 0. */
9964 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9966 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9969 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9975 get_symbol_type (unsigned int type
)
9977 static char buff
[32];
9981 case STT_NOTYPE
: return "NOTYPE";
9982 case STT_OBJECT
: return "OBJECT";
9983 case STT_FUNC
: return "FUNC";
9984 case STT_SECTION
: return "SECTION";
9985 case STT_FILE
: return "FILE";
9986 case STT_COMMON
: return "COMMON";
9987 case STT_TLS
: return "TLS";
9988 case STT_RELC
: return "RELC";
9989 case STT_SRELC
: return "SRELC";
9991 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9993 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9994 return "THUMB_FUNC";
9996 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9999 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10000 return "PARISC_MILLI";
10002 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10004 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10006 if (elf_header
.e_machine
== EM_PARISC
)
10008 if (type
== STT_HP_OPAQUE
)
10009 return "HP_OPAQUE";
10010 if (type
== STT_HP_STUB
)
10014 if (type
== STT_GNU_IFUNC
10015 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10016 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10017 /* GNU is still using the default value 0. */
10018 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10021 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10024 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10029 static const char *
10030 get_symbol_visibility (unsigned int visibility
)
10032 switch (visibility
)
10034 case STV_DEFAULT
: return "DEFAULT";
10035 case STV_INTERNAL
: return "INTERNAL";
10036 case STV_HIDDEN
: return "HIDDEN";
10037 case STV_PROTECTED
: return "PROTECTED";
10039 error (_("Unrecognized visibility value: %u"), visibility
);
10040 return _("<unknown>");
10044 static const char *
10045 get_mips_symbol_other (unsigned int other
)
10055 case STO_MICROMIPS
:
10056 return "MICROMIPS";
10057 case STO_MICROMIPS
| STO_MIPS_PIC
:
10058 return "MICROMIPS, MIPS PIC";
10066 static const char *
10067 get_ia64_symbol_other (unsigned int other
)
10069 if (is_ia64_vms ())
10071 static char res
[32];
10075 /* Function types is for images and .STB files only. */
10076 switch (elf_header
.e_type
)
10080 switch (VMS_ST_FUNC_TYPE (other
))
10082 case VMS_SFT_CODE_ADDR
:
10083 strcat (res
, " CA");
10085 case VMS_SFT_SYMV_IDX
:
10086 strcat (res
, " VEC");
10089 strcat (res
, " FD");
10091 case VMS_SFT_RESERVE
:
10092 strcat (res
, " RSV");
10095 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10096 VMS_ST_FUNC_TYPE (other
));
10097 strcat (res
, " <unknown>");
10104 switch (VMS_ST_LINKAGE (other
))
10106 case VMS_STL_IGNORE
:
10107 strcat (res
, " IGN");
10109 case VMS_STL_RESERVE
:
10110 strcat (res
, " RSV");
10113 strcat (res
, " STD");
10116 strcat (res
, " LNK");
10119 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10120 VMS_ST_LINKAGE (other
));
10121 strcat (res
, " <unknown>");
10133 static const char *
10134 get_ppc64_symbol_other (unsigned int other
)
10136 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10138 static char buf
[32];
10139 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10140 PPC64_LOCAL_ENTRY_OFFSET (other
));
10146 static const char *
10147 get_symbol_other (unsigned int other
)
10149 const char * result
= NULL
;
10150 static char buff
[32];
10155 switch (elf_header
.e_machine
)
10158 result
= get_mips_symbol_other (other
);
10161 result
= get_ia64_symbol_other (other
);
10164 result
= get_ppc64_symbol_other (other
);
10173 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10177 static const char *
10178 get_symbol_index_type (unsigned int type
)
10180 static char buff
[32];
10184 case SHN_UNDEF
: return "UND";
10185 case SHN_ABS
: return "ABS";
10186 case SHN_COMMON
: return "COM";
10188 if (type
== SHN_IA_64_ANSI_COMMON
10189 && elf_header
.e_machine
== EM_IA_64
10190 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10192 else if ((elf_header
.e_machine
== EM_X86_64
10193 || elf_header
.e_machine
== EM_L1OM
10194 || elf_header
.e_machine
== EM_K1OM
)
10195 && type
== SHN_X86_64_LCOMMON
)
10196 return "LARGE_COM";
10197 else if ((type
== SHN_MIPS_SCOMMON
10198 && elf_header
.e_machine
== EM_MIPS
)
10199 || (type
== SHN_TIC6X_SCOMMON
10200 && elf_header
.e_machine
== EM_TI_C6000
))
10202 else if (type
== SHN_MIPS_SUNDEFINED
10203 && elf_header
.e_machine
== EM_MIPS
)
10205 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10206 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10207 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10208 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10209 else if (type
>= SHN_LORESERVE
)
10210 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10211 else if (type
>= elf_header
.e_shnum
)
10212 sprintf (buff
, _("bad section index[%3d]"), type
);
10214 sprintf (buff
, "%3d", type
);
10222 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10224 unsigned char * e_data
;
10227 /* If the size_t type is smaller than the bfd_size_type, eg because
10228 you are building a 32-bit tool on a 64-bit host, then make sure
10229 that when (number) is cast to (size_t) no information is lost. */
10230 if (sizeof (size_t) < sizeof (bfd_size_type
)
10231 && (bfd_size_type
) ((size_t) number
) != number
)
10233 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10234 (unsigned long long) number
, ent_size
);
10238 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10239 attempting to allocate memory when the read is bound to fail. */
10240 if (ent_size
* number
> current_file_size
)
10242 error (_("Invalid number of dynamic entries: %llu\n"),
10243 (unsigned long long) number
);
10247 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10248 if (e_data
== NULL
)
10250 error (_("Out of memory reading %llu dynamic entries\n"),
10251 (unsigned long long) number
);
10255 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10257 error (_("Unable to read in %llu bytes of dynamic data\n"),
10258 (unsigned long long) (number
* ent_size
));
10263 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10264 if (i_data
== NULL
)
10266 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10267 (unsigned long long) number
);
10273 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10281 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10283 Elf_Internal_Sym
* psym
;
10286 n
= print_vma (si
, DEC_5
);
10288 fputs (&" "[n
], stdout
);
10289 printf (" %3lu: ", hn
);
10291 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10293 printf (_("<No info available for dynamic symbol number %lu>\n"),
10294 (unsigned long) si
);
10298 psym
= dynamic_symbols
+ si
;
10299 print_vma (psym
->st_value
, LONG_HEX
);
10301 print_vma (psym
->st_size
, DEC_5
);
10303 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10304 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10305 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10306 /* Check to see if any other bits in the st_other field are set.
10307 Note - displaying this information disrupts the layout of the
10308 table being generated, but for the moment this case is very
10310 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10311 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10312 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10313 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10314 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10316 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10320 static const char *
10321 get_symbol_version_string (FILE *file
, int is_dynsym
,
10322 const char *strtab
,
10323 unsigned long int strtab_size
,
10324 unsigned int si
, Elf_Internal_Sym
*psym
,
10325 enum versioned_symbol_info
*sym_info
,
10326 unsigned short *vna_other
)
10328 const char *version_string
= NULL
;
10331 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10333 unsigned char data
[2];
10334 unsigned short vers_data
;
10335 unsigned long offset
;
10339 offset
= offset_from_vma
10340 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10341 sizeof data
+ si
* sizeof (vers_data
));
10343 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10344 sizeof (data
), 1, _("version data")) == NULL
)
10347 vers_data
= byte_get (data
, 2);
10349 is_nobits
= (section_headers
!= NULL
10350 && psym
->st_shndx
< elf_header
.e_shnum
10351 && section_headers
[psym
->st_shndx
].sh_type
10354 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10356 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10358 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10359 && (is_nobits
|| ! check_def
))
10361 Elf_External_Verneed evn
;
10362 Elf_Internal_Verneed ivn
;
10363 Elf_Internal_Vernaux ivna
;
10365 /* We must test both. */
10366 offset
= offset_from_vma
10367 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10372 unsigned long vna_off
;
10374 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10375 _("version need")) == NULL
)
10378 ivna
.vna_other
= 0;
10383 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10384 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10386 vna_off
= offset
+ ivn
.vn_aux
;
10390 Elf_External_Vernaux evna
;
10392 if (get_data (&evna
, file
, vna_off
,
10394 _("version need aux (3)")) == NULL
)
10397 ivna
.vna_other
= 0;
10402 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10403 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10404 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10407 vna_off
+= ivna
.vna_next
;
10409 while (ivna
.vna_other
!= vers_data
10410 && ivna
.vna_next
!= 0);
10412 if (ivna
.vna_other
== vers_data
)
10415 offset
+= ivn
.vn_next
;
10417 while (ivn
.vn_next
!= 0);
10419 if (ivna
.vna_other
== vers_data
)
10421 *sym_info
= symbol_undefined
;
10422 *vna_other
= ivna
.vna_other
;
10423 version_string
= (ivna
.vna_name
< strtab_size
10424 ? strtab
+ ivna
.vna_name
10428 else if (! is_nobits
)
10429 error (_("bad dynamic symbol\n"));
10436 if (vers_data
!= 0x8001
10437 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10439 Elf_Internal_Verdef ivd
;
10440 Elf_Internal_Verdaux ivda
;
10441 Elf_External_Verdaux evda
;
10444 off
= offset_from_vma
10446 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10447 sizeof (Elf_External_Verdef
));
10451 Elf_External_Verdef evd
;
10453 if (get_data (&evd
, file
, off
, sizeof (evd
),
10454 1, _("version def")) == NULL
)
10462 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10463 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10464 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10467 off
+= ivd
.vd_next
;
10469 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10470 && ivd
.vd_next
!= 0);
10472 off
-= ivd
.vd_next
;
10475 if (get_data (&evda
, file
, off
, sizeof (evda
),
10476 1, _("version def aux")) == NULL
)
10477 return version_string
;
10479 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10481 if (psym
->st_name
!= ivda
.vda_name
)
10483 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10484 ? symbol_hidden
: symbol_public
);
10485 version_string
= (ivda
.vda_name
< strtab_size
10486 ? strtab
+ ivda
.vda_name
10493 return version_string
;
10496 /* Dump the symbol table. */
10498 process_symbol_table (FILE * file
)
10500 Elf_Internal_Shdr
* section
;
10501 bfd_size_type nbuckets
= 0;
10502 bfd_size_type nchains
= 0;
10503 bfd_vma
* buckets
= NULL
;
10504 bfd_vma
* chains
= NULL
;
10505 bfd_vma ngnubuckets
= 0;
10506 bfd_vma
* gnubuckets
= NULL
;
10507 bfd_vma
* gnuchains
= NULL
;
10508 bfd_vma gnusymidx
= 0;
10509 bfd_size_type ngnuchains
= 0;
10511 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10514 if (dynamic_info
[DT_HASH
]
10516 || (do_using_dynamic
10518 && dynamic_strings
!= NULL
)))
10520 unsigned char nb
[8];
10521 unsigned char nc
[8];
10522 unsigned int hash_ent_size
= 4;
10524 if ((elf_header
.e_machine
== EM_ALPHA
10525 || elf_header
.e_machine
== EM_S390
10526 || elf_header
.e_machine
== EM_S390_OLD
)
10527 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10531 (archive_file_offset
10532 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10533 sizeof nb
+ sizeof nc
)),
10536 error (_("Unable to seek to start of dynamic information\n"));
10540 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10542 error (_("Failed to read in number of buckets\n"));
10546 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10548 error (_("Failed to read in number of chains\n"));
10552 nbuckets
= byte_get (nb
, hash_ent_size
);
10553 nchains
= byte_get (nc
, hash_ent_size
);
10555 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10556 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10559 if (buckets
== NULL
|| chains
== NULL
)
10561 if (do_using_dynamic
)
10572 if (dynamic_info_DT_GNU_HASH
10574 || (do_using_dynamic
10576 && dynamic_strings
!= NULL
)))
10578 unsigned char nb
[16];
10579 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10580 bfd_vma buckets_vma
;
10583 (archive_file_offset
10584 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10588 error (_("Unable to seek to start of dynamic information\n"));
10592 if (fread (nb
, 16, 1, file
) != 1)
10594 error (_("Failed to read in number of buckets\n"));
10598 ngnubuckets
= byte_get (nb
, 4);
10599 gnusymidx
= byte_get (nb
+ 4, 4);
10600 bitmaskwords
= byte_get (nb
+ 8, 4);
10601 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10603 buckets_vma
+= bitmaskwords
* 4;
10605 buckets_vma
+= bitmaskwords
* 8;
10608 (archive_file_offset
10609 + offset_from_vma (file
, buckets_vma
, 4)),
10612 error (_("Unable to seek to start of dynamic information\n"));
10616 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10618 if (gnubuckets
== NULL
)
10621 for (i
= 0; i
< ngnubuckets
; i
++)
10622 if (gnubuckets
[i
] != 0)
10624 if (gnubuckets
[i
] < gnusymidx
)
10627 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10628 maxchain
= gnubuckets
[i
];
10631 if (maxchain
== 0xffffffff)
10634 maxchain
-= gnusymidx
;
10637 (archive_file_offset
10638 + offset_from_vma (file
, buckets_vma
10639 + 4 * (ngnubuckets
+ maxchain
), 4)),
10642 error (_("Unable to seek to start of dynamic information\n"));
10648 if (fread (nb
, 4, 1, file
) != 1)
10650 error (_("Failed to determine last chain length\n"));
10654 if (maxchain
+ 1 == 0)
10659 while ((byte_get (nb
, 4) & 1) == 0);
10662 (archive_file_offset
10663 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10666 error (_("Unable to seek to start of dynamic information\n"));
10670 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10671 ngnuchains
= maxchain
;
10674 if (gnuchains
== NULL
)
10679 if (do_using_dynamic
)
10684 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10686 && do_using_dynamic
10687 && dynamic_strings
!= NULL
10688 && dynamic_symbols
!= NULL
)
10692 if (dynamic_info
[DT_HASH
])
10696 printf (_("\nSymbol table for image:\n"));
10698 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10700 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10702 for (hn
= 0; hn
< nbuckets
; hn
++)
10707 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10708 print_dynamic_symbol (si
, hn
);
10712 if (dynamic_info_DT_GNU_HASH
)
10714 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10716 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10718 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10720 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10721 if (gnubuckets
[hn
] != 0)
10723 bfd_vma si
= gnubuckets
[hn
];
10724 bfd_vma off
= si
- gnusymidx
;
10728 print_dynamic_symbol (si
, hn
);
10731 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10735 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10736 && section_headers
!= NULL
)
10740 for (i
= 0, section
= section_headers
;
10741 i
< elf_header
.e_shnum
;
10745 char * strtab
= NULL
;
10746 unsigned long int strtab_size
= 0;
10747 Elf_Internal_Sym
* symtab
;
10748 Elf_Internal_Sym
* psym
;
10749 unsigned long num_syms
;
10751 if ((section
->sh_type
!= SHT_SYMTAB
10752 && section
->sh_type
!= SHT_DYNSYM
)
10754 && section
->sh_type
== SHT_SYMTAB
))
10757 if (section
->sh_entsize
== 0)
10759 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10760 printable_section_name (section
));
10764 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10765 printable_section_name (section
),
10766 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10769 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10771 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10773 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10774 if (symtab
== NULL
)
10777 if (section
->sh_link
== elf_header
.e_shstrndx
)
10779 strtab
= string_table
;
10780 strtab_size
= string_table_length
;
10782 else if (section
->sh_link
< elf_header
.e_shnum
)
10784 Elf_Internal_Shdr
* string_sec
;
10786 string_sec
= section_headers
+ section
->sh_link
;
10788 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10789 1, string_sec
->sh_size
,
10790 _("string table"));
10791 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10794 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10796 const char *version_string
;
10797 enum versioned_symbol_info sym_info
;
10798 unsigned short vna_other
;
10800 printf ("%6d: ", si
);
10801 print_vma (psym
->st_value
, LONG_HEX
);
10803 print_vma (psym
->st_size
, DEC_5
);
10804 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10805 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10806 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10807 /* Check to see if any other bits in the st_other field are set.
10808 Note - displaying this information disrupts the layout of the
10809 table being generated, but for the moment this case is very rare. */
10810 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10811 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10812 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10813 print_symbol (25, psym
->st_name
< strtab_size
10814 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10817 = get_symbol_version_string (file
,
10818 section
->sh_type
== SHT_DYNSYM
,
10819 strtab
, strtab_size
, si
,
10820 psym
, &sym_info
, &vna_other
);
10821 if (version_string
)
10823 if (sym_info
== symbol_undefined
)
10824 printf ("@%s (%d)", version_string
, vna_other
);
10826 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10834 if (strtab
!= string_table
)
10840 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10842 if (do_histogram
&& buckets
!= NULL
)
10844 unsigned long * lengths
;
10845 unsigned long * counts
;
10848 unsigned long maxlength
= 0;
10849 unsigned long nzero_counts
= 0;
10850 unsigned long nsyms
= 0;
10851 unsigned long chained
;
10853 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10854 (unsigned long) nbuckets
);
10856 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10857 if (lengths
== NULL
)
10859 error (_("Out of memory allocating space for histogram buckets\n"));
10863 printf (_(" Length Number %% of total Coverage\n"));
10864 for (hn
= 0; hn
< nbuckets
; ++hn
)
10866 for (si
= buckets
[hn
], chained
= 0;
10867 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10868 si
= chains
[si
], ++chained
)
10871 if (maxlength
< ++lengths
[hn
])
10875 /* PR binutils/17531: A corrupt binary could contain broken
10876 histogram data. Do not go into an infinite loop trying
10878 if (chained
> nchains
)
10880 error (_("histogram chain is corrupt\n"));
10885 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10886 if (counts
== NULL
)
10889 error (_("Out of memory allocating space for histogram counts\n"));
10893 for (hn
= 0; hn
< nbuckets
; ++hn
)
10894 ++counts
[lengths
[hn
]];
10899 printf (" 0 %-10lu (%5.1f%%)\n",
10900 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10901 for (i
= 1; i
<= maxlength
; ++i
)
10903 nzero_counts
+= counts
[i
] * i
;
10904 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10905 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10906 (nzero_counts
* 100.0) / nsyms
);
10914 if (buckets
!= NULL
)
10920 if (do_histogram
&& gnubuckets
!= NULL
)
10922 unsigned long * lengths
;
10923 unsigned long * counts
;
10925 unsigned long maxlength
= 0;
10926 unsigned long nzero_counts
= 0;
10927 unsigned long nsyms
= 0;
10929 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10930 (unsigned long) ngnubuckets
);
10932 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10933 if (lengths
== NULL
)
10935 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10939 printf (_(" Length Number %% of total Coverage\n"));
10941 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10942 if (gnubuckets
[hn
] != 0)
10944 bfd_vma off
, length
= 1;
10946 for (off
= gnubuckets
[hn
] - gnusymidx
;
10947 /* PR 17531 file: 010-77222-0.004. */
10948 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10951 lengths
[hn
] = length
;
10952 if (length
> maxlength
)
10953 maxlength
= length
;
10957 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10958 if (counts
== NULL
)
10961 error (_("Out of memory allocating space for gnu histogram counts\n"));
10965 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10966 ++counts
[lengths
[hn
]];
10968 if (ngnubuckets
> 0)
10971 printf (" 0 %-10lu (%5.1f%%)\n",
10972 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10973 for (j
= 1; j
<= maxlength
; ++j
)
10975 nzero_counts
+= counts
[j
] * j
;
10976 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10977 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10978 (nzero_counts
* 100.0) / nsyms
);
10992 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10996 if (dynamic_syminfo
== NULL
10998 /* No syminfo, this is ok. */
11001 /* There better should be a dynamic symbol section. */
11002 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11006 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11007 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11009 printf (_(" Num: Name BoundTo Flags\n"));
11010 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11012 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11014 printf ("%4d: ", i
);
11015 if (i
>= num_dynamic_syms
)
11016 printf (_("<corrupt index>"));
11017 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11018 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11020 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11023 switch (dynamic_syminfo
[i
].si_boundto
)
11025 case SYMINFO_BT_SELF
:
11026 fputs ("SELF ", stdout
);
11028 case SYMINFO_BT_PARENT
:
11029 fputs ("PARENT ", stdout
);
11032 if (dynamic_syminfo
[i
].si_boundto
> 0
11033 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11034 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11036 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11040 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11044 if (flags
& SYMINFO_FLG_DIRECT
)
11045 printf (" DIRECT");
11046 if (flags
& SYMINFO_FLG_PASSTHRU
)
11047 printf (" PASSTHRU");
11048 if (flags
& SYMINFO_FLG_COPY
)
11050 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11051 printf (" LAZYLOAD");
11059 /* Check to see if the given reloc needs to be handled in a target specific
11060 manner. If so then process the reloc and return TRUE otherwise return
11064 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11065 unsigned char * start
,
11066 Elf_Internal_Sym
* symtab
)
11068 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11070 switch (elf_header
.e_machine
)
11073 case EM_MSP430_OLD
:
11075 static Elf_Internal_Sym
* saved_sym
= NULL
;
11077 switch (reloc_type
)
11079 case 10: /* R_MSP430_SYM_DIFF */
11080 if (uses_msp430x_relocs ())
11082 case 21: /* R_MSP430X_SYM_DIFF */
11083 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11086 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11087 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11088 goto handle_sym_diff
;
11090 case 5: /* R_MSP430_16_BYTE */
11091 case 9: /* R_MSP430_8 */
11092 if (uses_msp430x_relocs ())
11094 goto handle_sym_diff
;
11096 case 2: /* R_MSP430_ABS16 */
11097 case 15: /* R_MSP430X_ABS16 */
11098 if (! uses_msp430x_relocs ())
11100 goto handle_sym_diff
;
11103 if (saved_sym
!= NULL
)
11107 value
= reloc
->r_addend
11108 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11109 - saved_sym
->st_value
);
11111 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11119 if (saved_sym
!= NULL
)
11120 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11127 case EM_CYGNUS_MN10300
:
11129 static Elf_Internal_Sym
* saved_sym
= NULL
;
11131 switch (reloc_type
)
11133 case 34: /* R_MN10300_ALIGN */
11135 case 33: /* R_MN10300_SYM_DIFF */
11136 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11138 case 1: /* R_MN10300_32 */
11139 case 2: /* R_MN10300_16 */
11140 if (saved_sym
!= NULL
)
11144 value
= reloc
->r_addend
11145 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11146 - saved_sym
->st_value
);
11148 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11155 if (saved_sym
!= NULL
)
11156 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11166 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11167 DWARF debug sections. This is a target specific test. Note - we do not
11168 go through the whole including-target-headers-multiple-times route, (as
11169 we have already done with <elf/h8.h>) because this would become very
11170 messy and even then this function would have to contain target specific
11171 information (the names of the relocs instead of their numeric values).
11172 FIXME: This is not the correct way to solve this problem. The proper way
11173 is to have target specific reloc sizing and typing functions created by
11174 the reloc-macros.h header, in the same way that it already creates the
11175 reloc naming functions. */
11178 is_32bit_abs_reloc (unsigned int reloc_type
)
11180 switch (elf_header
.e_machine
)
11184 return reloc_type
== 1; /* R_386_32. */
11186 return reloc_type
== 1; /* R_68K_32. */
11188 return reloc_type
== 1; /* R_860_32. */
11190 return reloc_type
== 2; /* R_960_32. */
11192 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11194 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11196 return reloc_type
== 1; /* R_ARC_32. */
11198 return reloc_type
== 2; /* R_ARM_ABS32 */
11201 return reloc_type
== 1;
11202 case EM_ADAPTEVA_EPIPHANY
:
11203 return reloc_type
== 3;
11205 return reloc_type
== 0x12; /* R_byte4_data. */
11207 return reloc_type
== 3; /* R_CRIS_32. */
11209 return reloc_type
== 3; /* R_CR16_NUM32. */
11211 return reloc_type
== 15; /* R_CRX_NUM32. */
11212 case EM_CYGNUS_FRV
:
11213 return reloc_type
== 1;
11214 case EM_CYGNUS_D10V
:
11216 return reloc_type
== 6; /* R_D10V_32. */
11217 case EM_CYGNUS_D30V
:
11219 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11221 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11222 case EM_CYGNUS_FR30
:
11224 return reloc_type
== 3; /* R_FR30_32. */
11226 return reloc_type
== 1; /* R_FT32_32. */
11230 return reloc_type
== 1; /* R_H8_DIR32. */
11232 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
11235 return reloc_type
== 2; /* R_IP2K_32. */
11237 return reloc_type
== 2; /* R_IQ2000_32. */
11238 case EM_LATTICEMICO32
:
11239 return reloc_type
== 3; /* R_LM32_32. */
11242 return reloc_type
== 3; /* R_M32C_32. */
11244 return reloc_type
== 34; /* R_M32R_32_RELA. */
11246 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11247 case EM_CYGNUS_MEP
:
11248 return reloc_type
== 4; /* R_MEP_32. */
11250 return reloc_type
== 2; /* R_METAG_ADDR32. */
11251 case EM_MICROBLAZE
:
11252 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11254 return reloc_type
== 2; /* R_MIPS_32. */
11256 return reloc_type
== 4; /* R_MMIX_32. */
11257 case EM_CYGNUS_MN10200
:
11259 return reloc_type
== 1; /* R_MN10200_32. */
11260 case EM_CYGNUS_MN10300
:
11262 return reloc_type
== 1; /* R_MN10300_32. */
11264 return reloc_type
== 1; /* R_MOXIE_32. */
11265 case EM_MSP430_OLD
:
11267 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11269 return reloc_type
== 2; /* R_MT_32. */
11271 return reloc_type
== 20; /* R_NDS32_RELA. */
11272 case EM_ALTERA_NIOS2
:
11273 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11275 return reloc_type
== 1; /* R_NIOS_32. */
11277 return reloc_type
== 1; /* R_OR1K_32. */
11279 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11280 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11283 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11285 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11287 return reloc_type
== 1; /* R_PPC_ADDR32. */
11289 return reloc_type
== 1; /* R_RL78_DIR32. */
11291 return reloc_type
== 1; /* R_RX_DIR32. */
11293 return reloc_type
== 1; /* R_I370_ADDR31. */
11296 return reloc_type
== 4; /* R_S390_32. */
11298 return reloc_type
== 8; /* R_SCORE_ABS32. */
11300 return reloc_type
== 1; /* R_SH_DIR32. */
11301 case EM_SPARC32PLUS
:
11304 return reloc_type
== 3 /* R_SPARC_32. */
11305 || reloc_type
== 23; /* R_SPARC_UA32. */
11307 return reloc_type
== 6; /* R_SPU_ADDR32 */
11309 return reloc_type
== 1; /* R_C6000_ABS32. */
11311 return reloc_type
== 2; /* R_TILEGX_32. */
11313 return reloc_type
== 1; /* R_TILEPRO_32. */
11314 case EM_CYGNUS_V850
:
11316 return reloc_type
== 6; /* R_V850_ABS32. */
11318 return reloc_type
== 0x33; /* R_V810_WORD. */
11320 return reloc_type
== 1; /* R_VAX_32. */
11322 return reloc_type
== 3; /* R_VISIUM_32. */
11326 return reloc_type
== 10; /* R_X86_64_32. */
11329 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11331 return reloc_type
== 4; /* R_XGATE_32. */
11333 return reloc_type
== 1; /* R_XSTROMY16_32. */
11334 case EM_XTENSA_OLD
:
11336 return reloc_type
== 1; /* R_XTENSA_32. */
11339 static unsigned int prev_warn
= 0;
11341 /* Avoid repeating the same warning multiple times. */
11342 if (prev_warn
!= elf_header
.e_machine
)
11343 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11344 elf_header
.e_machine
);
11345 prev_warn
= elf_header
.e_machine
;
11351 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11352 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11355 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11357 switch (elf_header
.e_machine
)
11361 return reloc_type
== 2; /* R_386_PC32. */
11363 return reloc_type
== 4; /* R_68K_PC32. */
11365 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11366 case EM_ADAPTEVA_EPIPHANY
:
11367 return reloc_type
== 6;
11369 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11371 return reloc_type
== 3; /* R_ARM_REL32 */
11372 case EM_MICROBLAZE
:
11373 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11375 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11377 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11379 return reloc_type
== 26; /* R_PPC_REL32. */
11381 return reloc_type
== 26; /* R_PPC64_REL32. */
11384 return reloc_type
== 5; /* R_390_PC32. */
11386 return reloc_type
== 2; /* R_SH_REL32. */
11387 case EM_SPARC32PLUS
:
11390 return reloc_type
== 6; /* R_SPARC_DISP32. */
11392 return reloc_type
== 13; /* R_SPU_REL32. */
11394 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11396 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11398 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11402 return reloc_type
== 2; /* R_X86_64_PC32. */
11403 case EM_XTENSA_OLD
:
11405 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11407 /* Do not abort or issue an error message here. Not all targets use
11408 pc-relative 32-bit relocs in their DWARF debug information and we
11409 have already tested for target coverage in is_32bit_abs_reloc. A
11410 more helpful warning message will be generated by apply_relocations
11411 anyway, so just return. */
11416 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11417 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11420 is_64bit_abs_reloc (unsigned int reloc_type
)
11422 switch (elf_header
.e_machine
)
11425 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11427 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11429 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11431 return reloc_type
== 80; /* R_PARISC_DIR64. */
11433 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11434 case EM_SPARC32PLUS
:
11437 return reloc_type
== 54; /* R_SPARC_UA64. */
11441 return reloc_type
== 1; /* R_X86_64_64. */
11444 return reloc_type
== 22; /* R_S390_64. */
11446 return reloc_type
== 1; /* R_TILEGX_64. */
11448 return reloc_type
== 18; /* R_MIPS_64. */
11454 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11455 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11458 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11460 switch (elf_header
.e_machine
)
11463 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11465 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11467 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11469 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11471 return reloc_type
== 44; /* R_PPC64_REL64. */
11472 case EM_SPARC32PLUS
:
11475 return reloc_type
== 46; /* R_SPARC_DISP64. */
11479 return reloc_type
== 24; /* R_X86_64_PC64. */
11482 return reloc_type
== 23; /* R_S390_PC64. */
11484 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11490 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11491 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11494 is_24bit_abs_reloc (unsigned int reloc_type
)
11496 switch (elf_header
.e_machine
)
11498 case EM_CYGNUS_MN10200
:
11500 return reloc_type
== 4; /* R_MN10200_24. */
11506 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11507 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11510 is_16bit_abs_reloc (unsigned int reloc_type
)
11512 switch (elf_header
.e_machine
)
11516 return reloc_type
== 4; /* R_AVR_16. */
11517 case EM_ADAPTEVA_EPIPHANY
:
11518 return reloc_type
== 5;
11519 case EM_CYGNUS_D10V
:
11521 return reloc_type
== 3; /* R_D10V_16. */
11525 return reloc_type
== R_H8_DIR16
;
11528 return reloc_type
== 1; /* R_IP2K_16. */
11531 return reloc_type
== 1; /* R_M32C_16 */
11533 if (uses_msp430x_relocs ())
11534 return reloc_type
== 2; /* R_MSP430_ABS16. */
11535 case EM_MSP430_OLD
:
11536 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11538 return reloc_type
== 19; /* R_NDS32_RELA. */
11539 case EM_ALTERA_NIOS2
:
11540 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11542 return reloc_type
== 9; /* R_NIOS_16. */
11544 return reloc_type
== 2; /* R_OR1K_16. */
11546 return reloc_type
== 2; /* R_C6000_ABS16. */
11549 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11550 case EM_CYGNUS_MN10200
:
11552 return reloc_type
== 2; /* R_MN10200_16. */
11553 case EM_CYGNUS_MN10300
:
11555 return reloc_type
== 2; /* R_MN10300_16. */
11557 return reloc_type
== 2; /* R_VISIUM_16. */
11559 return reloc_type
== 3; /* R_XGATE_16. */
11565 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11566 relocation entries (possibly formerly used for SHT_GROUP sections). */
11569 is_none_reloc (unsigned int reloc_type
)
11571 switch (elf_header
.e_machine
)
11573 case EM_68K
: /* R_68K_NONE. */
11574 case EM_386
: /* R_386_NONE. */
11575 case EM_SPARC32PLUS
:
11577 case EM_SPARC
: /* R_SPARC_NONE. */
11578 case EM_MIPS
: /* R_MIPS_NONE. */
11579 case EM_PARISC
: /* R_PARISC_NONE. */
11580 case EM_ALPHA
: /* R_ALPHA_NONE. */
11581 case EM_ADAPTEVA_EPIPHANY
:
11582 case EM_PPC
: /* R_PPC_NONE. */
11583 case EM_PPC64
: /* R_PPC64_NONE. */
11584 case EM_ARM
: /* R_ARM_NONE. */
11585 case EM_IA_64
: /* R_IA64_NONE. */
11586 case EM_SH
: /* R_SH_NONE. */
11588 case EM_S390
: /* R_390_NONE. */
11589 case EM_CRIS
: /* R_CRIS_NONE. */
11590 case EM_X86_64
: /* R_X86_64_NONE. */
11591 case EM_L1OM
: /* R_X86_64_NONE. */
11592 case EM_K1OM
: /* R_X86_64_NONE. */
11593 case EM_MN10300
: /* R_MN10300_NONE. */
11594 case EM_FT32
: /* R_FT32_NONE. */
11595 case EM_MOXIE
: /* R_MOXIE_NONE. */
11596 case EM_M32R
: /* R_M32R_NONE. */
11597 case EM_TI_C6000
:/* R_C6000_NONE. */
11598 case EM_TILEGX
: /* R_TILEGX_NONE. */
11599 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11601 case EM_C166
: /* R_XC16X_NONE. */
11602 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11603 case EM_NIOS32
: /* R_NIOS_NONE. */
11604 case EM_OR1K
: /* R_OR1K_NONE. */
11605 return reloc_type
== 0;
11607 return reloc_type
== 0 || reloc_type
== 256;
11609 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11610 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11611 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11612 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11613 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11614 case EM_XTENSA_OLD
:
11616 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11617 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11618 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11619 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11621 return reloc_type
== 3; /* R_METAG_NONE. */
11626 /* Apply relocations to a section.
11627 Note: So far support has been added only for those relocations
11628 which can be found in debug sections.
11629 FIXME: Add support for more relocations ? */
11632 apply_relocations (void * file
,
11633 Elf_Internal_Shdr
* section
,
11634 unsigned char * start
)
11636 Elf_Internal_Shdr
* relsec
;
11637 unsigned char * end
= start
+ section
->sh_size
;
11639 if (elf_header
.e_type
!= ET_REL
)
11642 /* Find the reloc section associated with the section. */
11643 for (relsec
= section_headers
;
11644 relsec
< section_headers
+ elf_header
.e_shnum
;
11647 bfd_boolean is_rela
;
11648 unsigned long num_relocs
;
11649 Elf_Internal_Rela
* relocs
;
11650 Elf_Internal_Rela
* rp
;
11651 Elf_Internal_Shdr
* symsec
;
11652 Elf_Internal_Sym
* symtab
;
11653 unsigned long num_syms
;
11654 Elf_Internal_Sym
* sym
;
11656 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11657 || relsec
->sh_info
>= elf_header
.e_shnum
11658 || section_headers
+ relsec
->sh_info
!= section
11659 || relsec
->sh_size
== 0
11660 || relsec
->sh_link
>= elf_header
.e_shnum
)
11663 is_rela
= relsec
->sh_type
== SHT_RELA
;
11667 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11668 relsec
->sh_size
, & relocs
, & num_relocs
))
11673 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11674 relsec
->sh_size
, & relocs
, & num_relocs
))
11678 /* SH uses RELA but uses in place value instead of the addend field. */
11679 if (elf_header
.e_machine
== EM_SH
)
11682 symsec
= section_headers
+ relsec
->sh_link
;
11683 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11685 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11688 unsigned int reloc_type
;
11689 unsigned int reloc_size
;
11690 unsigned char * rloc
;
11691 unsigned long sym_index
;
11693 reloc_type
= get_reloc_type (rp
->r_info
);
11695 if (target_specific_reloc_handling (rp
, start
, symtab
))
11697 else if (is_none_reloc (reloc_type
))
11699 else if (is_32bit_abs_reloc (reloc_type
)
11700 || is_32bit_pcrel_reloc (reloc_type
))
11702 else if (is_64bit_abs_reloc (reloc_type
)
11703 || is_64bit_pcrel_reloc (reloc_type
))
11705 else if (is_24bit_abs_reloc (reloc_type
))
11707 else if (is_16bit_abs_reloc (reloc_type
))
11711 static unsigned int prev_reloc
= 0;
11712 if (reloc_type
!= prev_reloc
)
11713 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11714 reloc_type
, printable_section_name (section
));
11715 prev_reloc
= reloc_type
;
11719 rloc
= start
+ rp
->r_offset
;
11720 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11722 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11723 (unsigned long) rp
->r_offset
,
11724 printable_section_name (section
));
11728 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11729 if (sym_index
>= num_syms
)
11731 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11732 sym_index
, printable_section_name (section
));
11735 sym
= symtab
+ sym_index
;
11737 /* If the reloc has a symbol associated with it,
11738 make sure that it is of an appropriate type.
11740 Relocations against symbols without type can happen.
11741 Gcc -feliminate-dwarf2-dups may generate symbols
11742 without type for debug info.
11744 Icc generates relocations against function symbols
11745 instead of local labels.
11747 Relocations against object symbols can happen, eg when
11748 referencing a global array. For an example of this see
11749 the _clz.o binary in libgcc.a. */
11751 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11753 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11754 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11755 (long int)(rp
- relocs
),
11756 printable_section_name (relsec
));
11762 addend
+= rp
->r_addend
;
11763 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11764 partial_inplace. */
11766 || (elf_header
.e_machine
== EM_XTENSA
11767 && reloc_type
== 1)
11768 || ((elf_header
.e_machine
== EM_PJ
11769 || elf_header
.e_machine
== EM_PJ_OLD
)
11770 && reloc_type
== 1)
11771 || ((elf_header
.e_machine
== EM_D30V
11772 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11773 && reloc_type
== 12))
11774 addend
+= byte_get (rloc
, reloc_size
);
11776 if (is_32bit_pcrel_reloc (reloc_type
)
11777 || is_64bit_pcrel_reloc (reloc_type
))
11779 /* On HPPA, all pc-relative relocations are biased by 8. */
11780 if (elf_header
.e_machine
== EM_PARISC
)
11782 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11786 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11795 #ifdef SUPPORT_DISASSEMBLY
11797 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11799 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11801 /* FIXME: XXX -- to be done --- XXX */
11807 /* Reads in the contents of SECTION from FILE, returning a pointer
11808 to a malloc'ed buffer or NULL if something went wrong. */
11811 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11813 bfd_size_type num_bytes
;
11815 num_bytes
= section
->sh_size
;
11817 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11819 printf (_("\nSection '%s' has no data to dump.\n"),
11820 printable_section_name (section
));
11824 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11825 _("section contents"));
11830 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11832 Elf_Internal_Shdr
* relsec
;
11833 bfd_size_type num_bytes
;
11837 bfd_boolean some_strings_shown
;
11839 start
= get_section_contents (section
, file
);
11843 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11845 /* If the section being dumped has relocations against it the user might
11846 be expecting these relocations to have been applied. Check for this
11847 case and issue a warning message in order to avoid confusion.
11848 FIXME: Maybe we ought to have an option that dumps a section with
11849 relocs applied ? */
11850 for (relsec
= section_headers
;
11851 relsec
< section_headers
+ elf_header
.e_shnum
;
11854 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11855 || relsec
->sh_info
>= elf_header
.e_shnum
11856 || section_headers
+ relsec
->sh_info
!= section
11857 || relsec
->sh_size
== 0
11858 || relsec
->sh_link
>= elf_header
.e_shnum
)
11861 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11865 num_bytes
= section
->sh_size
;
11867 end
= start
+ num_bytes
;
11868 some_strings_shown
= FALSE
;
11872 while (!ISPRINT (* data
))
11873 if (++ data
>= end
)
11878 size_t maxlen
= end
- data
;
11881 /* PR 11128: Use two separate invocations in order to work
11882 around bugs in the Solaris 8 implementation of printf. */
11883 printf (" [%6tx] ", data
- start
);
11885 printf (" [%6Ix] ", (size_t) (data
- start
));
11889 print_symbol ((int) maxlen
, data
);
11891 data
+= strnlen (data
, maxlen
);
11895 printf (_("<corrupt>\n"));
11898 some_strings_shown
= TRUE
;
11902 if (! some_strings_shown
)
11903 printf (_(" No strings found in this section."));
11911 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11913 bfd_boolean relocate
)
11915 Elf_Internal_Shdr
* relsec
;
11916 bfd_size_type bytes
;
11918 unsigned char * data
;
11919 unsigned char * start
;
11921 start
= (unsigned char *) get_section_contents (section
, file
);
11925 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11929 apply_relocations (file
, section
, start
);
11933 /* If the section being dumped has relocations against it the user might
11934 be expecting these relocations to have been applied. Check for this
11935 case and issue a warning message in order to avoid confusion.
11936 FIXME: Maybe we ought to have an option that dumps a section with
11937 relocs applied ? */
11938 for (relsec
= section_headers
;
11939 relsec
< section_headers
+ elf_header
.e_shnum
;
11942 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11943 || relsec
->sh_info
>= elf_header
.e_shnum
11944 || section_headers
+ relsec
->sh_info
!= section
11945 || relsec
->sh_size
== 0
11946 || relsec
->sh_link
>= elf_header
.e_shnum
)
11949 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11954 addr
= section
->sh_addr
;
11955 bytes
= section
->sh_size
;
11964 lbytes
= (bytes
> 16 ? 16 : bytes
);
11966 printf (" 0x%8.8lx ", (unsigned long) addr
);
11968 for (j
= 0; j
< 16; j
++)
11971 printf ("%2.2x", data
[j
]);
11979 for (j
= 0; j
< lbytes
; j
++)
11982 if (k
>= ' ' && k
< 0x7f)
12000 /* Uncompresses a section that was compressed using zlib, in place. */
12003 uncompress_section_contents (unsigned char **buffer
,
12004 dwarf_size_type
*size
)
12006 dwarf_size_type compressed_size
= *size
;
12007 unsigned char * compressed_buffer
= *buffer
;
12008 dwarf_size_type uncompressed_size
;
12009 unsigned char * uncompressed_buffer
;
12012 dwarf_size_type header_size
= 12;
12014 /* Read the zlib header. In this case, it should be "ZLIB" followed
12015 by the uncompressed section size, 8 bytes in big-endian order. */
12016 if (compressed_size
< header_size
12017 || ! streq ((char *) compressed_buffer
, "ZLIB"))
12020 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
12021 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
12022 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
12023 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
12024 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
12025 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
12026 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
12027 uncompressed_size
+= compressed_buffer
[11];
12029 /* It is possible the section consists of several compressed
12030 buffers concatenated together, so we uncompress in a loop. */
12031 strm
.zalloc
= NULL
;
12033 strm
.opaque
= NULL
;
12034 strm
.avail_in
= compressed_size
- header_size
;
12035 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
12036 strm
.avail_out
= uncompressed_size
;
12037 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12039 rc
= inflateInit (& strm
);
12040 while (strm
.avail_in
> 0)
12044 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12045 + (uncompressed_size
- strm
.avail_out
));
12046 rc
= inflate (&strm
, Z_FINISH
);
12047 if (rc
!= Z_STREAM_END
)
12049 rc
= inflateReset (& strm
);
12051 rc
= inflateEnd (& strm
);
12053 || strm
.avail_out
!= 0)
12056 *buffer
= uncompressed_buffer
;
12057 *size
= uncompressed_size
;
12061 free (uncompressed_buffer
);
12062 /* Indicate decompression failure. */
12068 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12069 Elf_Internal_Shdr
* sec
, void * file
)
12071 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12074 /* If it is already loaded, do nothing. */
12075 if (section
->start
!= NULL
)
12078 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12079 section
->address
= sec
->sh_addr
;
12080 section
->user_data
= NULL
;
12081 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12083 sec
->sh_size
, buf
);
12084 if (section
->start
== NULL
)
12088 unsigned char *start
= section
->start
;
12089 dwarf_size_type size
= sec
->sh_size
;
12091 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12093 Elf_Internal_Chdr chdr
;
12094 unsigned int compression_header_size
12095 = get_compression_header (&chdr
, start
);
12096 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
12097 || chdr
.ch_addralign
!= sec
->sh_addralign
)
12099 start
+= compression_header_size
;
12100 size
-= compression_header_size
;
12103 if (uncompress_section_contents (&start
, &size
))
12105 /* Free the compressed buffer, update the section buffer
12106 and the section size if uncompress is successful. */
12107 free (section
->start
);
12108 section
->start
= start
;
12109 sec
->sh_size
= size
;
12111 section
->size
= size
;
12114 if (section
->start
== NULL
)
12117 if (debug_displays
[debug
].relocate
)
12118 apply_relocations ((FILE *) file
, sec
, section
->start
);
12123 /* If this is not NULL, load_debug_section will only look for sections
12124 within the list of sections given here. */
12125 unsigned int *section_subset
= NULL
;
12128 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12130 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12131 Elf_Internal_Shdr
* sec
;
12133 /* Locate the debug section. */
12134 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12136 section
->name
= section
->uncompressed_name
;
12139 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12141 section
->name
= section
->compressed_name
;
12146 /* If we're loading from a subset of sections, and we've loaded
12147 a section matching this name before, it's likely that it's a
12149 if (section_subset
!= NULL
)
12150 free_debug_section (debug
);
12152 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12156 free_debug_section (enum dwarf_section_display_enum debug
)
12158 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12160 if (section
->start
== NULL
)
12163 free ((char *) section
->start
);
12164 section
->start
= NULL
;
12165 section
->address
= 0;
12170 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12172 char * name
= SECTION_NAME (section
);
12173 const char * print_name
= printable_section_name (section
);
12174 bfd_size_type length
;
12178 length
= section
->sh_size
;
12181 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12184 if (section
->sh_type
== SHT_NOBITS
)
12186 /* There is no point in dumping the contents of a debugging section
12187 which has the NOBITS type - the bits in the file will be random.
12188 This can happen when a file containing a .eh_frame section is
12189 stripped with the --only-keep-debug command line option. */
12190 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12195 if (const_strneq (name
, ".gnu.linkonce.wi."))
12196 name
= ".debug_info";
12198 /* See if we know how to display the contents of this section. */
12199 for (i
= 0; i
< max
; i
++)
12200 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12201 || (i
== line
&& const_strneq (name
, ".debug_line."))
12202 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12204 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12205 int secondary
= (section
!= find_section (name
));
12208 free_debug_section ((enum dwarf_section_display_enum
) i
);
12210 if (i
== line
&& const_strneq (name
, ".debug_line."))
12212 else if (streq (sec
->uncompressed_name
, name
))
12213 sec
->name
= sec
->uncompressed_name
;
12215 sec
->name
= sec
->compressed_name
;
12216 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12219 /* If this debug section is part of a CU/TU set in a .dwp file,
12220 restrict load_debug_section to the sections in that set. */
12221 section_subset
= find_cu_tu_set (file
, shndx
);
12223 result
&= debug_displays
[i
].display (sec
, file
);
12225 section_subset
= NULL
;
12227 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12228 free_debug_section ((enum dwarf_section_display_enum
) i
);
12236 printf (_("Unrecognized debug section: %s\n"), print_name
);
12243 /* Set DUMP_SECTS for all sections where dumps were requested
12244 based on section name. */
12247 initialise_dumps_byname (void)
12249 struct dump_list_entry
* cur
;
12251 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12256 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12257 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12259 request_dump_bynumber (i
, cur
->type
);
12264 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12270 process_section_contents (FILE * file
)
12272 Elf_Internal_Shdr
* section
;
12278 initialise_dumps_byname ();
12280 for (i
= 0, section
= section_headers
;
12281 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12284 #ifdef SUPPORT_DISASSEMBLY
12285 if (dump_sects
[i
] & DISASS_DUMP
)
12286 disassemble_section (section
, file
);
12288 if (dump_sects
[i
] & HEX_DUMP
)
12289 dump_section_as_bytes (section
, file
, FALSE
);
12291 if (dump_sects
[i
] & RELOC_DUMP
)
12292 dump_section_as_bytes (section
, file
, TRUE
);
12294 if (dump_sects
[i
] & STRING_DUMP
)
12295 dump_section_as_strings (section
, file
);
12297 if (dump_sects
[i
] & DEBUG_DUMP
)
12298 display_debug_section (i
, section
, file
);
12301 /* Check to see if the user requested a
12302 dump of a section that does not exist. */
12303 while (i
++ < num_dump_sects
)
12305 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12309 process_mips_fpe_exception (int mask
)
12314 if (mask
& OEX_FPU_INEX
)
12315 fputs ("INEX", stdout
), first
= 0;
12316 if (mask
& OEX_FPU_UFLO
)
12317 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12318 if (mask
& OEX_FPU_OFLO
)
12319 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12320 if (mask
& OEX_FPU_DIV0
)
12321 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12322 if (mask
& OEX_FPU_INVAL
)
12323 printf ("%sINVAL", first
? "" : "|");
12326 fputs ("0", stdout
);
12329 /* Display's the value of TAG at location P. If TAG is
12330 greater than 0 it is assumed to be an unknown tag, and
12331 a message is printed to this effect. Otherwise it is
12332 assumed that a message has already been printed.
12334 If the bottom bit of TAG is set it assumed to have a
12335 string value, otherwise it is assumed to have an integer
12338 Returns an updated P pointing to the first unread byte
12339 beyond the end of TAG's value.
12341 Reads at or beyond END will not be made. */
12343 static unsigned char *
12344 display_tag_value (int tag
,
12346 const unsigned char * const end
)
12351 printf (" Tag_unknown_%d: ", tag
);
12355 warn (_("<corrupt tag>\n"));
12359 /* PR 17531 file: 027-19978-0.004. */
12360 size_t maxlen
= (end
- p
) - 1;
12365 print_symbol ((int) maxlen
, (const char *) p
);
12366 p
+= strnlen ((char *) p
, maxlen
) + 1;
12370 printf (_("<corrupt string tag>"));
12371 p
= (unsigned char *) end
;
12379 val
= read_uleb128 (p
, &len
, end
);
12381 printf ("%ld (0x%lx)\n", val
, val
);
12388 /* ARM EABI attributes section. */
12393 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12395 const char ** table
;
12396 } arm_attr_public_tag
;
12398 static const char * arm_attr_tag_CPU_arch
[] =
12399 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12400 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12401 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12402 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12403 {"No", "Thumb-1", "Thumb-2"};
12404 static const char * arm_attr_tag_FP_arch
[] =
12405 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12406 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12407 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12408 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12409 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12410 static const char * arm_attr_tag_PCS_config
[] =
12411 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12412 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12413 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12414 {"V6", "SB", "TLS", "Unused"};
12415 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12416 {"Absolute", "PC-relative", "SB-relative", "None"};
12417 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12418 {"Absolute", "PC-relative", "None"};
12419 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12420 {"None", "direct", "GOT-indirect"};
12421 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12422 {"None", "??? 1", "2", "??? 3", "4"};
12423 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12424 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12425 {"Unused", "Needed", "Sign only"};
12426 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12427 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12428 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12429 {"Unused", "Finite", "RTABI", "IEEE 754"};
12430 static const char * arm_attr_tag_ABI_enum_size
[] =
12431 {"Unused", "small", "int", "forced to int"};
12432 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12433 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12434 static const char * arm_attr_tag_ABI_VFP_args
[] =
12435 {"AAPCS", "VFP registers", "custom", "compatible"};
12436 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12437 {"AAPCS", "WMMX registers", "custom"};
12438 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12439 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12440 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12441 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12442 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12443 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12444 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12445 static const char * arm_attr_tag_FP_HP_extension
[] =
12446 {"Not Allowed", "Allowed"};
12447 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12448 {"None", "IEEE 754", "Alternative Format"};
12449 static const char * arm_attr_tag_MPextension_use
[] =
12450 {"Not Allowed", "Allowed"};
12451 static const char * arm_attr_tag_DIV_use
[] =
12452 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12453 "Allowed in v7-A with integer division extension"};
12454 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12455 static const char * arm_attr_tag_Virtualization_use
[] =
12456 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12457 "TrustZone and Virtualization Extensions"};
12458 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12459 {"Not Allowed", "Allowed"};
12461 #define LOOKUP(id, name) \
12462 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12463 static arm_attr_public_tag arm_attr_public_tags
[] =
12465 {4, "CPU_raw_name", 1, NULL
},
12466 {5, "CPU_name", 1, NULL
},
12467 LOOKUP(6, CPU_arch
),
12468 {7, "CPU_arch_profile", 0, NULL
},
12469 LOOKUP(8, ARM_ISA_use
),
12470 LOOKUP(9, THUMB_ISA_use
),
12471 LOOKUP(10, FP_arch
),
12472 LOOKUP(11, WMMX_arch
),
12473 LOOKUP(12, Advanced_SIMD_arch
),
12474 LOOKUP(13, PCS_config
),
12475 LOOKUP(14, ABI_PCS_R9_use
),
12476 LOOKUP(15, ABI_PCS_RW_data
),
12477 LOOKUP(16, ABI_PCS_RO_data
),
12478 LOOKUP(17, ABI_PCS_GOT_use
),
12479 LOOKUP(18, ABI_PCS_wchar_t
),
12480 LOOKUP(19, ABI_FP_rounding
),
12481 LOOKUP(20, ABI_FP_denormal
),
12482 LOOKUP(21, ABI_FP_exceptions
),
12483 LOOKUP(22, ABI_FP_user_exceptions
),
12484 LOOKUP(23, ABI_FP_number_model
),
12485 {24, "ABI_align_needed", 0, NULL
},
12486 {25, "ABI_align_preserved", 0, NULL
},
12487 LOOKUP(26, ABI_enum_size
),
12488 LOOKUP(27, ABI_HardFP_use
),
12489 LOOKUP(28, ABI_VFP_args
),
12490 LOOKUP(29, ABI_WMMX_args
),
12491 LOOKUP(30, ABI_optimization_goals
),
12492 LOOKUP(31, ABI_FP_optimization_goals
),
12493 {32, "compatibility", 0, NULL
},
12494 LOOKUP(34, CPU_unaligned_access
),
12495 LOOKUP(36, FP_HP_extension
),
12496 LOOKUP(38, ABI_FP_16bit_format
),
12497 LOOKUP(42, MPextension_use
),
12498 LOOKUP(44, DIV_use
),
12499 {64, "nodefaults", 0, NULL
},
12500 {65, "also_compatible_with", 0, NULL
},
12501 LOOKUP(66, T2EE_use
),
12502 {67, "conformance", 1, NULL
},
12503 LOOKUP(68, Virtualization_use
),
12504 LOOKUP(70, MPextension_use_legacy
)
12508 static unsigned char *
12509 display_arm_attribute (unsigned char * p
,
12510 const unsigned char * const end
)
12515 arm_attr_public_tag
* attr
;
12519 tag
= read_uleb128 (p
, &len
, end
);
12522 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12524 if (arm_attr_public_tags
[i
].tag
== tag
)
12526 attr
= &arm_attr_public_tags
[i
];
12533 printf (" Tag_%s: ", attr
->name
);
12534 switch (attr
->type
)
12539 case 7: /* Tag_CPU_arch_profile. */
12540 val
= read_uleb128 (p
, &len
, end
);
12544 case 0: printf (_("None\n")); break;
12545 case 'A': printf (_("Application\n")); break;
12546 case 'R': printf (_("Realtime\n")); break;
12547 case 'M': printf (_("Microcontroller\n")); break;
12548 case 'S': printf (_("Application or Realtime\n")); break;
12549 default: printf ("??? (%d)\n", val
); break;
12553 case 24: /* Tag_align_needed. */
12554 val
= read_uleb128 (p
, &len
, end
);
12558 case 0: printf (_("None\n")); break;
12559 case 1: printf (_("8-byte\n")); break;
12560 case 2: printf (_("4-byte\n")); break;
12561 case 3: printf ("??? 3\n"); break;
12564 printf (_("8-byte and up to %d-byte extended\n"),
12567 printf ("??? (%d)\n", val
);
12572 case 25: /* Tag_align_preserved. */
12573 val
= read_uleb128 (p
, &len
, end
);
12577 case 0: printf (_("None\n")); break;
12578 case 1: printf (_("8-byte, except leaf SP\n")); break;
12579 case 2: printf (_("8-byte\n")); break;
12580 case 3: printf ("??? 3\n"); break;
12583 printf (_("8-byte and up to %d-byte extended\n"),
12586 printf ("??? (%d)\n", val
);
12591 case 32: /* Tag_compatibility. */
12593 val
= read_uleb128 (p
, &len
, end
);
12595 printf (_("flag = %d, vendor = "), val
);
12598 size_t maxlen
= (end
- p
) - 1;
12600 print_symbol ((int) maxlen
, (const char *) p
);
12601 p
+= strnlen ((char *) p
, maxlen
) + 1;
12605 printf (_("<corrupt>"));
12606 p
= (unsigned char *) end
;
12612 case 64: /* Tag_nodefaults. */
12613 /* PR 17531: file: 001-505008-0.01. */
12616 printf (_("True\n"));
12619 case 65: /* Tag_also_compatible_with. */
12620 val
= read_uleb128 (p
, &len
, end
);
12622 if (val
== 6 /* Tag_CPU_arch. */)
12624 val
= read_uleb128 (p
, &len
, end
);
12626 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12627 printf ("??? (%d)\n", val
);
12629 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12633 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12638 printf (_("<unknown: %d>\n"), tag
);
12644 return display_tag_value (-1, p
, end
);
12646 return display_tag_value (0, p
, end
);
12649 assert (attr
->type
& 0x80);
12650 val
= read_uleb128 (p
, &len
, end
);
12652 type
= attr
->type
& 0x7f;
12654 printf ("??? (%d)\n", val
);
12656 printf ("%s\n", attr
->table
[val
]);
12661 return display_tag_value (tag
, p
, end
);
12664 static unsigned char *
12665 display_gnu_attribute (unsigned char * p
,
12666 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12667 const unsigned char * const end
)
12673 tag
= read_uleb128 (p
, &len
, end
);
12676 /* Tag_compatibility is the only generic GNU attribute defined at
12680 val
= read_uleb128 (p
, &len
, end
);
12683 printf (_("flag = %d, vendor = "), val
);
12686 printf (_("<corrupt>\n"));
12687 warn (_("corrupt vendor attribute\n"));
12693 size_t maxlen
= (end
- p
) - 1;
12695 print_symbol ((int) maxlen
, (const char *) p
);
12696 p
+= strnlen ((char *) p
, maxlen
) + 1;
12700 printf (_("<corrupt>"));
12701 p
= (unsigned char *) end
;
12708 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12709 return display_proc_gnu_attribute (p
, tag
, end
);
12711 return display_tag_value (tag
, p
, end
);
12714 static unsigned char *
12715 display_power_gnu_attribute (unsigned char * p
,
12717 const unsigned char * const end
)
12722 if (tag
== Tag_GNU_Power_ABI_FP
)
12724 val
= read_uleb128 (p
, &len
, end
);
12726 printf (" Tag_GNU_Power_ABI_FP: ");
12731 printf (_("Hard or soft float\n"));
12734 printf (_("Hard float\n"));
12737 printf (_("Soft float\n"));
12740 printf (_("Single-precision hard float\n"));
12743 printf ("??? (%d)\n", val
);
12749 if (tag
== Tag_GNU_Power_ABI_Vector
)
12751 val
= read_uleb128 (p
, &len
, end
);
12753 printf (" Tag_GNU_Power_ABI_Vector: ");
12757 printf (_("Any\n"));
12760 printf (_("Generic\n"));
12763 printf ("AltiVec\n");
12769 printf ("??? (%d)\n", val
);
12775 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12779 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12783 val
= read_uleb128 (p
, &len
, end
);
12785 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12789 printf (_("Any\n"));
12792 printf ("r3/r4\n");
12795 printf (_("Memory\n"));
12798 printf ("??? (%d)\n", val
);
12804 return display_tag_value (tag
& 1, p
, end
);
12808 display_sparc_hwcaps (int mask
)
12814 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12815 fputs ("mul32", stdout
), first
= 0;
12816 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12817 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12818 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12819 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12820 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12821 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12822 if (mask
& ELF_SPARC_HWCAP_POPC
)
12823 printf ("%spopc", first
? "" : "|"), first
= 0;
12824 if (mask
& ELF_SPARC_HWCAP_VIS
)
12825 printf ("%svis", first
? "" : "|"), first
= 0;
12826 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12827 printf ("%svis2", first
? "" : "|"), first
= 0;
12828 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12829 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12830 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12831 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12832 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12833 printf ("%svis3", first
? "" : "|"), first
= 0;
12834 if (mask
& ELF_SPARC_HWCAP_HPC
)
12835 printf ("%shpc", first
? "" : "|"), first
= 0;
12836 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12837 printf ("%srandom", first
? "" : "|"), first
= 0;
12838 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12839 printf ("%strans", first
? "" : "|"), first
= 0;
12840 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12841 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12842 if (mask
& ELF_SPARC_HWCAP_IMA
)
12843 printf ("%sima", first
? "" : "|"), first
= 0;
12844 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12845 printf ("%scspare", first
? "" : "|"), first
= 0;
12848 fputc ('0', stdout
);
12849 fputc ('\n', stdout
);
12853 display_sparc_hwcaps2 (int mask
)
12859 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12860 fputs ("fjathplus", stdout
), first
= 0;
12861 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12862 printf ("%svis3b", first
? "" : "|"), first
= 0;
12863 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12864 printf ("%sadp", first
? "" : "|"), first
= 0;
12865 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12866 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12867 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12868 printf ("%smwait", first
? "" : "|"), first
= 0;
12869 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12870 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12871 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12872 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12873 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12874 printf ("%snsec", first
? "" : "|"), first
= 0;
12875 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12876 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12877 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12878 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12879 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12880 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12883 fputc ('0', stdout
);
12884 fputc ('\n', stdout
);
12887 static unsigned char *
12888 display_sparc_gnu_attribute (unsigned char * p
,
12890 const unsigned char * const end
)
12895 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12897 val
= read_uleb128 (p
, &len
, end
);
12899 printf (" Tag_GNU_Sparc_HWCAPS: ");
12900 display_sparc_hwcaps (val
);
12903 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12905 val
= read_uleb128 (p
, &len
, end
);
12907 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12908 display_sparc_hwcaps2 (val
);
12912 return display_tag_value (tag
, p
, end
);
12916 print_mips_fp_abi_value (int val
)
12920 case Val_GNU_MIPS_ABI_FP_ANY
:
12921 printf (_("Hard or soft float\n"));
12923 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12924 printf (_("Hard float (double precision)\n"));
12926 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12927 printf (_("Hard float (single precision)\n"));
12929 case Val_GNU_MIPS_ABI_FP_SOFT
:
12930 printf (_("Soft float\n"));
12932 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12933 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12935 case Val_GNU_MIPS_ABI_FP_XX
:
12936 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12938 case Val_GNU_MIPS_ABI_FP_64
:
12939 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12941 case Val_GNU_MIPS_ABI_FP_64A
:
12942 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12945 printf ("??? (%d)\n", val
);
12950 static unsigned char *
12951 display_mips_gnu_attribute (unsigned char * p
,
12953 const unsigned char * const end
)
12955 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12960 val
= read_uleb128 (p
, &len
, end
);
12962 printf (" Tag_GNU_MIPS_ABI_FP: ");
12964 print_mips_fp_abi_value (val
);
12969 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12974 val
= read_uleb128 (p
, &len
, end
);
12976 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12980 case Val_GNU_MIPS_ABI_MSA_ANY
:
12981 printf (_("Any MSA or not\n"));
12983 case Val_GNU_MIPS_ABI_MSA_128
:
12984 printf (_("128-bit MSA\n"));
12987 printf ("??? (%d)\n", val
);
12993 return display_tag_value (tag
& 1, p
, end
);
12996 static unsigned char *
12997 display_tic6x_attribute (unsigned char * p
,
12998 const unsigned char * const end
)
13004 tag
= read_uleb128 (p
, &len
, end
);
13010 val
= read_uleb128 (p
, &len
, end
);
13012 printf (" Tag_ISA: ");
13016 case C6XABI_Tag_ISA_none
:
13017 printf (_("None\n"));
13019 case C6XABI_Tag_ISA_C62X
:
13022 case C6XABI_Tag_ISA_C67X
:
13025 case C6XABI_Tag_ISA_C67XP
:
13026 printf ("C67x+\n");
13028 case C6XABI_Tag_ISA_C64X
:
13031 case C6XABI_Tag_ISA_C64XP
:
13032 printf ("C64x+\n");
13034 case C6XABI_Tag_ISA_C674X
:
13035 printf ("C674x\n");
13038 printf ("??? (%d)\n", val
);
13043 case Tag_ABI_wchar_t
:
13044 val
= read_uleb128 (p
, &len
, end
);
13046 printf (" Tag_ABI_wchar_t: ");
13050 printf (_("Not used\n"));
13053 printf (_("2 bytes\n"));
13056 printf (_("4 bytes\n"));
13059 printf ("??? (%d)\n", val
);
13064 case Tag_ABI_stack_align_needed
:
13065 val
= read_uleb128 (p
, &len
, end
);
13067 printf (" Tag_ABI_stack_align_needed: ");
13071 printf (_("8-byte\n"));
13074 printf (_("16-byte\n"));
13077 printf ("??? (%d)\n", val
);
13082 case Tag_ABI_stack_align_preserved
:
13083 val
= read_uleb128 (p
, &len
, end
);
13085 printf (" Tag_ABI_stack_align_preserved: ");
13089 printf (_("8-byte\n"));
13092 printf (_("16-byte\n"));
13095 printf ("??? (%d)\n", val
);
13101 val
= read_uleb128 (p
, &len
, end
);
13103 printf (" Tag_ABI_DSBT: ");
13107 printf (_("DSBT addressing not used\n"));
13110 printf (_("DSBT addressing used\n"));
13113 printf ("??? (%d)\n", val
);
13119 val
= read_uleb128 (p
, &len
, end
);
13121 printf (" Tag_ABI_PID: ");
13125 printf (_("Data addressing position-dependent\n"));
13128 printf (_("Data addressing position-independent, GOT near DP\n"));
13131 printf (_("Data addressing position-independent, GOT far from DP\n"));
13134 printf ("??? (%d)\n", val
);
13140 val
= read_uleb128 (p
, &len
, end
);
13142 printf (" Tag_ABI_PIC: ");
13146 printf (_("Code addressing position-dependent\n"));
13149 printf (_("Code addressing position-independent\n"));
13152 printf ("??? (%d)\n", val
);
13157 case Tag_ABI_array_object_alignment
:
13158 val
= read_uleb128 (p
, &len
, end
);
13160 printf (" Tag_ABI_array_object_alignment: ");
13164 printf (_("8-byte\n"));
13167 printf (_("4-byte\n"));
13170 printf (_("16-byte\n"));
13173 printf ("??? (%d)\n", val
);
13178 case Tag_ABI_array_object_align_expected
:
13179 val
= read_uleb128 (p
, &len
, end
);
13181 printf (" Tag_ABI_array_object_align_expected: ");
13185 printf (_("8-byte\n"));
13188 printf (_("4-byte\n"));
13191 printf (_("16-byte\n"));
13194 printf ("??? (%d)\n", val
);
13199 case Tag_ABI_compatibility
:
13201 val
= read_uleb128 (p
, &len
, end
);
13203 printf (" Tag_ABI_compatibility: ");
13204 printf (_("flag = %d, vendor = "), val
);
13207 size_t maxlen
= (end
- p
) - 1;
13209 print_symbol ((int) maxlen
, (const char *) p
);
13210 p
+= strnlen ((char *) p
, maxlen
) + 1;
13214 printf (_("<corrupt>"));
13215 p
= (unsigned char *) end
;
13221 case Tag_ABI_conformance
:
13223 printf (" Tag_ABI_conformance: \"");
13226 size_t maxlen
= (end
- p
) - 1;
13228 print_symbol ((int) maxlen
, (const char *) p
);
13229 p
+= strnlen ((char *) p
, maxlen
) + 1;
13233 printf (_("<corrupt>"));
13234 p
= (unsigned char *) end
;
13241 return display_tag_value (tag
, p
, end
);
13245 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13247 unsigned long addr
= 0;
13248 size_t bytes
= end
- p
;
13255 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13257 printf (" 0x%8.8lx ", addr
);
13259 for (j
= 0; j
< 16; j
++)
13262 printf ("%2.2x", p
[j
]);
13270 for (j
= 0; j
< lbytes
; j
++)
13273 if (k
>= ' ' && k
< 0x7f)
13289 static unsigned char *
13290 display_msp430x_attribute (unsigned char * p
,
13291 const unsigned char * const end
)
13297 tag
= read_uleb128 (p
, & len
, end
);
13302 case OFBA_MSPABI_Tag_ISA
:
13303 val
= read_uleb128 (p
, &len
, end
);
13305 printf (" Tag_ISA: ");
13308 case 0: printf (_("None\n")); break;
13309 case 1: printf (_("MSP430\n")); break;
13310 case 2: printf (_("MSP430X\n")); break;
13311 default: printf ("??? (%d)\n", val
); break;
13315 case OFBA_MSPABI_Tag_Code_Model
:
13316 val
= read_uleb128 (p
, &len
, end
);
13318 printf (" Tag_Code_Model: ");
13321 case 0: printf (_("None\n")); break;
13322 case 1: printf (_("Small\n")); break;
13323 case 2: printf (_("Large\n")); break;
13324 default: printf ("??? (%d)\n", val
); break;
13328 case OFBA_MSPABI_Tag_Data_Model
:
13329 val
= read_uleb128 (p
, &len
, end
);
13331 printf (" Tag_Data_Model: ");
13334 case 0: printf (_("None\n")); break;
13335 case 1: printf (_("Small\n")); break;
13336 case 2: printf (_("Large\n")); break;
13337 case 3: printf (_("Restricted Large\n")); break;
13338 default: printf ("??? (%d)\n", val
); break;
13343 printf (_(" <unknown tag %d>: "), tag
);
13350 size_t maxlen
= (end
- p
) - 1;
13352 print_symbol ((int) maxlen
, (const char *) p
);
13353 p
+= strnlen ((char *) p
, maxlen
) + 1;
13357 printf (_("<corrupt>"));
13358 p
= (unsigned char *) end
;
13364 val
= read_uleb128 (p
, &len
, end
);
13366 printf ("%d (0x%x)\n", val
, val
);
13376 process_attributes (FILE * file
,
13377 const char * public_name
,
13378 unsigned int proc_type
,
13379 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13380 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13382 Elf_Internal_Shdr
* sect
;
13385 /* Find the section header so that we get the size. */
13386 for (i
= 0, sect
= section_headers
;
13387 i
< elf_header
.e_shnum
;
13390 unsigned char * contents
;
13393 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13396 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13397 sect
->sh_size
, _("attributes"));
13398 if (contents
== NULL
)
13404 bfd_vma section_len
;
13406 section_len
= sect
->sh_size
- 1;
13409 while (section_len
> 0)
13412 unsigned int namelen
;
13413 bfd_boolean public_section
;
13414 bfd_boolean gnu_section
;
13416 if (section_len
<= 4)
13418 error (_("Tag section ends prematurely\n"));
13421 attr_len
= byte_get (p
, 4);
13424 if (attr_len
> section_len
)
13426 error (_("Bad attribute length (%u > %u)\n"),
13427 (unsigned) attr_len
, (unsigned) section_len
);
13428 attr_len
= section_len
;
13430 /* PR 17531: file: 001-101425-0.004 */
13431 else if (attr_len
< 5)
13433 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13437 section_len
-= attr_len
;
13440 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13441 if (namelen
== 0 || namelen
>= attr_len
)
13443 error (_("Corrupt attribute section name\n"));
13447 printf (_("Attribute Section: "));
13448 print_symbol (INT_MAX
, (const char *) p
);
13451 if (public_name
&& streq ((char *) p
, public_name
))
13452 public_section
= TRUE
;
13454 public_section
= FALSE
;
13456 if (streq ((char *) p
, "gnu"))
13457 gnu_section
= TRUE
;
13459 gnu_section
= FALSE
;
13462 attr_len
-= namelen
;
13464 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13469 unsigned char * end
;
13471 /* PR binutils/17531: Safe handling of corrupt files. */
13474 error (_("Unused bytes at end of section\n"));
13480 size
= byte_get (p
, 4);
13481 if (size
> attr_len
)
13483 error (_("Bad subsection length (%u > %u)\n"),
13484 (unsigned) size
, (unsigned) attr_len
);
13487 /* PR binutils/17531: Safe handling of corrupt files. */
13490 error (_("Bad subsection length (%u < 6)\n"),
13497 end
= p
+ size
- 1;
13498 assert (end
<= contents
+ sect
->sh_size
);
13504 printf (_("File Attributes\n"));
13507 printf (_("Section Attributes:"));
13510 printf (_("Symbol Attributes:"));
13516 val
= read_uleb128 (p
, &j
, end
);
13520 printf (" %d", val
);
13525 printf (_("Unknown tag: %d\n"), tag
);
13526 public_section
= FALSE
;
13530 if (public_section
&& display_pub_attribute
!= NULL
)
13533 p
= display_pub_attribute (p
, end
);
13536 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13539 p
= display_gnu_attribute (p
,
13540 display_proc_gnu_attribute
,
13546 printf (_(" Unknown attribute:\n"));
13547 display_raw_attribute (p
, end
);
13556 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13564 process_arm_specific (FILE * file
)
13566 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13567 display_arm_attribute
, NULL
);
13571 process_power_specific (FILE * file
)
13573 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13574 display_power_gnu_attribute
);
13578 process_sparc_specific (FILE * file
)
13580 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13581 display_sparc_gnu_attribute
);
13585 process_tic6x_specific (FILE * file
)
13587 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13588 display_tic6x_attribute
, NULL
);
13592 process_msp430x_specific (FILE * file
)
13594 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13595 display_msp430x_attribute
, NULL
);
13598 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13599 Print the Address, Access and Initial fields of an entry at VMA ADDR
13600 and return the VMA of the next entry, or -1 if there was a problem.
13601 Does not read from DATA_END or beyond. */
13604 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13605 unsigned char * data_end
)
13608 print_vma (addr
, LONG_HEX
);
13610 if (addr
< pltgot
+ 0xfff0)
13611 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13613 printf ("%10s", "");
13616 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13620 unsigned char * from
= data
+ addr
- pltgot
;
13622 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13624 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13625 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13626 return (bfd_vma
) -1;
13630 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13631 print_vma (entry
, LONG_HEX
);
13634 return addr
+ (is_32bit_elf
? 4 : 8);
13637 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13638 PLTGOT. Print the Address and Initial fields of an entry at VMA
13639 ADDR and return the VMA of the next entry. */
13642 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13645 print_vma (addr
, LONG_HEX
);
13648 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13653 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13654 print_vma (entry
, LONG_HEX
);
13656 return addr
+ (is_32bit_elf
? 4 : 8);
13660 print_mips_ases (unsigned int mask
)
13662 if (mask
& AFL_ASE_DSP
)
13663 fputs ("\n\tDSP ASE", stdout
);
13664 if (mask
& AFL_ASE_DSPR2
)
13665 fputs ("\n\tDSP R2 ASE", stdout
);
13666 if (mask
& AFL_ASE_EVA
)
13667 fputs ("\n\tEnhanced VA Scheme", stdout
);
13668 if (mask
& AFL_ASE_MCU
)
13669 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13670 if (mask
& AFL_ASE_MDMX
)
13671 fputs ("\n\tMDMX ASE", stdout
);
13672 if (mask
& AFL_ASE_MIPS3D
)
13673 fputs ("\n\tMIPS-3D ASE", stdout
);
13674 if (mask
& AFL_ASE_MT
)
13675 fputs ("\n\tMT ASE", stdout
);
13676 if (mask
& AFL_ASE_SMARTMIPS
)
13677 fputs ("\n\tSmartMIPS ASE", stdout
);
13678 if (mask
& AFL_ASE_VIRT
)
13679 fputs ("\n\tVZ ASE", stdout
);
13680 if (mask
& AFL_ASE_MSA
)
13681 fputs ("\n\tMSA ASE", stdout
);
13682 if (mask
& AFL_ASE_MIPS16
)
13683 fputs ("\n\tMIPS16 ASE", stdout
);
13684 if (mask
& AFL_ASE_MICROMIPS
)
13685 fputs ("\n\tMICROMIPS ASE", stdout
);
13686 if (mask
& AFL_ASE_XPA
)
13687 fputs ("\n\tXPA ASE", stdout
);
13689 fprintf (stdout
, "\n\t%s", _("None"));
13690 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13691 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13695 print_mips_isa_ext (unsigned int isa_ext
)
13700 fputs (_("None"), stdout
);
13703 fputs ("RMI XLR", stdout
);
13705 case AFL_EXT_OCTEON3
:
13706 fputs ("Cavium Networks Octeon3", stdout
);
13708 case AFL_EXT_OCTEON2
:
13709 fputs ("Cavium Networks Octeon2", stdout
);
13711 case AFL_EXT_OCTEONP
:
13712 fputs ("Cavium Networks OcteonP", stdout
);
13714 case AFL_EXT_LOONGSON_3A
:
13715 fputs ("Loongson 3A", stdout
);
13717 case AFL_EXT_OCTEON
:
13718 fputs ("Cavium Networks Octeon", stdout
);
13721 fputs ("Toshiba R5900", stdout
);
13724 fputs ("MIPS R4650", stdout
);
13727 fputs ("LSI R4010", stdout
);
13730 fputs ("NEC VR4100", stdout
);
13733 fputs ("Toshiba R3900", stdout
);
13735 case AFL_EXT_10000
:
13736 fputs ("MIPS R10000", stdout
);
13739 fputs ("Broadcom SB-1", stdout
);
13742 fputs ("NEC VR4111/VR4181", stdout
);
13745 fputs ("NEC VR4120", stdout
);
13748 fputs ("NEC VR5400", stdout
);
13751 fputs ("NEC VR5500", stdout
);
13753 case AFL_EXT_LOONGSON_2E
:
13754 fputs ("ST Microelectronics Loongson 2E", stdout
);
13756 case AFL_EXT_LOONGSON_2F
:
13757 fputs ("ST Microelectronics Loongson 2F", stdout
);
13760 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13765 get_mips_reg_size (int reg_size
)
13767 return (reg_size
== AFL_REG_NONE
) ? 0
13768 : (reg_size
== AFL_REG_32
) ? 32
13769 : (reg_size
== AFL_REG_64
) ? 64
13770 : (reg_size
== AFL_REG_128
) ? 128
13775 process_mips_specific (FILE * file
)
13777 Elf_Internal_Dyn
* entry
;
13778 Elf_Internal_Shdr
*sect
= NULL
;
13779 size_t liblist_offset
= 0;
13780 size_t liblistno
= 0;
13781 size_t conflictsno
= 0;
13782 size_t options_offset
= 0;
13783 size_t conflicts_offset
= 0;
13784 size_t pltrelsz
= 0;
13786 bfd_vma pltgot
= 0;
13787 bfd_vma mips_pltgot
= 0;
13788 bfd_vma jmprel
= 0;
13789 bfd_vma local_gotno
= 0;
13790 bfd_vma gotsym
= 0;
13791 bfd_vma symtabno
= 0;
13793 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13794 display_mips_gnu_attribute
);
13796 sect
= find_section (".MIPS.abiflags");
13800 Elf_External_ABIFlags_v0
*abiflags_ext
;
13801 Elf_Internal_ABIFlags_v0 abiflags_in
;
13803 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13804 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13807 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13808 sect
->sh_size
, _("MIPS ABI Flags section"));
13811 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13812 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13813 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13814 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13815 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13816 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13817 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13818 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13819 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13820 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13821 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13823 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13824 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13825 if (abiflags_in
.isa_rev
> 1)
13826 printf ("r%d", abiflags_in
.isa_rev
);
13827 printf ("\nGPR size: %d",
13828 get_mips_reg_size (abiflags_in
.gpr_size
));
13829 printf ("\nCPR1 size: %d",
13830 get_mips_reg_size (abiflags_in
.cpr1_size
));
13831 printf ("\nCPR2 size: %d",
13832 get_mips_reg_size (abiflags_in
.cpr2_size
));
13833 fputs ("\nFP ABI: ", stdout
);
13834 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13835 fputs ("ISA Extension: ", stdout
);
13836 print_mips_isa_ext (abiflags_in
.isa_ext
);
13837 fputs ("\nASEs:", stdout
);
13838 print_mips_ases (abiflags_in
.ases
);
13839 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13840 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13841 fputc ('\n', stdout
);
13842 free (abiflags_ext
);
13847 /* We have a lot of special sections. Thanks SGI! */
13848 if (dynamic_section
== NULL
)
13849 /* No information available. */
13852 for (entry
= dynamic_section
;
13853 /* PR 17531 file: 012-50589-0.004. */
13854 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13856 switch (entry
->d_tag
)
13858 case DT_MIPS_LIBLIST
:
13860 = offset_from_vma (file
, entry
->d_un
.d_val
,
13861 liblistno
* sizeof (Elf32_External_Lib
));
13863 case DT_MIPS_LIBLISTNO
:
13864 liblistno
= entry
->d_un
.d_val
;
13866 case DT_MIPS_OPTIONS
:
13867 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13869 case DT_MIPS_CONFLICT
:
13871 = offset_from_vma (file
, entry
->d_un
.d_val
,
13872 conflictsno
* sizeof (Elf32_External_Conflict
));
13874 case DT_MIPS_CONFLICTNO
:
13875 conflictsno
= entry
->d_un
.d_val
;
13878 pltgot
= entry
->d_un
.d_ptr
;
13880 case DT_MIPS_LOCAL_GOTNO
:
13881 local_gotno
= entry
->d_un
.d_val
;
13883 case DT_MIPS_GOTSYM
:
13884 gotsym
= entry
->d_un
.d_val
;
13886 case DT_MIPS_SYMTABNO
:
13887 symtabno
= entry
->d_un
.d_val
;
13889 case DT_MIPS_PLTGOT
:
13890 mips_pltgot
= entry
->d_un
.d_ptr
;
13893 pltrel
= entry
->d_un
.d_val
;
13896 pltrelsz
= entry
->d_un
.d_val
;
13899 jmprel
= entry
->d_un
.d_ptr
;
13905 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13907 Elf32_External_Lib
* elib
;
13910 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13912 sizeof (Elf32_External_Lib
),
13913 _("liblist section data"));
13916 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13917 (unsigned long) liblistno
);
13918 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13921 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13928 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13929 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13930 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13931 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13932 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13934 tmp
= gmtime (&atime
);
13935 snprintf (timebuf
, sizeof (timebuf
),
13936 "%04u-%02u-%02uT%02u:%02u:%02u",
13937 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13938 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13940 printf ("%3lu: ", (unsigned long) cnt
);
13941 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13942 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13944 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13945 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13946 liblist
.l_version
);
13948 if (liblist
.l_flags
== 0)
13952 static const struct
13959 { " EXACT_MATCH", LL_EXACT_MATCH
},
13960 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13961 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13962 { " EXPORTS", LL_EXPORTS
},
13963 { " DELAY_LOAD", LL_DELAY_LOAD
},
13964 { " DELTA", LL_DELTA
}
13966 int flags
= liblist
.l_flags
;
13969 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13970 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13972 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13973 flags
^= l_flags_vals
[fcnt
].bit
;
13976 printf (" %#x", (unsigned int) flags
);
13986 if (options_offset
!= 0)
13988 Elf_External_Options
* eopt
;
13989 Elf_Internal_Options
* iopt
;
13990 Elf_Internal_Options
* option
;
13993 sect
= section_headers
;
13995 /* Find the section header so that we get the size. */
13996 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13997 /* PR 17533 file: 012-277276-0.004. */
14000 error (_("No MIPS_OPTIONS header found\n"));
14004 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14005 sect
->sh_size
, _("options"));
14008 iopt
= (Elf_Internal_Options
*)
14009 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14012 error (_("Out of memory allocatinf space for MIPS options\n"));
14019 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14021 Elf_External_Options
* eoption
;
14023 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14025 option
->kind
= BYTE_GET (eoption
->kind
);
14026 option
->size
= BYTE_GET (eoption
->size
);
14027 option
->section
= BYTE_GET (eoption
->section
);
14028 option
->info
= BYTE_GET (eoption
->info
);
14030 /* PR 17531: file: ffa0fa3b. */
14031 if (option
->size
< sizeof (* eopt
)
14032 || offset
+ option
->size
> sect
->sh_size
)
14034 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14037 offset
+= option
->size
;
14043 printf (_("\nSection '%s' contains %d entries:\n"),
14044 printable_section_name (sect
), cnt
);
14053 switch (option
->kind
)
14056 /* This shouldn't happen. */
14057 printf (" NULL %d %lx", option
->section
, option
->info
);
14060 printf (" REGINFO ");
14061 if (elf_header
.e_machine
== EM_MIPS
)
14064 Elf32_External_RegInfo
* ereg
;
14065 Elf32_RegInfo reginfo
;
14067 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14068 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14069 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14070 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14071 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14072 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14073 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14075 printf ("GPR %08lx GP 0x%lx\n",
14076 reginfo
.ri_gprmask
,
14077 (unsigned long) reginfo
.ri_gp_value
);
14078 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14079 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14080 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14085 Elf64_External_RegInfo
* ereg
;
14086 Elf64_Internal_RegInfo reginfo
;
14088 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14089 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14090 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14091 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14092 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14093 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14094 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14096 printf ("GPR %08lx GP 0x",
14097 reginfo
.ri_gprmask
);
14098 printf_vma (reginfo
.ri_gp_value
);
14101 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14102 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14103 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14107 case ODK_EXCEPTIONS
:
14108 fputs (" EXCEPTIONS fpe_min(", stdout
);
14109 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14110 fputs (") fpe_max(", stdout
);
14111 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14112 fputs (")", stdout
);
14114 if (option
->info
& OEX_PAGE0
)
14115 fputs (" PAGE0", stdout
);
14116 if (option
->info
& OEX_SMM
)
14117 fputs (" SMM", stdout
);
14118 if (option
->info
& OEX_FPDBUG
)
14119 fputs (" FPDBUG", stdout
);
14120 if (option
->info
& OEX_DISMISS
)
14121 fputs (" DISMISS", stdout
);
14124 fputs (" PAD ", stdout
);
14125 if (option
->info
& OPAD_PREFIX
)
14126 fputs (" PREFIX", stdout
);
14127 if (option
->info
& OPAD_POSTFIX
)
14128 fputs (" POSTFIX", stdout
);
14129 if (option
->info
& OPAD_SYMBOL
)
14130 fputs (" SYMBOL", stdout
);
14133 fputs (" HWPATCH ", stdout
);
14134 if (option
->info
& OHW_R4KEOP
)
14135 fputs (" R4KEOP", stdout
);
14136 if (option
->info
& OHW_R8KPFETCH
)
14137 fputs (" R8KPFETCH", stdout
);
14138 if (option
->info
& OHW_R5KEOP
)
14139 fputs (" R5KEOP", stdout
);
14140 if (option
->info
& OHW_R5KCVTL
)
14141 fputs (" R5KCVTL", stdout
);
14144 fputs (" FILL ", stdout
);
14145 /* XXX Print content of info word? */
14148 fputs (" TAGS ", stdout
);
14149 /* XXX Print content of info word? */
14152 fputs (" HWAND ", stdout
);
14153 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14154 fputs (" R4KEOP_CHECKED", stdout
);
14155 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14156 fputs (" R4KEOP_CLEAN", stdout
);
14159 fputs (" HWOR ", stdout
);
14160 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14161 fputs (" R4KEOP_CHECKED", stdout
);
14162 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14163 fputs (" R4KEOP_CLEAN", stdout
);
14166 printf (" GP_GROUP %#06lx self-contained %#06lx",
14167 option
->info
& OGP_GROUP
,
14168 (option
->info
& OGP_SELF
) >> 16);
14171 printf (" IDENT %#06lx self-contained %#06lx",
14172 option
->info
& OGP_GROUP
,
14173 (option
->info
& OGP_SELF
) >> 16);
14176 /* This shouldn't happen. */
14177 printf (" %3d ??? %d %lx",
14178 option
->kind
, option
->section
, option
->info
);
14182 len
= sizeof (* eopt
);
14183 while (len
< option
->size
)
14185 char datum
= * ((char *) eopt
+ offset
+ len
);
14187 if (ISPRINT (datum
))
14188 printf ("%c", datum
);
14190 printf ("\\%03o", datum
);
14193 fputs ("\n", stdout
);
14195 offset
+= option
->size
;
14203 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14205 Elf32_Conflict
* iconf
;
14208 if (dynamic_symbols
== NULL
)
14210 error (_("conflict list found without a dynamic symbol table\n"));
14214 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14217 error (_("Out of memory allocating space for dynamic conflicts\n"));
14223 Elf32_External_Conflict
* econf32
;
14225 econf32
= (Elf32_External_Conflict
*)
14226 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14227 sizeof (* econf32
), _("conflict"));
14231 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14232 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14238 Elf64_External_Conflict
* econf64
;
14240 econf64
= (Elf64_External_Conflict
*)
14241 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14242 sizeof (* econf64
), _("conflict"));
14246 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14247 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14252 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14253 (unsigned long) conflictsno
);
14254 puts (_(" Num: Index Value Name"));
14256 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14258 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14260 if (iconf
[cnt
] >= num_dynamic_syms
)
14261 printf (_("<corrupt symbol index>"));
14264 Elf_Internal_Sym
* psym
;
14266 psym
= & dynamic_symbols
[iconf
[cnt
]];
14267 print_vma (psym
->st_value
, FULL_HEX
);
14269 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14270 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14272 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14280 if (pltgot
!= 0 && local_gotno
!= 0)
14282 bfd_vma ent
, local_end
, global_end
;
14284 unsigned char * data
;
14285 unsigned char * data_end
;
14289 addr_size
= (is_32bit_elf
? 4 : 8);
14290 local_end
= pltgot
+ local_gotno
* addr_size
;
14292 /* PR binutils/17533 file: 012-111227-0.004 */
14293 if (symtabno
< gotsym
)
14295 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14296 (unsigned long) gotsym
, (unsigned long) symtabno
);
14300 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14301 /* PR 17531: file: 54c91a34. */
14302 if (global_end
< local_end
)
14304 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14308 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14309 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14310 global_end
- pltgot
, 1,
14311 _("Global Offset Table data"));
14314 data_end
= data
+ (global_end
- pltgot
);
14316 printf (_("\nPrimary GOT:\n"));
14317 printf (_(" Canonical gp value: "));
14318 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14321 printf (_(" Reserved entries:\n"));
14322 printf (_(" %*s %10s %*s Purpose\n"),
14323 addr_size
* 2, _("Address"), _("Access"),
14324 addr_size
* 2, _("Initial"));
14325 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14326 printf (_(" Lazy resolver\n"));
14327 if (ent
== (bfd_vma
) -1)
14328 goto got_print_fail
;
14330 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14331 >> (addr_size
* 8 - 1)) != 0)
14333 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14334 printf (_(" Module pointer (GNU extension)\n"));
14335 if (ent
== (bfd_vma
) -1)
14336 goto got_print_fail
;
14340 if (ent
< local_end
)
14342 printf (_(" Local entries:\n"));
14343 printf (" %*s %10s %*s\n",
14344 addr_size
* 2, _("Address"), _("Access"),
14345 addr_size
* 2, _("Initial"));
14346 while (ent
< local_end
)
14348 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14350 if (ent
== (bfd_vma
) -1)
14351 goto got_print_fail
;
14356 if (gotsym
< symtabno
)
14360 printf (_(" Global entries:\n"));
14361 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14362 addr_size
* 2, _("Address"),
14364 addr_size
* 2, _("Initial"),
14365 addr_size
* 2, _("Sym.Val."),
14367 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14368 _("Ndx"), _("Name"));
14370 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14372 for (i
= gotsym
; i
< symtabno
; i
++)
14374 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14377 if (dynamic_symbols
== NULL
)
14378 printf (_("<no dynamic symbols>"));
14379 else if (i
< num_dynamic_syms
)
14381 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14383 print_vma (psym
->st_value
, LONG_HEX
);
14384 printf (" %-7s %3s ",
14385 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14386 get_symbol_index_type (psym
->st_shndx
));
14388 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14389 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14391 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14394 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14395 (unsigned long) i
);
14398 if (ent
== (bfd_vma
) -1)
14409 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14412 size_t offset
, rel_offset
;
14413 unsigned long count
, i
;
14414 unsigned char * data
;
14415 int addr_size
, sym_width
;
14416 Elf_Internal_Rela
* rels
;
14418 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14419 if (pltrel
== DT_RELA
)
14421 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14426 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14431 addr_size
= (is_32bit_elf
? 4 : 8);
14432 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14434 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14435 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14436 1, _("Procedure Linkage Table data"));
14440 printf ("\nPLT GOT:\n\n");
14441 printf (_(" Reserved entries:\n"));
14442 printf (_(" %*s %*s Purpose\n"),
14443 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14444 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14445 printf (_(" PLT lazy resolver\n"));
14446 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14447 printf (_(" Module pointer\n"));
14450 printf (_(" Entries:\n"));
14451 printf (" %*s %*s %*s %-7s %3s %s\n",
14452 addr_size
* 2, _("Address"),
14453 addr_size
* 2, _("Initial"),
14454 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14455 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14456 for (i
= 0; i
< count
; i
++)
14458 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14460 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14463 if (idx
>= num_dynamic_syms
)
14464 printf (_("<corrupt symbol index: %lu>"), idx
);
14467 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14469 print_vma (psym
->st_value
, LONG_HEX
);
14470 printf (" %-7s %3s ",
14471 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14472 get_symbol_index_type (psym
->st_shndx
));
14473 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14474 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14476 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14491 process_nds32_specific (FILE * file
)
14493 Elf_Internal_Shdr
*sect
= NULL
;
14495 sect
= find_section (".nds32_e_flags");
14498 unsigned int *flag
;
14500 printf ("\nNDS32 elf flags section:\n");
14501 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14502 sect
->sh_size
, _("NDS32 elf flags section"));
14504 switch ((*flag
) & 0x3)
14507 printf ("(VEC_SIZE):\tNo entry.\n");
14510 printf ("(VEC_SIZE):\t4 bytes\n");
14513 printf ("(VEC_SIZE):\t16 bytes\n");
14516 printf ("(VEC_SIZE):\treserved\n");
14525 process_gnu_liblist (FILE * file
)
14527 Elf_Internal_Shdr
* section
;
14528 Elf_Internal_Shdr
* string_sec
;
14529 Elf32_External_Lib
* elib
;
14531 size_t strtab_size
;
14538 for (i
= 0, section
= section_headers
;
14539 i
< elf_header
.e_shnum
;
14542 switch (section
->sh_type
)
14544 case SHT_GNU_LIBLIST
:
14545 if (section
->sh_link
>= elf_header
.e_shnum
)
14548 elib
= (Elf32_External_Lib
*)
14549 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14550 _("liblist section data"));
14554 string_sec
= section_headers
+ section
->sh_link
;
14556 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14557 string_sec
->sh_size
,
14558 _("liblist string table"));
14560 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14566 strtab_size
= string_sec
->sh_size
;
14568 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14569 printable_section_name (section
),
14570 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14572 puts (_(" Library Time Stamp Checksum Version Flags"));
14574 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14582 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14583 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14584 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14585 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14586 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14588 tmp
= gmtime (&atime
);
14589 snprintf (timebuf
, sizeof (timebuf
),
14590 "%04u-%02u-%02uT%02u:%02u:%02u",
14591 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14592 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14594 printf ("%3lu: ", (unsigned long) cnt
);
14596 printf ("%-20s", liblist
.l_name
< strtab_size
14597 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14599 printf ("%-20.20s", liblist
.l_name
< strtab_size
14600 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14601 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14602 liblist
.l_version
, liblist
.l_flags
);
14613 static const char *
14614 get_note_type (unsigned e_type
)
14616 static char buff
[64];
14618 if (elf_header
.e_type
== ET_CORE
)
14622 return _("NT_AUXV (auxiliary vector)");
14624 return _("NT_PRSTATUS (prstatus structure)");
14626 return _("NT_FPREGSET (floating point registers)");
14628 return _("NT_PRPSINFO (prpsinfo structure)");
14629 case NT_TASKSTRUCT
:
14630 return _("NT_TASKSTRUCT (task structure)");
14632 return _("NT_PRXFPREG (user_xfpregs structure)");
14634 return _("NT_PPC_VMX (ppc Altivec registers)");
14636 return _("NT_PPC_VSX (ppc VSX registers)");
14638 return _("NT_386_TLS (x86 TLS information)");
14639 case NT_386_IOPERM
:
14640 return _("NT_386_IOPERM (x86 I/O permissions)");
14641 case NT_X86_XSTATE
:
14642 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14643 case NT_S390_HIGH_GPRS
:
14644 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14645 case NT_S390_TIMER
:
14646 return _("NT_S390_TIMER (s390 timer register)");
14647 case NT_S390_TODCMP
:
14648 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14649 case NT_S390_TODPREG
:
14650 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14652 return _("NT_S390_CTRS (s390 control registers)");
14653 case NT_S390_PREFIX
:
14654 return _("NT_S390_PREFIX (s390 prefix register)");
14655 case NT_S390_LAST_BREAK
:
14656 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14657 case NT_S390_SYSTEM_CALL
:
14658 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14660 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14661 case NT_S390_VXRS_LOW
:
14662 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14663 case NT_S390_VXRS_HIGH
:
14664 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14666 return _("NT_ARM_VFP (arm VFP registers)");
14668 return _("NT_ARM_TLS (AArch TLS registers)");
14669 case NT_ARM_HW_BREAK
:
14670 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14671 case NT_ARM_HW_WATCH
:
14672 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14674 return _("NT_PSTATUS (pstatus structure)");
14676 return _("NT_FPREGS (floating point registers)");
14678 return _("NT_PSINFO (psinfo structure)");
14680 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14682 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14683 case NT_WIN32PSTATUS
:
14684 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14686 return _("NT_SIGINFO (siginfo_t data)");
14688 return _("NT_FILE (mapped files)");
14696 return _("NT_VERSION (version)");
14698 return _("NT_ARCH (architecture)");
14703 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14708 print_core_note (Elf_Internal_Note
*pnote
)
14710 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14711 bfd_vma count
, page_size
;
14712 unsigned char *descdata
, *filenames
, *descend
;
14714 if (pnote
->type
!= NT_FILE
)
14720 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14721 /* Still "successful". */
14726 if (pnote
->descsz
< 2 * addr_size
)
14728 printf (_(" Malformed note - too short for header\n"));
14732 descdata
= (unsigned char *) pnote
->descdata
;
14733 descend
= descdata
+ pnote
->descsz
;
14735 if (descdata
[pnote
->descsz
- 1] != '\0')
14737 printf (_(" Malformed note - does not end with \\0\n"));
14741 count
= byte_get (descdata
, addr_size
);
14742 descdata
+= addr_size
;
14744 page_size
= byte_get (descdata
, addr_size
);
14745 descdata
+= addr_size
;
14747 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14749 printf (_(" Malformed note - too short for supplied file count\n"));
14753 printf (_(" Page size: "));
14754 print_vma (page_size
, DEC
);
14757 printf (_(" %*s%*s%*s\n"),
14758 (int) (2 + 2 * addr_size
), _("Start"),
14759 (int) (4 + 2 * addr_size
), _("End"),
14760 (int) (4 + 2 * addr_size
), _("Page Offset"));
14761 filenames
= descdata
+ count
* 3 * addr_size
;
14762 while (--count
> 0)
14764 bfd_vma start
, end
, file_ofs
;
14766 if (filenames
== descend
)
14768 printf (_(" Malformed note - filenames end too early\n"));
14772 start
= byte_get (descdata
, addr_size
);
14773 descdata
+= addr_size
;
14774 end
= byte_get (descdata
, addr_size
);
14775 descdata
+= addr_size
;
14776 file_ofs
= byte_get (descdata
, addr_size
);
14777 descdata
+= addr_size
;
14780 print_vma (start
, FULL_HEX
);
14782 print_vma (end
, FULL_HEX
);
14784 print_vma (file_ofs
, FULL_HEX
);
14785 printf ("\n %s\n", filenames
);
14787 filenames
+= 1 + strlen ((char *) filenames
);
14793 static const char *
14794 get_gnu_elf_note_type (unsigned e_type
)
14796 static char buff
[64];
14800 case NT_GNU_ABI_TAG
:
14801 return _("NT_GNU_ABI_TAG (ABI version tag)");
14803 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14804 case NT_GNU_BUILD_ID
:
14805 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14806 case NT_GNU_GOLD_VERSION
:
14807 return _("NT_GNU_GOLD_VERSION (gold version)");
14812 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14817 print_gnu_note (Elf_Internal_Note
*pnote
)
14819 switch (pnote
->type
)
14821 case NT_GNU_BUILD_ID
:
14825 printf (_(" Build ID: "));
14826 for (i
= 0; i
< pnote
->descsz
; ++i
)
14827 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14832 case NT_GNU_ABI_TAG
:
14834 unsigned long os
, major
, minor
, subminor
;
14835 const char *osname
;
14837 /* PR 17531: file: 030-599401-0.004. */
14838 if (pnote
->descsz
< 16)
14840 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14844 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14845 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14846 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14847 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14851 case GNU_ABI_TAG_LINUX
:
14854 case GNU_ABI_TAG_HURD
:
14857 case GNU_ABI_TAG_SOLARIS
:
14858 osname
= "Solaris";
14860 case GNU_ABI_TAG_FREEBSD
:
14861 osname
= "FreeBSD";
14863 case GNU_ABI_TAG_NETBSD
:
14867 osname
= "Unknown";
14871 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14872 major
, minor
, subminor
);
14876 case NT_GNU_GOLD_VERSION
:
14880 printf (_(" Version: "));
14881 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14882 printf ("%c", pnote
->descdata
[i
]);
14891 static const char *
14892 get_v850_elf_note_type (enum v850_notes n_type
)
14894 static char buff
[64];
14898 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
14899 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
14900 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
14901 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
14902 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
14903 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
14905 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
14911 print_v850_note (Elf_Internal_Note
* pnote
)
14915 if (pnote
->descsz
!= 4)
14917 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
14921 printf (_("not set\n"));
14925 switch (pnote
->type
)
14927 case V850_NOTE_ALIGNMENT
:
14930 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
14931 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
14935 case V850_NOTE_DATA_SIZE
:
14938 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
14939 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
14943 case V850_NOTE_FPU_INFO
:
14946 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
14947 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
14951 case V850_NOTE_MMU_INFO
:
14952 case V850_NOTE_CACHE_INFO
:
14953 case V850_NOTE_SIMD_INFO
:
14954 if (val
== EF_RH850_SIMD
)
14956 printf (_("yes\n"));
14962 /* An 'unknown note type' message will already have been displayed. */
14966 printf (_("unknown value: %x\n"), val
);
14970 static const char *
14971 get_netbsd_elfcore_note_type (unsigned e_type
)
14973 static char buff
[64];
14975 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14977 /* NetBSD core "procinfo" structure. */
14978 return _("NetBSD procinfo structure");
14981 /* As of Jan 2002 there are no other machine-independent notes
14982 defined for NetBSD core files. If the note type is less
14983 than the start of the machine-dependent note types, we don't
14986 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14988 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14992 switch (elf_header
.e_machine
)
14994 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14995 and PT_GETFPREGS == mach+2. */
15000 case EM_SPARC32PLUS
:
15004 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15005 return _("PT_GETREGS (reg structure)");
15006 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15007 return _("PT_GETFPREGS (fpreg structure)");
15013 /* On all other arch's, PT_GETREGS == mach+1 and
15014 PT_GETFPREGS == mach+3. */
15018 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15019 return _("PT_GETREGS (reg structure)");
15020 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15021 return _("PT_GETFPREGS (fpreg structure)");
15027 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15028 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15032 static const char *
15033 get_stapsdt_note_type (unsigned e_type
)
15035 static char buff
[64];
15040 return _("NT_STAPSDT (SystemTap probe descriptors)");
15046 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15051 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15053 int addr_size
= is_32bit_elf
? 4 : 8;
15054 char *data
= pnote
->descdata
;
15055 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15056 bfd_vma pc
, base_addr
, semaphore
;
15057 char *provider
, *probe
, *arg_fmt
;
15059 pc
= byte_get ((unsigned char *) data
, addr_size
);
15061 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15063 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15067 data
+= strlen (data
) + 1;
15069 data
+= strlen (data
) + 1;
15071 data
+= strlen (data
) + 1;
15073 printf (_(" Provider: %s\n"), provider
);
15074 printf (_(" Name: %s\n"), probe
);
15075 printf (_(" Location: "));
15076 print_vma (pc
, FULL_HEX
);
15077 printf (_(", Base: "));
15078 print_vma (base_addr
, FULL_HEX
);
15079 printf (_(", Semaphore: "));
15080 print_vma (semaphore
, FULL_HEX
);
15082 printf (_(" Arguments: %s\n"), arg_fmt
);
15084 return data
== data_end
;
15087 static const char *
15088 get_ia64_vms_note_type (unsigned e_type
)
15090 static char buff
[64];
15095 return _("NT_VMS_MHD (module header)");
15097 return _("NT_VMS_LNM (language name)");
15099 return _("NT_VMS_SRC (source files)");
15101 return "NT_VMS_TITLE";
15103 return _("NT_VMS_EIDC (consistency check)");
15104 case NT_VMS_FPMODE
:
15105 return _("NT_VMS_FPMODE (FP mode)");
15106 case NT_VMS_LINKTIME
:
15107 return "NT_VMS_LINKTIME";
15108 case NT_VMS_IMGNAM
:
15109 return _("NT_VMS_IMGNAM (image name)");
15111 return _("NT_VMS_IMGID (image id)");
15112 case NT_VMS_LINKID
:
15113 return _("NT_VMS_LINKID (link id)");
15114 case NT_VMS_IMGBID
:
15115 return _("NT_VMS_IMGBID (build id)");
15116 case NT_VMS_GSTNAM
:
15117 return _("NT_VMS_GSTNAM (sym table name)");
15118 case NT_VMS_ORIG_DYN
:
15119 return "NT_VMS_ORIG_DYN";
15120 case NT_VMS_PATCHTIME
:
15121 return "NT_VMS_PATCHTIME";
15123 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15129 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15131 switch (pnote
->type
)
15134 if (pnote
->descsz
> 36)
15136 size_t l
= strlen (pnote
->descdata
+ 34);
15137 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15138 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15139 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15140 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15143 printf (_(" Invalid size\n"));
15146 printf (_(" Language: %s\n"), pnote
->descdata
);
15149 case NT_VMS_FPMODE
:
15150 printf (_(" Floating Point mode: "));
15151 printf ("0x%016" BFD_VMA_FMT
"x\n",
15152 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15154 case NT_VMS_LINKTIME
:
15155 printf (_(" Link time: "));
15157 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15160 case NT_VMS_PATCHTIME
:
15161 printf (_(" Patch time: "));
15163 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15166 case NT_VMS_ORIG_DYN
:
15167 printf (_(" Major id: %u, minor id: %u\n"),
15168 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15169 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15170 printf (_(" Last modified : "));
15172 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15173 printf (_("\n Link flags : "));
15174 printf ("0x%016" BFD_VMA_FMT
"x\n",
15175 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15176 printf (_(" Header flags: 0x%08x\n"),
15177 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15178 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15181 case NT_VMS_IMGNAM
:
15182 printf (_(" Image name: %s\n"), pnote
->descdata
);
15184 case NT_VMS_GSTNAM
:
15185 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15188 printf (_(" Image id: %s\n"), pnote
->descdata
);
15190 case NT_VMS_LINKID
:
15191 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15199 /* Note that by the ELF standard, the name field is already null byte
15200 terminated, and namesz includes the terminating null byte.
15201 I.E. the value of namesz for the name "FSF" is 4.
15203 If the value of namesz is zero, there is no name present. */
15205 process_note (Elf_Internal_Note
* pnote
)
15207 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15210 if (pnote
->namesz
== 0)
15211 /* If there is no note name, then use the default set of
15212 note type strings. */
15213 nt
= get_note_type (pnote
->type
);
15215 else if (const_strneq (pnote
->namedata
, "GNU"))
15216 /* GNU-specific object file notes. */
15217 nt
= get_gnu_elf_note_type (pnote
->type
);
15219 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15220 /* NetBSD-specific core file notes. */
15221 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15223 else if (strneq (pnote
->namedata
, "SPU/", 4))
15225 /* SPU-specific core file notes. */
15226 nt
= pnote
->namedata
+ 4;
15230 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15231 /* VMS/ia64-specific file notes. */
15232 nt
= get_ia64_vms_note_type (pnote
->type
);
15234 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15235 nt
= get_stapsdt_note_type (pnote
->type
);
15238 /* Don't recognize this note name; just use the default set of
15239 note type strings. */
15240 nt
= get_note_type (pnote
->type
);
15242 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15244 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15245 return print_ia64_vms_note (pnote
);
15246 else if (const_strneq (pnote
->namedata
, "GNU"))
15247 return print_gnu_note (pnote
);
15248 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15249 return print_stapsdt_note (pnote
);
15250 else if (const_strneq (pnote
->namedata
, "CORE"))
15251 return print_core_note (pnote
);
15258 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15260 Elf_External_Note
* pnotes
;
15261 Elf_External_Note
* external
;
15268 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15270 if (pnotes
== NULL
)
15275 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15276 (unsigned long) offset
, (unsigned long) length
);
15277 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15279 end
= (char *) pnotes
+ length
;
15280 while ((char *) external
< end
)
15282 Elf_Internal_Note inote
;
15285 char * temp
= NULL
;
15286 size_t data_remaining
= end
- (char *) external
;
15288 if (!is_ia64_vms ())
15290 /* PR binutils/15191
15291 Make sure that there is enough data to read. */
15292 min_notesz
= offsetof (Elf_External_Note
, name
);
15293 if (data_remaining
< min_notesz
)
15295 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15296 (int) data_remaining
);
15299 inote
.type
= BYTE_GET (external
->type
);
15300 inote
.namesz
= BYTE_GET (external
->namesz
);
15301 inote
.namedata
= external
->name
;
15302 inote
.descsz
= BYTE_GET (external
->descsz
);
15303 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15304 /* PR 17531: file: 3443835e. */
15305 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15307 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15308 inote
.descdata
= inote
.namedata
;
15312 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15313 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15317 Elf64_External_VMS_Note
*vms_external
;
15319 /* PR binutils/15191
15320 Make sure that there is enough data to read. */
15321 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15322 if (data_remaining
< min_notesz
)
15324 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15325 (int) data_remaining
);
15329 vms_external
= (Elf64_External_VMS_Note
*) external
;
15330 inote
.type
= BYTE_GET (vms_external
->type
);
15331 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15332 inote
.namedata
= vms_external
->name
;
15333 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15334 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15335 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15336 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15339 if (inote
.descdata
< (char *) external
+ min_notesz
15340 || next
< (char *) external
+ min_notesz
15341 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15342 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15343 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15344 || data_remaining
< (size_t)(next
- (char *) external
))
15346 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15347 (unsigned long) ((char *) external
- (char *) pnotes
));
15348 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15349 inote
.type
, inote
.namesz
, inote
.descsz
);
15353 external
= (Elf_External_Note
*) next
;
15355 /* Verify that name is null terminated. It appears that at least
15356 one version of Linux (RedHat 6.0) generates corefiles that don't
15357 comply with the ELF spec by failing to include the null byte in
15359 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15361 temp
= (char *) malloc (inote
.namesz
+ 1);
15364 error (_("Out of memory allocating space for inote name\n"));
15369 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15370 temp
[inote
.namesz
] = 0;
15372 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15373 inote
.namedata
= temp
;
15376 res
&= process_note (& inote
);
15391 process_corefile_note_segments (FILE * file
)
15393 Elf_Internal_Phdr
* segment
;
15397 if (! get_program_headers (file
))
15400 for (i
= 0, segment
= program_headers
;
15401 i
< elf_header
.e_phnum
;
15404 if (segment
->p_type
== PT_NOTE
)
15405 res
&= process_corefile_note_segment (file
,
15406 (bfd_vma
) segment
->p_offset
,
15407 (bfd_vma
) segment
->p_filesz
);
15414 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15416 Elf_External_Note
* pnotes
;
15417 Elf_External_Note
* external
;
15424 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15426 if (pnotes
== NULL
)
15430 end
= (char*) pnotes
+ length
;
15432 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15433 (unsigned long) offset
, (unsigned long) length
);
15435 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15437 Elf_External_Note
* next
;
15438 Elf_Internal_Note inote
;
15440 inote
.type
= BYTE_GET (external
->type
);
15441 inote
.namesz
= BYTE_GET (external
->namesz
);
15442 inote
.namedata
= external
->name
;
15443 inote
.descsz
= BYTE_GET (external
->descsz
);
15444 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15445 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15447 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15449 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15450 inote
.descdata
= inote
.namedata
;
15454 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15456 if ( ((char *) next
> end
)
15457 || ((char *) next
< (char *) pnotes
))
15459 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15460 (unsigned long) ((char *) external
- (char *) pnotes
));
15461 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15462 inote
.type
, inote
.namesz
, inote
.descsz
);
15468 /* Prevent out-of-bounds indexing. */
15469 if ( inote
.namedata
+ inote
.namesz
> end
15470 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15472 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15473 (unsigned long) ((char *) external
- (char *) pnotes
));
15474 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15475 inote
.type
, inote
.namesz
, inote
.descsz
);
15479 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15481 if (! print_v850_note (& inote
))
15484 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15485 inote
.namesz
, inote
.descsz
);
15495 process_note_sections (FILE * file
)
15497 Elf_Internal_Shdr
* section
;
15502 for (i
= 0, section
= section_headers
;
15503 i
< elf_header
.e_shnum
&& section
!= NULL
;
15506 if (section
->sh_type
== SHT_NOTE
)
15508 res
&= process_corefile_note_segment (file
,
15509 (bfd_vma
) section
->sh_offset
,
15510 (bfd_vma
) section
->sh_size
);
15514 if (( elf_header
.e_machine
== EM_V800
15515 || elf_header
.e_machine
== EM_V850
15516 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15517 && section
->sh_type
== SHT_RENESAS_INFO
)
15519 res
&= process_v850_notes (file
,
15520 (bfd_vma
) section
->sh_offset
,
15521 (bfd_vma
) section
->sh_size
);
15527 /* Try processing NOTE segments instead. */
15528 return process_corefile_note_segments (file
);
15534 process_notes (FILE * file
)
15536 /* If we have not been asked to display the notes then do nothing. */
15540 if (elf_header
.e_type
!= ET_CORE
)
15541 return process_note_sections (file
);
15543 /* No program headers means no NOTE segment. */
15544 if (elf_header
.e_phnum
> 0)
15545 return process_corefile_note_segments (file
);
15547 printf (_("No note segments present in the core file.\n"));
15552 process_arch_specific (FILE * file
)
15557 switch (elf_header
.e_machine
)
15560 return process_arm_specific (file
);
15562 case EM_MIPS_RS3_LE
:
15563 return process_mips_specific (file
);
15566 return process_nds32_specific (file
);
15569 return process_power_specific (file
);
15572 case EM_SPARC32PLUS
:
15574 return process_sparc_specific (file
);
15577 return process_tic6x_specific (file
);
15580 return process_msp430x_specific (file
);
15588 get_file_header (FILE * file
)
15590 /* Read in the identity array. */
15591 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15594 /* Determine how to read the rest of the header. */
15595 switch (elf_header
.e_ident
[EI_DATA
])
15597 default: /* fall through */
15598 case ELFDATANONE
: /* fall through */
15600 byte_get
= byte_get_little_endian
;
15601 byte_put
= byte_put_little_endian
;
15604 byte_get
= byte_get_big_endian
;
15605 byte_put
= byte_put_big_endian
;
15609 /* For now we only support 32 bit and 64 bit ELF files. */
15610 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15612 /* Read in the rest of the header. */
15615 Elf32_External_Ehdr ehdr32
;
15617 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15620 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15621 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15622 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15623 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15624 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15625 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15626 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15627 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15628 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15629 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15630 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15631 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15632 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15636 Elf64_External_Ehdr ehdr64
;
15638 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15639 we will not be able to cope with the 64bit data found in
15640 64 ELF files. Detect this now and abort before we start
15641 overwriting things. */
15642 if (sizeof (bfd_vma
) < 8)
15644 error (_("This instance of readelf has been built without support for a\n\
15645 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15649 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15652 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15653 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15654 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15655 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15656 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15657 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15658 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15659 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15660 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15661 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15662 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15663 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15664 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15667 if (elf_header
.e_shoff
)
15669 /* There may be some extensions in the first section header. Don't
15670 bomb if we can't read it. */
15672 get_32bit_section_headers (file
, TRUE
);
15674 get_64bit_section_headers (file
, TRUE
);
15680 /* Process one ELF object file according to the command line options.
15681 This file may actually be stored in an archive. The file is
15682 positioned at the start of the ELF object. */
15685 process_object (char * file_name
, FILE * file
)
15689 if (! get_file_header (file
))
15691 error (_("%s: Failed to read file header\n"), file_name
);
15695 /* Initialise per file variables. */
15696 for (i
= ARRAY_SIZE (version_info
); i
--;)
15697 version_info
[i
] = 0;
15699 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15700 dynamic_info
[i
] = 0;
15701 dynamic_info_DT_GNU_HASH
= 0;
15703 /* Process the file. */
15705 printf (_("\nFile: %s\n"), file_name
);
15707 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15708 Note we do this even if cmdline_dump_sects is empty because we
15709 must make sure that the dump_sets array is zeroed out before each
15710 object file is processed. */
15711 if (num_dump_sects
> num_cmdline_dump_sects
)
15712 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15714 if (num_cmdline_dump_sects
> 0)
15716 if (num_dump_sects
== 0)
15717 /* A sneaky way of allocating the dump_sects array. */
15718 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15720 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15721 memcpy (dump_sects
, cmdline_dump_sects
,
15722 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15725 if (! process_file_header ())
15728 if (! process_section_headers (file
))
15730 /* Without loaded section headers we cannot process lots of
15732 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15734 if (! do_using_dynamic
)
15735 do_syms
= do_dyn_syms
= do_reloc
= 0;
15738 if (! process_section_groups (file
))
15740 /* Without loaded section groups we cannot process unwind. */
15744 if (process_program_headers (file
))
15745 process_dynamic_section (file
);
15747 process_relocs (file
);
15749 process_unwind (file
);
15751 process_symbol_table (file
);
15753 process_syminfo (file
);
15755 process_version_sections (file
);
15757 process_section_contents (file
);
15759 process_notes (file
);
15761 process_gnu_liblist (file
);
15763 process_arch_specific (file
);
15765 if (program_headers
)
15767 free (program_headers
);
15768 program_headers
= NULL
;
15771 if (section_headers
)
15773 free (section_headers
);
15774 section_headers
= NULL
;
15779 free (string_table
);
15780 string_table
= NULL
;
15781 string_table_length
= 0;
15784 if (dynamic_strings
)
15786 free (dynamic_strings
);
15787 dynamic_strings
= NULL
;
15788 dynamic_strings_length
= 0;
15791 if (dynamic_symbols
)
15793 free (dynamic_symbols
);
15794 dynamic_symbols
= NULL
;
15795 num_dynamic_syms
= 0;
15798 if (dynamic_syminfo
)
15800 free (dynamic_syminfo
);
15801 dynamic_syminfo
= NULL
;
15804 if (dynamic_section
)
15806 free (dynamic_section
);
15807 dynamic_section
= NULL
;
15810 if (section_headers_groups
)
15812 free (section_headers_groups
);
15813 section_headers_groups
= NULL
;
15816 if (section_groups
)
15818 struct group_list
* g
;
15819 struct group_list
* next
;
15821 for (i
= 0; i
< group_count
; i
++)
15823 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15830 free (section_groups
);
15831 section_groups
= NULL
;
15834 free_debug_memory ();
15839 /* Process an ELF archive.
15840 On entry the file is positioned just after the ARMAG string. */
15843 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15845 struct archive_info arch
;
15846 struct archive_info nested_arch
;
15852 /* The ARCH structure is used to hold information about this archive. */
15853 arch
.file_name
= NULL
;
15855 arch
.index_array
= NULL
;
15856 arch
.sym_table
= NULL
;
15857 arch
.longnames
= NULL
;
15859 /* The NESTED_ARCH structure is used as a single-item cache of information
15860 about a nested archive (when members of a thin archive reside within
15861 another regular archive file). */
15862 nested_arch
.file_name
= NULL
;
15863 nested_arch
.file
= NULL
;
15864 nested_arch
.index_array
= NULL
;
15865 nested_arch
.sym_table
= NULL
;
15866 nested_arch
.longnames
= NULL
;
15868 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15874 if (do_archive_index
)
15876 if (arch
.sym_table
== NULL
)
15877 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15880 unsigned long i
, l
;
15881 unsigned long current_pos
;
15883 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15884 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15885 current_pos
= ftell (file
);
15887 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15889 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15891 char * member_name
;
15893 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15895 if (member_name
!= NULL
)
15897 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15899 if (qualified_name
!= NULL
)
15901 printf (_("Contents of binary %s at offset "), qualified_name
);
15902 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15904 free (qualified_name
);
15909 if (l
>= arch
.sym_size
)
15911 error (_("%s: end of the symbol table reached before the end of the index\n"),
15915 /* PR 17531: file: 0b6630b2. */
15916 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15917 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15920 if (arch
.uses_64bit_indicies
)
15925 if (l
< arch
.sym_size
)
15926 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15927 file_name
, arch
.sym_size
- l
);
15929 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15931 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15937 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15938 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15939 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15940 && !do_section_groups
&& !do_dyn_syms
)
15942 ret
= 0; /* Archive index only. */
15953 char * qualified_name
;
15955 /* Read the next archive header. */
15956 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15958 error (_("%s: failed to seek to next archive header\n"), file_name
);
15961 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15962 if (got
!= sizeof arch
.arhdr
)
15966 error (_("%s: failed to read archive header\n"), file_name
);
15970 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15972 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15977 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15979 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15980 if (archive_file_size
& 01)
15981 ++archive_file_size
;
15983 name
= get_archive_member_name (&arch
, &nested_arch
);
15986 error (_("%s: bad archive file name\n"), file_name
);
15990 namelen
= strlen (name
);
15992 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15993 if (qualified_name
== NULL
)
15995 error (_("%s: bad archive file name\n"), file_name
);
16000 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16002 /* This is a proxy for an external member of a thin archive. */
16003 FILE * member_file
;
16004 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16005 if (member_file_name
== NULL
)
16011 member_file
= fopen (member_file_name
, "rb");
16012 if (member_file
== NULL
)
16014 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16015 free (member_file_name
);
16020 archive_file_offset
= arch
.nested_member_origin
;
16022 ret
|= process_object (qualified_name
, member_file
);
16024 fclose (member_file
);
16025 free (member_file_name
);
16027 else if (is_thin_archive
)
16029 /* PR 15140: Allow for corrupt thin archives. */
16030 if (nested_arch
.file
== NULL
)
16032 error (_("%s: contains corrupt thin archive: %s\n"),
16038 /* This is a proxy for a member of a nested archive. */
16039 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16041 /* The nested archive file will have been opened and setup by
16042 get_archive_member_name. */
16043 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16045 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16050 ret
|= process_object (qualified_name
, nested_arch
.file
);
16054 archive_file_offset
= arch
.next_arhdr_offset
;
16055 arch
.next_arhdr_offset
+= archive_file_size
;
16057 ret
|= process_object (qualified_name
, file
);
16060 if (dump_sects
!= NULL
)
16064 num_dump_sects
= 0;
16067 free (qualified_name
);
16071 if (nested_arch
.file
!= NULL
)
16072 fclose (nested_arch
.file
);
16073 release_archive (&nested_arch
);
16074 release_archive (&arch
);
16080 process_file (char * file_name
)
16083 struct stat statbuf
;
16084 char armag
[SARMAG
];
16087 if (stat (file_name
, &statbuf
) < 0)
16089 if (errno
== ENOENT
)
16090 error (_("'%s': No such file\n"), file_name
);
16092 error (_("Could not locate '%s'. System error message: %s\n"),
16093 file_name
, strerror (errno
));
16097 if (! S_ISREG (statbuf
.st_mode
))
16099 error (_("'%s' is not an ordinary file\n"), file_name
);
16103 file
= fopen (file_name
, "rb");
16106 error (_("Input file '%s' is not readable.\n"), file_name
);
16110 if (fread (armag
, SARMAG
, 1, file
) != 1)
16112 error (_("%s: Failed to read file's magic number\n"), file_name
);
16117 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16119 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16120 ret
= process_archive (file_name
, file
, FALSE
);
16121 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16122 ret
= process_archive (file_name
, file
, TRUE
);
16125 if (do_archive_index
)
16126 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16130 archive_file_size
= archive_file_offset
= 0;
16131 ret
= process_object (file_name
, file
);
16136 current_file_size
= 0;
16140 #ifdef SUPPORT_DISASSEMBLY
16141 /* Needed by the i386 disassembler. For extra credit, someone could
16142 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16146 print_address (unsigned int addr
, FILE * outfile
)
16148 fprintf (outfile
,"0x%8.8x", addr
);
16151 /* Needed by the i386 disassembler. */
16153 db_task_printsym (unsigned int addr
)
16155 print_address (addr
, stderr
);
16160 main (int argc
, char ** argv
)
16164 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16165 setlocale (LC_MESSAGES
, "");
16167 #if defined (HAVE_SETLOCALE)
16168 setlocale (LC_CTYPE
, "");
16170 bindtextdomain (PACKAGE
, LOCALEDIR
);
16171 textdomain (PACKAGE
);
16173 expandargv (&argc
, &argv
);
16175 parse_args (argc
, argv
);
16177 if (num_dump_sects
> 0)
16179 /* Make a copy of the dump_sects array. */
16180 cmdline_dump_sects
= (dump_type
*)
16181 malloc (num_dump_sects
* sizeof (* dump_sects
));
16182 if (cmdline_dump_sects
== NULL
)
16183 error (_("Out of memory allocating dump request table.\n"));
16186 memcpy (cmdline_dump_sects
, dump_sects
,
16187 num_dump_sects
* sizeof (* dump_sects
));
16188 num_cmdline_dump_sects
= num_dump_sects
;
16192 if (optind
< (argc
- 1))
16194 else if (optind
>= argc
)
16196 warn (_("Nothing to do.\n"));
16201 while (optind
< argc
)
16202 err
|= process_file (argv
[optind
++]);
16204 if (dump_sects
!= NULL
)
16206 if (cmdline_dump_sects
!= NULL
)
16207 free (cmdline_dump_sects
);