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. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/mcore.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
136 #include "elf/nios2.h"
137 #include "elf/or1k.h"
140 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 char * program_name
= "readelf";
170 static unsigned long archive_file_offset
;
171 static unsigned long archive_file_size
;
172 static bfd_size_type current_file_size
;
173 static unsigned long dynamic_addr
;
174 static bfd_size_type dynamic_size
;
175 static size_t dynamic_nent
;
176 static char * dynamic_strings
;
177 static unsigned long dynamic_strings_length
;
178 static char * string_table
;
179 static unsigned long string_table_length
;
180 static unsigned long num_dynamic_syms
;
181 static Elf_Internal_Sym
* dynamic_symbols
;
182 static Elf_Internal_Syminfo
* dynamic_syminfo
;
183 static unsigned long dynamic_syminfo_offset
;
184 static unsigned int dynamic_syminfo_nent
;
185 static char program_interpreter
[PATH_MAX
];
186 static bfd_vma dynamic_info
[DT_ENCODING
];
187 static bfd_vma dynamic_info_DT_GNU_HASH
;
188 static bfd_vma version_info
[16];
189 static Elf_Internal_Ehdr elf_header
;
190 static Elf_Internal_Shdr
* section_headers
;
191 static Elf_Internal_Phdr
* program_headers
;
192 static Elf_Internal_Dyn
* dynamic_section
;
193 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
194 static int show_name
;
195 static int do_dynamic
;
197 static int do_dyn_syms
;
199 static int do_sections
;
200 static int do_section_groups
;
201 static int do_section_details
;
202 static int do_segments
;
203 static int do_unwind
;
204 static int do_using_dynamic
;
205 static int do_header
;
207 static int do_version
;
208 static int do_histogram
;
209 static int do_debugging
;
212 static int do_archive_index
;
213 static int is_32bit_elf
;
217 struct group_list
* next
;
218 unsigned int section_index
;
223 struct group_list
* root
;
224 unsigned int group_index
;
227 static size_t group_count
;
228 static struct group
* section_groups
;
229 static struct group
** section_headers_groups
;
232 /* Flag bits indicating particular types of dump. */
233 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
234 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
237 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
239 typedef unsigned char dump_type
;
241 /* A linked list of the section names for which dumps were requested. */
242 struct dump_list_entry
246 struct dump_list_entry
* next
;
248 static struct dump_list_entry
* dump_sects_byname
;
250 /* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252 static dump_type
* cmdline_dump_sects
= NULL
;
253 static unsigned int num_cmdline_dump_sects
= 0;
255 /* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
260 static dump_type
* dump_sects
= NULL
;
261 static unsigned int num_dump_sects
= 0;
264 /* How to print a vma value. */
265 typedef enum print_mode
277 /* Versioned symbol info. */
278 enum versioned_symbol_info
285 static const char *get_symbol_version_string
286 (FILE *file
, int is_dynsym
, const char *strtab
,
287 unsigned long int strtab_size
, unsigned int si
,
288 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
289 unsigned short *vna_other
);
293 #define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
297 : string_table + (X)->sh_name))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
305 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
310 #define REMOVE_ARCH_BITS(ADDR) \
313 if (elf_header.e_machine == EM_ARM) \
318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
323 and REASON is not NULL then emit an error message using REASON as part of the
327 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
328 bfd_size_type nmemb
, const char * reason
)
331 bfd_size_type amt
= size
* nmemb
;
333 if (size
== 0 || nmemb
== 0)
336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type
)
340 && ( (bfd_size_type
) ((size_t) size
) != size
341 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
349 /* Check for size overflow. */
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt
> current_file_size
361 || offset
+ archive_file_offset
+ amt
> current_file_size
)
364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt
, reason
);
369 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset
+ offset
, reason
);
380 /* Check for overflow. */
381 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
382 /* + 1 so that we can '\0' terminate invalid string table sections. */
383 mvar
= malloc ((size_t) amt
+ 1);
388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt
, reason
);
393 ((char *) mvar
)[amt
] = '\0';
396 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt
, reason
);
409 /* Print a VMA value. */
412 print_vma (bfd_vma vma
, print_mode mode
)
425 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
432 return printf ("%5" BFD_VMA_FMT
"d", vma
);
440 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
443 return printf ("%" BFD_VMA_FMT
"d", vma
);
446 return printf ("%" BFD_VMA_FMT
"u", vma
);
451 /* Display a symbol on stdout. Handles the display of control characters and
452 multibye characters (assuming the host environment supports them).
454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
459 Returns the number of emitted characters. */
462 print_symbol (int width
, const char *symbol
)
464 bfd_boolean extra_padding
= FALSE
;
466 #ifdef HAVE_MBSTATE_T
473 /* Keep the width positive. This also helps. */
475 extra_padding
= TRUE
;
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining
= INT_MAX
;
484 width_remaining
= width
;
486 #ifdef HAVE_MBSTATE_T
487 /* Initialise the multibyte conversion state. */
488 memset (& state
, 0, sizeof (state
));
491 while (width_remaining
)
494 const char c
= *symbol
++;
499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
504 if (width_remaining
< 2)
507 printf ("^%c", c
+ 0x40);
508 width_remaining
-= 2;
511 else if (ISPRINT (c
))
519 #ifdef HAVE_MBSTATE_T
522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol
- 1);
527 #ifdef HAVE_MBSTATE_T
528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
531 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
535 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
540 if (extra_padding
&& num_printed
< width
)
542 /* Fill in the remaining spaces. */
543 printf ("%-*s", width
- num_printed
, " ");
550 /* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
555 printable_section_name (Elf_Internal_Shdr
* sec
)
557 #define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
559 const char * name
= SECTION_NAME (sec
);
560 char * buf
= sec_name_buf
;
562 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
564 while ((c
= * name
++) != 0)
575 else if (ISPRINT (c
))
582 static char hex
[17] = "0123456789ABCDEF";
587 * buf
++ = hex
[(c
& 0xf0) >> 4];
588 * buf
++ = hex
[c
& 0x0f];
602 printable_section_name_from_index (unsigned long ndx
)
604 if (ndx
>= elf_header
.e_shnum
)
605 return _("<corrupt>");
607 return printable_section_name (section_headers
+ ndx
);
610 /* Return a pointer to section NAME, or NULL if no such section exists. */
612 static Elf_Internal_Shdr
*
613 find_section (const char * name
)
617 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
618 if (streq (SECTION_NAME (section_headers
+ i
), name
))
619 return section_headers
+ i
;
624 /* Return a pointer to a section containing ADDR, or NULL if no such
627 static Elf_Internal_Shdr
*
628 find_section_by_address (bfd_vma addr
)
632 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
634 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
635 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
642 static Elf_Internal_Shdr
*
643 find_section_by_type (unsigned int type
)
647 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
649 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
650 if (sec
->sh_type
== type
)
657 /* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
660 static Elf_Internal_Shdr
*
661 find_section_in_set (const char * name
, unsigned int * set
)
667 while ((i
= *set
++) > 0)
668 if (streq (SECTION_NAME (section_headers
+ i
), name
))
669 return section_headers
+ i
;
672 return find_section (name
);
675 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
678 static inline unsigned long
679 read_uleb128 (unsigned char *data
,
680 unsigned int *length_return
,
681 const unsigned char * const end
)
683 return read_leb128 (data
, length_return
, FALSE
, end
);
686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
693 return elf_header
.e_machine
== EM_IA_64
694 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
697 /* Guess the relocation size commonly used by the specific machines. */
700 guess_is_rela (unsigned int e_machine
)
704 /* Targets that use REL relocations. */
719 /* Targets that use RELA relocations. */
723 case EM_ADAPTEVA_EPIPHANY
:
725 case EM_ALTERA_NIOS2
:
745 case EM_LATTICEMICO32
:
754 case EM_CYGNUS_MN10200
:
756 case EM_CYGNUS_MN10300
:
790 case EM_MICROBLAZE_OLD
:
811 warn (_("Don't know about relocations on this machine architecture\n"));
817 slurp_rela_relocs (FILE * file
,
818 unsigned long rel_offset
,
819 unsigned long rel_size
,
820 Elf_Internal_Rela
** relasp
,
821 unsigned long * nrelasp
)
823 Elf_Internal_Rela
* relas
;
829 Elf32_External_Rela
* erelas
;
831 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
832 rel_size
, _("32-bit relocation data"));
836 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
838 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
839 sizeof (Elf_Internal_Rela
));
844 error (_("out of memory parsing relocs\n"));
848 for (i
= 0; i
< nrelas
; i
++)
850 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
851 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
852 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
859 Elf64_External_Rela
* erelas
;
861 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
862 rel_size
, _("64-bit relocation data"));
866 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
868 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
869 sizeof (Elf_Internal_Rela
));
874 error (_("out of memory parsing relocs\n"));
878 for (i
= 0; i
< nrelas
; i
++)
880 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
881 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
882 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
888 if (elf_header
.e_machine
== EM_MIPS
889 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
896 bfd_vma inf
= relas
[i
].r_info
;
897 inf
= (((inf
& 0xffffffff) << 32)
898 | ((inf
>> 56) & 0xff)
899 | ((inf
>> 40) & 0xff00)
900 | ((inf
>> 24) & 0xff0000)
901 | ((inf
>> 8) & 0xff000000));
902 relas
[i
].r_info
= inf
;
915 slurp_rel_relocs (FILE * file
,
916 unsigned long rel_offset
,
917 unsigned long rel_size
,
918 Elf_Internal_Rela
** relsp
,
919 unsigned long * nrelsp
)
921 Elf_Internal_Rela
* rels
;
927 Elf32_External_Rel
* erels
;
929 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
930 rel_size
, _("32-bit relocation data"));
934 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
936 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
941 error (_("out of memory parsing relocs\n"));
945 for (i
= 0; i
< nrels
; i
++)
947 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
948 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
949 rels
[i
].r_addend
= 0;
956 Elf64_External_Rel
* erels
;
958 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
959 rel_size
, _("64-bit relocation data"));
963 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
965 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
970 error (_("out of memory parsing relocs\n"));
974 for (i
= 0; i
< nrels
; i
++)
976 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
977 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
978 rels
[i
].r_addend
= 0;
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
984 if (elf_header
.e_machine
== EM_MIPS
985 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
992 bfd_vma inf
= rels
[i
].r_info
;
993 inf
= (((inf
& 0xffffffff) << 32)
994 | ((inf
>> 56) & 0xff)
995 | ((inf
>> 40) & 0xff00)
996 | ((inf
>> 24) & 0xff0000)
997 | ((inf
>> 8) & 0xff000000));
998 rels
[i
].r_info
= inf
;
1010 /* Returns the reloc type extracted from the reloc info field. */
1013 get_reloc_type (bfd_vma reloc_info
)
1016 return ELF32_R_TYPE (reloc_info
);
1018 switch (elf_header
.e_machine
)
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info
);
1025 return ELF64_R_TYPE_ID (reloc_info
);
1028 return ELF64_R_TYPE (reloc_info
);
1032 /* Return the symbol index extracted from the reloc info field. */
1035 get_reloc_symindex (bfd_vma reloc_info
)
1037 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1044 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1051 /* Display the contents of the relocation data found at the specified
1055 dump_relocations (FILE * file
,
1056 unsigned long rel_offset
,
1057 unsigned long rel_size
,
1058 Elf_Internal_Sym
* symtab
,
1059 unsigned long nsyms
,
1061 unsigned long strtablen
,
1066 Elf_Internal_Rela
* rels
;
1068 if (is_rela
== UNKNOWN
)
1069 is_rela
= guess_is_rela (elf_header
.e_machine
);
1073 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1078 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1117 for (i
= 0; i
< rel_size
; i
++)
1122 bfd_vma symtab_index
;
1125 offset
= rels
[i
].r_offset
;
1126 inf
= rels
[i
].r_info
;
1128 type
= get_reloc_type (inf
);
1129 symtab_index
= get_reloc_symindex (inf
);
1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset
& 0xffffffff,
1135 (unsigned long) inf
& 0xffffffff);
1139 #if BFD_HOST_64BIT_LONG
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
1144 #elif BFD_HOST_64BIT_LONG_LONG
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1160 _bfd_int64_high (offset
),
1161 _bfd_int64_low (offset
),
1162 _bfd_int64_high (inf
),
1163 _bfd_int64_low (inf
));
1167 switch (elf_header
.e_machine
)
1174 rtype
= elf_aarch64_reloc_type (type
);
1178 case EM_CYGNUS_M32R
:
1179 rtype
= elf_m32r_reloc_type (type
);
1184 rtype
= elf_i386_reloc_type (type
);
1189 rtype
= elf_m68hc11_reloc_type (type
);
1193 rtype
= elf_m68k_reloc_type (type
);
1197 rtype
= elf_i960_reloc_type (type
);
1202 rtype
= elf_avr_reloc_type (type
);
1205 case EM_OLD_SPARCV9
:
1206 case EM_SPARC32PLUS
:
1209 rtype
= elf_sparc_reloc_type (type
);
1213 rtype
= elf_spu_reloc_type (type
);
1217 rtype
= v800_reloc_type (type
);
1220 case EM_CYGNUS_V850
:
1221 rtype
= v850_reloc_type (type
);
1225 case EM_CYGNUS_D10V
:
1226 rtype
= elf_d10v_reloc_type (type
);
1230 case EM_CYGNUS_D30V
:
1231 rtype
= elf_d30v_reloc_type (type
);
1235 rtype
= elf_dlx_reloc_type (type
);
1239 rtype
= elf_sh_reloc_type (type
);
1243 case EM_CYGNUS_MN10300
:
1244 rtype
= elf_mn10300_reloc_type (type
);
1248 case EM_CYGNUS_MN10200
:
1249 rtype
= elf_mn10200_reloc_type (type
);
1253 case EM_CYGNUS_FR30
:
1254 rtype
= elf_fr30_reloc_type (type
);
1258 rtype
= elf_frv_reloc_type (type
);
1262 rtype
= elf_ft32_reloc_type (type
);
1266 rtype
= elf_mcore_reloc_type (type
);
1270 rtype
= elf_mmix_reloc_type (type
);
1274 rtype
= elf_moxie_reloc_type (type
);
1278 if (uses_msp430x_relocs ())
1280 rtype
= elf_msp430x_reloc_type (type
);
1284 rtype
= elf_msp430_reloc_type (type
);
1288 rtype
= elf_nds32_reloc_type (type
);
1292 rtype
= elf_ppc_reloc_type (type
);
1296 rtype
= elf_ppc64_reloc_type (type
);
1300 case EM_MIPS_RS3_LE
:
1301 rtype
= elf_mips_reloc_type (type
);
1305 rtype
= elf_alpha_reloc_type (type
);
1309 rtype
= elf_arm_reloc_type (type
);
1313 rtype
= elf_arc_reloc_type (type
);
1317 rtype
= elf_hppa_reloc_type (type
);
1323 rtype
= elf_h8_reloc_type (type
);
1327 rtype
= elf_or1k_reloc_type (type
);
1332 rtype
= elf_pj_reloc_type (type
);
1335 rtype
= elf_ia64_reloc_type (type
);
1339 rtype
= elf_cris_reloc_type (type
);
1343 rtype
= elf_i860_reloc_type (type
);
1349 rtype
= elf_x86_64_reloc_type (type
);
1353 rtype
= i370_reloc_type (type
);
1358 rtype
= elf_s390_reloc_type (type
);
1362 rtype
= elf_score_reloc_type (type
);
1366 rtype
= elf_xstormy16_reloc_type (type
);
1370 rtype
= elf_crx_reloc_type (type
);
1374 rtype
= elf_vax_reloc_type (type
);
1378 rtype
= elf_visium_reloc_type (type
);
1381 case EM_ADAPTEVA_EPIPHANY
:
1382 rtype
= elf_epiphany_reloc_type (type
);
1387 rtype
= elf_ip2k_reloc_type (type
);
1391 rtype
= elf_iq2000_reloc_type (type
);
1396 rtype
= elf_xtensa_reloc_type (type
);
1399 case EM_LATTICEMICO32
:
1400 rtype
= elf_lm32_reloc_type (type
);
1405 rtype
= elf_m32c_reloc_type (type
);
1409 rtype
= elf_mt_reloc_type (type
);
1413 rtype
= elf_bfin_reloc_type (type
);
1417 rtype
= elf_mep_reloc_type (type
);
1421 rtype
= elf_cr16_reloc_type (type
);
1425 case EM_MICROBLAZE_OLD
:
1426 rtype
= elf_microblaze_reloc_type (type
);
1430 rtype
= elf_rl78_reloc_type (type
);
1434 rtype
= elf_rx_reloc_type (type
);
1438 rtype
= elf_metag_reloc_type (type
);
1443 rtype
= elf_xc16x_reloc_type (type
);
1447 rtype
= elf_tic6x_reloc_type (type
);
1451 rtype
= elf_tilegx_reloc_type (type
);
1455 rtype
= elf_tilepro_reloc_type (type
);
1459 rtype
= elf_xgate_reloc_type (type
);
1462 case EM_ALTERA_NIOS2
:
1463 rtype
= elf_nios2_reloc_type (type
);
1468 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1470 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1472 if (elf_header
.e_machine
== EM_ALPHA
1474 && streq (rtype
, "R_ALPHA_LITUSE")
1477 switch (rels
[i
].r_addend
)
1479 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1480 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1486 default: rtype
= NULL
;
1489 printf (" (%s)", rtype
);
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels
[i
].r_addend
);
1497 else if (symtab_index
)
1499 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1503 Elf_Internal_Sym
* psym
;
1504 const char * version_string
;
1505 enum versioned_symbol_info sym_info
;
1506 unsigned short vna_other
;
1508 psym
= symtab
+ symtab_index
;
1511 = get_symbol_version_string (file
, is_dynsym
,
1520 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1524 unsigned int width
= is_32bit_elf
? 8 : 14;
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1537 || psym
->st_name
== 0
1538 || psym
->st_name
>= strtablen
)
1541 name
= strtab
+ psym
->st_name
;
1543 len
= print_symbol (width
, name
);
1545 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1547 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1551 print_vma (psym
->st_value
, LONG_HEX
);
1553 printf (is_32bit_elf
? " " : " ");
1556 if (psym
->st_name
== 0)
1558 const char * sec_name
= "<null>";
1561 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1563 if (psym
->st_shndx
< elf_header
.e_shnum
)
1564 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1565 else if (psym
->st_shndx
== SHN_ABS
)
1567 else if (psym
->st_shndx
== SHN_COMMON
)
1568 sec_name
= "COMMON";
1569 else if ((elf_header
.e_machine
== EM_MIPS
1570 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1571 || (elf_header
.e_machine
== EM_TI_C6000
1572 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1573 sec_name
= "SCOMMON";
1574 else if (elf_header
.e_machine
== EM_MIPS
1575 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1576 sec_name
= "SUNDEF";
1577 else if ((elf_header
.e_machine
== EM_X86_64
1578 || elf_header
.e_machine
== EM_L1OM
1579 || elf_header
.e_machine
== EM_K1OM
)
1580 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1581 sec_name
= "LARGE_COMMON";
1582 else if (elf_header
.e_machine
== EM_IA_64
1583 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1584 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1585 sec_name
= "ANSI_COM";
1586 else if (is_ia64_vms ()
1587 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1588 sec_name
= "VMS_SYMVEC";
1591 sprintf (name_buf
, "<section 0x%x>",
1592 (unsigned int) psym
->st_shndx
);
1593 sec_name
= name_buf
;
1596 print_symbol (22, sec_name
);
1598 else if (strtab
== NULL
)
1599 printf (_("<string table index: %3ld>"), psym
->st_name
);
1600 else if (psym
->st_name
>= strtablen
)
1601 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1604 print_symbol (22, strtab
+ psym
->st_name
);
1606 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1612 bfd_signed_vma off
= rels
[i
].r_addend
;
1614 /* PR 17531: file: 2e63226f. */
1615 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1616 printf (" + %" BFD_VMA_FMT
"x", off
);
1618 printf (" - %" BFD_VMA_FMT
"x", - off
);
1620 printf (" + %" BFD_VMA_FMT
"x", off
);
1626 bfd_signed_vma off
= rels
[i
].r_addend
;
1628 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1629 /* PR 17531: file: 2e63226f. */
1630 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1631 printf ("%" BFD_VMA_FMT
"x", off
);
1633 printf ("-%" BFD_VMA_FMT
"x", - off
);
1635 printf ("%" BFD_VMA_FMT
"x", off
);
1638 if (elf_header
.e_machine
== EM_SPARCV9
1640 && streq (rtype
, "R_SPARC_OLO10"))
1641 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1646 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1648 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1649 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1650 const char * rtype2
= elf_mips_reloc_type (type2
);
1651 const char * rtype3
= elf_mips_reloc_type (type3
);
1653 printf (" Type2: ");
1656 printf (_("unrecognized: %-7lx"),
1657 (unsigned long) type2
& 0xffffffff);
1659 printf ("%-17.17s", rtype2
);
1661 printf ("\n Type3: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type3
& 0xffffffff);
1667 printf ("%-17.17s", rtype3
);
1678 get_mips_dynamic_type (unsigned long type
)
1682 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1683 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1684 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1685 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1686 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1687 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1688 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1689 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1690 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1691 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1692 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1693 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1694 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1695 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1696 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1697 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1698 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1699 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1725 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1733 get_sparc64_dynamic_type (unsigned long type
)
1737 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1744 get_ppc_dynamic_type (unsigned long type
)
1748 case DT_PPC_GOT
: return "PPC_GOT";
1749 case DT_PPC_OPT
: return "PPC_OPT";
1756 get_ppc64_dynamic_type (unsigned long type
)
1760 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1761 case DT_PPC64_OPD
: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1763 case DT_PPC64_OPT
: return "PPC64_OPT";
1770 get_parisc_dynamic_type (unsigned long type
)
1774 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT
: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED
: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1787 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED
: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT
: return "PLT";
1795 case DT_PLT_SIZE
: return "PLT_SIZE";
1796 case DT_DLT
: return "DLT";
1797 case DT_DLT_SIZE
: return "DLT_SIZE";
1804 get_ia64_dynamic_type (unsigned long type
)
1808 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1845 get_alpha_dynamic_type (unsigned long type
)
1849 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1856 get_score_dynamic_type (unsigned long type
)
1860 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1872 get_tic6x_dynamic_type (unsigned long type
)
1876 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1888 get_nios2_dynamic_type (unsigned long type
)
1892 case DT_NIOS2_GP
: return "NIOS2_GP";
1899 get_dynamic_type (unsigned long type
)
1901 static char buff
[64];
1905 case DT_NULL
: return "NULL";
1906 case DT_NEEDED
: return "NEEDED";
1907 case DT_PLTRELSZ
: return "PLTRELSZ";
1908 case DT_PLTGOT
: return "PLTGOT";
1909 case DT_HASH
: return "HASH";
1910 case DT_STRTAB
: return "STRTAB";
1911 case DT_SYMTAB
: return "SYMTAB";
1912 case DT_RELA
: return "RELA";
1913 case DT_RELASZ
: return "RELASZ";
1914 case DT_RELAENT
: return "RELAENT";
1915 case DT_STRSZ
: return "STRSZ";
1916 case DT_SYMENT
: return "SYMENT";
1917 case DT_INIT
: return "INIT";
1918 case DT_FINI
: return "FINI";
1919 case DT_SONAME
: return "SONAME";
1920 case DT_RPATH
: return "RPATH";
1921 case DT_SYMBOLIC
: return "SYMBOLIC";
1922 case DT_REL
: return "REL";
1923 case DT_RELSZ
: return "RELSZ";
1924 case DT_RELENT
: return "RELENT";
1925 case DT_PLTREL
: return "PLTREL";
1926 case DT_DEBUG
: return "DEBUG";
1927 case DT_TEXTREL
: return "TEXTREL";
1928 case DT_JMPREL
: return "JMPREL";
1929 case DT_BIND_NOW
: return "BIND_NOW";
1930 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1934 case DT_RUNPATH
: return "RUNPATH";
1935 case DT_FLAGS
: return "FLAGS";
1937 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1940 case DT_CHECKSUM
: return "CHECKSUM";
1941 case DT_PLTPADSZ
: return "PLTPADSZ";
1942 case DT_MOVEENT
: return "MOVEENT";
1943 case DT_MOVESZ
: return "MOVESZ";
1944 case DT_FEATURE
: return "FEATURE";
1945 case DT_POSFLAG_1
: return "POSFLAG_1";
1946 case DT_SYMINSZ
: return "SYMINSZ";
1947 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1949 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1950 case DT_CONFIG
: return "CONFIG";
1951 case DT_DEPAUDIT
: return "DEPAUDIT";
1952 case DT_AUDIT
: return "AUDIT";
1953 case DT_PLTPAD
: return "PLTPAD";
1954 case DT_MOVETAB
: return "MOVETAB";
1955 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1957 case DT_VERSYM
: return "VERSYM";
1959 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1961 case DT_RELACOUNT
: return "RELACOUNT";
1962 case DT_RELCOUNT
: return "RELCOUNT";
1963 case DT_FLAGS_1
: return "FLAGS_1";
1964 case DT_VERDEF
: return "VERDEF";
1965 case DT_VERDEFNUM
: return "VERDEFNUM";
1966 case DT_VERNEED
: return "VERNEED";
1967 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1969 case DT_AUXILIARY
: return "AUXILIARY";
1970 case DT_USED
: return "USED";
1971 case DT_FILTER
: return "FILTER";
1973 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1978 case DT_GNU_HASH
: return "GNU_HASH";
1981 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1983 const char * result
;
1985 switch (elf_header
.e_machine
)
1988 case EM_MIPS_RS3_LE
:
1989 result
= get_mips_dynamic_type (type
);
1992 result
= get_sparc64_dynamic_type (type
);
1995 result
= get_ppc_dynamic_type (type
);
1998 result
= get_ppc64_dynamic_type (type
);
2001 result
= get_ia64_dynamic_type (type
);
2004 result
= get_alpha_dynamic_type (type
);
2007 result
= get_score_dynamic_type (type
);
2010 result
= get_tic6x_dynamic_type (type
);
2012 case EM_ALTERA_NIOS2
:
2013 result
= get_nios2_dynamic_type (type
);
2023 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2025 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2026 || (elf_header
.e_machine
== EM_PARISC
2027 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2029 const char * result
;
2031 switch (elf_header
.e_machine
)
2034 result
= get_parisc_dynamic_type (type
);
2037 result
= get_ia64_dynamic_type (type
);
2047 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2051 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2058 get_file_type (unsigned e_type
)
2060 static char buff
[32];
2064 case ET_NONE
: return _("NONE (None)");
2065 case ET_REL
: return _("REL (Relocatable file)");
2066 case ET_EXEC
: return _("EXEC (Executable file)");
2067 case ET_DYN
: return _("DYN (Shared object file)");
2068 case ET_CORE
: return _("CORE (Core file)");
2071 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2072 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2073 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2074 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2076 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2082 get_machine_name (unsigned e_machine
)
2084 static char buff
[64]; /* XXX */
2088 case EM_NONE
: return _("None");
2089 case EM_AARCH64
: return "AArch64";
2090 case EM_M32
: return "WE32100";
2091 case EM_SPARC
: return "Sparc";
2092 case EM_SPU
: return "SPU";
2093 case EM_386
: return "Intel 80386";
2094 case EM_68K
: return "MC68000";
2095 case EM_88K
: return "MC88000";
2096 case EM_486
: return "Intel 80486";
2097 case EM_860
: return "Intel 80860";
2098 case EM_MIPS
: return "MIPS R3000";
2099 case EM_S370
: return "IBM System/370";
2100 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2101 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2102 case EM_PARISC
: return "HPPA";
2103 case EM_PPC_OLD
: return "Power PC (old)";
2104 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2105 case EM_960
: return "Intel 90860";
2106 case EM_PPC
: return "PowerPC";
2107 case EM_PPC64
: return "PowerPC64";
2108 case EM_FR20
: return "Fujitsu FR20";
2109 case EM_FT32
: return "FTDI FT32";
2110 case EM_RH32
: return "TRW RH32";
2111 case EM_MCORE
: return "MCORE";
2112 case EM_ARM
: return "ARM";
2113 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2114 case EM_SH
: return "Renesas / SuperH SH";
2115 case EM_SPARCV9
: return "Sparc v9";
2116 case EM_TRICORE
: return "Siemens Tricore";
2117 case EM_ARC
: return "ARC";
2118 case EM_H8_300
: return "Renesas H8/300";
2119 case EM_H8_300H
: return "Renesas H8/300H";
2120 case EM_H8S
: return "Renesas H8S";
2121 case EM_H8_500
: return "Renesas H8/500";
2122 case EM_IA_64
: return "Intel IA-64";
2123 case EM_MIPS_X
: return "Stanford MIPS-X";
2124 case EM_COLDFIRE
: return "Motorola Coldfire";
2125 case EM_ALPHA
: return "Alpha";
2126 case EM_CYGNUS_D10V
:
2127 case EM_D10V
: return "d10v";
2128 case EM_CYGNUS_D30V
:
2129 case EM_D30V
: return "d30v";
2130 case EM_CYGNUS_M32R
:
2131 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2132 case EM_CYGNUS_V850
:
2133 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2134 case EM_V850
: return "Renesas V850";
2135 case EM_CYGNUS_MN10300
:
2136 case EM_MN10300
: return "mn10300";
2137 case EM_CYGNUS_MN10200
:
2138 case EM_MN10200
: return "mn10200";
2139 case EM_MOXIE
: return "Moxie";
2140 case EM_CYGNUS_FR30
:
2141 case EM_FR30
: return "Fujitsu FR30";
2142 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2144 case EM_PJ
: return "picoJava";
2145 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP
: return "Siemens PCP";
2147 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE
: return "Motorola Star*Core processor";
2150 case EM_ME16
: return "Toyota ME16 processor";
2151 case EM_ST100
: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2153 case EM_PDSP
: return "Sony DSP processor";
2154 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2156 case EM_FX66
: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2160 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2161 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX
: return "Silicon Graphics SVx";
2165 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX
: return "Digital VAX";
2167 case EM_VISIUM
: return "CDS VISIUMcore processor";
2169 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2170 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2171 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2174 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2175 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2176 case EM_PRISM
: return "Vitesse Prism";
2177 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2178 case EM_L1OM
: return "Intel L1OM";
2179 case EM_K1OM
: return "Intel K1OM";
2181 case EM_S390
: return "IBM S/390";
2182 case EM_SCORE
: return "SUNPLUS S+Core";
2183 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2184 case EM_OR1K
: return "OpenRISC 1000";
2185 case EM_ARC_A5
: return "ARC International ARCompact processor";
2186 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2187 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2188 case EM_DLX
: return "OpenDLX";
2190 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2191 case EM_IQ2000
: return "Vitesse IQ2000";
2193 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2194 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K
: return "National Semiconductor 32000 series";
2197 case EM_TPC
: return "Tenor Network TPC processor";
2198 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX
: return "MAX Processor";
2200 case EM_CR
: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16
: return "Fujitsu F2MC16";
2202 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2203 case EM_LATTICEMICO32
: return "Lattice Mico32";
2205 case EM_M32C
: return "Renesas M32c";
2206 case EM_MT
: return "Morpho Techologies MT processor";
2207 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2208 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP
: return "Sharp embedded microprocessor";
2210 case EM_ARCA
: return "Arca RISC microprocessor";
2211 case EM_UNICORE
: return "Unicore";
2212 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2214 case EM_NIOS32
: return "Altera Nios";
2215 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2217 case EM_XC16X
: return "Infineon Technologies xc16x";
2218 case EM_M16C
: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE
: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000
: return "Altium TSK3000 core";
2222 case EM_RS08
: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17
: return "Seiko Epson C17 family";
2227 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2232 case EM_R32C
: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2235 case EM_8051
: return "Intel 8051 and variants";
2236 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2243 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2246 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2247 case EM_RL78
: return "Renesas RL78";
2248 case EM_RX
: return "Renesas RX";
2249 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2250 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2258 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2259 case EM_CUDA
: return "NVIDIA CUDA architecture";
2260 case EM_XGATE
: return "Motorola XGATE embedded processor";
2262 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2268 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2273 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2274 e_flags
&= ~ EF_ARM_EABIMASK
;
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags
& EF_ARM_RELEXEC
)
2279 strcat (buf
, ", relocatable executable");
2280 e_flags
&= ~ EF_ARM_RELEXEC
;
2283 if (e_flags
& EF_ARM_HASENTRY
)
2285 strcat (buf
, ", has entry point");
2286 e_flags
&= ~ EF_ARM_HASENTRY
;
2289 /* Now handle EABI specific flags. */
2293 strcat (buf
, ", <unrecognized EABI>");
2298 case EF_ARM_EABI_VER1
:
2299 strcat (buf
, ", Version1 EABI");
2304 /* Process flags one bit at a time. */
2305 flag
= e_flags
& - e_flags
;
2310 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2311 strcat (buf
, ", sorted symbol tables");
2321 case EF_ARM_EABI_VER2
:
2322 strcat (buf
, ", Version2 EABI");
2327 /* Process flags one bit at a time. */
2328 flag
= e_flags
& - e_flags
;
2333 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf
, ", sorted symbol tables");
2337 case EF_ARM_DYNSYMSUSESEGIDX
:
2338 strcat (buf
, ", dynamic symbols use segment index");
2341 case EF_ARM_MAPSYMSFIRST
:
2342 strcat (buf
, ", mapping symbols precede others");
2352 case EF_ARM_EABI_VER3
:
2353 strcat (buf
, ", Version3 EABI");
2356 case EF_ARM_EABI_VER4
:
2357 strcat (buf
, ", Version4 EABI");
2362 /* Process flags one bit at a time. */
2363 flag
= e_flags
& - e_flags
;
2369 strcat (buf
, ", BE8");
2373 strcat (buf
, ", LE8");
2384 case EF_ARM_EABI_VER5
:
2385 strcat (buf
, ", Version5 EABI");
2390 /* Process flags one bit at a time. */
2391 flag
= e_flags
& - e_flags
;
2397 strcat (buf
, ", BE8");
2401 strcat (buf
, ", LE8");
2404 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf
, ", soft-float ABI");
2408 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf
, ", hard-float ABI");
2419 case EF_ARM_EABI_UNKNOWN
:
2420 strcat (buf
, ", GNU EABI");
2425 /* Process flags one bit at a time. */
2426 flag
= e_flags
& - e_flags
;
2431 case EF_ARM_INTERWORK
:
2432 strcat (buf
, ", interworking enabled");
2435 case EF_ARM_APCS_26
:
2436 strcat (buf
, ", uses APCS/26");
2439 case EF_ARM_APCS_FLOAT
:
2440 strcat (buf
, ", uses APCS/float");
2444 strcat (buf
, ", position independent");
2448 strcat (buf
, ", 8 bit structure alignment");
2451 case EF_ARM_NEW_ABI
:
2452 strcat (buf
, ", uses new ABI");
2455 case EF_ARM_OLD_ABI
:
2456 strcat (buf
, ", uses old ABI");
2459 case EF_ARM_SOFT_FLOAT
:
2460 strcat (buf
, ", software FP");
2463 case EF_ARM_VFP_FLOAT
:
2464 strcat (buf
, ", VFP");
2467 case EF_ARM_MAVERICK_FLOAT
:
2468 strcat (buf
, ", Maverick FP");
2479 strcat (buf
,_(", <unknown>"));
2483 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2485 --size
; /* Leave space for null terminator. */
2487 switch (e_flags
& EF_AVR_MACH
)
2489 case E_AVR_MACH_AVR1
:
2490 strncat (buf
, ", avr:1", size
);
2492 case E_AVR_MACH_AVR2
:
2493 strncat (buf
, ", avr:2", size
);
2495 case E_AVR_MACH_AVR25
:
2496 strncat (buf
, ", avr:25", size
);
2498 case E_AVR_MACH_AVR3
:
2499 strncat (buf
, ", avr:3", size
);
2501 case E_AVR_MACH_AVR31
:
2502 strncat (buf
, ", avr:31", size
);
2504 case E_AVR_MACH_AVR35
:
2505 strncat (buf
, ", avr:35", size
);
2507 case E_AVR_MACH_AVR4
:
2508 strncat (buf
, ", avr:4", size
);
2510 case E_AVR_MACH_AVR5
:
2511 strncat (buf
, ", avr:5", size
);
2513 case E_AVR_MACH_AVR51
:
2514 strncat (buf
, ", avr:51", size
);
2516 case E_AVR_MACH_AVR6
:
2517 strncat (buf
, ", avr:6", size
);
2519 case E_AVR_MACH_AVRTINY
:
2520 strncat (buf
, ", avr:100", size
);
2522 case E_AVR_MACH_XMEGA1
:
2523 strncat (buf
, ", avr:101", size
);
2525 case E_AVR_MACH_XMEGA2
:
2526 strncat (buf
, ", avr:102", size
);
2528 case E_AVR_MACH_XMEGA3
:
2529 strncat (buf
, ", avr:103", size
);
2531 case E_AVR_MACH_XMEGA4
:
2532 strncat (buf
, ", avr:104", size
);
2534 case E_AVR_MACH_XMEGA5
:
2535 strncat (buf
, ", avr:105", size
);
2537 case E_AVR_MACH_XMEGA6
:
2538 strncat (buf
, ", avr:106", size
);
2540 case E_AVR_MACH_XMEGA7
:
2541 strncat (buf
, ", avr:107", size
);
2544 strncat (buf
, ", avr:<unknown>", size
);
2548 size
-= strlen (buf
);
2549 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2550 strncat (buf
, ", link-relax", size
);
2554 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2563 static const char *ABI_STRINGS
[] =
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
2572 static const char *VER_STRINGS
[] =
2574 "Andes ELF V1.3 or older",
2578 static const char *ARCH_STRINGS
[] =
2587 abi
= EF_NDS_ABI
& e_flags
;
2588 arch
= EF_NDS_ARCH
& e_flags
;
2589 config
= EF_NDS_INST
& e_flags
;
2590 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2592 memset (buf
, 0, size
);
2599 case E_NDS_ABI_V2FP
:
2600 case E_NDS_ABI_AABI
:
2601 case E_NDS_ABI_V2FP_PLUS
:
2602 /* In case there are holes in the array. */
2603 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2607 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2613 case E_NDS32_ELF_VER_1_2
:
2614 case E_NDS32_ELF_VER_1_3
:
2615 case E_NDS32_ELF_VER_1_4
:
2616 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2620 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2624 if (E_NDS_ABI_V0
== abi
)
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2629 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2635 case E_NDS_ARCH_STAR_V1_0
:
2636 case E_NDS_ARCH_STAR_V2_0
:
2637 case E_NDS_ARCH_STAR_V3_0
:
2638 case E_NDS_ARCH_STAR_V3_M
:
2639 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2643 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2652 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2655 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2656 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2658 if (config
& E_NDS32_HAS_DIV_INST
)
2659 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2661 if (config
& E_NDS32_HAS_16BIT_INST
)
2662 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2666 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2668 if (version
<= E_NDS32_ELF_VER_1_3
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2671 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2674 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2677 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2678 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2680 if (config
& E_NDS32_HAS_16BIT_INST
)
2682 if (version
<= E_NDS32_ELF_VER_1_3
)
2683 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2685 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2689 if (config
& E_NDS32_HAS_EXT_INST
)
2690 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2692 if (config
& E_NDS32_HAS_EXT2_INST
)
2693 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2695 if (config
& E_NDS32_HAS_FPU_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2701 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2707 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2710 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2715 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2717 case E_NDS32_FPU_REG_8SP_4DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2720 case E_NDS32_FPU_REG_16SP_8DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2723 case E_NDS32_FPU_REG_32SP_16DP
:
2724 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2726 case E_NDS32_FPU_REG_32SP_32DP
:
2727 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2732 if (config
& E_NDS32_HAS_AUDIO_INST
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2735 if (config
& E_NDS32_HAS_STRING_INST
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2738 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2739 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2741 if (config
& E_NDS32_HAS_VIDEO_INST
)
2743 if (version
<= E_NDS32_ELF_VER_1_3
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2746 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2749 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2750 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2752 if (config
& E_NDS32_HAS_L2C_INST
)
2753 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2757 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2759 static char buf
[1024];
2771 decode_ARM_machine_flags (e_flags
, buf
);
2775 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2779 if (e_flags
& EF_BFIN_PIC
)
2780 strcat (buf
, ", PIC");
2782 if (e_flags
& EF_BFIN_FDPIC
)
2783 strcat (buf
, ", FDPIC");
2785 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2786 strcat (buf
, ", code in L1");
2788 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2789 strcat (buf
, ", data in L1");
2794 switch (e_flags
& EF_FRV_CPU_MASK
)
2796 case EF_FRV_CPU_GENERIC
:
2800 strcat (buf
, ", fr???");
2803 case EF_FRV_CPU_FR300
:
2804 strcat (buf
, ", fr300");
2807 case EF_FRV_CPU_FR400
:
2808 strcat (buf
, ", fr400");
2810 case EF_FRV_CPU_FR405
:
2811 strcat (buf
, ", fr405");
2814 case EF_FRV_CPU_FR450
:
2815 strcat (buf
, ", fr450");
2818 case EF_FRV_CPU_FR500
:
2819 strcat (buf
, ", fr500");
2821 case EF_FRV_CPU_FR550
:
2822 strcat (buf
, ", fr550");
2825 case EF_FRV_CPU_SIMPLE
:
2826 strcat (buf
, ", simple");
2828 case EF_FRV_CPU_TOMCAT
:
2829 strcat (buf
, ", tomcat");
2835 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2836 strcat (buf
, ", m68000");
2837 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2838 strcat (buf
, ", cpu32");
2839 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2840 strcat (buf
, ", fido_a");
2843 char const * isa
= _("unknown");
2844 char const * mac
= _("unknown mac");
2845 char const * additional
= NULL
;
2847 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2849 case EF_M68K_CF_ISA_A_NODIV
:
2851 additional
= ", nodiv";
2853 case EF_M68K_CF_ISA_A
:
2856 case EF_M68K_CF_ISA_A_PLUS
:
2859 case EF_M68K_CF_ISA_B_NOUSP
:
2861 additional
= ", nousp";
2863 case EF_M68K_CF_ISA_B
:
2866 case EF_M68K_CF_ISA_C
:
2869 case EF_M68K_CF_ISA_C_NODIV
:
2871 additional
= ", nodiv";
2874 strcat (buf
, ", cf, isa ");
2877 strcat (buf
, additional
);
2878 if (e_flags
& EF_M68K_CF_FLOAT
)
2879 strcat (buf
, ", float");
2880 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2885 case EF_M68K_CF_MAC
:
2888 case EF_M68K_CF_EMAC
:
2891 case EF_M68K_CF_EMAC_B
:
2904 if (e_flags
& EF_PPC_EMB
)
2905 strcat (buf
, ", emb");
2907 if (e_flags
& EF_PPC_RELOCATABLE
)
2908 strcat (buf
, _(", relocatable"));
2910 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2911 strcat (buf
, _(", relocatable-lib"));
2915 if (e_flags
& EF_PPC64_ABI
)
2917 char abi
[] = ", abiv0";
2919 abi
[6] += e_flags
& EF_PPC64_ABI
;
2925 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2926 strcat (buf
, ", RH850 ABI");
2928 if (e_flags
& EF_V800_850E3
)
2929 strcat (buf
, ", V3 architecture");
2931 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2932 strcat (buf
, ", FPU not used");
2934 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2935 strcat (buf
, ", regmode: COMMON");
2937 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2938 strcat (buf
, ", r4 not used");
2940 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2941 strcat (buf
, ", r30 not used");
2943 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2944 strcat (buf
, ", r5 not used");
2946 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2947 strcat (buf
, ", r2 not used");
2949 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2951 switch (e_flags
& - e_flags
)
2953 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2954 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2955 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2956 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2957 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2958 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2959 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2960 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2961 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2962 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2963 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2964 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2965 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2966 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2967 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2968 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2975 case EM_CYGNUS_V850
:
2976 switch (e_flags
& EF_V850_ARCH
)
2978 case E_V850E3V5_ARCH
:
2979 strcat (buf
, ", v850e3v5");
2981 case E_V850E2V3_ARCH
:
2982 strcat (buf
, ", v850e2v3");
2985 strcat (buf
, ", v850e2");
2988 strcat (buf
, ", v850e1");
2991 strcat (buf
, ", v850e");
2994 strcat (buf
, ", v850");
2997 strcat (buf
, _(", unknown v850 architecture variant"));
3003 case EM_CYGNUS_M32R
:
3004 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3005 strcat (buf
, ", m32r");
3009 case EM_MIPS_RS3_LE
:
3010 if (e_flags
& EF_MIPS_NOREORDER
)
3011 strcat (buf
, ", noreorder");
3013 if (e_flags
& EF_MIPS_PIC
)
3014 strcat (buf
, ", pic");
3016 if (e_flags
& EF_MIPS_CPIC
)
3017 strcat (buf
, ", cpic");
3019 if (e_flags
& EF_MIPS_UCODE
)
3020 strcat (buf
, ", ugen_reserved");
3022 if (e_flags
& EF_MIPS_ABI2
)
3023 strcat (buf
, ", abi2");
3025 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3026 strcat (buf
, ", odk first");
3028 if (e_flags
& EF_MIPS_32BITMODE
)
3029 strcat (buf
, ", 32bitmode");
3031 if (e_flags
& EF_MIPS_NAN2008
)
3032 strcat (buf
, ", nan2008");
3034 if (e_flags
& EF_MIPS_FP64
)
3035 strcat (buf
, ", fp64");
3037 switch ((e_flags
& EF_MIPS_MACH
))
3039 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3040 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3041 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3042 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3043 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3044 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3045 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3046 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3047 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3048 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3049 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3050 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3051 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3052 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3053 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3054 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3055 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3057 /* We simply ignore the field in this case to avoid confusion:
3058 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3061 default: strcat (buf
, _(", unknown CPU")); break;
3064 switch ((e_flags
& EF_MIPS_ABI
))
3066 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3067 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3068 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3069 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3071 /* We simply ignore the field in this case to avoid confusion:
3072 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3073 This means it is likely to be an o32 file, but not for
3076 default: strcat (buf
, _(", unknown ABI")); break;
3079 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3080 strcat (buf
, ", mdmx");
3082 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3083 strcat (buf
, ", mips16");
3085 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3086 strcat (buf
, ", micromips");
3088 switch ((e_flags
& EF_MIPS_ARCH
))
3090 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3091 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3092 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3093 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3094 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3095 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3096 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3097 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3098 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3099 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3100 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3101 default: strcat (buf
, _(", unknown ISA")); break;
3106 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3110 switch ((e_flags
& EF_SH_MACH_MASK
))
3112 case EF_SH1
: strcat (buf
, ", sh1"); break;
3113 case EF_SH2
: strcat (buf
, ", sh2"); break;
3114 case EF_SH3
: strcat (buf
, ", sh3"); break;
3115 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3116 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3117 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3118 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3119 case EF_SH4
: strcat (buf
, ", sh4"); break;
3120 case EF_SH5
: strcat (buf
, ", sh5"); break;
3121 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3122 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3123 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3124 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3125 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3126 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3127 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3128 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3129 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3130 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3131 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3132 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3133 default: strcat (buf
, _(", unknown ISA")); break;
3136 if (e_flags
& EF_SH_PIC
)
3137 strcat (buf
, ", pic");
3139 if (e_flags
& EF_SH_FDPIC
)
3140 strcat (buf
, ", fdpic");
3144 if (e_flags
& EF_OR1K_NODELAY
)
3145 strcat (buf
, ", no delay");
3149 if (e_flags
& EF_SPARC_32PLUS
)
3150 strcat (buf
, ", v8+");
3152 if (e_flags
& EF_SPARC_SUN_US1
)
3153 strcat (buf
, ", ultrasparcI");
3155 if (e_flags
& EF_SPARC_SUN_US3
)
3156 strcat (buf
, ", ultrasparcIII");
3158 if (e_flags
& EF_SPARC_HAL_R1
)
3159 strcat (buf
, ", halr1");
3161 if (e_flags
& EF_SPARC_LEDATA
)
3162 strcat (buf
, ", ledata");
3164 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3165 strcat (buf
, ", tso");
3167 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3168 strcat (buf
, ", pso");
3170 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3171 strcat (buf
, ", rmo");
3175 switch (e_flags
& EF_PARISC_ARCH
)
3177 case EFA_PARISC_1_0
:
3178 strcpy (buf
, ", PA-RISC 1.0");
3180 case EFA_PARISC_1_1
:
3181 strcpy (buf
, ", PA-RISC 1.1");
3183 case EFA_PARISC_2_0
:
3184 strcpy (buf
, ", PA-RISC 2.0");
3189 if (e_flags
& EF_PARISC_TRAPNIL
)
3190 strcat (buf
, ", trapnil");
3191 if (e_flags
& EF_PARISC_EXT
)
3192 strcat (buf
, ", ext");
3193 if (e_flags
& EF_PARISC_LSB
)
3194 strcat (buf
, ", lsb");
3195 if (e_flags
& EF_PARISC_WIDE
)
3196 strcat (buf
, ", wide");
3197 if (e_flags
& EF_PARISC_NO_KABP
)
3198 strcat (buf
, ", no kabp");
3199 if (e_flags
& EF_PARISC_LAZYSWAP
)
3200 strcat (buf
, ", lazyswap");
3205 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3206 strcat (buf
, ", new calling convention");
3208 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3209 strcat (buf
, ", gnu calling convention");
3213 if ((e_flags
& EF_IA_64_ABI64
))
3214 strcat (buf
, ", 64-bit");
3216 strcat (buf
, ", 32-bit");
3217 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3218 strcat (buf
, ", reduced fp model");
3219 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3220 strcat (buf
, ", no function descriptors, constant gp");
3221 else if ((e_flags
& EF_IA_64_CONS_GP
))
3222 strcat (buf
, ", constant gp");
3223 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3224 strcat (buf
, ", absolute");
3225 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3227 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3228 strcat (buf
, ", vms_linkages");
3229 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3231 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3233 case EF_IA_64_VMS_COMCOD_WARNING
:
3234 strcat (buf
, ", warning");
3236 case EF_IA_64_VMS_COMCOD_ERROR
:
3237 strcat (buf
, ", error");
3239 case EF_IA_64_VMS_COMCOD_ABORT
:
3240 strcat (buf
, ", abort");
3243 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3244 e_flags
& EF_IA_64_VMS_COMCOD
);
3245 strcat (buf
, ", <unknown>");
3251 if ((e_flags
& EF_VAX_NONPIC
))
3252 strcat (buf
, ", non-PIC");
3253 if ((e_flags
& EF_VAX_DFLOAT
))
3254 strcat (buf
, ", D-Float");
3255 if ((e_flags
& EF_VAX_GFLOAT
))
3256 strcat (buf
, ", G-Float");
3260 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3261 strcat (buf
, ", mcm");
3262 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3263 strcat (buf
, ", mcm24");
3264 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3265 strcat (buf
, ", gr6");
3269 if (e_flags
& E_FLAG_RL78_G10
)
3270 strcat (buf
, ", G10");
3271 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3272 strcat (buf
, ", 64-bit doubles");
3276 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3277 strcat (buf
, ", 64-bit doubles");
3278 if (e_flags
& E_FLAG_RX_DSP
)
3279 strcat (buf
, ", dsp");
3280 if (e_flags
& E_FLAG_RX_PID
)
3281 strcat (buf
, ", pid");
3282 if (e_flags
& E_FLAG_RX_ABI
)
3283 strcat (buf
, ", RX ABI");
3287 if (e_flags
& EF_S390_HIGH_GPRS
)
3288 strcat (buf
, ", highgprs");
3292 if ((e_flags
& EF_C6000_REL
))
3293 strcat (buf
, ", relocatable module");
3297 strcat (buf
, _(": architecture variant: "));
3298 switch (e_flags
& EF_MSP430_MACH
)
3300 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3301 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3302 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3303 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3304 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3305 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3306 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3307 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3308 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3309 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3310 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3311 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3312 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3313 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3314 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3316 strcat (buf
, _(": unknown")); break;
3319 if (e_flags
& ~ EF_MSP430_MACH
)
3320 strcat (buf
, _(": unknown extra flag bits also present"));
3328 get_osabi_name (unsigned int osabi
)
3330 static char buff
[32];
3334 case ELFOSABI_NONE
: return "UNIX - System V";
3335 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3336 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3337 case ELFOSABI_GNU
: return "UNIX - GNU";
3338 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3339 case ELFOSABI_AIX
: return "UNIX - AIX";
3340 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3341 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3342 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3343 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3344 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3345 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3346 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3347 case ELFOSABI_AROS
: return "AROS";
3348 case ELFOSABI_FENIXOS
: return "FenixOS";
3351 switch (elf_header
.e_machine
)
3356 case ELFOSABI_ARM
: return "ARM";
3367 case ELFOSABI_STANDALONE
: return _("Standalone App");
3376 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3377 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3386 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3392 get_aarch64_segment_type (unsigned long type
)
3396 case PT_AARCH64_ARCHEXT
:
3397 return "AARCH64_ARCHEXT";
3406 get_arm_segment_type (unsigned long type
)
3420 get_mips_segment_type (unsigned long type
)
3424 case PT_MIPS_REGINFO
:
3426 case PT_MIPS_RTPROC
:
3428 case PT_MIPS_OPTIONS
:
3430 case PT_MIPS_ABIFLAGS
:
3440 get_parisc_segment_type (unsigned long type
)
3444 case PT_HP_TLS
: return "HP_TLS";
3445 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3446 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3447 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3448 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3449 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3450 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3451 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3452 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3453 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3454 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3455 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3456 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3457 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3458 case PT_HP_STACK
: return "HP_STACK";
3459 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3460 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3461 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3462 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3471 get_ia64_segment_type (unsigned long type
)
3475 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3476 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3477 case PT_HP_TLS
: return "HP_TLS";
3478 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3479 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3480 case PT_IA_64_HP_STACK
: return "HP_STACK";
3489 get_tic6x_segment_type (unsigned long type
)
3493 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3502 get_segment_type (unsigned long p_type
)
3504 static char buff
[32];
3508 case PT_NULL
: return "NULL";
3509 case PT_LOAD
: return "LOAD";
3510 case PT_DYNAMIC
: return "DYNAMIC";
3511 case PT_INTERP
: return "INTERP";
3512 case PT_NOTE
: return "NOTE";
3513 case PT_SHLIB
: return "SHLIB";
3514 case PT_PHDR
: return "PHDR";
3515 case PT_TLS
: return "TLS";
3517 case PT_GNU_EH_FRAME
:
3518 return "GNU_EH_FRAME";
3519 case PT_GNU_STACK
: return "GNU_STACK";
3520 case PT_GNU_RELRO
: return "GNU_RELRO";
3523 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3525 const char * result
;
3527 switch (elf_header
.e_machine
)
3530 result
= get_aarch64_segment_type (p_type
);
3533 result
= get_arm_segment_type (p_type
);
3536 case EM_MIPS_RS3_LE
:
3537 result
= get_mips_segment_type (p_type
);
3540 result
= get_parisc_segment_type (p_type
);
3543 result
= get_ia64_segment_type (p_type
);
3546 result
= get_tic6x_segment_type (p_type
);
3556 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3558 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3560 const char * result
;
3562 switch (elf_header
.e_machine
)
3565 result
= get_parisc_segment_type (p_type
);
3568 result
= get_ia64_segment_type (p_type
);
3578 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3581 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3588 get_mips_section_type_name (unsigned int sh_type
)
3592 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3593 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3594 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3595 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3596 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3597 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3598 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3599 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3600 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3601 case SHT_MIPS_RELD
: return "MIPS_RELD";
3602 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3603 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3604 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3605 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3606 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3607 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3608 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3609 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3610 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3611 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3612 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3613 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3614 case SHT_MIPS_LINE
: return "MIPS_LINE";
3615 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3616 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3617 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3618 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3619 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3620 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3621 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3622 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3623 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3624 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3625 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3626 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3627 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3628 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3629 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3630 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3631 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3639 get_parisc_section_type_name (unsigned int sh_type
)
3643 case SHT_PARISC_EXT
: return "PARISC_EXT";
3644 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3645 case SHT_PARISC_DOC
: return "PARISC_DOC";
3646 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3647 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3648 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3649 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3657 get_ia64_section_type_name (unsigned int sh_type
)
3659 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3660 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3661 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3665 case SHT_IA_64_EXT
: return "IA_64_EXT";
3666 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3667 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3668 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3669 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3670 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3671 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3672 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3673 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3674 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3682 get_x86_64_section_type_name (unsigned int sh_type
)
3686 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3694 get_aarch64_section_type_name (unsigned int sh_type
)
3698 case SHT_AARCH64_ATTRIBUTES
:
3699 return "AARCH64_ATTRIBUTES";
3707 get_arm_section_type_name (unsigned int sh_type
)
3711 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3712 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3713 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3714 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3715 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3723 get_tic6x_section_type_name (unsigned int sh_type
)
3727 case SHT_C6000_UNWIND
:
3728 return "C6000_UNWIND";
3729 case SHT_C6000_PREEMPTMAP
:
3730 return "C6000_PREEMPTMAP";
3731 case SHT_C6000_ATTRIBUTES
:
3732 return "C6000_ATTRIBUTES";
3737 case SHT_TI_HANDLER
:
3738 return "TI_HANDLER";
3739 case SHT_TI_INITINFO
:
3740 return "TI_INITINFO";
3741 case SHT_TI_PHATTRS
:
3742 return "TI_PHATTRS";
3750 get_msp430x_section_type_name (unsigned int sh_type
)
3754 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3755 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3756 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3757 default: return NULL
;
3762 get_section_type_name (unsigned int sh_type
)
3764 static char buff
[32];
3768 case SHT_NULL
: return "NULL";
3769 case SHT_PROGBITS
: return "PROGBITS";
3770 case SHT_SYMTAB
: return "SYMTAB";
3771 case SHT_STRTAB
: return "STRTAB";
3772 case SHT_RELA
: return "RELA";
3773 case SHT_HASH
: return "HASH";
3774 case SHT_DYNAMIC
: return "DYNAMIC";
3775 case SHT_NOTE
: return "NOTE";
3776 case SHT_NOBITS
: return "NOBITS";
3777 case SHT_REL
: return "REL";
3778 case SHT_SHLIB
: return "SHLIB";
3779 case SHT_DYNSYM
: return "DYNSYM";
3780 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3781 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3782 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3783 case SHT_GNU_HASH
: return "GNU_HASH";
3784 case SHT_GROUP
: return "GROUP";
3785 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3786 case SHT_GNU_verdef
: return "VERDEF";
3787 case SHT_GNU_verneed
: return "VERNEED";
3788 case SHT_GNU_versym
: return "VERSYM";
3789 case 0x6ffffff0: return "VERSYM";
3790 case 0x6ffffffc: return "VERDEF";
3791 case 0x7ffffffd: return "AUXILIARY";
3792 case 0x7fffffff: return "FILTER";
3793 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3796 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3798 const char * result
;
3800 switch (elf_header
.e_machine
)
3803 case EM_MIPS_RS3_LE
:
3804 result
= get_mips_section_type_name (sh_type
);
3807 result
= get_parisc_section_type_name (sh_type
);
3810 result
= get_ia64_section_type_name (sh_type
);
3815 result
= get_x86_64_section_type_name (sh_type
);
3818 result
= get_aarch64_section_type_name (sh_type
);
3821 result
= get_arm_section_type_name (sh_type
);
3824 result
= get_tic6x_section_type_name (sh_type
);
3827 result
= get_msp430x_section_type_name (sh_type
);
3837 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3839 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3841 const char * result
;
3843 switch (elf_header
.e_machine
)
3846 result
= get_ia64_section_type_name (sh_type
);
3856 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3858 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3859 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3861 /* This message is probably going to be displayed in a 15
3862 character wide field, so put the hex value first. */
3863 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3869 #define OPTION_DEBUG_DUMP 512
3870 #define OPTION_DYN_SYMS 513
3871 #define OPTION_DWARF_DEPTH 514
3872 #define OPTION_DWARF_START 515
3873 #define OPTION_DWARF_CHECK 516
3875 static struct option options
[] =
3877 {"all", no_argument
, 0, 'a'},
3878 {"file-header", no_argument
, 0, 'h'},
3879 {"program-headers", no_argument
, 0, 'l'},
3880 {"headers", no_argument
, 0, 'e'},
3881 {"histogram", no_argument
, 0, 'I'},
3882 {"segments", no_argument
, 0, 'l'},
3883 {"sections", no_argument
, 0, 'S'},
3884 {"section-headers", no_argument
, 0, 'S'},
3885 {"section-groups", no_argument
, 0, 'g'},
3886 {"section-details", no_argument
, 0, 't'},
3887 {"full-section-name",no_argument
, 0, 'N'},
3888 {"symbols", no_argument
, 0, 's'},
3889 {"syms", no_argument
, 0, 's'},
3890 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3891 {"relocs", no_argument
, 0, 'r'},
3892 {"notes", no_argument
, 0, 'n'},
3893 {"dynamic", no_argument
, 0, 'd'},
3894 {"arch-specific", no_argument
, 0, 'A'},
3895 {"version-info", no_argument
, 0, 'V'},
3896 {"use-dynamic", no_argument
, 0, 'D'},
3897 {"unwind", no_argument
, 0, 'u'},
3898 {"archive-index", no_argument
, 0, 'c'},
3899 {"hex-dump", required_argument
, 0, 'x'},
3900 {"relocated-dump", required_argument
, 0, 'R'},
3901 {"string-dump", required_argument
, 0, 'p'},
3902 #ifdef SUPPORT_DISASSEMBLY
3903 {"instruction-dump", required_argument
, 0, 'i'},
3905 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3907 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3908 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3909 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3911 {"version", no_argument
, 0, 'v'},
3912 {"wide", no_argument
, 0, 'W'},
3913 {"help", no_argument
, 0, 'H'},
3914 {0, no_argument
, 0, 0}
3918 usage (FILE * stream
)
3920 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3921 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3922 fprintf (stream
, _(" Options are:\n\
3923 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3924 -h --file-header Display the ELF file header\n\
3925 -l --program-headers Display the program headers\n\
3926 --segments An alias for --program-headers\n\
3927 -S --section-headers Display the sections' header\n\
3928 --sections An alias for --section-headers\n\
3929 -g --section-groups Display the section groups\n\
3930 -t --section-details Display the section details\n\
3931 -e --headers Equivalent to: -h -l -S\n\
3932 -s --syms Display the symbol table\n\
3933 --symbols An alias for --syms\n\
3934 --dyn-syms Display the dynamic symbol table\n\
3935 -n --notes Display the core notes (if present)\n\
3936 -r --relocs Display the relocations (if present)\n\
3937 -u --unwind Display the unwind info (if present)\n\
3938 -d --dynamic Display the dynamic section (if present)\n\
3939 -V --version-info Display the version sections (if present)\n\
3940 -A --arch-specific Display architecture specific information (if any)\n\
3941 -c --archive-index Display the symbol/file index in an archive\n\
3942 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3943 -x --hex-dump=<number|name>\n\
3944 Dump the contents of section <number|name> as bytes\n\
3945 -p --string-dump=<number|name>\n\
3946 Dump the contents of section <number|name> as strings\n\
3947 -R --relocated-dump=<number|name>\n\
3948 Dump the contents of section <number|name> as relocated bytes\n\
3949 -w[lLiaprmfFsoRt] or\n\
3950 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3951 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3952 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3954 Display the contents of DWARF2 debug sections\n"));
3955 fprintf (stream
, _("\
3956 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3957 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3959 #ifdef SUPPORT_DISASSEMBLY
3960 fprintf (stream
, _("\
3961 -i --instruction-dump=<number|name>\n\
3962 Disassemble the contents of section <number|name>\n"));
3964 fprintf (stream
, _("\
3965 -I --histogram Display histogram of bucket list lengths\n\
3966 -W --wide Allow output width to exceed 80 characters\n\
3967 @<file> Read options from <file>\n\
3968 -H --help Display this information\n\
3969 -v --version Display the version number of readelf\n"));
3971 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3972 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3974 exit (stream
== stdout
? 0 : 1);
3977 /* Record the fact that the user wants the contents of section number
3978 SECTION to be displayed using the method(s) encoded as flags bits
3979 in TYPE. Note, TYPE can be zero if we are creating the array for
3983 request_dump_bynumber (unsigned int section
, dump_type type
)
3985 if (section
>= num_dump_sects
)
3987 dump_type
* new_dump_sects
;
3989 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3990 sizeof (* dump_sects
));
3992 if (new_dump_sects
== NULL
)
3993 error (_("Out of memory allocating dump request table.\n"));
3996 /* Copy current flag settings. */
3997 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4001 dump_sects
= new_dump_sects
;
4002 num_dump_sects
= section
+ 1;
4007 dump_sects
[section
] |= type
;
4012 /* Request a dump by section name. */
4015 request_dump_byname (const char * section
, dump_type type
)
4017 struct dump_list_entry
* new_request
;
4019 new_request
= (struct dump_list_entry
*)
4020 malloc (sizeof (struct dump_list_entry
));
4022 error (_("Out of memory allocating dump request table.\n"));
4024 new_request
->name
= strdup (section
);
4025 if (!new_request
->name
)
4026 error (_("Out of memory allocating dump request table.\n"));
4028 new_request
->type
= type
;
4030 new_request
->next
= dump_sects_byname
;
4031 dump_sects_byname
= new_request
;
4035 request_dump (dump_type type
)
4041 section
= strtoul (optarg
, & cp
, 0);
4043 if (! *cp
&& section
>= 0)
4044 request_dump_bynumber (section
, type
);
4046 request_dump_byname (optarg
, type
);
4051 parse_args (int argc
, char ** argv
)
4058 while ((c
= getopt_long
4059 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4077 do_section_groups
++;
4085 do_section_groups
++;
4090 do_section_details
++;
4134 request_dump (HEX_DUMP
);
4137 request_dump (STRING_DUMP
);
4140 request_dump (RELOC_DUMP
);
4147 dwarf_select_sections_all ();
4152 dwarf_select_sections_by_letters (optarg
);
4155 case OPTION_DEBUG_DUMP
:
4162 dwarf_select_sections_by_names (optarg
);
4165 case OPTION_DWARF_DEPTH
:
4169 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4172 case OPTION_DWARF_START
:
4176 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4179 case OPTION_DWARF_CHECK
:
4182 case OPTION_DYN_SYMS
:
4185 #ifdef SUPPORT_DISASSEMBLY
4187 request_dump (DISASS_DUMP
);
4191 print_version (program_name
);
4200 /* xgettext:c-format */
4201 error (_("Invalid option '-%c'\n"), c
);
4208 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4209 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4210 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4211 && !do_section_groups
&& !do_archive_index
4216 warn (_("Nothing to do.\n"));
4222 get_elf_class (unsigned int elf_class
)
4224 static char buff
[32];
4228 case ELFCLASSNONE
: return _("none");
4229 case ELFCLASS32
: return "ELF32";
4230 case ELFCLASS64
: return "ELF64";
4232 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4238 get_data_encoding (unsigned int encoding
)
4240 static char buff
[32];
4244 case ELFDATANONE
: return _("none");
4245 case ELFDATA2LSB
: return _("2's complement, little endian");
4246 case ELFDATA2MSB
: return _("2's complement, big endian");
4248 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4253 /* Decode the data held in 'elf_header'. */
4256 process_file_header (void)
4258 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4259 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4260 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4261 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4264 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4268 init_dwarf_regnames (elf_header
.e_machine
);
4274 printf (_("ELF Header:\n"));
4275 printf (_(" Magic: "));
4276 for (i
= 0; i
< EI_NIDENT
; i
++)
4277 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4279 printf (_(" Class: %s\n"),
4280 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4281 printf (_(" Data: %s\n"),
4282 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4283 printf (_(" Version: %d %s\n"),
4284 elf_header
.e_ident
[EI_VERSION
],
4285 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4287 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4288 ? _("<unknown: %lx>")
4290 printf (_(" OS/ABI: %s\n"),
4291 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4292 printf (_(" ABI Version: %d\n"),
4293 elf_header
.e_ident
[EI_ABIVERSION
]);
4294 printf (_(" Type: %s\n"),
4295 get_file_type (elf_header
.e_type
));
4296 printf (_(" Machine: %s\n"),
4297 get_machine_name (elf_header
.e_machine
));
4298 printf (_(" Version: 0x%lx\n"),
4299 (unsigned long) elf_header
.e_version
);
4301 printf (_(" Entry point address: "));
4302 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4303 printf (_("\n Start of program headers: "));
4304 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4305 printf (_(" (bytes into file)\n Start of section headers: "));
4306 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4307 printf (_(" (bytes into file)\n"));
4309 printf (_(" Flags: 0x%lx%s\n"),
4310 (unsigned long) elf_header
.e_flags
,
4311 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4312 printf (_(" Size of this header: %ld (bytes)\n"),
4313 (long) elf_header
.e_ehsize
);
4314 printf (_(" Size of program headers: %ld (bytes)\n"),
4315 (long) elf_header
.e_phentsize
);
4316 printf (_(" Number of program headers: %ld"),
4317 (long) elf_header
.e_phnum
);
4318 if (section_headers
!= NULL
4319 && elf_header
.e_phnum
== PN_XNUM
4320 && section_headers
[0].sh_info
!= 0)
4321 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4322 putc ('\n', stdout
);
4323 printf (_(" Size of section headers: %ld (bytes)\n"),
4324 (long) elf_header
.e_shentsize
);
4325 printf (_(" Number of section headers: %ld"),
4326 (long) elf_header
.e_shnum
);
4327 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4328 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4329 putc ('\n', stdout
);
4330 printf (_(" Section header string table index: %ld"),
4331 (long) elf_header
.e_shstrndx
);
4332 if (section_headers
!= NULL
4333 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4334 printf (" (%u)", section_headers
[0].sh_link
);
4335 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4336 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4337 printf (_(" <corrupt: out of range>"));
4338 putc ('\n', stdout
);
4341 if (section_headers
!= NULL
)
4343 if (elf_header
.e_phnum
== PN_XNUM
4344 && section_headers
[0].sh_info
!= 0)
4345 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4346 if (elf_header
.e_shnum
== SHN_UNDEF
)
4347 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4348 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4349 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4350 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4351 elf_header
.e_shstrndx
= SHN_UNDEF
;
4352 free (section_headers
);
4353 section_headers
= NULL
;
4360 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4362 Elf32_External_Phdr
* phdrs
;
4363 Elf32_External_Phdr
* external
;
4364 Elf_Internal_Phdr
* internal
;
4366 unsigned int size
= elf_header
.e_phentsize
;
4367 unsigned int num
= elf_header
.e_phnum
;
4369 /* PR binutils/17531: Cope with unexpected section header sizes. */
4370 if (size
== 0 || num
== 0)
4372 if (size
< sizeof * phdrs
)
4374 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4377 if (size
> sizeof * phdrs
)
4378 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4380 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4381 size
, num
, _("program headers"));
4385 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4386 i
< elf_header
.e_phnum
;
4387 i
++, internal
++, external
++)
4389 internal
->p_type
= BYTE_GET (external
->p_type
);
4390 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4391 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4392 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4393 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4394 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4395 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4396 internal
->p_align
= BYTE_GET (external
->p_align
);
4404 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4406 Elf64_External_Phdr
* phdrs
;
4407 Elf64_External_Phdr
* external
;
4408 Elf_Internal_Phdr
* internal
;
4410 unsigned int size
= elf_header
.e_phentsize
;
4411 unsigned int num
= elf_header
.e_phnum
;
4413 /* PR binutils/17531: Cope with unexpected section header sizes. */
4414 if (size
== 0 || num
== 0)
4416 if (size
< sizeof * phdrs
)
4418 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4421 if (size
> sizeof * phdrs
)
4422 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4424 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4425 size
, num
, _("program headers"));
4429 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4430 i
< elf_header
.e_phnum
;
4431 i
++, internal
++, external
++)
4433 internal
->p_type
= BYTE_GET (external
->p_type
);
4434 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4435 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4436 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4437 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4438 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4439 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4440 internal
->p_align
= BYTE_GET (external
->p_align
);
4447 /* Returns 1 if the program headers were read into `program_headers'. */
4450 get_program_headers (FILE * file
)
4452 Elf_Internal_Phdr
* phdrs
;
4454 /* Check cache of prior read. */
4455 if (program_headers
!= NULL
)
4458 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4459 sizeof (Elf_Internal_Phdr
));
4463 error (_("Out of memory reading %u program headers\n"),
4464 elf_header
.e_phnum
);
4469 ? get_32bit_program_headers (file
, phdrs
)
4470 : get_64bit_program_headers (file
, phdrs
))
4472 program_headers
= phdrs
;
4480 /* Returns 1 if the program headers were loaded. */
4483 process_program_headers (FILE * file
)
4485 Elf_Internal_Phdr
* segment
;
4488 if (elf_header
.e_phnum
== 0)
4490 /* PR binutils/12467. */
4491 if (elf_header
.e_phoff
!= 0)
4492 warn (_("possibly corrupt ELF header - it has a non-zero program"
4493 " header offset, but no program headers"));
4494 else if (do_segments
)
4495 printf (_("\nThere are no program headers in this file.\n"));
4499 if (do_segments
&& !do_header
)
4501 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4502 printf (_("Entry point "));
4503 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4504 printf (_("\nThere are %d program headers, starting at offset "),
4505 elf_header
.e_phnum
);
4506 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4510 if (! get_program_headers (file
))
4515 if (elf_header
.e_phnum
> 1)
4516 printf (_("\nProgram Headers:\n"));
4518 printf (_("\nProgram Headers:\n"));
4522 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4525 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4529 (_(" Type Offset VirtAddr PhysAddr\n"));
4531 (_(" FileSiz MemSiz Flags Align\n"));
4538 for (i
= 0, segment
= program_headers
;
4539 i
< elf_header
.e_phnum
;
4544 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4548 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4549 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4550 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4551 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4552 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4554 (segment
->p_flags
& PF_R
? 'R' : ' '),
4555 (segment
->p_flags
& PF_W
? 'W' : ' '),
4556 (segment
->p_flags
& PF_X
? 'E' : ' '));
4557 printf ("%#lx", (unsigned long) segment
->p_align
);
4561 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4562 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4565 print_vma (segment
->p_offset
, FULL_HEX
);
4569 print_vma (segment
->p_vaddr
, FULL_HEX
);
4571 print_vma (segment
->p_paddr
, FULL_HEX
);
4574 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4575 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4578 print_vma (segment
->p_filesz
, FULL_HEX
);
4582 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4583 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4586 print_vma (segment
->p_memsz
, FULL_HEX
);
4590 (segment
->p_flags
& PF_R
? 'R' : ' '),
4591 (segment
->p_flags
& PF_W
? 'W' : ' '),
4592 (segment
->p_flags
& PF_X
? 'E' : ' '));
4594 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4595 printf ("%#lx", (unsigned long) segment
->p_align
);
4598 print_vma (segment
->p_align
, PREFIX_HEX
);
4603 print_vma (segment
->p_offset
, FULL_HEX
);
4605 print_vma (segment
->p_vaddr
, FULL_HEX
);
4607 print_vma (segment
->p_paddr
, FULL_HEX
);
4609 print_vma (segment
->p_filesz
, FULL_HEX
);
4611 print_vma (segment
->p_memsz
, FULL_HEX
);
4613 (segment
->p_flags
& PF_R
? 'R' : ' '),
4614 (segment
->p_flags
& PF_W
? 'W' : ' '),
4615 (segment
->p_flags
& PF_X
? 'E' : ' '));
4616 print_vma (segment
->p_align
, HEX
);
4621 putc ('\n', stdout
);
4623 switch (segment
->p_type
)
4627 error (_("more than one dynamic segment\n"));
4629 /* By default, assume that the .dynamic section is the first
4630 section in the DYNAMIC segment. */
4631 dynamic_addr
= segment
->p_offset
;
4632 dynamic_size
= segment
->p_filesz
;
4633 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4634 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4636 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4637 dynamic_addr
= dynamic_size
= 0;
4640 /* Try to locate the .dynamic section. If there is
4641 a section header table, we can easily locate it. */
4642 if (section_headers
!= NULL
)
4644 Elf_Internal_Shdr
* sec
;
4646 sec
= find_section (".dynamic");
4647 if (sec
== NULL
|| sec
->sh_size
== 0)
4649 /* A corresponding .dynamic section is expected, but on
4650 IA-64/OpenVMS it is OK for it to be missing. */
4651 if (!is_ia64_vms ())
4652 error (_("no .dynamic section in the dynamic segment\n"));
4656 if (sec
->sh_type
== SHT_NOBITS
)
4662 dynamic_addr
= sec
->sh_offset
;
4663 dynamic_size
= sec
->sh_size
;
4665 if (dynamic_addr
< segment
->p_offset
4666 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4667 warn (_("the .dynamic section is not contained"
4668 " within the dynamic segment\n"));
4669 else if (dynamic_addr
> segment
->p_offset
)
4670 warn (_("the .dynamic section is not the first section"
4671 " in the dynamic segment.\n"));
4676 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4678 error (_("Unable to find program interpreter name\n"));
4682 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4684 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4685 error (_("Internal error: failed to create format string to display program interpreter\n"));
4687 program_interpreter
[0] = 0;
4688 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4689 error (_("Unable to read program interpreter name\n"));
4692 printf (_(" [Requesting program interpreter: %s]\n"),
4693 program_interpreter
);
4699 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4701 printf (_("\n Section to Segment mapping:\n"));
4702 printf (_(" Segment Sections...\n"));
4704 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4707 Elf_Internal_Shdr
* section
;
4709 segment
= program_headers
+ i
;
4710 section
= section_headers
+ 1;
4712 printf (" %2.2d ", i
);
4714 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4716 if (!ELF_TBSS_SPECIAL (section
, segment
)
4717 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4718 printf ("%s ", printable_section_name (section
));
4729 /* Find the file offset corresponding to VMA by using the program headers. */
4732 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4734 Elf_Internal_Phdr
* seg
;
4736 if (! get_program_headers (file
))
4738 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4742 for (seg
= program_headers
;
4743 seg
< program_headers
+ elf_header
.e_phnum
;
4746 if (seg
->p_type
!= PT_LOAD
)
4749 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4750 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4751 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4754 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4755 (unsigned long) vma
);
4760 /* Allocate memory and load the sections headers into the global pointer
4761 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4762 generate any error messages if the load fails. */
4765 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4767 Elf32_External_Shdr
* shdrs
;
4768 Elf_Internal_Shdr
* internal
;
4770 unsigned int size
= elf_header
.e_shentsize
;
4771 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4773 /* PR binutils/17531: Cope with unexpected section header sizes. */
4774 if (size
== 0 || num
== 0)
4776 if (size
< sizeof * shdrs
)
4779 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4782 if (!probe
&& size
> sizeof * shdrs
)
4783 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4785 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4787 probe
? NULL
: _("section headers"));
4791 if (section_headers
!= NULL
)
4792 free (section_headers
);
4793 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4794 sizeof (Elf_Internal_Shdr
));
4795 if (section_headers
== NULL
)
4798 error (_("Out of memory reading %u section headers\n"), num
);
4802 for (i
= 0, internal
= section_headers
;
4806 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4807 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4808 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4809 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4810 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4811 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4812 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4813 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4814 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4815 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4823 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4825 Elf64_External_Shdr
* shdrs
;
4826 Elf_Internal_Shdr
* internal
;
4828 unsigned int size
= elf_header
.e_shentsize
;
4829 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4831 /* PR binutils/17531: Cope with unexpected section header sizes. */
4832 if (size
== 0 || num
== 0)
4834 if (size
< sizeof * shdrs
)
4837 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4840 if (! probe
&& size
> sizeof * shdrs
)
4841 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4843 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4845 probe
? NULL
: _("section headers"));
4849 if (section_headers
!= NULL
)
4850 free (section_headers
);
4851 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4852 sizeof (Elf_Internal_Shdr
));
4853 if (section_headers
== NULL
)
4856 error (_("Out of memory reading %u section headers\n"), num
);
4860 for (i
= 0, internal
= section_headers
;
4864 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4865 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4866 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4867 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4868 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4869 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4870 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4871 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4872 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4873 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4880 static Elf_Internal_Sym
*
4881 get_32bit_elf_symbols (FILE * file
,
4882 Elf_Internal_Shdr
* section
,
4883 unsigned long * num_syms_return
)
4885 unsigned long number
= 0;
4886 Elf32_External_Sym
* esyms
= NULL
;
4887 Elf_External_Sym_Shndx
* shndx
= NULL
;
4888 Elf_Internal_Sym
* isyms
= NULL
;
4889 Elf_Internal_Sym
* psym
;
4892 if (section
->sh_size
== 0)
4894 if (num_syms_return
!= NULL
)
4895 * num_syms_return
= 0;
4899 /* Run some sanity checks first. */
4900 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4902 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4903 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4907 if (section
->sh_size
> current_file_size
)
4909 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4910 printable_section_name (section
), (unsigned long) section
->sh_size
);
4914 number
= section
->sh_size
/ section
->sh_entsize
;
4916 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4918 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4919 (unsigned long) section
->sh_size
,
4920 printable_section_name (section
),
4921 (unsigned long) section
->sh_entsize
);
4925 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4926 section
->sh_size
, _("symbols"));
4931 if (symtab_shndx_hdr
!= NULL
4932 && (symtab_shndx_hdr
->sh_link
4933 == (unsigned long) (section
- section_headers
)))
4935 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4936 symtab_shndx_hdr
->sh_offset
,
4937 1, symtab_shndx_hdr
->sh_size
,
4938 _("symbol table section indicies"));
4941 /* PR17531: file: heap-buffer-overflow */
4942 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4944 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4945 printable_section_name (symtab_shndx_hdr
),
4946 (unsigned long) symtab_shndx_hdr
->sh_size
,
4947 (unsigned long) section
->sh_size
);
4952 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4956 error (_("Out of memory reading %lu symbols\n"),
4957 (unsigned long) number
);
4961 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4963 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4964 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4965 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4966 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4967 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4969 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4970 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4971 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4972 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4973 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4982 if (num_syms_return
!= NULL
)
4983 * num_syms_return
= isyms
== NULL
? 0 : number
;
4988 static Elf_Internal_Sym
*
4989 get_64bit_elf_symbols (FILE * file
,
4990 Elf_Internal_Shdr
* section
,
4991 unsigned long * num_syms_return
)
4993 unsigned long number
= 0;
4994 Elf64_External_Sym
* esyms
= NULL
;
4995 Elf_External_Sym_Shndx
* shndx
= NULL
;
4996 Elf_Internal_Sym
* isyms
= NULL
;
4997 Elf_Internal_Sym
* psym
;
5000 if (section
->sh_size
== 0)
5002 if (num_syms_return
!= NULL
)
5003 * num_syms_return
= 0;
5007 /* Run some sanity checks first. */
5008 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5010 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5011 printable_section_name (section
),
5012 (unsigned long) section
->sh_entsize
);
5016 if (section
->sh_size
> current_file_size
)
5018 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5019 printable_section_name (section
),
5020 (unsigned long) section
->sh_size
);
5024 number
= section
->sh_size
/ section
->sh_entsize
;
5026 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5028 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5029 (unsigned long) section
->sh_size
,
5030 printable_section_name (section
),
5031 (unsigned long) section
->sh_entsize
);
5035 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5036 section
->sh_size
, _("symbols"));
5040 if (symtab_shndx_hdr
!= NULL
5041 && (symtab_shndx_hdr
->sh_link
5042 == (unsigned long) (section
- section_headers
)))
5044 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5045 symtab_shndx_hdr
->sh_offset
,
5046 1, symtab_shndx_hdr
->sh_size
,
5047 _("symbol table section indicies"));
5050 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5052 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5053 printable_section_name (symtab_shndx_hdr
),
5054 (unsigned long) symtab_shndx_hdr
->sh_size
,
5055 (unsigned long) section
->sh_size
);
5060 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5064 error (_("Out of memory reading %lu symbols\n"),
5065 (unsigned long) number
);
5069 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5071 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5072 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5073 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5074 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5076 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5078 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5079 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5080 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5082 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5083 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5092 if (num_syms_return
!= NULL
)
5093 * num_syms_return
= isyms
== NULL
? 0 : number
;
5099 get_elf_section_flags (bfd_vma sh_flags
)
5101 static char buff
[1024];
5103 int field_size
= is_32bit_elf
? 8 : 16;
5105 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5106 bfd_vma os_flags
= 0;
5107 bfd_vma proc_flags
= 0;
5108 bfd_vma unknown_flags
= 0;
5116 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5117 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5118 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5119 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5120 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5121 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5122 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5123 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5124 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5125 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5126 /* IA-64 specific. */
5127 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5128 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5129 /* IA-64 OpenVMS specific. */
5130 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5131 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5132 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5133 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5134 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5135 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5137 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5138 /* SPARC specific. */
5139 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5142 if (do_section_details
)
5144 sprintf (buff
, "[%*.*lx]: ",
5145 field_size
, field_size
, (unsigned long) sh_flags
);
5146 p
+= field_size
+ 4;
5153 flag
= sh_flags
& - sh_flags
;
5156 if (do_section_details
)
5160 case SHF_WRITE
: sindex
= 0; break;
5161 case SHF_ALLOC
: sindex
= 1; break;
5162 case SHF_EXECINSTR
: sindex
= 2; break;
5163 case SHF_MERGE
: sindex
= 3; break;
5164 case SHF_STRINGS
: sindex
= 4; break;
5165 case SHF_INFO_LINK
: sindex
= 5; break;
5166 case SHF_LINK_ORDER
: sindex
= 6; break;
5167 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5168 case SHF_GROUP
: sindex
= 8; break;
5169 case SHF_TLS
: sindex
= 9; break;
5170 case SHF_EXCLUDE
: sindex
= 18; break;
5174 switch (elf_header
.e_machine
)
5177 if (flag
== SHF_IA_64_SHORT
)
5179 else if (flag
== SHF_IA_64_NORECOV
)
5182 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5185 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5186 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5187 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5188 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5189 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5190 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5201 case EM_OLD_SPARCV9
:
5202 case EM_SPARC32PLUS
:
5205 if (flag
== SHF_ORDERED
)
5215 if (p
!= buff
+ field_size
+ 4)
5217 if (size
< (10 + 2))
5219 warn (_("Internal error: not enough buffer room for section flag info"));
5220 return _("<unknown>");
5227 size
-= flags
[sindex
].len
;
5228 p
= stpcpy (p
, flags
[sindex
].str
);
5230 else if (flag
& SHF_MASKOS
)
5232 else if (flag
& SHF_MASKPROC
)
5235 unknown_flags
|= flag
;
5241 case SHF_WRITE
: *p
= 'W'; break;
5242 case SHF_ALLOC
: *p
= 'A'; break;
5243 case SHF_EXECINSTR
: *p
= 'X'; break;
5244 case SHF_MERGE
: *p
= 'M'; break;
5245 case SHF_STRINGS
: *p
= 'S'; break;
5246 case SHF_INFO_LINK
: *p
= 'I'; break;
5247 case SHF_LINK_ORDER
: *p
= 'L'; break;
5248 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5249 case SHF_GROUP
: *p
= 'G'; break;
5250 case SHF_TLS
: *p
= 'T'; break;
5251 case SHF_EXCLUDE
: *p
= 'E'; break;
5254 if ((elf_header
.e_machine
== EM_X86_64
5255 || elf_header
.e_machine
== EM_L1OM
5256 || elf_header
.e_machine
== EM_K1OM
)
5257 && flag
== SHF_X86_64_LARGE
)
5259 else if (flag
& SHF_MASKOS
)
5262 sh_flags
&= ~ SHF_MASKOS
;
5264 else if (flag
& SHF_MASKPROC
)
5267 sh_flags
&= ~ SHF_MASKPROC
;
5277 if (do_section_details
)
5281 size
-= 5 + field_size
;
5282 if (p
!= buff
+ field_size
+ 4)
5286 warn (_("Internal error: not enough buffer room for section flag info"));
5287 return _("<unknown>");
5293 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5294 (unsigned long) os_flags
);
5295 p
+= 5 + field_size
;
5299 size
-= 7 + field_size
;
5300 if (p
!= buff
+ field_size
+ 4)
5304 warn (_("Internal error: not enough buffer room for section flag info"));
5305 return _("<unknown>");
5311 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5312 (unsigned long) proc_flags
);
5313 p
+= 7 + field_size
;
5317 size
-= 10 + field_size
;
5318 if (p
!= buff
+ field_size
+ 4)
5322 warn (_("Internal error: not enough buffer room for section flag info"));
5323 return _("<unknown>");
5329 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5330 (unsigned long) unknown_flags
);
5331 p
+= 10 + field_size
;
5340 process_section_headers (FILE * file
)
5342 Elf_Internal_Shdr
* section
;
5345 section_headers
= NULL
;
5347 if (elf_header
.e_shnum
== 0)
5349 /* PR binutils/12467. */
5350 if (elf_header
.e_shoff
!= 0)
5351 warn (_("possibly corrupt ELF file header - it has a non-zero"
5352 " section header offset, but no section headers\n"));
5353 else if (do_sections
)
5354 printf (_("\nThere are no sections in this file.\n"));
5359 if (do_sections
&& !do_header
)
5360 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5361 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5365 if (! get_32bit_section_headers (file
, FALSE
))
5368 else if (! get_64bit_section_headers (file
, FALSE
))
5371 /* Read in the string table, so that we have names to display. */
5372 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5373 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5375 section
= section_headers
+ elf_header
.e_shstrndx
;
5377 if (section
->sh_size
!= 0)
5379 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5380 1, section
->sh_size
,
5383 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5387 /* Scan the sections for the dynamic symbol table
5388 and dynamic string table and debug sections. */
5389 dynamic_symbols
= NULL
;
5390 dynamic_strings
= NULL
;
5391 dynamic_syminfo
= NULL
;
5392 symtab_shndx_hdr
= NULL
;
5394 eh_addr_size
= is_32bit_elf
? 4 : 8;
5395 switch (elf_header
.e_machine
)
5398 case EM_MIPS_RS3_LE
:
5399 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5400 FDE addresses. However, the ABI also has a semi-official ILP32
5401 variant for which the normal FDE address size rules apply.
5403 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5404 section, where XX is the size of longs in bits. Unfortunately,
5405 earlier compilers provided no way of distinguishing ILP32 objects
5406 from LP64 objects, so if there's any doubt, we should assume that
5407 the official LP64 form is being used. */
5408 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5409 && find_section (".gcc_compiled_long32") == NULL
)
5415 switch (elf_header
.e_flags
& EF_H8_MACH
)
5417 case E_H8_MACH_H8300
:
5418 case E_H8_MACH_H8300HN
:
5419 case E_H8_MACH_H8300SN
:
5420 case E_H8_MACH_H8300SXN
:
5423 case E_H8_MACH_H8300H
:
5424 case E_H8_MACH_H8300S
:
5425 case E_H8_MACH_H8300SX
:
5433 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5435 case EF_M32C_CPU_M16C
:
5442 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5445 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5446 if (section->sh_entsize != expected_entsize) \
5449 sprintf_vma (buf, section->sh_entsize); \
5450 /* Note: coded this way so that there is a single string for \
5452 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5453 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5454 (unsigned) expected_entsize); \
5455 section->sh_entsize = expected_entsize; \
5460 #define CHECK_ENTSIZE(section, i, type) \
5461 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5462 sizeof (Elf64_External_##type))
5464 for (i
= 0, section
= section_headers
;
5465 i
< elf_header
.e_shnum
;
5468 char * name
= SECTION_NAME (section
);
5470 if (section
->sh_type
== SHT_DYNSYM
)
5472 if (dynamic_symbols
!= NULL
)
5474 error (_("File contains multiple dynamic symbol tables\n"));
5478 CHECK_ENTSIZE (section
, i
, Sym
);
5479 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5481 else if (section
->sh_type
== SHT_STRTAB
5482 && streq (name
, ".dynstr"))
5484 if (dynamic_strings
!= NULL
)
5486 error (_("File contains multiple dynamic string tables\n"));
5490 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5491 1, section
->sh_size
,
5492 _("dynamic strings"));
5493 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5495 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5497 if (symtab_shndx_hdr
!= NULL
)
5499 error (_("File contains multiple symtab shndx tables\n"));
5502 symtab_shndx_hdr
= section
;
5504 else if (section
->sh_type
== SHT_SYMTAB
)
5505 CHECK_ENTSIZE (section
, i
, Sym
);
5506 else if (section
->sh_type
== SHT_GROUP
)
5507 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5508 else if (section
->sh_type
== SHT_REL
)
5509 CHECK_ENTSIZE (section
, i
, Rel
);
5510 else if (section
->sh_type
== SHT_RELA
)
5511 CHECK_ENTSIZE (section
, i
, Rela
);
5512 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5513 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5514 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5515 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5516 || do_debug_addr
|| do_debug_cu_index
)
5517 && (const_strneq (name
, ".debug_")
5518 || const_strneq (name
, ".zdebug_")))
5521 name
+= sizeof (".zdebug_") - 1;
5523 name
+= sizeof (".debug_") - 1;
5526 || (do_debug_info
&& const_strneq (name
, "info"))
5527 || (do_debug_info
&& const_strneq (name
, "types"))
5528 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5529 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5530 || (do_debug_lines
&& const_strneq (name
, "line."))
5531 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5532 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5533 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5534 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5535 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5536 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5537 || (do_debug_frames
&& const_strneq (name
, "frame"))
5538 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5539 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5540 || (do_debug_str
&& const_strneq (name
, "str"))
5541 || (do_debug_loc
&& const_strneq (name
, "loc"))
5542 || (do_debug_addr
&& const_strneq (name
, "addr"))
5543 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5544 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5546 request_dump_bynumber (i
, DEBUG_DUMP
);
5548 /* Linkonce section to be combined with .debug_info at link time. */
5549 else if ((do_debugging
|| do_debug_info
)
5550 && const_strneq (name
, ".gnu.linkonce.wi."))
5551 request_dump_bynumber (i
, DEBUG_DUMP
);
5552 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5553 request_dump_bynumber (i
, DEBUG_DUMP
);
5554 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5555 request_dump_bynumber (i
, DEBUG_DUMP
);
5556 /* Trace sections for Itanium VMS. */
5557 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5558 || do_trace_aranges
)
5559 && const_strneq (name
, ".trace_"))
5561 name
+= sizeof (".trace_") - 1;
5564 || (do_trace_info
&& streq (name
, "info"))
5565 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5566 || (do_trace_aranges
&& streq (name
, "aranges"))
5568 request_dump_bynumber (i
, DEBUG_DUMP
);
5575 if (elf_header
.e_shnum
> 1)
5576 printf (_("\nSection Headers:\n"));
5578 printf (_("\nSection Header:\n"));
5582 if (do_section_details
)
5584 printf (_(" [Nr] Name\n"));
5585 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5589 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5593 if (do_section_details
)
5595 printf (_(" [Nr] Name\n"));
5596 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5600 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5604 if (do_section_details
)
5606 printf (_(" [Nr] Name\n"));
5607 printf (_(" Type Address Offset Link\n"));
5608 printf (_(" Size EntSize Info Align\n"));
5612 printf (_(" [Nr] Name Type Address Offset\n"));
5613 printf (_(" Size EntSize Flags Link Info Align\n"));
5617 if (do_section_details
)
5618 printf (_(" Flags\n"));
5620 for (i
= 0, section
= section_headers
;
5621 i
< elf_header
.e_shnum
;
5624 printf (" [%2u] ", i
);
5625 if (do_section_details
)
5626 printf ("%s\n ", printable_section_name (section
));
5628 print_symbol (-17, SECTION_NAME (section
));
5630 printf (do_wide
? " %-15s " : " %-15.15s ",
5631 get_section_type_name (section
->sh_type
));
5635 const char * link_too_big
= NULL
;
5637 print_vma (section
->sh_addr
, LONG_HEX
);
5639 printf ( " %6.6lx %6.6lx %2.2lx",
5640 (unsigned long) section
->sh_offset
,
5641 (unsigned long) section
->sh_size
,
5642 (unsigned long) section
->sh_entsize
);
5644 if (do_section_details
)
5645 fputs (" ", stdout
);
5647 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5649 if (section
->sh_link
>= elf_header
.e_shnum
)
5652 /* The sh_link value is out of range. Normally this indicates
5653 an error but it can have special values in Solaris binaries. */
5654 switch (elf_header
.e_machine
)
5661 case EM_OLD_SPARCV9
:
5662 case EM_SPARC32PLUS
:
5665 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5666 link_too_big
= "BEFORE";
5667 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5668 link_too_big
= "AFTER";
5675 if (do_section_details
)
5677 if (link_too_big
!= NULL
&& * link_too_big
)
5678 printf ("<%s> ", link_too_big
);
5680 printf ("%2u ", section
->sh_link
);
5681 printf ("%3u %2lu\n", section
->sh_info
,
5682 (unsigned long) section
->sh_addralign
);
5685 printf ("%2u %3u %2lu\n",
5688 (unsigned long) section
->sh_addralign
);
5690 if (link_too_big
&& ! * link_too_big
)
5691 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5692 i
, section
->sh_link
);
5696 print_vma (section
->sh_addr
, LONG_HEX
);
5698 if ((long) section
->sh_offset
== section
->sh_offset
)
5699 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5703 print_vma (section
->sh_offset
, LONG_HEX
);
5706 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5707 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5711 print_vma (section
->sh_size
, LONG_HEX
);
5714 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5715 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5719 print_vma (section
->sh_entsize
, LONG_HEX
);
5722 if (do_section_details
)
5723 fputs (" ", stdout
);
5725 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5727 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5729 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5730 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5733 print_vma (section
->sh_addralign
, DEC
);
5737 else if (do_section_details
)
5739 printf (" %-15.15s ",
5740 get_section_type_name (section
->sh_type
));
5741 print_vma (section
->sh_addr
, LONG_HEX
);
5742 if ((long) section
->sh_offset
== section
->sh_offset
)
5743 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5747 print_vma (section
->sh_offset
, LONG_HEX
);
5749 printf (" %u\n ", section
->sh_link
);
5750 print_vma (section
->sh_size
, LONG_HEX
);
5752 print_vma (section
->sh_entsize
, LONG_HEX
);
5754 printf (" %-16u %lu\n",
5756 (unsigned long) section
->sh_addralign
);
5761 print_vma (section
->sh_addr
, LONG_HEX
);
5762 if ((long) section
->sh_offset
== section
->sh_offset
)
5763 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5767 print_vma (section
->sh_offset
, LONG_HEX
);
5770 print_vma (section
->sh_size
, LONG_HEX
);
5772 print_vma (section
->sh_entsize
, LONG_HEX
);
5774 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5776 printf (" %2u %3u %lu\n",
5779 (unsigned long) section
->sh_addralign
);
5782 if (do_section_details
)
5783 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5786 if (!do_section_details
)
5788 if (elf_header
.e_machine
== EM_X86_64
5789 || elf_header
.e_machine
== EM_L1OM
5790 || elf_header
.e_machine
== EM_K1OM
)
5791 printf (_("Key to Flags:\n\
5792 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5793 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5794 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5796 printf (_("Key to Flags:\n\
5797 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5798 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5799 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5806 get_group_flags (unsigned int flags
)
5808 static char buff
[32];
5818 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5825 process_section_groups (FILE * file
)
5827 Elf_Internal_Shdr
* section
;
5829 struct group
* group
;
5830 Elf_Internal_Shdr
* symtab_sec
;
5831 Elf_Internal_Shdr
* strtab_sec
;
5832 Elf_Internal_Sym
* symtab
;
5833 unsigned long num_syms
;
5837 /* Don't process section groups unless needed. */
5838 if (!do_unwind
&& !do_section_groups
)
5841 if (elf_header
.e_shnum
== 0)
5843 if (do_section_groups
)
5844 printf (_("\nThere are no sections to group in this file.\n"));
5849 if (section_headers
== NULL
)
5851 error (_("Section headers are not available!\n"));
5852 /* PR 13622: This can happen with a corrupt ELF header. */
5856 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5857 sizeof (struct group
*));
5859 if (section_headers_groups
== NULL
)
5861 error (_("Out of memory reading %u section group headers\n"),
5862 elf_header
.e_shnum
);
5866 /* Scan the sections for the group section. */
5868 for (i
= 0, section
= section_headers
;
5869 i
< elf_header
.e_shnum
;
5871 if (section
->sh_type
== SHT_GROUP
)
5874 if (group_count
== 0)
5876 if (do_section_groups
)
5877 printf (_("\nThere are no section groups in this file.\n"));
5882 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5884 if (section_groups
== NULL
)
5886 error (_("Out of memory reading %lu groups\n"),
5887 (unsigned long) group_count
);
5897 for (i
= 0, section
= section_headers
, group
= section_groups
;
5898 i
< elf_header
.e_shnum
;
5901 if (section
->sh_type
== SHT_GROUP
)
5903 const char * name
= printable_section_name (section
);
5904 const char * group_name
;
5905 unsigned char * start
;
5906 unsigned char * indices
;
5907 unsigned int entry
, j
, size
;
5908 Elf_Internal_Shdr
* sec
;
5909 Elf_Internal_Sym
* sym
;
5911 /* Get the symbol table. */
5912 if (section
->sh_link
>= elf_header
.e_shnum
5913 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5916 error (_("Bad sh_link in group section `%s'\n"), name
);
5920 if (symtab_sec
!= sec
)
5925 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5930 error (_("Corrupt header in group section `%s'\n"), name
);
5934 if (section
->sh_info
>= num_syms
)
5936 error (_("Bad sh_info in group section `%s'\n"), name
);
5940 sym
= symtab
+ section
->sh_info
;
5942 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5944 if (sym
->st_shndx
== 0
5945 || sym
->st_shndx
>= elf_header
.e_shnum
)
5947 error (_("Bad sh_info in group section `%s'\n"), name
);
5951 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5960 /* Get the string table. */
5961 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5970 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5976 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5977 1, strtab_sec
->sh_size
,
5979 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5981 group_name
= sym
->st_name
< strtab_size
5982 ? strtab
+ sym
->st_name
: _("<corrupt>");
5985 /* PR 17531: file: loop. */
5986 if (section
->sh_entsize
> section
->sh_size
)
5988 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5989 printable_section_name (section
),
5990 (unsigned long) section
->sh_entsize
,
5991 (unsigned long) section
->sh_size
);
5995 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5996 1, section
->sh_size
,
6002 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6003 entry
= byte_get (indices
, 4);
6006 if (do_section_groups
)
6008 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6009 get_group_flags (entry
), i
, name
, group_name
, size
);
6011 printf (_(" [Index] Name\n"));
6014 group
->group_index
= i
;
6016 for (j
= 0; j
< size
; j
++)
6018 struct group_list
* g
;
6020 entry
= byte_get (indices
, 4);
6023 if (entry
>= elf_header
.e_shnum
)
6025 static unsigned num_group_errors
= 0;
6027 if (num_group_errors
++ < 10)
6029 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6030 entry
, i
, elf_header
.e_shnum
- 1);
6031 if (num_group_errors
== 10)
6032 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6037 if (section_headers_groups
[entry
] != NULL
)
6041 static unsigned num_errs
= 0;
6043 if (num_errs
++ < 10)
6045 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6047 section_headers_groups
[entry
]->group_index
);
6049 warn (_("Further error messages about already contained group sections suppressed\n"));
6055 /* Intel C/C++ compiler may put section 0 in a
6056 section group. We just warn it the first time
6057 and ignore it afterwards. */
6058 static int warned
= 0;
6061 error (_("section 0 in group section [%5u]\n"),
6062 section_headers_groups
[entry
]->group_index
);
6068 section_headers_groups
[entry
] = group
;
6070 if (do_section_groups
)
6072 sec
= section_headers
+ entry
;
6073 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6076 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6077 g
->section_index
= entry
;
6078 g
->next
= group
->root
;
6096 /* Data used to display dynamic fixups. */
6098 struct ia64_vms_dynfixup
6100 bfd_vma needed_ident
; /* Library ident number. */
6101 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6102 bfd_vma fixup_needed
; /* Index of the library. */
6103 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6104 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6107 /* Data used to display dynamic relocations. */
6109 struct ia64_vms_dynimgrela
6111 bfd_vma img_rela_cnt
; /* Number of relocations. */
6112 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6115 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6119 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6120 const char *strtab
, unsigned int strtab_sz
)
6122 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6124 const char *lib_name
;
6126 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6127 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6128 _("dynamic section image fixups"));
6132 if (fixup
->needed
< strtab_sz
)
6133 lib_name
= strtab
+ fixup
->needed
;
6136 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6137 (unsigned long) fixup
->needed
);
6140 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6141 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6143 (_("Seg Offset Type SymVec DataType\n"));
6145 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6150 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6151 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6152 type
= BYTE_GET (imfs
[i
].type
);
6153 rtype
= elf_ia64_reloc_type (type
);
6155 printf (" 0x%08x ", type
);
6157 printf (" %-32s ", rtype
);
6158 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6159 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6165 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6168 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6170 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6173 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6174 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6175 _("dynamic section image relocations"));
6179 printf (_("\nImage relocs\n"));
6181 (_("Seg Offset Type Addend Seg Sym Off\n"));
6183 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6188 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6189 printf ("%08" BFD_VMA_FMT
"x ",
6190 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6191 type
= BYTE_GET (imrs
[i
].type
);
6192 rtype
= elf_ia64_reloc_type (type
);
6194 printf ("0x%08x ", type
);
6196 printf ("%-31s ", rtype
);
6197 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6198 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6199 printf ("%08" BFD_VMA_FMT
"x\n",
6200 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6206 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6209 process_ia64_vms_dynamic_relocs (FILE *file
)
6211 struct ia64_vms_dynfixup fixup
;
6212 struct ia64_vms_dynimgrela imgrela
;
6213 Elf_Internal_Dyn
*entry
;
6215 bfd_vma strtab_off
= 0;
6216 bfd_vma strtab_sz
= 0;
6217 char *strtab
= NULL
;
6219 memset (&fixup
, 0, sizeof (fixup
));
6220 memset (&imgrela
, 0, sizeof (imgrela
));
6222 /* Note: the order of the entries is specified by the OpenVMS specs. */
6223 for (entry
= dynamic_section
;
6224 entry
< dynamic_section
+ dynamic_nent
;
6227 switch (entry
->d_tag
)
6229 case DT_IA_64_VMS_STRTAB_OFFSET
:
6230 strtab_off
= entry
->d_un
.d_val
;
6233 strtab_sz
= entry
->d_un
.d_val
;
6235 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6236 1, strtab_sz
, _("dynamic string section"));
6239 case DT_IA_64_VMS_NEEDED_IDENT
:
6240 fixup
.needed_ident
= entry
->d_un
.d_val
;
6243 fixup
.needed
= entry
->d_un
.d_val
;
6245 case DT_IA_64_VMS_FIXUP_NEEDED
:
6246 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6248 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6249 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6251 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6252 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6254 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6257 case DT_IA_64_VMS_IMG_RELA_CNT
:
6258 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6260 case DT_IA_64_VMS_IMG_RELA_OFF
:
6261 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6263 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6283 } dynamic_relocations
[] =
6285 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6286 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6287 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6290 /* Process the reloc section. */
6293 process_relocs (FILE * file
)
6295 unsigned long rel_size
;
6296 unsigned long rel_offset
;
6302 if (do_using_dynamic
)
6306 int has_dynamic_reloc
;
6309 has_dynamic_reloc
= 0;
6311 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6313 is_rela
= dynamic_relocations
[i
].rela
;
6314 name
= dynamic_relocations
[i
].name
;
6315 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6316 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6318 has_dynamic_reloc
|= rel_size
;
6320 if (is_rela
== UNKNOWN
)
6322 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6323 switch (dynamic_info
[DT_PLTREL
])
6337 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6338 name
, rel_offset
, rel_size
);
6340 dump_relocations (file
,
6341 offset_from_vma (file
, rel_offset
, rel_size
),
6343 dynamic_symbols
, num_dynamic_syms
,
6344 dynamic_strings
, dynamic_strings_length
,
6350 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6352 if (! has_dynamic_reloc
)
6353 printf (_("\nThere are no dynamic relocations in this file.\n"));
6357 Elf_Internal_Shdr
* section
;
6361 for (i
= 0, section
= section_headers
;
6362 i
< elf_header
.e_shnum
;
6365 if ( section
->sh_type
!= SHT_RELA
6366 && section
->sh_type
!= SHT_REL
)
6369 rel_offset
= section
->sh_offset
;
6370 rel_size
= section
->sh_size
;
6374 Elf_Internal_Shdr
* strsec
;
6377 printf (_("\nRelocation section "));
6379 if (string_table
== NULL
)
6380 printf ("%d", section
->sh_name
);
6382 printf ("'%s'", printable_section_name (section
));
6384 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6385 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6387 is_rela
= section
->sh_type
== SHT_RELA
;
6389 if (section
->sh_link
!= 0
6390 && section
->sh_link
< elf_header
.e_shnum
)
6392 Elf_Internal_Shdr
* symsec
;
6393 Elf_Internal_Sym
* symtab
;
6394 unsigned long nsyms
;
6395 unsigned long strtablen
= 0;
6396 char * strtab
= NULL
;
6398 symsec
= section_headers
+ section
->sh_link
;
6399 if (symsec
->sh_type
!= SHT_SYMTAB
6400 && symsec
->sh_type
!= SHT_DYNSYM
)
6403 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6408 if (symsec
->sh_link
!= 0
6409 && symsec
->sh_link
< elf_header
.e_shnum
)
6411 strsec
= section_headers
+ symsec
->sh_link
;
6413 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6416 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6419 dump_relocations (file
, rel_offset
, rel_size
,
6420 symtab
, nsyms
, strtab
, strtablen
,
6422 symsec
->sh_type
== SHT_DYNSYM
);
6428 dump_relocations (file
, rel_offset
, rel_size
,
6429 NULL
, 0, NULL
, 0, is_rela
, 0);
6436 printf (_("\nThere are no relocations in this file.\n"));
6442 /* Process the unwind section. */
6444 #include "unwind-ia64.h"
6446 /* An absolute address consists of a section and an offset. If the
6447 section is NULL, the offset itself is the address, otherwise, the
6448 address equals to LOAD_ADDRESS(section) + offset. */
6452 unsigned short section
;
6456 #define ABSADDR(a) \
6458 ? section_headers [(a).section].sh_addr + (a).offset \
6461 struct ia64_unw_table_entry
6463 struct absaddr start
;
6465 struct absaddr info
;
6468 struct ia64_unw_aux_info
6471 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6472 unsigned long table_len
; /* Length of unwind table. */
6473 unsigned char * info
; /* Unwind info. */
6474 unsigned long info_size
; /* Size of unwind info. */
6475 bfd_vma info_addr
; /* starting address of unwind info. */
6476 bfd_vma seg_base
; /* Starting address of segment. */
6477 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6478 unsigned long nsyms
; /* Number of symbols. */
6479 char * strtab
; /* The string table. */
6480 unsigned long strtab_size
; /* Size of string table. */
6484 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6485 unsigned long nsyms
,
6486 const char * strtab
,
6487 unsigned long strtab_size
,
6488 struct absaddr addr
,
6489 const char ** symname
,
6492 bfd_vma dist
= 0x100000;
6493 Elf_Internal_Sym
* sym
;
6494 Elf_Internal_Sym
* best
= NULL
;
6497 REMOVE_ARCH_BITS (addr
.offset
);
6499 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6501 bfd_vma value
= sym
->st_value
;
6503 REMOVE_ARCH_BITS (value
);
6505 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6506 && sym
->st_name
!= 0
6507 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6508 && addr
.offset
>= value
6509 && addr
.offset
- value
< dist
)
6512 dist
= addr
.offset
- value
;
6520 *symname
= (best
->st_name
>= strtab_size
6521 ? _("<corrupt>") : strtab
+ best
->st_name
);
6527 *offset
= addr
.offset
;
6531 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6533 struct ia64_unw_table_entry
* tp
;
6536 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6540 const unsigned char * dp
;
6541 const unsigned char * head
;
6542 const unsigned char * end
;
6543 const char * procname
;
6545 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6546 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6548 fputs ("\n<", stdout
);
6552 fputs (procname
, stdout
);
6555 printf ("+%lx", (unsigned long) offset
);
6558 fputs (">: [", stdout
);
6559 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6560 fputc ('-', stdout
);
6561 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6562 printf ("], info at +0x%lx\n",
6563 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6565 /* PR 17531: file: 86232b32. */
6566 if (aux
->info
== NULL
)
6569 /* PR 17531: file: 0997b4d1. */
6570 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6572 warn (_("Invalid offset %lx in table entry %ld\n"),
6573 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6577 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6578 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6580 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6581 (unsigned) UNW_VER (stamp
),
6582 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6583 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6584 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6585 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6587 if (UNW_VER (stamp
) != 1)
6589 printf (_("\tUnknown version.\n"));
6594 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6595 /* PR 17531: file: 16ceda89. */
6596 if (end
> aux
->info
+ aux
->info_size
)
6597 end
= aux
->info
+ aux
->info_size
;
6598 for (dp
= head
+ 8; dp
< end
;)
6599 dp
= unw_decode (dp
, in_body
, & in_body
);
6604 slurp_ia64_unwind_table (FILE * file
,
6605 struct ia64_unw_aux_info
* aux
,
6606 Elf_Internal_Shdr
* sec
)
6608 unsigned long size
, nrelas
, i
;
6609 Elf_Internal_Phdr
* seg
;
6610 struct ia64_unw_table_entry
* tep
;
6611 Elf_Internal_Shdr
* relsec
;
6612 Elf_Internal_Rela
* rela
;
6613 Elf_Internal_Rela
* rp
;
6614 unsigned char * table
;
6616 Elf_Internal_Sym
* sym
;
6617 const char * relname
;
6621 /* First, find the starting address of the segment that includes
6624 if (elf_header
.e_phnum
)
6626 if (! get_program_headers (file
))
6629 for (seg
= program_headers
;
6630 seg
< program_headers
+ elf_header
.e_phnum
;
6633 if (seg
->p_type
!= PT_LOAD
)
6636 if (sec
->sh_addr
>= seg
->p_vaddr
6637 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6639 aux
->seg_base
= seg
->p_vaddr
;
6645 /* Second, build the unwind table from the contents of the unwind section: */
6646 size
= sec
->sh_size
;
6647 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6652 aux
->table_len
= size
/ (3 * eh_addr_size
);
6653 aux
->table
= (struct ia64_unw_table_entry
*)
6654 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6657 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6659 tep
->start
.section
= SHN_UNDEF
;
6660 tep
->end
.section
= SHN_UNDEF
;
6661 tep
->info
.section
= SHN_UNDEF
;
6662 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6663 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6664 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6665 tep
->start
.offset
+= aux
->seg_base
;
6666 tep
->end
.offset
+= aux
->seg_base
;
6667 tep
->info
.offset
+= aux
->seg_base
;
6671 /* Third, apply any relocations to the unwind table: */
6672 for (relsec
= section_headers
;
6673 relsec
< section_headers
+ elf_header
.e_shnum
;
6676 if (relsec
->sh_type
!= SHT_RELA
6677 || relsec
->sh_info
>= elf_header
.e_shnum
6678 || section_headers
+ relsec
->sh_info
!= sec
)
6681 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6690 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6692 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6693 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6695 /* PR 17531: file: 9fa67536. */
6696 if (relname
== NULL
)
6698 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6702 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6704 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6708 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6710 /* PR 17531: file: 5bc8d9bf. */
6711 if (i
>= aux
->table_len
)
6713 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6717 switch (rp
->r_offset
/ eh_addr_size
% 3)
6720 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6721 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6724 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6725 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6728 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6729 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6743 ia64_process_unwind (FILE * file
)
6745 Elf_Internal_Shdr
* sec
;
6746 Elf_Internal_Shdr
* unwsec
= NULL
;
6747 Elf_Internal_Shdr
* strsec
;
6748 unsigned long i
, unwcount
= 0, unwstart
= 0;
6749 struct ia64_unw_aux_info aux
;
6751 memset (& aux
, 0, sizeof (aux
));
6753 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6755 if (sec
->sh_type
== SHT_SYMTAB
6756 && sec
->sh_link
< elf_header
.e_shnum
)
6758 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6760 strsec
= section_headers
+ sec
->sh_link
;
6761 if (aux
.strtab
!= NULL
)
6763 error (_("Multiple auxillary string tables encountered\n"));
6766 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6769 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6771 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6776 printf (_("\nThere are no unwind sections in this file.\n"));
6778 while (unwcount
-- > 0)
6783 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6784 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6785 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6790 /* We have already counted the number of SHT_IA64_UNWIND
6791 sections so the loop above should never fail. */
6792 assert (unwsec
!= NULL
);
6795 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6797 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6799 /* We need to find which section group it is in. */
6800 struct group_list
* g
;
6802 if (section_headers_groups
== NULL
6803 || section_headers_groups
[i
] == NULL
)
6804 i
= elf_header
.e_shnum
;
6807 g
= section_headers_groups
[i
]->root
;
6809 for (; g
!= NULL
; g
= g
->next
)
6811 sec
= section_headers
+ g
->section_index
;
6813 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6818 i
= elf_header
.e_shnum
;
6821 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6823 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6824 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6825 suffix
= SECTION_NAME (unwsec
) + len
;
6826 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6828 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6829 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6834 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6835 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6836 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6837 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6839 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6840 suffix
= SECTION_NAME (unwsec
) + len
;
6841 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6843 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6844 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6848 if (i
== elf_header
.e_shnum
)
6850 printf (_("\nCould not find unwind info section for "));
6852 if (string_table
== NULL
)
6853 printf ("%d", unwsec
->sh_name
);
6855 printf ("'%s'", printable_section_name (unwsec
));
6859 aux
.info_addr
= sec
->sh_addr
;
6860 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6863 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6865 printf (_("\nUnwind section "));
6867 if (string_table
== NULL
)
6868 printf ("%d", unwsec
->sh_name
);
6870 printf ("'%s'", printable_section_name (unwsec
));
6872 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6873 (unsigned long) unwsec
->sh_offset
,
6874 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6876 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
6877 && aux
.table_len
> 0)
6878 dump_ia64_unwind (& aux
);
6881 free ((char *) aux
.table
);
6883 free ((char *) aux
.info
);
6892 free ((char *) aux
.strtab
);
6895 struct hppa_unw_table_entry
6897 struct absaddr start
;
6899 unsigned int Cannot_unwind
:1; /* 0 */
6900 unsigned int Millicode
:1; /* 1 */
6901 unsigned int Millicode_save_sr0
:1; /* 2 */
6902 unsigned int Region_description
:2; /* 3..4 */
6903 unsigned int reserved1
:1; /* 5 */
6904 unsigned int Entry_SR
:1; /* 6 */
6905 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6906 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6907 unsigned int Args_stored
:1; /* 16 */
6908 unsigned int Variable_Frame
:1; /* 17 */
6909 unsigned int Separate_Package_Body
:1; /* 18 */
6910 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6911 unsigned int Stack_Overflow_Check
:1; /* 20 */
6912 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6913 unsigned int Ada_Region
:1; /* 22 */
6914 unsigned int cxx_info
:1; /* 23 */
6915 unsigned int cxx_try_catch
:1; /* 24 */
6916 unsigned int sched_entry_seq
:1; /* 25 */
6917 unsigned int reserved2
:1; /* 26 */
6918 unsigned int Save_SP
:1; /* 27 */
6919 unsigned int Save_RP
:1; /* 28 */
6920 unsigned int Save_MRP_in_frame
:1; /* 29 */
6921 unsigned int extn_ptr_defined
:1; /* 30 */
6922 unsigned int Cleanup_defined
:1; /* 31 */
6924 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6925 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6926 unsigned int Large_frame
:1; /* 2 */
6927 unsigned int Pseudo_SP_Set
:1; /* 3 */
6928 unsigned int reserved4
:1; /* 4 */
6929 unsigned int Total_frame_size
:27; /* 5..31 */
6932 struct hppa_unw_aux_info
6934 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6935 unsigned long table_len
; /* Length of unwind table. */
6936 bfd_vma seg_base
; /* Starting address of segment. */
6937 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6938 unsigned long nsyms
; /* Number of symbols. */
6939 char * strtab
; /* The string table. */
6940 unsigned long strtab_size
; /* Size of string table. */
6944 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6946 struct hppa_unw_table_entry
* tp
;
6948 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6951 const char * procname
;
6953 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6954 aux
->strtab_size
, tp
->start
, &procname
,
6957 fputs ("\n<", stdout
);
6961 fputs (procname
, stdout
);
6964 printf ("+%lx", (unsigned long) offset
);
6967 fputs (">: [", stdout
);
6968 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6969 fputc ('-', stdout
);
6970 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6973 #define PF(_m) if (tp->_m) printf (#_m " ");
6974 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6977 PF(Millicode_save_sr0
);
6978 /* PV(Region_description); */
6984 PF(Separate_Package_Body
);
6985 PF(Frame_Extension_Millicode
);
6986 PF(Stack_Overflow_Check
);
6987 PF(Two_Instruction_SP_Increment
);
6991 PF(sched_entry_seq
);
6994 PF(Save_MRP_in_frame
);
6995 PF(extn_ptr_defined
);
6996 PF(Cleanup_defined
);
6997 PF(MPE_XL_interrupt_marker
);
6998 PF(HP_UX_interrupt_marker
);
7001 PV(Total_frame_size
);
7010 slurp_hppa_unwind_table (FILE * file
,
7011 struct hppa_unw_aux_info
* aux
,
7012 Elf_Internal_Shdr
* sec
)
7014 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7015 Elf_Internal_Phdr
* seg
;
7016 struct hppa_unw_table_entry
* tep
;
7017 Elf_Internal_Shdr
* relsec
;
7018 Elf_Internal_Rela
* rela
;
7019 Elf_Internal_Rela
* rp
;
7020 unsigned char * table
;
7022 Elf_Internal_Sym
* sym
;
7023 const char * relname
;
7025 /* First, find the starting address of the segment that includes
7028 if (elf_header
.e_phnum
)
7030 if (! get_program_headers (file
))
7033 for (seg
= program_headers
;
7034 seg
< program_headers
+ elf_header
.e_phnum
;
7037 if (seg
->p_type
!= PT_LOAD
)
7040 if (sec
->sh_addr
>= seg
->p_vaddr
7041 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7043 aux
->seg_base
= seg
->p_vaddr
;
7049 /* Second, build the unwind table from the contents of the unwind
7051 size
= sec
->sh_size
;
7052 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7058 nentries
= size
/ unw_ent_size
;
7059 size
= unw_ent_size
* nentries
;
7061 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7062 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7064 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7066 unsigned int tmp1
, tmp2
;
7068 tep
->start
.section
= SHN_UNDEF
;
7069 tep
->end
.section
= SHN_UNDEF
;
7071 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7072 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7073 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7074 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7076 tep
->start
.offset
+= aux
->seg_base
;
7077 tep
->end
.offset
+= aux
->seg_base
;
7079 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7080 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7081 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7082 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7083 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7084 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7085 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7086 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7087 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7088 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7089 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7090 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7091 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7092 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7093 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7094 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7095 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7096 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7097 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7098 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7099 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7100 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7101 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7102 tep
->Cleanup_defined
= tmp1
& 0x1;
7104 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7105 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7106 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7107 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7108 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7109 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7113 /* Third, apply any relocations to the unwind table. */
7114 for (relsec
= section_headers
;
7115 relsec
< section_headers
+ elf_header
.e_shnum
;
7118 if (relsec
->sh_type
!= SHT_RELA
7119 || relsec
->sh_info
>= elf_header
.e_shnum
7120 || section_headers
+ relsec
->sh_info
!= sec
)
7123 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7127 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7129 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7130 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7132 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7133 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7135 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7139 i
= rp
->r_offset
/ unw_ent_size
;
7141 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7144 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7145 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7148 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7149 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7159 aux
->table_len
= nentries
;
7165 hppa_process_unwind (FILE * file
)
7167 struct hppa_unw_aux_info aux
;
7168 Elf_Internal_Shdr
* unwsec
= NULL
;
7169 Elf_Internal_Shdr
* strsec
;
7170 Elf_Internal_Shdr
* sec
;
7173 if (string_table
== NULL
)
7176 memset (& aux
, 0, sizeof (aux
));
7178 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7180 if (sec
->sh_type
== SHT_SYMTAB
7181 && sec
->sh_link
< elf_header
.e_shnum
)
7183 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7185 strsec
= section_headers
+ sec
->sh_link
;
7186 if (aux
.strtab
!= NULL
)
7188 error (_("Multiple auxillary string tables encountered\n"));
7191 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7194 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7196 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7201 printf (_("\nThere are no unwind sections in this file.\n"));
7203 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7205 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7207 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7208 printable_section_name (sec
),
7209 (unsigned long) sec
->sh_offset
,
7210 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7212 slurp_hppa_unwind_table (file
, &aux
, sec
);
7213 if (aux
.table_len
> 0)
7214 dump_hppa_unwind (&aux
);
7217 free ((char *) aux
.table
);
7225 free ((char *) aux
.strtab
);
7230 unsigned char * data
; /* The unwind data. */
7231 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7232 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7233 unsigned long nrelas
; /* The number of relocations. */
7234 unsigned int rel_type
; /* REL or RELA ? */
7235 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7238 struct arm_unw_aux_info
7240 FILE * file
; /* The file containing the unwind sections. */
7241 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7242 unsigned long nsyms
; /* Number of symbols. */
7243 char * strtab
; /* The file's string table. */
7244 unsigned long strtab_size
; /* Size of string table. */
7248 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7249 bfd_vma fn
, struct absaddr addr
)
7251 const char *procname
;
7254 if (addr
.section
== SHN_UNDEF
)
7257 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
7258 aux
->strtab_size
, addr
, &procname
,
7261 print_vma (fn
, PREFIX_HEX
);
7265 fputs (" <", stdout
);
7266 fputs (procname
, stdout
);
7269 printf ("+0x%lx", (unsigned long) sym_offset
);
7270 fputc ('>', stdout
);
7277 arm_free_section (struct arm_section
*arm_sec
)
7279 if (arm_sec
->data
!= NULL
)
7280 free (arm_sec
->data
);
7282 if (arm_sec
->rela
!= NULL
)
7283 free (arm_sec
->rela
);
7286 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7287 cached section and install SEC instead.
7288 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7289 and return its valued in * WORDP, relocating if necessary.
7290 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7291 relocation's offset in ADDR.
7292 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7293 into the string table of the symbol associated with the reloc. If no
7294 reloc was applied store -1 there.
7295 5) Return TRUE upon success, FALSE otherwise. */
7298 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7299 struct arm_section
* arm_sec
,
7300 Elf_Internal_Shdr
* sec
,
7301 bfd_vma word_offset
,
7302 unsigned int * wordp
,
7303 struct absaddr
* addr
,
7306 Elf_Internal_Rela
*rp
;
7307 Elf_Internal_Sym
*sym
;
7308 const char * relname
;
7310 bfd_boolean wrapped
;
7312 if (sec
== NULL
|| arm_sec
== NULL
)
7315 addr
->section
= SHN_UNDEF
;
7318 if (sym_name
!= NULL
)
7319 *sym_name
= (bfd_vma
) -1;
7321 /* If necessary, update the section cache. */
7322 if (sec
!= arm_sec
->sec
)
7324 Elf_Internal_Shdr
*relsec
;
7326 arm_free_section (arm_sec
);
7329 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7330 sec
->sh_size
, _("unwind data"));
7331 arm_sec
->rela
= NULL
;
7332 arm_sec
->nrelas
= 0;
7334 for (relsec
= section_headers
;
7335 relsec
< section_headers
+ elf_header
.e_shnum
;
7338 if (relsec
->sh_info
>= elf_header
.e_shnum
7339 || section_headers
+ relsec
->sh_info
!= sec
7340 /* PR 15745: Check the section type as well. */
7341 || (relsec
->sh_type
!= SHT_REL
7342 && relsec
->sh_type
!= SHT_RELA
))
7345 arm_sec
->rel_type
= relsec
->sh_type
;
7346 if (relsec
->sh_type
== SHT_REL
)
7348 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7350 & arm_sec
->rela
, & arm_sec
->nrelas
))
7353 else /* relsec->sh_type == SHT_RELA */
7355 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7357 & arm_sec
->rela
, & arm_sec
->nrelas
))
7363 arm_sec
->next_rela
= arm_sec
->rela
;
7366 /* If there is no unwind data we can do nothing. */
7367 if (arm_sec
->data
== NULL
)
7370 /* If the offset is invalid then fail. */
7371 if (word_offset
> sec
->sh_size
- 4)
7374 /* Get the word at the required offset. */
7375 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7377 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7378 if (arm_sec
->rela
== NULL
)
7384 /* Look through the relocs to find the one that applies to the provided offset. */
7386 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7388 bfd_vma prelval
, offset
;
7390 if (rp
->r_offset
> word_offset
&& !wrapped
)
7395 if (rp
->r_offset
> word_offset
)
7398 if (rp
->r_offset
& 3)
7400 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7401 (unsigned long) rp
->r_offset
);
7405 if (rp
->r_offset
< word_offset
)
7408 /* PR 17531: file: 027-161405-0.004 */
7409 if (aux
->symtab
== NULL
)
7412 if (arm_sec
->rel_type
== SHT_REL
)
7414 offset
= word
& 0x7fffffff;
7415 if (offset
& 0x40000000)
7416 offset
|= ~ (bfd_vma
) 0x7fffffff;
7418 else if (arm_sec
->rel_type
== SHT_RELA
)
7419 offset
= rp
->r_addend
;
7422 error (_("Unknown section relocation type %d encountered\n"),
7427 /* PR 17531 file: 027-1241568-0.004. */
7428 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7430 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7431 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7435 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7436 offset
+= sym
->st_value
;
7437 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7439 /* Check that we are processing the expected reloc type. */
7440 if (elf_header
.e_machine
== EM_ARM
)
7442 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7443 if (relname
== NULL
)
7445 warn (_("Skipping unknown ARM relocation type: %d\n"),
7446 (int) ELF32_R_TYPE (rp
->r_info
));
7450 if (streq (relname
, "R_ARM_NONE"))
7453 if (! streq (relname
, "R_ARM_PREL31"))
7455 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7459 else if (elf_header
.e_machine
== EM_TI_C6000
)
7461 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7462 if (relname
== NULL
)
7464 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7465 (int) ELF32_R_TYPE (rp
->r_info
));
7469 if (streq (relname
, "R_C6000_NONE"))
7472 if (! streq (relname
, "R_C6000_PREL31"))
7474 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7482 /* This function currently only supports ARM and TI unwinders. */
7483 warn (_("Only TI and ARM unwinders are currently supported\n"));
7487 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7488 addr
->section
= sym
->st_shndx
;
7489 addr
->offset
= offset
;
7492 * sym_name
= sym
->st_name
;
7497 arm_sec
->next_rela
= rp
;
7502 static const char *tic6x_unwind_regnames
[16] =
7504 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7505 "A14", "A13", "A12", "A11", "A10",
7506 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7510 decode_tic6x_unwind_regmask (unsigned int mask
)
7514 for (i
= 12; mask
; mask
>>= 1, i
--)
7518 fputs (tic6x_unwind_regnames
[i
], stdout
);
7520 fputs (", ", stdout
);
7526 if (remaining == 0 && more_words) \
7529 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7530 data_offset, & word, & addr, NULL)) \
7536 #define GET_OP(OP) \
7541 (OP) = word >> 24; \
7546 printf (_("[Truncated opcode]\n")); \
7549 printf ("0x%02x ", OP)
7552 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7553 unsigned int word
, unsigned int remaining
,
7554 unsigned int more_words
,
7555 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7556 struct arm_section
*data_arm_sec
)
7558 struct absaddr addr
;
7560 /* Decode the unwinding instructions. */
7563 unsigned int op
, op2
;
7572 printf (" 0x%02x ", op
);
7574 if ((op
& 0xc0) == 0x00)
7576 int offset
= ((op
& 0x3f) << 2) + 4;
7578 printf (" vsp = vsp + %d", offset
);
7580 else if ((op
& 0xc0) == 0x40)
7582 int offset
= ((op
& 0x3f) << 2) + 4;
7584 printf (" vsp = vsp - %d", offset
);
7586 else if ((op
& 0xf0) == 0x80)
7589 if (op
== 0x80 && op2
== 0)
7590 printf (_("Refuse to unwind"));
7593 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7598 for (i
= 0; i
< 12; i
++)
7599 if (mask
& (1 << i
))
7605 printf ("r%d", 4 + i
);
7610 else if ((op
& 0xf0) == 0x90)
7612 if (op
== 0x9d || op
== 0x9f)
7613 printf (_(" [Reserved]"));
7615 printf (" vsp = r%d", op
& 0x0f);
7617 else if ((op
& 0xf0) == 0xa0)
7619 int end
= 4 + (op
& 0x07);
7624 for (i
= 4; i
<= end
; i
++)
7640 else if (op
== 0xb0)
7641 printf (_(" finish"));
7642 else if (op
== 0xb1)
7645 if (op2
== 0 || (op2
& 0xf0) != 0)
7646 printf (_("[Spare]"));
7649 unsigned int mask
= op2
& 0x0f;
7654 for (i
= 0; i
< 12; i
++)
7655 if (mask
& (1 << i
))
7666 else if (op
== 0xb2)
7668 unsigned char buf
[9];
7669 unsigned int i
, len
;
7670 unsigned long offset
;
7672 for (i
= 0; i
< sizeof (buf
); i
++)
7675 if ((buf
[i
] & 0x80) == 0)
7678 if (i
== sizeof (buf
))
7679 printf (_("corrupt change to vsp"));
7682 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7683 assert (len
== i
+ 1);
7684 offset
= offset
* 4 + 0x204;
7685 printf ("vsp = vsp + %ld", offset
);
7688 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7690 unsigned int first
, last
;
7697 printf ("pop {D%d", first
);
7699 printf ("-D%d", first
+ last
);
7702 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7704 unsigned int count
= op
& 0x07;
7708 printf ("-D%d", 8 + count
);
7711 else if (op
>= 0xc0 && op
<= 0xc5)
7713 unsigned int count
= op
& 0x07;
7715 printf (" pop {wR10");
7717 printf ("-wR%d", 10 + count
);
7720 else if (op
== 0xc6)
7722 unsigned int first
, last
;
7727 printf ("pop {wR%d", first
);
7729 printf ("-wR%d", first
+ last
);
7732 else if (op
== 0xc7)
7735 if (op2
== 0 || (op2
& 0xf0) != 0)
7736 printf (_("[Spare]"));
7739 unsigned int mask
= op2
& 0x0f;
7744 for (i
= 0; i
< 4; i
++)
7745 if (mask
& (1 << i
))
7751 printf ("wCGR%d", i
);
7757 printf (_(" [unsupported opcode]"));
7763 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7764 unsigned int word
, unsigned int remaining
,
7765 unsigned int more_words
,
7766 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7767 struct arm_section
*data_arm_sec
)
7769 struct absaddr addr
;
7771 /* Decode the unwinding instructions. */
7774 unsigned int op
, op2
;
7783 printf (" 0x%02x ", op
);
7785 if ((op
& 0xc0) == 0x00)
7787 int offset
= ((op
& 0x3f) << 3) + 8;
7788 printf (" sp = sp + %d", offset
);
7790 else if ((op
& 0xc0) == 0x80)
7793 if (op
== 0x80 && op2
== 0)
7794 printf (_("Refuse to unwind"));
7797 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7799 printf ("pop compact {");
7803 decode_tic6x_unwind_regmask (mask
);
7807 else if ((op
& 0xf0) == 0xc0)
7815 unsigned int offset
;
7819 /* Scan entire instruction first so that GET_OP output is not
7820 interleaved with disassembly. */
7822 for (i
= 0; nregs
< (op
& 0xf); i
++)
7828 regpos
[nregs
].offset
= i
* 2;
7829 regpos
[nregs
].reg
= reg
;
7836 regpos
[nregs
].offset
= i
* 2 + 1;
7837 regpos
[nregs
].reg
= reg
;
7842 printf (_("pop frame {"));
7844 for (i
= i
* 2; i
> 0; i
--)
7846 if (regpos
[reg
].offset
== i
- 1)
7848 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7855 fputs (name
, stdout
);
7862 else if (op
== 0xd0)
7863 printf (" MOV FP, SP");
7864 else if (op
== 0xd1)
7865 printf (" __c6xabi_pop_rts");
7866 else if (op
== 0xd2)
7868 unsigned char buf
[9];
7869 unsigned int i
, len
;
7870 unsigned long offset
;
7872 for (i
= 0; i
< sizeof (buf
); i
++)
7875 if ((buf
[i
] & 0x80) == 0)
7878 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7879 if (i
== sizeof (buf
))
7881 printf ("<corrupt sp adjust>\n");
7882 warn (_("Corrupt stack pointer adjustment detected\n"));
7886 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7887 assert (len
== i
+ 1);
7888 offset
= offset
* 8 + 0x408;
7889 printf (_("sp = sp + %ld"), offset
);
7891 else if ((op
& 0xf0) == 0xe0)
7893 if ((op
& 0x0f) == 7)
7896 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7900 printf (_(" [unsupported opcode]"));
7907 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7911 offset
= word
& 0x7fffffff;
7912 if (offset
& 0x40000000)
7913 offset
|= ~ (bfd_vma
) 0x7fffffff;
7915 if (elf_header
.e_machine
== EM_TI_C6000
)
7918 return offset
+ where
;
7922 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7924 unsigned int remaining
,
7925 bfd_vma data_offset
,
7926 Elf_Internal_Shdr
* data_sec
,
7927 struct arm_section
* data_arm_sec
)
7930 unsigned int more_words
= 0;
7931 struct absaddr addr
;
7932 bfd_vma sym_name
= (bfd_vma
) -1;
7936 /* Fetch the first word.
7937 Note - when decoding an object file the address extracted
7938 here will always be 0. So we also pass in the sym_name
7939 parameter so that we can find the symbol associated with
7940 the personality routine. */
7941 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7942 & word
, & addr
, & sym_name
))
7948 if ((word
& 0x80000000) == 0)
7950 /* Expand prel31 for personality routine. */
7952 const char *procname
;
7954 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7955 printf (_(" Personality routine: "));
7957 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7958 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7960 procname
= aux
->strtab
+ sym_name
;
7961 print_vma (fn
, PREFIX_HEX
);
7964 fputs (" <", stdout
);
7965 fputs (procname
, stdout
);
7966 fputc ('>', stdout
);
7970 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7971 fputc ('\n', stdout
);
7973 /* The GCC personality routines use the standard compact
7974 encoding, starting with one byte giving the number of
7976 if (procname
!= NULL
7977 && (const_strneq (procname
, "__gcc_personality_v0")
7978 || const_strneq (procname
, "__gxx_personality_v0")
7979 || const_strneq (procname
, "__gcj_personality_v0")
7980 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7987 printf (_(" [Truncated data]\n"));
7990 more_words
= word
>> 24;
8000 /* ARM EHABI Section 6.3:
8002 An exception-handling table entry for the compact model looks like:
8006 1 0 index Data for personalityRoutine[index] */
8008 if (elf_header
.e_machine
== EM_ARM
8009 && (word
& 0x70000000))
8010 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8012 per_index
= (word
>> 24) & 0x7f;
8013 printf (_(" Compact model index: %d\n"), per_index
);
8020 else if (per_index
< 3)
8022 more_words
= (word
>> 16) & 0xff;
8028 switch (elf_header
.e_machine
)
8033 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8034 data_offset
, data_sec
, data_arm_sec
);
8038 warn (_("Unknown ARM compact model index encountered\n"));
8039 printf (_(" [reserved]\n"));
8046 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8047 data_offset
, data_sec
, data_arm_sec
);
8049 else if (per_index
< 5)
8051 if (((word
>> 17) & 0x7f) == 0x7f)
8052 printf (_(" Restore stack from frame pointer\n"));
8054 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8055 printf (_(" Registers restored: "));
8057 printf (" (compact) ");
8058 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8060 printf (_(" Return register: %s\n"),
8061 tic6x_unwind_regnames
[word
& 0xf]);
8064 printf (_(" [reserved (%d)]\n"), per_index
);
8068 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8069 elf_header
.e_machine
);
8072 /* Decode the descriptors. Not implemented. */
8076 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8078 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8079 unsigned int i
, exidx_len
;
8081 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8082 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8083 exidx_len
= exidx_sec
->sh_size
/ 8;
8085 for (i
= 0; i
< exidx_len
; i
++)
8087 unsigned int exidx_fn
, exidx_entry
;
8088 struct absaddr fn_addr
, entry_addr
;
8091 fputc ('\n', stdout
);
8093 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8094 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8095 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8096 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8098 arm_free_section (& exidx_arm_sec
);
8099 arm_free_section (& extab_arm_sec
);
8103 /* ARM EHABI, Section 5:
8104 An index table entry consists of 2 words.
8105 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8106 if (exidx_fn
& 0x80000000)
8107 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8109 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8111 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8112 fputs (": ", stdout
);
8114 if (exidx_entry
== 1)
8116 print_vma (exidx_entry
, PREFIX_HEX
);
8117 fputs (" [cantunwind]\n", stdout
);
8119 else if (exidx_entry
& 0x80000000)
8121 print_vma (exidx_entry
, PREFIX_HEX
);
8122 fputc ('\n', stdout
);
8123 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8127 bfd_vma table
, table_offset
= 0;
8128 Elf_Internal_Shdr
*table_sec
;
8130 fputs ("@", stdout
);
8131 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8132 print_vma (table
, PREFIX_HEX
);
8135 /* Locate the matching .ARM.extab. */
8136 if (entry_addr
.section
!= SHN_UNDEF
8137 && entry_addr
.section
< elf_header
.e_shnum
)
8139 table_sec
= section_headers
+ entry_addr
.section
;
8140 table_offset
= entry_addr
.offset
;
8144 table_sec
= find_section_by_address (table
);
8145 if (table_sec
!= NULL
)
8146 table_offset
= table
- table_sec
->sh_addr
;
8148 if (table_sec
== NULL
)
8150 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8151 (unsigned long) table
);
8154 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8161 arm_free_section (&exidx_arm_sec
);
8162 arm_free_section (&extab_arm_sec
);
8165 /* Used for both ARM and C6X unwinding tables. */
8168 arm_process_unwind (FILE *file
)
8170 struct arm_unw_aux_info aux
;
8171 Elf_Internal_Shdr
*unwsec
= NULL
;
8172 Elf_Internal_Shdr
*strsec
;
8173 Elf_Internal_Shdr
*sec
;
8175 unsigned int sec_type
;
8177 switch (elf_header
.e_machine
)
8180 sec_type
= SHT_ARM_EXIDX
;
8184 sec_type
= SHT_C6000_UNWIND
;
8188 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8189 elf_header
.e_machine
);
8193 if (string_table
== NULL
)
8196 memset (& aux
, 0, sizeof (aux
));
8199 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8201 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8203 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8205 strsec
= section_headers
+ sec
->sh_link
;
8207 /* PR binutils/17531 file: 011-12666-0.004. */
8208 if (aux
.strtab
!= NULL
)
8210 error (_("Multiple string tables found in file.\n"));
8213 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8214 1, strsec
->sh_size
, _("string table"));
8215 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8217 else if (sec
->sh_type
== sec_type
)
8222 printf (_("\nThere are no unwind sections in this file.\n"));
8224 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8226 if (sec
->sh_type
== sec_type
)
8228 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8229 printable_section_name (sec
),
8230 (unsigned long) sec
->sh_offset
,
8231 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8233 dump_arm_unwind (&aux
, sec
);
8240 free ((char *) aux
.strtab
);
8244 process_unwind (FILE * file
)
8246 struct unwind_handler
8249 void (* handler
)(FILE *);
8252 { EM_ARM
, arm_process_unwind
},
8253 { EM_IA_64
, ia64_process_unwind
},
8254 { EM_PARISC
, hppa_process_unwind
},
8255 { EM_TI_C6000
, arm_process_unwind
},
8263 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8264 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8266 handlers
[i
].handler (file
);
8270 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8271 get_machine_name (elf_header
.e_machine
));
8275 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8277 switch (entry
->d_tag
)
8280 if (entry
->d_un
.d_val
== 0)
8284 static const char * opts
[] =
8286 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8287 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8288 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8289 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8295 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8296 if (entry
->d_un
.d_val
& (1 << cnt
))
8298 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8304 case DT_MIPS_IVERSION
:
8305 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8306 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8310 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8311 /* Note: coded this way so that there is a single string for translation. */
8312 printf (_("<corrupt: %s>"), buf
);
8316 case DT_MIPS_TIME_STAMP
:
8320 time_t atime
= entry
->d_un
.d_val
;
8322 tmp
= gmtime (&atime
);
8323 /* PR 17531: file: 6accc532. */
8325 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8327 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8328 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8329 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8330 printf (_("Time Stamp: %s"), timebuf
);
8334 case DT_MIPS_RLD_VERSION
:
8335 case DT_MIPS_LOCAL_GOTNO
:
8336 case DT_MIPS_CONFLICTNO
:
8337 case DT_MIPS_LIBLISTNO
:
8338 case DT_MIPS_SYMTABNO
:
8339 case DT_MIPS_UNREFEXTNO
:
8340 case DT_MIPS_HIPAGENO
:
8341 case DT_MIPS_DELTA_CLASS_NO
:
8342 case DT_MIPS_DELTA_INSTANCE_NO
:
8343 case DT_MIPS_DELTA_RELOC_NO
:
8344 case DT_MIPS_DELTA_SYM_NO
:
8345 case DT_MIPS_DELTA_CLASSSYM_NO
:
8346 case DT_MIPS_COMPACT_SIZE
:
8347 print_vma (entry
->d_un
.d_ptr
, DEC
);
8351 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8357 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8359 switch (entry
->d_tag
)
8361 case DT_HP_DLD_FLAGS
:
8370 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8371 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8372 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8373 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8374 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8375 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8376 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8377 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8378 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8379 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8380 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8381 { DT_HP_GST
, "HP_GST" },
8382 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8383 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8384 { DT_HP_NODELETE
, "HP_NODELETE" },
8385 { DT_HP_GROUP
, "HP_GROUP" },
8386 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8390 bfd_vma val
= entry
->d_un
.d_val
;
8392 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8393 if (val
& flags
[cnt
].bit
)
8397 fputs (flags
[cnt
].str
, stdout
);
8399 val
^= flags
[cnt
].bit
;
8402 if (val
!= 0 || first
)
8406 print_vma (val
, HEX
);
8412 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8420 /* VMS vs Unix time offset and factor. */
8422 #define VMS_EPOCH_OFFSET 35067168000000000LL
8423 #define VMS_GRANULARITY_FACTOR 10000000
8425 /* Display a VMS time in a human readable format. */
8428 print_vms_time (bfd_int64_t vmstime
)
8433 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8434 tm
= gmtime (&unxtime
);
8435 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8436 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8437 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8442 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8444 switch (entry
->d_tag
)
8446 case DT_IA_64_PLT_RESERVE
:
8447 /* First 3 slots reserved. */
8448 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8450 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8453 case DT_IA_64_VMS_LINKTIME
:
8455 print_vms_time (entry
->d_un
.d_val
);
8459 case DT_IA_64_VMS_LNKFLAGS
:
8460 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8461 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8462 printf (" CALL_DEBUG");
8463 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8464 printf (" NOP0BUFS");
8465 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8466 printf (" P0IMAGE");
8467 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8468 printf (" MKTHREADS");
8469 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8470 printf (" UPCALLS");
8471 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8473 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8474 printf (" INITIALIZE");
8475 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8477 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8478 printf (" EXE_INIT");
8479 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8480 printf (" TBK_IN_IMG");
8481 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8482 printf (" DBG_IN_IMG");
8483 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8484 printf (" TBK_IN_DSF");
8485 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8486 printf (" DBG_IN_DSF");
8487 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8488 printf (" SIGNATURES");
8489 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8490 printf (" REL_SEG_OFF");
8494 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8501 get_32bit_dynamic_section (FILE * file
)
8503 Elf32_External_Dyn
* edyn
;
8504 Elf32_External_Dyn
* ext
;
8505 Elf_Internal_Dyn
* entry
;
8507 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8508 dynamic_size
, _("dynamic section"));
8512 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8513 might not have the luxury of section headers. Look for the DT_NULL
8514 terminator to determine the number of entries. */
8515 for (ext
= edyn
, dynamic_nent
= 0;
8516 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8520 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8524 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8526 if (dynamic_section
== NULL
)
8528 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8529 (unsigned long) dynamic_nent
);
8534 for (ext
= edyn
, entry
= dynamic_section
;
8535 entry
< dynamic_section
+ dynamic_nent
;
8538 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8539 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8548 get_64bit_dynamic_section (FILE * file
)
8550 Elf64_External_Dyn
* edyn
;
8551 Elf64_External_Dyn
* ext
;
8552 Elf_Internal_Dyn
* entry
;
8554 /* Read in the data. */
8555 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8556 dynamic_size
, _("dynamic section"));
8560 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8561 might not have the luxury of section headers. Look for the DT_NULL
8562 terminator to determine the number of entries. */
8563 for (ext
= edyn
, dynamic_nent
= 0;
8564 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8565 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8569 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8573 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8575 if (dynamic_section
== NULL
)
8577 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8578 (unsigned long) dynamic_nent
);
8583 /* Convert from external to internal formats. */
8584 for (ext
= edyn
, entry
= dynamic_section
;
8585 entry
< dynamic_section
+ dynamic_nent
;
8588 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8589 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8598 print_dynamic_flags (bfd_vma flags
)
8606 flag
= flags
& - flags
;
8616 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8617 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8618 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8619 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8620 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8621 default: fputs (_("unknown"), stdout
); break;
8627 /* Parse and display the contents of the dynamic section. */
8630 process_dynamic_section (FILE * file
)
8632 Elf_Internal_Dyn
* entry
;
8634 if (dynamic_size
== 0)
8637 printf (_("\nThere is no dynamic section in this file.\n"));
8644 if (! get_32bit_dynamic_section (file
))
8647 else if (! get_64bit_dynamic_section (file
))
8650 /* Find the appropriate symbol table. */
8651 if (dynamic_symbols
== NULL
)
8653 for (entry
= dynamic_section
;
8654 entry
< dynamic_section
+ dynamic_nent
;
8657 Elf_Internal_Shdr section
;
8659 if (entry
->d_tag
!= DT_SYMTAB
)
8662 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8664 /* Since we do not know how big the symbol table is,
8665 we default to reading in the entire file (!) and
8666 processing that. This is overkill, I know, but it
8668 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8670 if (archive_file_offset
!= 0)
8671 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8674 if (fseek (file
, 0, SEEK_END
))
8675 error (_("Unable to seek to end of file!\n"));
8677 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8681 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8683 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8684 section
.sh_name
= string_table_length
;
8686 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8687 if (num_dynamic_syms
< 1)
8689 error (_("Unable to determine the number of symbols to load\n"));
8695 /* Similarly find a string table. */
8696 if (dynamic_strings
== NULL
)
8698 for (entry
= dynamic_section
;
8699 entry
< dynamic_section
+ dynamic_nent
;
8702 unsigned long offset
;
8705 if (entry
->d_tag
!= DT_STRTAB
)
8708 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8710 /* Since we do not know how big the string table is,
8711 we default to reading in the entire file (!) and
8712 processing that. This is overkill, I know, but it
8715 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8717 if (archive_file_offset
!= 0)
8718 str_tab_len
= archive_file_size
- offset
;
8721 if (fseek (file
, 0, SEEK_END
))
8722 error (_("Unable to seek to end of file\n"));
8723 str_tab_len
= ftell (file
) - offset
;
8726 if (str_tab_len
< 1)
8729 (_("Unable to determine the length of the dynamic string table\n"));
8733 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8735 _("dynamic string table"));
8736 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8741 /* And find the syminfo section if available. */
8742 if (dynamic_syminfo
== NULL
)
8744 unsigned long syminsz
= 0;
8746 for (entry
= dynamic_section
;
8747 entry
< dynamic_section
+ dynamic_nent
;
8750 if (entry
->d_tag
== DT_SYMINENT
)
8752 /* Note: these braces are necessary to avoid a syntax
8753 error from the SunOS4 C compiler. */
8754 /* PR binutils/17531: A corrupt file can trigger this test.
8755 So do not use an assert, instead generate an error message. */
8756 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8757 error (_("Bad value (%d) for SYMINENT entry\n"),
8758 (int) entry
->d_un
.d_val
);
8760 else if (entry
->d_tag
== DT_SYMINSZ
)
8761 syminsz
= entry
->d_un
.d_val
;
8762 else if (entry
->d_tag
== DT_SYMINFO
)
8763 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8767 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8769 Elf_External_Syminfo
* extsyminfo
;
8770 Elf_External_Syminfo
* extsym
;
8771 Elf_Internal_Syminfo
* syminfo
;
8773 /* There is a syminfo section. Read the data. */
8774 extsyminfo
= (Elf_External_Syminfo
*)
8775 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8776 _("symbol information"));
8780 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8781 if (dynamic_syminfo
== NULL
)
8783 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8784 (unsigned long) syminsz
);
8788 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8789 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8790 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8791 ++syminfo
, ++extsym
)
8793 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8794 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8801 if (do_dynamic
&& dynamic_addr
)
8802 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8803 dynamic_addr
, (unsigned long) dynamic_nent
);
8805 printf (_(" Tag Type Name/Value\n"));
8807 for (entry
= dynamic_section
;
8808 entry
< dynamic_section
+ dynamic_nent
;
8816 print_vma (entry
->d_tag
, FULL_HEX
);
8817 dtype
= get_dynamic_type (entry
->d_tag
);
8818 printf (" (%s)%*s", dtype
,
8819 ((is_32bit_elf
? 27 : 19)
8820 - (int) strlen (dtype
)),
8824 switch (entry
->d_tag
)
8828 print_dynamic_flags (entry
->d_un
.d_val
);
8838 switch (entry
->d_tag
)
8841 printf (_("Auxiliary library"));
8845 printf (_("Filter library"));
8849 printf (_("Configuration file"));
8853 printf (_("Dependency audit library"));
8857 printf (_("Audit library"));
8861 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8862 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8866 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8875 printf (_("Flags:"));
8877 if (entry
->d_un
.d_val
== 0)
8878 printf (_(" None\n"));
8881 unsigned long int val
= entry
->d_un
.d_val
;
8883 if (val
& DTF_1_PARINIT
)
8885 printf (" PARINIT");
8886 val
^= DTF_1_PARINIT
;
8888 if (val
& DTF_1_CONFEXP
)
8890 printf (" CONFEXP");
8891 val
^= DTF_1_CONFEXP
;
8894 printf (" %lx", val
);
8903 printf (_("Flags:"));
8905 if (entry
->d_un
.d_val
== 0)
8906 printf (_(" None\n"));
8909 unsigned long int val
= entry
->d_un
.d_val
;
8911 if (val
& DF_P1_LAZYLOAD
)
8913 printf (" LAZYLOAD");
8914 val
^= DF_P1_LAZYLOAD
;
8916 if (val
& DF_P1_GROUPPERM
)
8918 printf (" GROUPPERM");
8919 val
^= DF_P1_GROUPPERM
;
8922 printf (" %lx", val
);
8931 printf (_("Flags:"));
8932 if (entry
->d_un
.d_val
== 0)
8933 printf (_(" None\n"));
8936 unsigned long int val
= entry
->d_un
.d_val
;
8943 if (val
& DF_1_GLOBAL
)
8948 if (val
& DF_1_GROUP
)
8953 if (val
& DF_1_NODELETE
)
8955 printf (" NODELETE");
8956 val
^= DF_1_NODELETE
;
8958 if (val
& DF_1_LOADFLTR
)
8960 printf (" LOADFLTR");
8961 val
^= DF_1_LOADFLTR
;
8963 if (val
& DF_1_INITFIRST
)
8965 printf (" INITFIRST");
8966 val
^= DF_1_INITFIRST
;
8968 if (val
& DF_1_NOOPEN
)
8973 if (val
& DF_1_ORIGIN
)
8978 if (val
& DF_1_DIRECT
)
8983 if (val
& DF_1_TRANS
)
8988 if (val
& DF_1_INTERPOSE
)
8990 printf (" INTERPOSE");
8991 val
^= DF_1_INTERPOSE
;
8993 if (val
& DF_1_NODEFLIB
)
8995 printf (" NODEFLIB");
8996 val
^= DF_1_NODEFLIB
;
8998 if (val
& DF_1_NODUMP
)
9003 if (val
& DF_1_CONFALT
)
9005 printf (" CONFALT");
9006 val
^= DF_1_CONFALT
;
9008 if (val
& DF_1_ENDFILTEE
)
9010 printf (" ENDFILTEE");
9011 val
^= DF_1_ENDFILTEE
;
9013 if (val
& DF_1_DISPRELDNE
)
9015 printf (" DISPRELDNE");
9016 val
^= DF_1_DISPRELDNE
;
9018 if (val
& DF_1_DISPRELPND
)
9020 printf (" DISPRELPND");
9021 val
^= DF_1_DISPRELPND
;
9023 if (val
& DF_1_NODIRECT
)
9025 printf (" NODIRECT");
9026 val
^= DF_1_NODIRECT
;
9028 if (val
& DF_1_IGNMULDEF
)
9030 printf (" IGNMULDEF");
9031 val
^= DF_1_IGNMULDEF
;
9033 if (val
& DF_1_NOKSYMS
)
9035 printf (" NOKSYMS");
9036 val
^= DF_1_NOKSYMS
;
9038 if (val
& DF_1_NOHDR
)
9043 if (val
& DF_1_EDITED
)
9048 if (val
& DF_1_NORELOC
)
9050 printf (" NORELOC");
9051 val
^= DF_1_NORELOC
;
9053 if (val
& DF_1_SYMINTPOSE
)
9055 printf (" SYMINTPOSE");
9056 val
^= DF_1_SYMINTPOSE
;
9058 if (val
& DF_1_GLOBAUDIT
)
9060 printf (" GLOBAUDIT");
9061 val
^= DF_1_GLOBAUDIT
;
9063 if (val
& DF_1_SINGLETON
)
9065 printf (" SINGLETON");
9066 val
^= DF_1_SINGLETON
;
9069 printf (" %lx", val
);
9076 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9078 puts (get_dynamic_type (entry
->d_un
.d_val
));
9098 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9104 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9105 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9111 switch (entry
->d_tag
)
9114 printf (_("Shared library: [%s]"), name
);
9116 if (streq (name
, program_interpreter
))
9117 printf (_(" program interpreter"));
9121 printf (_("Library soname: [%s]"), name
);
9125 printf (_("Library rpath: [%s]"), name
);
9129 printf (_("Library runpath: [%s]"), name
);
9133 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9138 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9151 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9155 case DT_INIT_ARRAYSZ
:
9156 case DT_FINI_ARRAYSZ
:
9157 case DT_GNU_CONFLICTSZ
:
9158 case DT_GNU_LIBLISTSZ
:
9161 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9162 printf (_(" (bytes)\n"));
9172 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9185 if (entry
->d_tag
== DT_USED
9186 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9188 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9192 printf (_("Not needed object: [%s]\n"), name
);
9197 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9203 /* The value of this entry is ignored. */
9208 case DT_GNU_PRELINKED
:
9212 time_t atime
= entry
->d_un
.d_val
;
9214 tmp
= gmtime (&atime
);
9215 /* PR 17533 file: 041-1244816-0.004. */
9217 printf (_("<corrupt time val: %lx"),
9218 (unsigned long) atime
);
9220 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9221 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9222 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9228 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9231 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9237 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9238 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9243 switch (elf_header
.e_machine
)
9246 case EM_MIPS_RS3_LE
:
9247 dynamic_section_mips_val (entry
);
9250 dynamic_section_parisc_val (entry
);
9253 dynamic_section_ia64_val (entry
);
9256 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9268 get_ver_flags (unsigned int flags
)
9270 static char buff
[32];
9277 if (flags
& VER_FLG_BASE
)
9278 strcat (buff
, "BASE ");
9280 if (flags
& VER_FLG_WEAK
)
9282 if (flags
& VER_FLG_BASE
)
9283 strcat (buff
, "| ");
9285 strcat (buff
, "WEAK ");
9288 if (flags
& VER_FLG_INFO
)
9290 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9291 strcat (buff
, "| ");
9293 strcat (buff
, "INFO ");
9296 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9297 strcat (buff
, _("| <unknown>"));
9302 /* Display the contents of the version sections. */
9305 process_version_sections (FILE * file
)
9307 Elf_Internal_Shdr
* section
;
9314 for (i
= 0, section
= section_headers
;
9315 i
< elf_header
.e_shnum
;
9318 switch (section
->sh_type
)
9320 case SHT_GNU_verdef
:
9322 Elf_External_Verdef
* edefs
;
9329 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9330 printable_section_name (section
),
9333 printf (_(" Addr: 0x"));
9334 printf_vma (section
->sh_addr
);
9335 printf (_(" Offset: %#08lx Link: %u (%s)"),
9336 (unsigned long) section
->sh_offset
, section
->sh_link
,
9337 printable_section_name_from_index (section
->sh_link
));
9339 edefs
= (Elf_External_Verdef
*)
9340 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9341 _("version definition section"));
9344 endbuf
= (char *) edefs
+ section
->sh_size
;
9346 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9349 Elf_External_Verdef
* edef
;
9350 Elf_Internal_Verdef ent
;
9351 Elf_External_Verdaux
* eaux
;
9352 Elf_Internal_Verdaux aux
;
9356 /* Check for very large indicies. */
9357 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9360 vstart
= ((char *) edefs
) + idx
;
9361 if (vstart
+ sizeof (*edef
) > endbuf
)
9364 edef
= (Elf_External_Verdef
*) vstart
;
9366 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9367 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9368 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9369 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9370 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9371 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9372 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9374 printf (_(" %#06x: Rev: %d Flags: %s"),
9375 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9377 printf (_(" Index: %d Cnt: %d "),
9378 ent
.vd_ndx
, ent
.vd_cnt
);
9380 /* Check for overflow. */
9381 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9384 vstart
+= ent
.vd_aux
;
9386 eaux
= (Elf_External_Verdaux
*) vstart
;
9388 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9389 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9391 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9392 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9394 printf (_("Name index: %ld\n"), aux
.vda_name
);
9396 isum
= idx
+ ent
.vd_aux
;
9398 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9400 /* Check for overflow. */
9401 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9404 isum
+= aux
.vda_next
;
9405 vstart
+= aux
.vda_next
;
9407 eaux
= (Elf_External_Verdaux
*) vstart
;
9408 if (vstart
+ sizeof (*eaux
) > endbuf
)
9411 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9412 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9414 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9415 printf (_(" %#06x: Parent %d: %s\n"),
9416 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9418 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9419 isum
, j
, aux
.vda_name
);
9423 printf (_(" Version def aux past end of section\n"));
9425 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9426 if (idx
+ ent
.vd_next
<= idx
)
9432 if (cnt
< section
->sh_info
)
9433 printf (_(" Version definition past end of section\n"));
9439 case SHT_GNU_verneed
:
9441 Elf_External_Verneed
* eneed
;
9448 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9449 printable_section_name (section
), section
->sh_info
);
9451 printf (_(" Addr: 0x"));
9452 printf_vma (section
->sh_addr
);
9453 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9454 (unsigned long) section
->sh_offset
, section
->sh_link
,
9455 printable_section_name_from_index (section
->sh_link
));
9457 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9458 section
->sh_offset
, 1,
9460 _("Version Needs section"));
9463 endbuf
= (char *) eneed
+ section
->sh_size
;
9465 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9467 Elf_External_Verneed
* entry
;
9468 Elf_Internal_Verneed ent
;
9473 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9476 vstart
= ((char *) eneed
) + idx
;
9477 if (vstart
+ sizeof (*entry
) > endbuf
)
9480 entry
= (Elf_External_Verneed
*) vstart
;
9482 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9483 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9484 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9485 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9486 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9488 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9490 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9491 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9493 printf (_(" File: %lx"), ent
.vn_file
);
9495 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9497 /* Check for overflow. */
9498 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9500 vstart
+= ent
.vn_aux
;
9502 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9504 Elf_External_Vernaux
* eaux
;
9505 Elf_Internal_Vernaux aux
;
9507 if (vstart
+ sizeof (*eaux
) > endbuf
)
9509 eaux
= (Elf_External_Vernaux
*) vstart
;
9511 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9512 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9513 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9514 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9515 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9517 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9518 printf (_(" %#06x: Name: %s"),
9519 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9521 printf (_(" %#06x: Name index: %lx"),
9522 isum
, aux
.vna_name
);
9524 printf (_(" Flags: %s Version: %d\n"),
9525 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9527 /* Check for overflow. */
9528 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9529 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9531 warn (_("Invalid vna_next field of %lx\n"),
9536 isum
+= aux
.vna_next
;
9537 vstart
+= aux
.vna_next
;
9541 warn (_("Missing Version Needs auxillary information\n"));
9543 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9545 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9546 cnt
= section
->sh_info
;
9552 if (cnt
< section
->sh_info
)
9553 warn (_("Missing Version Needs information\n"));
9559 case SHT_GNU_versym
:
9561 Elf_Internal_Shdr
* link_section
;
9564 unsigned char * edata
;
9565 unsigned short * data
;
9567 Elf_Internal_Sym
* symbols
;
9568 Elf_Internal_Shdr
* string_sec
;
9569 unsigned long num_syms
;
9572 if (section
->sh_link
>= elf_header
.e_shnum
)
9575 link_section
= section_headers
+ section
->sh_link
;
9576 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9578 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9583 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9584 if (symbols
== NULL
)
9587 string_sec
= section_headers
+ link_section
->sh_link
;
9589 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9590 string_sec
->sh_size
,
9591 _("version string table"));
9598 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9599 printable_section_name (section
), (unsigned long) total
);
9601 printf (_(" Addr: "));
9602 printf_vma (section
->sh_addr
);
9603 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9604 (unsigned long) section
->sh_offset
, section
->sh_link
,
9605 printable_section_name (link_section
));
9607 off
= offset_from_vma (file
,
9608 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9609 total
* sizeof (short));
9610 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9612 _("version symbol data"));
9620 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9622 for (cnt
= total
; cnt
--;)
9623 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9628 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9631 int check_def
, check_need
;
9634 printf (" %03x:", cnt
);
9636 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9637 switch (data
[cnt
+ j
])
9640 fputs (_(" 0 (*local*) "), stdout
);
9644 fputs (_(" 1 (*global*) "), stdout
);
9648 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9649 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9651 /* If this index value is greater than the size of the symbols
9652 array, break to avoid an out-of-bounds read. */
9653 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9655 warn (_("invalid index into symbol array\n"));
9661 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9662 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9665 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9672 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9674 Elf_Internal_Verneed ivn
;
9675 unsigned long offset
;
9677 offset
= offset_from_vma
9678 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9679 sizeof (Elf_External_Verneed
));
9683 Elf_Internal_Vernaux ivna
;
9684 Elf_External_Verneed evn
;
9685 Elf_External_Vernaux evna
;
9686 unsigned long a_off
;
9688 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9689 _("version need")) == NULL
)
9692 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9693 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9695 a_off
= offset
+ ivn
.vn_aux
;
9699 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9700 1, _("version need aux (2)")) == NULL
)
9707 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9708 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9711 a_off
+= ivna
.vna_next
;
9713 while (ivna
.vna_other
!= data
[cnt
+ j
]
9714 && ivna
.vna_next
!= 0);
9716 if (ivna
.vna_other
== data
[cnt
+ j
])
9718 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9720 if (ivna
.vna_name
>= string_sec
->sh_size
)
9721 name
= _("*invalid*");
9723 name
= strtab
+ ivna
.vna_name
;
9724 nn
+= printf ("(%s%-*s",
9726 12 - (int) strlen (name
),
9732 offset
+= ivn
.vn_next
;
9734 while (ivn
.vn_next
);
9737 if (check_def
&& data
[cnt
+ j
] != 0x8001
9738 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9740 Elf_Internal_Verdef ivd
;
9741 Elf_External_Verdef evd
;
9742 unsigned long offset
;
9744 offset
= offset_from_vma
9745 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9750 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9751 _("version def")) == NULL
)
9754 /* PR 17531: file: 046-1082287-0.004. */
9755 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9760 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9761 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9764 offset
+= ivd
.vd_next
;
9766 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9767 && ivd
.vd_next
!= 0);
9769 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9771 Elf_External_Verdaux evda
;
9772 Elf_Internal_Verdaux ivda
;
9774 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9776 if (get_data (&evda
, file
,
9777 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9779 _("version def aux")) == NULL
)
9782 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9784 if (ivda
.vda_name
>= string_sec
->sh_size
)
9785 name
= _("*invalid*");
9787 name
= strtab
+ ivda
.vda_name
;
9788 nn
+= printf ("(%s%-*s",
9790 12 - (int) strlen (name
),
9796 printf ("%*c", 18 - nn
, ' ');
9814 printf (_("\nNo version information found in this file.\n"));
9820 get_symbol_binding (unsigned int binding
)
9822 static char buff
[32];
9826 case STB_LOCAL
: return "LOCAL";
9827 case STB_GLOBAL
: return "GLOBAL";
9828 case STB_WEAK
: return "WEAK";
9830 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9831 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9833 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9835 if (binding
== STB_GNU_UNIQUE
9836 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9837 /* GNU is still using the default value 0. */
9838 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9840 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9843 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9849 get_symbol_type (unsigned int type
)
9851 static char buff
[32];
9855 case STT_NOTYPE
: return "NOTYPE";
9856 case STT_OBJECT
: return "OBJECT";
9857 case STT_FUNC
: return "FUNC";
9858 case STT_SECTION
: return "SECTION";
9859 case STT_FILE
: return "FILE";
9860 case STT_COMMON
: return "COMMON";
9861 case STT_TLS
: return "TLS";
9862 case STT_RELC
: return "RELC";
9863 case STT_SRELC
: return "SRELC";
9865 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9867 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9868 return "THUMB_FUNC";
9870 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9873 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9874 return "PARISC_MILLI";
9876 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9878 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9880 if (elf_header
.e_machine
== EM_PARISC
)
9882 if (type
== STT_HP_OPAQUE
)
9884 if (type
== STT_HP_STUB
)
9888 if (type
== STT_GNU_IFUNC
9889 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9890 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9891 /* GNU is still using the default value 0. */
9892 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9895 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9898 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9904 get_symbol_visibility (unsigned int visibility
)
9908 case STV_DEFAULT
: return "DEFAULT";
9909 case STV_INTERNAL
: return "INTERNAL";
9910 case STV_HIDDEN
: return "HIDDEN";
9911 case STV_PROTECTED
: return "PROTECTED";
9913 error (_("Unrecognized visibility value: %u"), visibility
);
9914 return _("<unknown>");
9919 get_mips_symbol_other (unsigned int other
)
9931 case STO_MICROMIPS
| STO_MIPS_PIC
:
9932 return "MICROMIPS, MIPS PIC";
9941 get_ia64_symbol_other (unsigned int other
)
9945 static char res
[32];
9949 /* Function types is for images and .STB files only. */
9950 switch (elf_header
.e_type
)
9954 switch (VMS_ST_FUNC_TYPE (other
))
9956 case VMS_SFT_CODE_ADDR
:
9957 strcat (res
, " CA");
9959 case VMS_SFT_SYMV_IDX
:
9960 strcat (res
, " VEC");
9963 strcat (res
, " FD");
9965 case VMS_SFT_RESERVE
:
9966 strcat (res
, " RSV");
9969 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9970 VMS_ST_FUNC_TYPE (other
));
9971 strcat (res
, " <unknown>");
9978 switch (VMS_ST_LINKAGE (other
))
9980 case VMS_STL_IGNORE
:
9981 strcat (res
, " IGN");
9983 case VMS_STL_RESERVE
:
9984 strcat (res
, " RSV");
9987 strcat (res
, " STD");
9990 strcat (res
, " LNK");
9993 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9994 VMS_ST_LINKAGE (other
));
9995 strcat (res
, " <unknown>");
10007 static const char *
10008 get_ppc64_symbol_other (unsigned int other
)
10010 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10012 static char buf
[32];
10013 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10014 PPC64_LOCAL_ENTRY_OFFSET (other
));
10020 static const char *
10021 get_symbol_other (unsigned int other
)
10023 const char * result
= NULL
;
10024 static char buff
[32];
10029 switch (elf_header
.e_machine
)
10032 result
= get_mips_symbol_other (other
);
10035 result
= get_ia64_symbol_other (other
);
10038 result
= get_ppc64_symbol_other (other
);
10047 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10051 static const char *
10052 get_symbol_index_type (unsigned int type
)
10054 static char buff
[32];
10058 case SHN_UNDEF
: return "UND";
10059 case SHN_ABS
: return "ABS";
10060 case SHN_COMMON
: return "COM";
10062 if (type
== SHN_IA_64_ANSI_COMMON
10063 && elf_header
.e_machine
== EM_IA_64
10064 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10066 else if ((elf_header
.e_machine
== EM_X86_64
10067 || elf_header
.e_machine
== EM_L1OM
10068 || elf_header
.e_machine
== EM_K1OM
)
10069 && type
== SHN_X86_64_LCOMMON
)
10070 return "LARGE_COM";
10071 else if ((type
== SHN_MIPS_SCOMMON
10072 && elf_header
.e_machine
== EM_MIPS
)
10073 || (type
== SHN_TIC6X_SCOMMON
10074 && elf_header
.e_machine
== EM_TI_C6000
))
10076 else if (type
== SHN_MIPS_SUNDEFINED
10077 && elf_header
.e_machine
== EM_MIPS
)
10079 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10080 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10081 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10082 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10083 else if (type
>= SHN_LORESERVE
)
10084 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10085 else if (type
>= elf_header
.e_shnum
)
10086 sprintf (buff
, _("bad section index[%3d]"), type
);
10088 sprintf (buff
, "%3d", type
);
10096 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10098 unsigned char * e_data
;
10101 /* If the size_t type is smaller than the bfd_size_type, eg because
10102 you are building a 32-bit tool on a 64-bit host, then make sure
10103 that when (number) is cast to (size_t) no information is lost. */
10104 if (sizeof (size_t) < sizeof (bfd_size_type
)
10105 && (bfd_size_type
) ((size_t) number
) != number
)
10107 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10108 (unsigned long long) number
, ent_size
);
10112 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10113 attempting to allocate memory when the read is bound to fail. */
10114 if (ent_size
* number
> current_file_size
)
10116 error (_("Invalid number of dynamic entries: %llu\n"),
10117 (unsigned long long) number
);
10121 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10122 if (e_data
== NULL
)
10124 error (_("Out of memory reading %llu dynamic entries\n"),
10125 (unsigned long long) number
);
10129 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10131 error (_("Unable to read in %llu bytes of dynamic data\n"),
10132 (unsigned long long) (number
* ent_size
));
10137 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10138 if (i_data
== NULL
)
10140 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10141 (unsigned long long) number
);
10147 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10155 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10157 Elf_Internal_Sym
* psym
;
10160 n
= print_vma (si
, DEC_5
);
10162 fputs (&" "[n
], stdout
);
10163 printf (" %3lu: ", hn
);
10165 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10167 printf (_("<No info available for dynamic symbol number %lu>\n"),
10168 (unsigned long) si
);
10172 psym
= dynamic_symbols
+ si
;
10173 print_vma (psym
->st_value
, LONG_HEX
);
10175 print_vma (psym
->st_size
, DEC_5
);
10177 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10178 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10179 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10180 /* Check to see if any other bits in the st_other field are set.
10181 Note - displaying this information disrupts the layout of the
10182 table being generated, but for the moment this case is very
10184 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10185 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10186 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10187 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10188 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10190 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10194 static const char *
10195 get_symbol_version_string (FILE *file
, int is_dynsym
,
10196 const char *strtab
,
10197 unsigned long int strtab_size
,
10198 unsigned int si
, Elf_Internal_Sym
*psym
,
10199 enum versioned_symbol_info
*sym_info
,
10200 unsigned short *vna_other
)
10202 const char *version_string
= NULL
;
10205 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10207 unsigned char data
[2];
10208 unsigned short vers_data
;
10209 unsigned long offset
;
10213 offset
= offset_from_vma
10214 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10215 sizeof data
+ si
* sizeof (vers_data
));
10217 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10218 sizeof (data
), 1, _("version data")) == NULL
)
10221 vers_data
= byte_get (data
, 2);
10223 is_nobits
= (section_headers
!= NULL
10224 && psym
->st_shndx
< elf_header
.e_shnum
10225 && section_headers
[psym
->st_shndx
].sh_type
10228 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10230 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10232 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10233 && (is_nobits
|| ! check_def
))
10235 Elf_External_Verneed evn
;
10236 Elf_Internal_Verneed ivn
;
10237 Elf_Internal_Vernaux ivna
;
10239 /* We must test both. */
10240 offset
= offset_from_vma
10241 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10246 unsigned long vna_off
;
10248 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10249 _("version need")) == NULL
)
10252 ivna
.vna_other
= 0;
10257 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10258 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10260 vna_off
= offset
+ ivn
.vn_aux
;
10264 Elf_External_Vernaux evna
;
10266 if (get_data (&evna
, file
, vna_off
,
10268 _("version need aux (3)")) == NULL
)
10271 ivna
.vna_other
= 0;
10276 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10277 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10278 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10281 vna_off
+= ivna
.vna_next
;
10283 while (ivna
.vna_other
!= vers_data
10284 && ivna
.vna_next
!= 0);
10286 if (ivna
.vna_other
== vers_data
)
10289 offset
+= ivn
.vn_next
;
10291 while (ivn
.vn_next
!= 0);
10293 if (ivna
.vna_other
== vers_data
)
10295 *sym_info
= symbol_undefined
;
10296 *vna_other
= ivna
.vna_other
;
10297 version_string
= (ivna
.vna_name
< strtab_size
10298 ? strtab
+ ivna
.vna_name
10302 else if (! is_nobits
)
10303 error (_("bad dynamic symbol\n"));
10310 if (vers_data
!= 0x8001
10311 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10313 Elf_Internal_Verdef ivd
;
10314 Elf_Internal_Verdaux ivda
;
10315 Elf_External_Verdaux evda
;
10318 off
= offset_from_vma
10320 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10321 sizeof (Elf_External_Verdef
));
10325 Elf_External_Verdef evd
;
10327 if (get_data (&evd
, file
, off
, sizeof (evd
),
10328 1, _("version def")) == NULL
)
10336 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10337 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10338 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10341 off
+= ivd
.vd_next
;
10343 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10344 && ivd
.vd_next
!= 0);
10346 off
-= ivd
.vd_next
;
10349 if (get_data (&evda
, file
, off
, sizeof (evda
),
10350 1, _("version def aux")) == NULL
)
10351 return version_string
;
10353 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10355 if (psym
->st_name
!= ivda
.vda_name
)
10357 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10358 ? symbol_hidden
: symbol_public
);
10359 version_string
= (ivda
.vda_name
< strtab_size
10360 ? strtab
+ ivda
.vda_name
10367 return version_string
;
10370 /* Dump the symbol table. */
10372 process_symbol_table (FILE * file
)
10374 Elf_Internal_Shdr
* section
;
10375 bfd_size_type nbuckets
= 0;
10376 bfd_size_type nchains
= 0;
10377 bfd_vma
* buckets
= NULL
;
10378 bfd_vma
* chains
= NULL
;
10379 bfd_vma ngnubuckets
= 0;
10380 bfd_vma
* gnubuckets
= NULL
;
10381 bfd_vma
* gnuchains
= NULL
;
10382 bfd_vma gnusymidx
= 0;
10383 bfd_size_type ngnuchains
= 0;
10385 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10388 if (dynamic_info
[DT_HASH
]
10390 || (do_using_dynamic
10392 && dynamic_strings
!= NULL
)))
10394 unsigned char nb
[8];
10395 unsigned char nc
[8];
10396 unsigned int hash_ent_size
= 4;
10398 if ((elf_header
.e_machine
== EM_ALPHA
10399 || elf_header
.e_machine
== EM_S390
10400 || elf_header
.e_machine
== EM_S390_OLD
)
10401 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10405 (archive_file_offset
10406 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10407 sizeof nb
+ sizeof nc
)),
10410 error (_("Unable to seek to start of dynamic information\n"));
10414 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10416 error (_("Failed to read in number of buckets\n"));
10420 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10422 error (_("Failed to read in number of chains\n"));
10426 nbuckets
= byte_get (nb
, hash_ent_size
);
10427 nchains
= byte_get (nc
, hash_ent_size
);
10429 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10430 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10433 if (buckets
== NULL
|| chains
== NULL
)
10435 if (do_using_dynamic
)
10446 if (dynamic_info_DT_GNU_HASH
10448 || (do_using_dynamic
10450 && dynamic_strings
!= NULL
)))
10452 unsigned char nb
[16];
10453 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10454 bfd_vma buckets_vma
;
10457 (archive_file_offset
10458 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10462 error (_("Unable to seek to start of dynamic information\n"));
10466 if (fread (nb
, 16, 1, file
) != 1)
10468 error (_("Failed to read in number of buckets\n"));
10472 ngnubuckets
= byte_get (nb
, 4);
10473 gnusymidx
= byte_get (nb
+ 4, 4);
10474 bitmaskwords
= byte_get (nb
+ 8, 4);
10475 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10477 buckets_vma
+= bitmaskwords
* 4;
10479 buckets_vma
+= bitmaskwords
* 8;
10482 (archive_file_offset
10483 + offset_from_vma (file
, buckets_vma
, 4)),
10486 error (_("Unable to seek to start of dynamic information\n"));
10490 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10492 if (gnubuckets
== NULL
)
10495 for (i
= 0; i
< ngnubuckets
; i
++)
10496 if (gnubuckets
[i
] != 0)
10498 if (gnubuckets
[i
] < gnusymidx
)
10501 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10502 maxchain
= gnubuckets
[i
];
10505 if (maxchain
== 0xffffffff)
10508 maxchain
-= gnusymidx
;
10511 (archive_file_offset
10512 + offset_from_vma (file
, buckets_vma
10513 + 4 * (ngnubuckets
+ maxchain
), 4)),
10516 error (_("Unable to seek to start of dynamic information\n"));
10522 if (fread (nb
, 4, 1, file
) != 1)
10524 error (_("Failed to determine last chain length\n"));
10528 if (maxchain
+ 1 == 0)
10533 while ((byte_get (nb
, 4) & 1) == 0);
10536 (archive_file_offset
10537 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10540 error (_("Unable to seek to start of dynamic information\n"));
10544 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10545 ngnuchains
= maxchain
;
10548 if (gnuchains
== NULL
)
10553 if (do_using_dynamic
)
10558 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10560 && do_using_dynamic
10561 && dynamic_strings
!= NULL
10562 && dynamic_symbols
!= NULL
)
10566 if (dynamic_info
[DT_HASH
])
10570 printf (_("\nSymbol table for image:\n"));
10572 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10574 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10576 for (hn
= 0; hn
< nbuckets
; hn
++)
10581 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10582 print_dynamic_symbol (si
, hn
);
10586 if (dynamic_info_DT_GNU_HASH
)
10588 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10590 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10592 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10594 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10595 if (gnubuckets
[hn
] != 0)
10597 bfd_vma si
= gnubuckets
[hn
];
10598 bfd_vma off
= si
- gnusymidx
;
10602 print_dynamic_symbol (si
, hn
);
10605 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10609 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10610 && section_headers
!= NULL
)
10614 for (i
= 0, section
= section_headers
;
10615 i
< elf_header
.e_shnum
;
10619 char * strtab
= NULL
;
10620 unsigned long int strtab_size
= 0;
10621 Elf_Internal_Sym
* symtab
;
10622 Elf_Internal_Sym
* psym
;
10623 unsigned long num_syms
;
10625 if ((section
->sh_type
!= SHT_SYMTAB
10626 && section
->sh_type
!= SHT_DYNSYM
)
10628 && section
->sh_type
== SHT_SYMTAB
))
10631 if (section
->sh_entsize
== 0)
10633 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10634 printable_section_name (section
));
10638 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10639 printable_section_name (section
),
10640 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10643 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10645 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10647 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10648 if (symtab
== NULL
)
10651 if (section
->sh_link
== elf_header
.e_shstrndx
)
10653 strtab
= string_table
;
10654 strtab_size
= string_table_length
;
10656 else if (section
->sh_link
< elf_header
.e_shnum
)
10658 Elf_Internal_Shdr
* string_sec
;
10660 string_sec
= section_headers
+ section
->sh_link
;
10662 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10663 1, string_sec
->sh_size
,
10664 _("string table"));
10665 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10668 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10670 const char *version_string
;
10671 enum versioned_symbol_info sym_info
;
10672 unsigned short vna_other
;
10674 printf ("%6d: ", si
);
10675 print_vma (psym
->st_value
, LONG_HEX
);
10677 print_vma (psym
->st_size
, DEC_5
);
10678 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10679 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10680 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10681 /* Check to see if any other bits in the st_other field are set.
10682 Note - displaying this information disrupts the layout of the
10683 table being generated, but for the moment this case is very rare. */
10684 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10685 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10686 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10687 print_symbol (25, psym
->st_name
< strtab_size
10688 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10691 = get_symbol_version_string (file
,
10692 section
->sh_type
== SHT_DYNSYM
,
10693 strtab
, strtab_size
, si
,
10694 psym
, &sym_info
, &vna_other
);
10695 if (version_string
)
10697 if (sym_info
== symbol_undefined
)
10698 printf ("@%s (%d)", version_string
, vna_other
);
10700 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10708 if (strtab
!= string_table
)
10714 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10716 if (do_histogram
&& buckets
!= NULL
)
10718 unsigned long * lengths
;
10719 unsigned long * counts
;
10722 unsigned long maxlength
= 0;
10723 unsigned long nzero_counts
= 0;
10724 unsigned long nsyms
= 0;
10726 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10727 (unsigned long) nbuckets
);
10729 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10730 if (lengths
== NULL
)
10732 error (_("Out of memory allocating space for histogram buckets\n"));
10736 printf (_(" Length Number %% of total Coverage\n"));
10737 for (hn
= 0; hn
< nbuckets
; ++hn
)
10739 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
&& si
< nbuckets
; si
= chains
[si
])
10742 if (maxlength
< ++lengths
[hn
])
10745 /* PR binutils/17531: A corrupt binary could contain broken
10746 histogram data. Do not go into an infinite loop trying
10748 if (chains
[si
] == si
)
10750 error (_("histogram chain links to itself\n"));
10756 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10757 if (counts
== NULL
)
10760 error (_("Out of memory allocating space for histogram counts\n"));
10764 for (hn
= 0; hn
< nbuckets
; ++hn
)
10765 ++counts
[lengths
[hn
]];
10770 printf (" 0 %-10lu (%5.1f%%)\n",
10771 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10772 for (i
= 1; i
<= maxlength
; ++i
)
10774 nzero_counts
+= counts
[i
] * i
;
10775 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10776 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10777 (nzero_counts
* 100.0) / nsyms
);
10785 if (buckets
!= NULL
)
10791 if (do_histogram
&& gnubuckets
!= NULL
)
10793 unsigned long * lengths
;
10794 unsigned long * counts
;
10796 unsigned long maxlength
= 0;
10797 unsigned long nzero_counts
= 0;
10798 unsigned long nsyms
= 0;
10800 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10801 (unsigned long) ngnubuckets
);
10803 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10804 if (lengths
== NULL
)
10806 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10810 printf (_(" Length Number %% of total Coverage\n"));
10812 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10813 if (gnubuckets
[hn
] != 0)
10815 bfd_vma off
, length
= 1;
10817 for (off
= gnubuckets
[hn
] - gnusymidx
;
10818 /* PR 17531 file: 010-77222-0.004. */
10819 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10822 lengths
[hn
] = length
;
10823 if (length
> maxlength
)
10824 maxlength
= length
;
10828 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10829 if (counts
== NULL
)
10832 error (_("Out of memory allocating space for gnu histogram counts\n"));
10836 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10837 ++counts
[lengths
[hn
]];
10839 if (ngnubuckets
> 0)
10842 printf (" 0 %-10lu (%5.1f%%)\n",
10843 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10844 for (j
= 1; j
<= maxlength
; ++j
)
10846 nzero_counts
+= counts
[j
] * j
;
10847 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10848 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10849 (nzero_counts
* 100.0) / nsyms
);
10863 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10867 if (dynamic_syminfo
== NULL
10869 /* No syminfo, this is ok. */
10872 /* There better should be a dynamic symbol section. */
10873 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10877 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10878 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10880 printf (_(" Num: Name BoundTo Flags\n"));
10881 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10883 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10885 printf ("%4d: ", i
);
10886 if (i
>= num_dynamic_syms
)
10887 printf (_("<corrupt index>"));
10888 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10889 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10891 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10894 switch (dynamic_syminfo
[i
].si_boundto
)
10896 case SYMINFO_BT_SELF
:
10897 fputs ("SELF ", stdout
);
10899 case SYMINFO_BT_PARENT
:
10900 fputs ("PARENT ", stdout
);
10903 if (dynamic_syminfo
[i
].si_boundto
> 0
10904 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10905 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10907 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10911 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10915 if (flags
& SYMINFO_FLG_DIRECT
)
10916 printf (" DIRECT");
10917 if (flags
& SYMINFO_FLG_PASSTHRU
)
10918 printf (" PASSTHRU");
10919 if (flags
& SYMINFO_FLG_COPY
)
10921 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10922 printf (" LAZYLOAD");
10930 /* Check to see if the given reloc needs to be handled in a target specific
10931 manner. If so then process the reloc and return TRUE otherwise return
10935 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10936 unsigned char * start
,
10937 Elf_Internal_Sym
* symtab
)
10939 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10941 switch (elf_header
.e_machine
)
10944 case EM_MSP430_OLD
:
10946 static Elf_Internal_Sym
* saved_sym
= NULL
;
10948 switch (reloc_type
)
10950 case 10: /* R_MSP430_SYM_DIFF */
10951 if (uses_msp430x_relocs ())
10953 case 21: /* R_MSP430X_SYM_DIFF */
10954 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10957 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10958 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10959 goto handle_sym_diff
;
10961 case 5: /* R_MSP430_16_BYTE */
10962 case 9: /* R_MSP430_8 */
10963 if (uses_msp430x_relocs ())
10965 goto handle_sym_diff
;
10967 case 2: /* R_MSP430_ABS16 */
10968 case 15: /* R_MSP430X_ABS16 */
10969 if (! uses_msp430x_relocs ())
10971 goto handle_sym_diff
;
10974 if (saved_sym
!= NULL
)
10978 value
= reloc
->r_addend
10979 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10980 - saved_sym
->st_value
);
10982 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10990 if (saved_sym
!= NULL
)
10991 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10998 case EM_CYGNUS_MN10300
:
11000 static Elf_Internal_Sym
* saved_sym
= NULL
;
11002 switch (reloc_type
)
11004 case 34: /* R_MN10300_ALIGN */
11006 case 33: /* R_MN10300_SYM_DIFF */
11007 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11009 case 1: /* R_MN10300_32 */
11010 case 2: /* R_MN10300_16 */
11011 if (saved_sym
!= NULL
)
11015 value
= reloc
->r_addend
11016 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11017 - saved_sym
->st_value
);
11019 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11026 if (saved_sym
!= NULL
)
11027 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11037 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11038 DWARF debug sections. This is a target specific test. Note - we do not
11039 go through the whole including-target-headers-multiple-times route, (as
11040 we have already done with <elf/h8.h>) because this would become very
11041 messy and even then this function would have to contain target specific
11042 information (the names of the relocs instead of their numeric values).
11043 FIXME: This is not the correct way to solve this problem. The proper way
11044 is to have target specific reloc sizing and typing functions created by
11045 the reloc-macros.h header, in the same way that it already creates the
11046 reloc naming functions. */
11049 is_32bit_abs_reloc (unsigned int reloc_type
)
11051 switch (elf_header
.e_machine
)
11055 return reloc_type
== 1; /* R_386_32. */
11057 return reloc_type
== 1; /* R_68K_32. */
11059 return reloc_type
== 1; /* R_860_32. */
11061 return reloc_type
== 2; /* R_960_32. */
11063 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11065 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11067 return reloc_type
== 1; /* R_ARC_32. */
11069 return reloc_type
== 2; /* R_ARM_ABS32 */
11072 return reloc_type
== 1;
11073 case EM_ADAPTEVA_EPIPHANY
:
11074 return reloc_type
== 3;
11076 return reloc_type
== 0x12; /* R_byte4_data. */
11078 return reloc_type
== 3; /* R_CRIS_32. */
11080 return reloc_type
== 3; /* R_CR16_NUM32. */
11082 return reloc_type
== 15; /* R_CRX_NUM32. */
11083 case EM_CYGNUS_FRV
:
11084 return reloc_type
== 1;
11085 case EM_CYGNUS_D10V
:
11087 return reloc_type
== 6; /* R_D10V_32. */
11088 case EM_CYGNUS_D30V
:
11090 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11092 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11093 case EM_CYGNUS_FR30
:
11095 return reloc_type
== 3; /* R_FR30_32. */
11097 return reloc_type
== 1; /* R_FT32_32. */
11101 return reloc_type
== 1; /* R_H8_DIR32. */
11103 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
11106 return reloc_type
== 2; /* R_IP2K_32. */
11108 return reloc_type
== 2; /* R_IQ2000_32. */
11109 case EM_LATTICEMICO32
:
11110 return reloc_type
== 3; /* R_LM32_32. */
11113 return reloc_type
== 3; /* R_M32C_32. */
11115 return reloc_type
== 34; /* R_M32R_32_RELA. */
11117 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11118 case EM_CYGNUS_MEP
:
11119 return reloc_type
== 4; /* R_MEP_32. */
11121 return reloc_type
== 2; /* R_METAG_ADDR32. */
11122 case EM_MICROBLAZE
:
11123 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11125 return reloc_type
== 2; /* R_MIPS_32. */
11127 return reloc_type
== 4; /* R_MMIX_32. */
11128 case EM_CYGNUS_MN10200
:
11130 return reloc_type
== 1; /* R_MN10200_32. */
11131 case EM_CYGNUS_MN10300
:
11133 return reloc_type
== 1; /* R_MN10300_32. */
11135 return reloc_type
== 1; /* R_MOXIE_32. */
11136 case EM_MSP430_OLD
:
11138 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11140 return reloc_type
== 2; /* R_MT_32. */
11142 return reloc_type
== 20; /* R_NDS32_RELA. */
11143 case EM_ALTERA_NIOS2
:
11144 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11146 return reloc_type
== 1; /* R_NIOS_32. */
11148 return reloc_type
== 1; /* R_OR1K_32. */
11150 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11151 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11154 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11156 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11158 return reloc_type
== 1; /* R_PPC_ADDR32. */
11160 return reloc_type
== 1; /* R_RL78_DIR32. */
11162 return reloc_type
== 1; /* R_RX_DIR32. */
11164 return reloc_type
== 1; /* R_I370_ADDR31. */
11167 return reloc_type
== 4; /* R_S390_32. */
11169 return reloc_type
== 8; /* R_SCORE_ABS32. */
11171 return reloc_type
== 1; /* R_SH_DIR32. */
11172 case EM_SPARC32PLUS
:
11175 return reloc_type
== 3 /* R_SPARC_32. */
11176 || reloc_type
== 23; /* R_SPARC_UA32. */
11178 return reloc_type
== 6; /* R_SPU_ADDR32 */
11180 return reloc_type
== 1; /* R_C6000_ABS32. */
11182 return reloc_type
== 2; /* R_TILEGX_32. */
11184 return reloc_type
== 1; /* R_TILEPRO_32. */
11185 case EM_CYGNUS_V850
:
11187 return reloc_type
== 6; /* R_V850_ABS32. */
11189 return reloc_type
== 0x33; /* R_V810_WORD. */
11191 return reloc_type
== 1; /* R_VAX_32. */
11193 return reloc_type
== 3; /* R_VISIUM_32. */
11197 return reloc_type
== 10; /* R_X86_64_32. */
11200 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11202 return reloc_type
== 4; /* R_XGATE_32. */
11204 return reloc_type
== 1; /* R_XSTROMY16_32. */
11205 case EM_XTENSA_OLD
:
11207 return reloc_type
== 1; /* R_XTENSA_32. */
11210 static unsigned int prev_warn
= 0;
11212 /* Avoid repeating the same warning multiple times. */
11213 if (prev_warn
!= elf_header
.e_machine
)
11214 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11215 elf_header
.e_machine
);
11216 prev_warn
= elf_header
.e_machine
;
11222 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11223 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11226 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11228 switch (elf_header
.e_machine
)
11232 return reloc_type
== 2; /* R_386_PC32. */
11234 return reloc_type
== 4; /* R_68K_PC32. */
11236 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11237 case EM_ADAPTEVA_EPIPHANY
:
11238 return reloc_type
== 6;
11240 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11242 return reloc_type
== 3; /* R_ARM_REL32 */
11243 case EM_MICROBLAZE
:
11244 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11246 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11248 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11250 return reloc_type
== 26; /* R_PPC_REL32. */
11252 return reloc_type
== 26; /* R_PPC64_REL32. */
11255 return reloc_type
== 5; /* R_390_PC32. */
11257 return reloc_type
== 2; /* R_SH_REL32. */
11258 case EM_SPARC32PLUS
:
11261 return reloc_type
== 6; /* R_SPARC_DISP32. */
11263 return reloc_type
== 13; /* R_SPU_REL32. */
11265 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11267 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11269 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11273 return reloc_type
== 2; /* R_X86_64_PC32. */
11274 case EM_XTENSA_OLD
:
11276 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11278 /* Do not abort or issue an error message here. Not all targets use
11279 pc-relative 32-bit relocs in their DWARF debug information and we
11280 have already tested for target coverage in is_32bit_abs_reloc. A
11281 more helpful warning message will be generated by apply_relocations
11282 anyway, so just return. */
11287 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11288 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11291 is_64bit_abs_reloc (unsigned int reloc_type
)
11293 switch (elf_header
.e_machine
)
11296 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11298 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11300 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11302 return reloc_type
== 80; /* R_PARISC_DIR64. */
11304 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11305 case EM_SPARC32PLUS
:
11308 return reloc_type
== 54; /* R_SPARC_UA64. */
11312 return reloc_type
== 1; /* R_X86_64_64. */
11315 return reloc_type
== 22; /* R_S390_64. */
11317 return reloc_type
== 1; /* R_TILEGX_64. */
11319 return reloc_type
== 18; /* R_MIPS_64. */
11325 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11326 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11329 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11331 switch (elf_header
.e_machine
)
11334 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11336 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11338 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11340 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11342 return reloc_type
== 44; /* R_PPC64_REL64. */
11343 case EM_SPARC32PLUS
:
11346 return reloc_type
== 46; /* R_SPARC_DISP64. */
11350 return reloc_type
== 24; /* R_X86_64_PC64. */
11353 return reloc_type
== 23; /* R_S390_PC64. */
11355 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11361 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11362 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11365 is_24bit_abs_reloc (unsigned int reloc_type
)
11367 switch (elf_header
.e_machine
)
11369 case EM_CYGNUS_MN10200
:
11371 return reloc_type
== 4; /* R_MN10200_24. */
11377 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11378 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11381 is_16bit_abs_reloc (unsigned int reloc_type
)
11383 switch (elf_header
.e_machine
)
11387 return reloc_type
== 4; /* R_AVR_16. */
11388 case EM_ADAPTEVA_EPIPHANY
:
11389 return reloc_type
== 5;
11390 case EM_CYGNUS_D10V
:
11392 return reloc_type
== 3; /* R_D10V_16. */
11396 return reloc_type
== R_H8_DIR16
;
11399 return reloc_type
== 1; /* R_IP2K_16. */
11402 return reloc_type
== 1; /* R_M32C_16 */
11404 if (uses_msp430x_relocs ())
11405 return reloc_type
== 2; /* R_MSP430_ABS16. */
11406 case EM_MSP430_OLD
:
11407 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11409 return reloc_type
== 19; /* R_NDS32_RELA. */
11410 case EM_ALTERA_NIOS2
:
11411 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11413 return reloc_type
== 9; /* R_NIOS_16. */
11415 return reloc_type
== 2; /* R_OR1K_16. */
11417 return reloc_type
== 2; /* R_C6000_ABS16. */
11420 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11421 case EM_CYGNUS_MN10200
:
11423 return reloc_type
== 2; /* R_MN10200_16. */
11424 case EM_CYGNUS_MN10300
:
11426 return reloc_type
== 2; /* R_MN10300_16. */
11428 return reloc_type
== 2; /* R_VISIUM_16. */
11430 return reloc_type
== 3; /* R_XGATE_16. */
11436 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11437 relocation entries (possibly formerly used for SHT_GROUP sections). */
11440 is_none_reloc (unsigned int reloc_type
)
11442 switch (elf_header
.e_machine
)
11444 case EM_68K
: /* R_68K_NONE. */
11445 case EM_386
: /* R_386_NONE. */
11446 case EM_SPARC32PLUS
:
11448 case EM_SPARC
: /* R_SPARC_NONE. */
11449 case EM_MIPS
: /* R_MIPS_NONE. */
11450 case EM_PARISC
: /* R_PARISC_NONE. */
11451 case EM_ALPHA
: /* R_ALPHA_NONE. */
11452 case EM_ADAPTEVA_EPIPHANY
:
11453 case EM_PPC
: /* R_PPC_NONE. */
11454 case EM_PPC64
: /* R_PPC64_NONE. */
11455 case EM_ARM
: /* R_ARM_NONE. */
11456 case EM_IA_64
: /* R_IA64_NONE. */
11457 case EM_SH
: /* R_SH_NONE. */
11459 case EM_S390
: /* R_390_NONE. */
11460 case EM_CRIS
: /* R_CRIS_NONE. */
11461 case EM_X86_64
: /* R_X86_64_NONE. */
11462 case EM_L1OM
: /* R_X86_64_NONE. */
11463 case EM_K1OM
: /* R_X86_64_NONE. */
11464 case EM_MN10300
: /* R_MN10300_NONE. */
11465 case EM_FT32
: /* R_FT32_NONE. */
11466 case EM_MOXIE
: /* R_MOXIE_NONE. */
11467 case EM_M32R
: /* R_M32R_NONE. */
11468 case EM_TI_C6000
:/* R_C6000_NONE. */
11469 case EM_TILEGX
: /* R_TILEGX_NONE. */
11470 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11472 case EM_C166
: /* R_XC16X_NONE. */
11473 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11474 case EM_NIOS32
: /* R_NIOS_NONE. */
11475 case EM_OR1K
: /* R_OR1K_NONE. */
11476 return reloc_type
== 0;
11478 return reloc_type
== 0 || reloc_type
== 256;
11480 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11481 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11482 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11483 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11484 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11485 case EM_XTENSA_OLD
:
11487 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11488 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11489 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11490 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11492 return reloc_type
== 3; /* R_METAG_NONE. */
11497 /* Apply relocations to a section.
11498 Note: So far support has been added only for those relocations
11499 which can be found in debug sections.
11500 FIXME: Add support for more relocations ? */
11503 apply_relocations (void * file
,
11504 Elf_Internal_Shdr
* section
,
11505 unsigned char * start
)
11507 Elf_Internal_Shdr
* relsec
;
11508 unsigned char * end
= start
+ section
->sh_size
;
11510 if (elf_header
.e_type
!= ET_REL
)
11513 /* Find the reloc section associated with the section. */
11514 for (relsec
= section_headers
;
11515 relsec
< section_headers
+ elf_header
.e_shnum
;
11518 bfd_boolean is_rela
;
11519 unsigned long num_relocs
;
11520 Elf_Internal_Rela
* relocs
;
11521 Elf_Internal_Rela
* rp
;
11522 Elf_Internal_Shdr
* symsec
;
11523 Elf_Internal_Sym
* symtab
;
11524 unsigned long num_syms
;
11525 Elf_Internal_Sym
* sym
;
11527 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11528 || relsec
->sh_info
>= elf_header
.e_shnum
11529 || section_headers
+ relsec
->sh_info
!= section
11530 || relsec
->sh_size
== 0
11531 || relsec
->sh_link
>= elf_header
.e_shnum
)
11534 is_rela
= relsec
->sh_type
== SHT_RELA
;
11538 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11539 relsec
->sh_size
, & relocs
, & num_relocs
))
11544 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11545 relsec
->sh_size
, & relocs
, & num_relocs
))
11549 /* SH uses RELA but uses in place value instead of the addend field. */
11550 if (elf_header
.e_machine
== EM_SH
)
11553 symsec
= section_headers
+ relsec
->sh_link
;
11554 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11556 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11559 unsigned int reloc_type
;
11560 unsigned int reloc_size
;
11561 unsigned char * rloc
;
11562 unsigned long sym_index
;
11564 reloc_type
= get_reloc_type (rp
->r_info
);
11566 if (target_specific_reloc_handling (rp
, start
, symtab
))
11568 else if (is_none_reloc (reloc_type
))
11570 else if (is_32bit_abs_reloc (reloc_type
)
11571 || is_32bit_pcrel_reloc (reloc_type
))
11573 else if (is_64bit_abs_reloc (reloc_type
)
11574 || is_64bit_pcrel_reloc (reloc_type
))
11576 else if (is_24bit_abs_reloc (reloc_type
))
11578 else if (is_16bit_abs_reloc (reloc_type
))
11582 static unsigned int prev_reloc
= 0;
11583 if (reloc_type
!= prev_reloc
)
11584 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11585 reloc_type
, printable_section_name (section
));
11586 prev_reloc
= reloc_type
;
11590 rloc
= start
+ rp
->r_offset
;
11591 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11593 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11594 (unsigned long) rp
->r_offset
,
11595 printable_section_name (section
));
11599 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11600 if (sym_index
>= num_syms
)
11602 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11603 sym_index
, printable_section_name (section
));
11606 sym
= symtab
+ sym_index
;
11608 /* If the reloc has a symbol associated with it,
11609 make sure that it is of an appropriate type.
11611 Relocations against symbols without type can happen.
11612 Gcc -feliminate-dwarf2-dups may generate symbols
11613 without type for debug info.
11615 Icc generates relocations against function symbols
11616 instead of local labels.
11618 Relocations against object symbols can happen, eg when
11619 referencing a global array. For an example of this see
11620 the _clz.o binary in libgcc.a. */
11622 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11624 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11625 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11626 (long int)(rp
- relocs
),
11627 printable_section_name (relsec
));
11633 addend
+= rp
->r_addend
;
11634 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11635 partial_inplace. */
11637 || (elf_header
.e_machine
== EM_XTENSA
11638 && reloc_type
== 1)
11639 || ((elf_header
.e_machine
== EM_PJ
11640 || elf_header
.e_machine
== EM_PJ_OLD
)
11641 && reloc_type
== 1)
11642 || ((elf_header
.e_machine
== EM_D30V
11643 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11644 && reloc_type
== 12))
11645 addend
+= byte_get (rloc
, reloc_size
);
11647 if (is_32bit_pcrel_reloc (reloc_type
)
11648 || is_64bit_pcrel_reloc (reloc_type
))
11650 /* On HPPA, all pc-relative relocations are biased by 8. */
11651 if (elf_header
.e_machine
== EM_PARISC
)
11653 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11657 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11666 #ifdef SUPPORT_DISASSEMBLY
11668 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11670 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11672 /* FIXME: XXX -- to be done --- XXX */
11678 /* Reads in the contents of SECTION from FILE, returning a pointer
11679 to a malloc'ed buffer or NULL if something went wrong. */
11682 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11684 bfd_size_type num_bytes
;
11686 num_bytes
= section
->sh_size
;
11688 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11690 printf (_("\nSection '%s' has no data to dump.\n"),
11691 printable_section_name (section
));
11695 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11696 _("section contents"));
11701 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11703 Elf_Internal_Shdr
* relsec
;
11704 bfd_size_type num_bytes
;
11708 bfd_boolean some_strings_shown
;
11710 start
= get_section_contents (section
, file
);
11714 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11716 /* If the section being dumped has relocations against it the user might
11717 be expecting these relocations to have been applied. Check for this
11718 case and issue a warning message in order to avoid confusion.
11719 FIXME: Maybe we ought to have an option that dumps a section with
11720 relocs applied ? */
11721 for (relsec
= section_headers
;
11722 relsec
< section_headers
+ elf_header
.e_shnum
;
11725 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11726 || relsec
->sh_info
>= elf_header
.e_shnum
11727 || section_headers
+ relsec
->sh_info
!= section
11728 || relsec
->sh_size
== 0
11729 || relsec
->sh_link
>= elf_header
.e_shnum
)
11732 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11736 num_bytes
= section
->sh_size
;
11738 end
= start
+ num_bytes
;
11739 some_strings_shown
= FALSE
;
11743 while (!ISPRINT (* data
))
11744 if (++ data
>= end
)
11749 size_t maxlen
= end
- data
;
11752 /* PR 11128: Use two separate invocations in order to work
11753 around bugs in the Solaris 8 implementation of printf. */
11754 printf (" [%6tx] ", data
- start
);
11756 printf (" [%6Ix] ", (size_t) (data
- start
));
11760 print_symbol ((int) maxlen
, data
);
11762 data
+= strnlen (data
, maxlen
);
11766 printf (_("<corrupt>\n"));
11769 some_strings_shown
= TRUE
;
11773 if (! some_strings_shown
)
11774 printf (_(" No strings found in this section."));
11782 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11784 bfd_boolean relocate
)
11786 Elf_Internal_Shdr
* relsec
;
11787 bfd_size_type bytes
;
11789 unsigned char * data
;
11790 unsigned char * start
;
11792 start
= (unsigned char *) get_section_contents (section
, file
);
11796 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11800 apply_relocations (file
, section
, start
);
11804 /* If the section being dumped has relocations against it the user might
11805 be expecting these relocations to have been applied. Check for this
11806 case and issue a warning message in order to avoid confusion.
11807 FIXME: Maybe we ought to have an option that dumps a section with
11808 relocs applied ? */
11809 for (relsec
= section_headers
;
11810 relsec
< section_headers
+ elf_header
.e_shnum
;
11813 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11814 || relsec
->sh_info
>= elf_header
.e_shnum
11815 || section_headers
+ relsec
->sh_info
!= section
11816 || relsec
->sh_size
== 0
11817 || relsec
->sh_link
>= elf_header
.e_shnum
)
11820 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11825 addr
= section
->sh_addr
;
11826 bytes
= section
->sh_size
;
11835 lbytes
= (bytes
> 16 ? 16 : bytes
);
11837 printf (" 0x%8.8lx ", (unsigned long) addr
);
11839 for (j
= 0; j
< 16; j
++)
11842 printf ("%2.2x", data
[j
]);
11850 for (j
= 0; j
< lbytes
; j
++)
11853 if (k
>= ' ' && k
< 0x7f)
11871 /* Uncompresses a section that was compressed using zlib, in place. */
11874 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11875 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11877 #ifndef HAVE_ZLIB_H
11880 dwarf_size_type compressed_size
= *size
;
11881 unsigned char * compressed_buffer
= *buffer
;
11882 dwarf_size_type uncompressed_size
;
11883 unsigned char * uncompressed_buffer
;
11886 dwarf_size_type header_size
= 12;
11888 /* Read the zlib header. In this case, it should be "ZLIB" followed
11889 by the uncompressed section size, 8 bytes in big-endian order. */
11890 if (compressed_size
< header_size
11891 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11894 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11895 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11896 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11897 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11898 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11899 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11900 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11901 uncompressed_size
+= compressed_buffer
[11];
11903 /* It is possible the section consists of several compressed
11904 buffers concatenated together, so we uncompress in a loop. */
11905 strm
.zalloc
= NULL
;
11907 strm
.opaque
= NULL
;
11908 strm
.avail_in
= compressed_size
- header_size
;
11909 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11910 strm
.avail_out
= uncompressed_size
;
11911 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11913 rc
= inflateInit (& strm
);
11914 while (strm
.avail_in
> 0)
11918 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11919 + (uncompressed_size
- strm
.avail_out
));
11920 rc
= inflate (&strm
, Z_FINISH
);
11921 if (rc
!= Z_STREAM_END
)
11923 rc
= inflateReset (& strm
);
11925 rc
= inflateEnd (& strm
);
11927 || strm
.avail_out
!= 0)
11930 free (compressed_buffer
);
11931 *buffer
= uncompressed_buffer
;
11932 *size
= uncompressed_size
;
11936 free (uncompressed_buffer
);
11937 /* Indicate decompression failure. */
11940 #endif /* HAVE_ZLIB_H */
11944 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11945 Elf_Internal_Shdr
* sec
, void * file
)
11947 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11950 /* If it is already loaded, do nothing. */
11951 if (section
->start
!= NULL
)
11954 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11955 section
->address
= sec
->sh_addr
;
11956 section
->user_data
= NULL
;
11957 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11959 sec
->sh_size
, buf
);
11960 if (section
->start
== NULL
)
11964 section
->size
= sec
->sh_size
;
11965 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11966 sec
->sh_size
= section
->size
;
11969 if (section
->start
== NULL
)
11972 if (debug_displays
[debug
].relocate
)
11973 apply_relocations ((FILE *) file
, sec
, section
->start
);
11978 /* If this is not NULL, load_debug_section will only look for sections
11979 within the list of sections given here. */
11980 unsigned int *section_subset
= NULL
;
11983 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11985 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11986 Elf_Internal_Shdr
* sec
;
11988 /* Locate the debug section. */
11989 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11991 section
->name
= section
->uncompressed_name
;
11994 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11996 section
->name
= section
->compressed_name
;
12001 /* If we're loading from a subset of sections, and we've loaded
12002 a section matching this name before, it's likely that it's a
12004 if (section_subset
!= NULL
)
12005 free_debug_section (debug
);
12007 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12011 free_debug_section (enum dwarf_section_display_enum debug
)
12013 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12015 if (section
->start
== NULL
)
12018 free ((char *) section
->start
);
12019 section
->start
= NULL
;
12020 section
->address
= 0;
12025 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12027 char * name
= SECTION_NAME (section
);
12028 const char * print_name
= printable_section_name (section
);
12029 bfd_size_type length
;
12033 length
= section
->sh_size
;
12036 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12039 if (section
->sh_type
== SHT_NOBITS
)
12041 /* There is no point in dumping the contents of a debugging section
12042 which has the NOBITS type - the bits in the file will be random.
12043 This can happen when a file containing a .eh_frame section is
12044 stripped with the --only-keep-debug command line option. */
12045 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12050 if (const_strneq (name
, ".gnu.linkonce.wi."))
12051 name
= ".debug_info";
12053 /* See if we know how to display the contents of this section. */
12054 for (i
= 0; i
< max
; i
++)
12055 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12056 || (i
== line
&& const_strneq (name
, ".debug_line."))
12057 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12059 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12060 int secondary
= (section
!= find_section (name
));
12063 free_debug_section ((enum dwarf_section_display_enum
) i
);
12065 if (i
== line
&& const_strneq (name
, ".debug_line."))
12067 else if (streq (sec
->uncompressed_name
, name
))
12068 sec
->name
= sec
->uncompressed_name
;
12070 sec
->name
= sec
->compressed_name
;
12071 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12074 /* If this debug section is part of a CU/TU set in a .dwp file,
12075 restrict load_debug_section to the sections in that set. */
12076 section_subset
= find_cu_tu_set (file
, shndx
);
12078 result
&= debug_displays
[i
].display (sec
, file
);
12080 section_subset
= NULL
;
12082 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12083 free_debug_section ((enum dwarf_section_display_enum
) i
);
12091 printf (_("Unrecognized debug section: %s\n"), print_name
);
12098 /* Set DUMP_SECTS for all sections where dumps were requested
12099 based on section name. */
12102 initialise_dumps_byname (void)
12104 struct dump_list_entry
* cur
;
12106 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12111 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12112 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12114 request_dump_bynumber (i
, cur
->type
);
12119 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12125 process_section_contents (FILE * file
)
12127 Elf_Internal_Shdr
* section
;
12133 initialise_dumps_byname ();
12135 for (i
= 0, section
= section_headers
;
12136 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12139 #ifdef SUPPORT_DISASSEMBLY
12140 if (dump_sects
[i
] & DISASS_DUMP
)
12141 disassemble_section (section
, file
);
12143 if (dump_sects
[i
] & HEX_DUMP
)
12144 dump_section_as_bytes (section
, file
, FALSE
);
12146 if (dump_sects
[i
] & RELOC_DUMP
)
12147 dump_section_as_bytes (section
, file
, TRUE
);
12149 if (dump_sects
[i
] & STRING_DUMP
)
12150 dump_section_as_strings (section
, file
);
12152 if (dump_sects
[i
] & DEBUG_DUMP
)
12153 display_debug_section (i
, section
, file
);
12156 /* Check to see if the user requested a
12157 dump of a section that does not exist. */
12158 while (i
++ < num_dump_sects
)
12160 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12164 process_mips_fpe_exception (int mask
)
12169 if (mask
& OEX_FPU_INEX
)
12170 fputs ("INEX", stdout
), first
= 0;
12171 if (mask
& OEX_FPU_UFLO
)
12172 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12173 if (mask
& OEX_FPU_OFLO
)
12174 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12175 if (mask
& OEX_FPU_DIV0
)
12176 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12177 if (mask
& OEX_FPU_INVAL
)
12178 printf ("%sINVAL", first
? "" : "|");
12181 fputs ("0", stdout
);
12184 /* Display's the value of TAG at location P. If TAG is
12185 greater than 0 it is assumed to be an unknown tag, and
12186 a message is printed to this effect. Otherwise it is
12187 assumed that a message has already been printed.
12189 If the bottom bit of TAG is set it assumed to have a
12190 string value, otherwise it is assumed to have an integer
12193 Returns an updated P pointing to the first unread byte
12194 beyond the end of TAG's value.
12196 Reads at or beyond END will not be made. */
12198 static unsigned char *
12199 display_tag_value (int tag
,
12201 const unsigned char * const end
)
12206 printf (" Tag_unknown_%d: ", tag
);
12210 warn (_("<corrupt tag>\n"));
12214 /* PR 17531 file: 027-19978-0.004. */
12215 size_t maxlen
= (end
- p
) - 1;
12220 print_symbol ((int) maxlen
, (const char *) p
);
12221 p
+= strnlen ((char *) p
, maxlen
) + 1;
12225 printf (_("<corrupt string tag>"));
12226 p
= (unsigned char *) end
;
12234 val
= read_uleb128 (p
, &len
, end
);
12236 printf ("%ld (0x%lx)\n", val
, val
);
12243 /* ARM EABI attributes section. */
12248 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12250 const char ** table
;
12251 } arm_attr_public_tag
;
12253 static const char * arm_attr_tag_CPU_arch
[] =
12254 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12255 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12256 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12257 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12258 {"No", "Thumb-1", "Thumb-2"};
12259 static const char * arm_attr_tag_FP_arch
[] =
12260 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12261 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12262 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12263 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12264 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12265 static const char * arm_attr_tag_PCS_config
[] =
12266 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12267 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12268 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12269 {"V6", "SB", "TLS", "Unused"};
12270 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12271 {"Absolute", "PC-relative", "SB-relative", "None"};
12272 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12273 {"Absolute", "PC-relative", "None"};
12274 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12275 {"None", "direct", "GOT-indirect"};
12276 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12277 {"None", "??? 1", "2", "??? 3", "4"};
12278 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12279 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12280 {"Unused", "Needed", "Sign only"};
12281 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12282 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12283 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12284 {"Unused", "Finite", "RTABI", "IEEE 754"};
12285 static const char * arm_attr_tag_ABI_enum_size
[] =
12286 {"Unused", "small", "int", "forced to int"};
12287 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12288 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12289 static const char * arm_attr_tag_ABI_VFP_args
[] =
12290 {"AAPCS", "VFP registers", "custom", "compatible"};
12291 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12292 {"AAPCS", "WMMX registers", "custom"};
12293 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12294 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12295 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12296 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12297 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12298 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12299 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12300 static const char * arm_attr_tag_FP_HP_extension
[] =
12301 {"Not Allowed", "Allowed"};
12302 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12303 {"None", "IEEE 754", "Alternative Format"};
12304 static const char * arm_attr_tag_MPextension_use
[] =
12305 {"Not Allowed", "Allowed"};
12306 static const char * arm_attr_tag_DIV_use
[] =
12307 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12308 "Allowed in v7-A with integer division extension"};
12309 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12310 static const char * arm_attr_tag_Virtualization_use
[] =
12311 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12312 "TrustZone and Virtualization Extensions"};
12313 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12314 {"Not Allowed", "Allowed"};
12316 #define LOOKUP(id, name) \
12317 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12318 static arm_attr_public_tag arm_attr_public_tags
[] =
12320 {4, "CPU_raw_name", 1, NULL
},
12321 {5, "CPU_name", 1, NULL
},
12322 LOOKUP(6, CPU_arch
),
12323 {7, "CPU_arch_profile", 0, NULL
},
12324 LOOKUP(8, ARM_ISA_use
),
12325 LOOKUP(9, THUMB_ISA_use
),
12326 LOOKUP(10, FP_arch
),
12327 LOOKUP(11, WMMX_arch
),
12328 LOOKUP(12, Advanced_SIMD_arch
),
12329 LOOKUP(13, PCS_config
),
12330 LOOKUP(14, ABI_PCS_R9_use
),
12331 LOOKUP(15, ABI_PCS_RW_data
),
12332 LOOKUP(16, ABI_PCS_RO_data
),
12333 LOOKUP(17, ABI_PCS_GOT_use
),
12334 LOOKUP(18, ABI_PCS_wchar_t
),
12335 LOOKUP(19, ABI_FP_rounding
),
12336 LOOKUP(20, ABI_FP_denormal
),
12337 LOOKUP(21, ABI_FP_exceptions
),
12338 LOOKUP(22, ABI_FP_user_exceptions
),
12339 LOOKUP(23, ABI_FP_number_model
),
12340 {24, "ABI_align_needed", 0, NULL
},
12341 {25, "ABI_align_preserved", 0, NULL
},
12342 LOOKUP(26, ABI_enum_size
),
12343 LOOKUP(27, ABI_HardFP_use
),
12344 LOOKUP(28, ABI_VFP_args
),
12345 LOOKUP(29, ABI_WMMX_args
),
12346 LOOKUP(30, ABI_optimization_goals
),
12347 LOOKUP(31, ABI_FP_optimization_goals
),
12348 {32, "compatibility", 0, NULL
},
12349 LOOKUP(34, CPU_unaligned_access
),
12350 LOOKUP(36, FP_HP_extension
),
12351 LOOKUP(38, ABI_FP_16bit_format
),
12352 LOOKUP(42, MPextension_use
),
12353 LOOKUP(44, DIV_use
),
12354 {64, "nodefaults", 0, NULL
},
12355 {65, "also_compatible_with", 0, NULL
},
12356 LOOKUP(66, T2EE_use
),
12357 {67, "conformance", 1, NULL
},
12358 LOOKUP(68, Virtualization_use
),
12359 LOOKUP(70, MPextension_use_legacy
)
12363 static unsigned char *
12364 display_arm_attribute (unsigned char * p
,
12365 const unsigned char * const end
)
12370 arm_attr_public_tag
* attr
;
12374 tag
= read_uleb128 (p
, &len
, end
);
12377 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12379 if (arm_attr_public_tags
[i
].tag
== tag
)
12381 attr
= &arm_attr_public_tags
[i
];
12388 printf (" Tag_%s: ", attr
->name
);
12389 switch (attr
->type
)
12394 case 7: /* Tag_CPU_arch_profile. */
12395 val
= read_uleb128 (p
, &len
, end
);
12399 case 0: printf (_("None\n")); break;
12400 case 'A': printf (_("Application\n")); break;
12401 case 'R': printf (_("Realtime\n")); break;
12402 case 'M': printf (_("Microcontroller\n")); break;
12403 case 'S': printf (_("Application or Realtime\n")); break;
12404 default: printf ("??? (%d)\n", val
); break;
12408 case 24: /* Tag_align_needed. */
12409 val
= read_uleb128 (p
, &len
, end
);
12413 case 0: printf (_("None\n")); break;
12414 case 1: printf (_("8-byte\n")); break;
12415 case 2: printf (_("4-byte\n")); break;
12416 case 3: printf ("??? 3\n"); break;
12419 printf (_("8-byte and up to %d-byte extended\n"),
12422 printf ("??? (%d)\n", val
);
12427 case 25: /* Tag_align_preserved. */
12428 val
= read_uleb128 (p
, &len
, end
);
12432 case 0: printf (_("None\n")); break;
12433 case 1: printf (_("8-byte, except leaf SP\n")); break;
12434 case 2: printf (_("8-byte\n")); break;
12435 case 3: printf ("??? 3\n"); break;
12438 printf (_("8-byte and up to %d-byte extended\n"),
12441 printf ("??? (%d)\n", val
);
12446 case 32: /* Tag_compatibility. */
12448 val
= read_uleb128 (p
, &len
, end
);
12450 printf (_("flag = %d, vendor = "), val
);
12453 size_t maxlen
= (end
- p
) - 1;
12455 print_symbol ((int) maxlen
, (const char *) p
);
12456 p
+= strnlen ((char *) p
, maxlen
) + 1;
12460 printf (_("<corrupt>"));
12461 p
= (unsigned char *) end
;
12467 case 64: /* Tag_nodefaults. */
12468 /* PR 17531: file: 001-505008-0.01. */
12471 printf (_("True\n"));
12474 case 65: /* Tag_also_compatible_with. */
12475 val
= read_uleb128 (p
, &len
, end
);
12477 if (val
== 6 /* Tag_CPU_arch. */)
12479 val
= read_uleb128 (p
, &len
, end
);
12481 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12482 printf ("??? (%d)\n", val
);
12484 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12488 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12493 printf (_("<unknown: %d>\n"), tag
);
12499 return display_tag_value (-1, p
, end
);
12501 return display_tag_value (0, p
, end
);
12504 assert (attr
->type
& 0x80);
12505 val
= read_uleb128 (p
, &len
, end
);
12507 type
= attr
->type
& 0x7f;
12509 printf ("??? (%d)\n", val
);
12511 printf ("%s\n", attr
->table
[val
]);
12516 return display_tag_value (tag
, p
, end
);
12519 static unsigned char *
12520 display_gnu_attribute (unsigned char * p
,
12521 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12522 const unsigned char * const end
)
12528 tag
= read_uleb128 (p
, &len
, end
);
12531 /* Tag_compatibility is the only generic GNU attribute defined at
12535 val
= read_uleb128 (p
, &len
, end
);
12538 printf (_("flag = %d, vendor = "), val
);
12541 printf (_("<corrupt>\n"));
12542 warn (_("corrupt vendor attribute\n"));
12548 size_t maxlen
= (end
- p
) - 1;
12550 print_symbol ((int) maxlen
, (const char *) p
);
12551 p
+= strnlen ((char *) p
, maxlen
) + 1;
12555 printf (_("<corrupt>"));
12556 p
= (unsigned char *) end
;
12563 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12564 return display_proc_gnu_attribute (p
, tag
, end
);
12566 return display_tag_value (tag
, p
, end
);
12569 static unsigned char *
12570 display_power_gnu_attribute (unsigned char * p
,
12572 const unsigned char * const end
)
12577 if (tag
== Tag_GNU_Power_ABI_FP
)
12579 val
= read_uleb128 (p
, &len
, end
);
12581 printf (" Tag_GNU_Power_ABI_FP: ");
12586 printf (_("Hard or soft float\n"));
12589 printf (_("Hard float\n"));
12592 printf (_("Soft float\n"));
12595 printf (_("Single-precision hard float\n"));
12598 printf ("??? (%d)\n", val
);
12604 if (tag
== Tag_GNU_Power_ABI_Vector
)
12606 val
= read_uleb128 (p
, &len
, end
);
12608 printf (" Tag_GNU_Power_ABI_Vector: ");
12612 printf (_("Any\n"));
12615 printf (_("Generic\n"));
12618 printf ("AltiVec\n");
12624 printf ("??? (%d)\n", val
);
12630 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12634 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12638 val
= read_uleb128 (p
, &len
, end
);
12640 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12644 printf (_("Any\n"));
12647 printf ("r3/r4\n");
12650 printf (_("Memory\n"));
12653 printf ("??? (%d)\n", val
);
12659 return display_tag_value (tag
& 1, p
, end
);
12663 display_sparc_hwcaps (int mask
)
12669 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12670 fputs ("mul32", stdout
), first
= 0;
12671 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12672 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12673 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12674 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12675 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12676 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12677 if (mask
& ELF_SPARC_HWCAP_POPC
)
12678 printf ("%spopc", first
? "" : "|"), first
= 0;
12679 if (mask
& ELF_SPARC_HWCAP_VIS
)
12680 printf ("%svis", first
? "" : "|"), first
= 0;
12681 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12682 printf ("%svis2", first
? "" : "|"), first
= 0;
12683 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12684 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12685 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12686 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12687 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12688 printf ("%svis3", first
? "" : "|"), first
= 0;
12689 if (mask
& ELF_SPARC_HWCAP_HPC
)
12690 printf ("%shpc", first
? "" : "|"), first
= 0;
12691 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12692 printf ("%srandom", first
? "" : "|"), first
= 0;
12693 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12694 printf ("%strans", first
? "" : "|"), first
= 0;
12695 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12696 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12697 if (mask
& ELF_SPARC_HWCAP_IMA
)
12698 printf ("%sima", first
? "" : "|"), first
= 0;
12699 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12700 printf ("%scspare", first
? "" : "|"), first
= 0;
12703 fputc ('0', stdout
);
12704 fputc ('\n', stdout
);
12708 display_sparc_hwcaps2 (int mask
)
12714 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12715 fputs ("fjathplus", stdout
), first
= 0;
12716 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12717 printf ("%svis3b", first
? "" : "|"), first
= 0;
12718 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12719 printf ("%sadp", first
? "" : "|"), first
= 0;
12720 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12721 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12722 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12723 printf ("%smwait", first
? "" : "|"), first
= 0;
12724 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12725 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12726 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12727 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12728 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12729 printf ("%snsec", first
? "" : "|"), first
= 0;
12730 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12731 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12732 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12733 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12734 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12735 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12738 fputc ('0', stdout
);
12739 fputc ('\n', stdout
);
12742 static unsigned char *
12743 display_sparc_gnu_attribute (unsigned char * p
,
12745 const unsigned char * const end
)
12750 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12752 val
= read_uleb128 (p
, &len
, end
);
12754 printf (" Tag_GNU_Sparc_HWCAPS: ");
12755 display_sparc_hwcaps (val
);
12758 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12760 val
= read_uleb128 (p
, &len
, end
);
12762 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12763 display_sparc_hwcaps2 (val
);
12767 return display_tag_value (tag
, p
, end
);
12771 print_mips_fp_abi_value (int val
)
12775 case Val_GNU_MIPS_ABI_FP_ANY
:
12776 printf (_("Hard or soft float\n"));
12778 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12779 printf (_("Hard float (double precision)\n"));
12781 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12782 printf (_("Hard float (single precision)\n"));
12784 case Val_GNU_MIPS_ABI_FP_SOFT
:
12785 printf (_("Soft float\n"));
12787 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12788 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12790 case Val_GNU_MIPS_ABI_FP_XX
:
12791 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12793 case Val_GNU_MIPS_ABI_FP_64
:
12794 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12796 case Val_GNU_MIPS_ABI_FP_64A
:
12797 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12800 printf ("??? (%d)\n", val
);
12805 static unsigned char *
12806 display_mips_gnu_attribute (unsigned char * p
,
12808 const unsigned char * const end
)
12810 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12815 val
= read_uleb128 (p
, &len
, end
);
12817 printf (" Tag_GNU_MIPS_ABI_FP: ");
12819 print_mips_fp_abi_value (val
);
12824 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12829 val
= read_uleb128 (p
, &len
, end
);
12831 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12835 case Val_GNU_MIPS_ABI_MSA_ANY
:
12836 printf (_("Any MSA or not\n"));
12838 case Val_GNU_MIPS_ABI_MSA_128
:
12839 printf (_("128-bit MSA\n"));
12842 printf ("??? (%d)\n", val
);
12848 return display_tag_value (tag
& 1, p
, end
);
12851 static unsigned char *
12852 display_tic6x_attribute (unsigned char * p
,
12853 const unsigned char * const end
)
12859 tag
= read_uleb128 (p
, &len
, end
);
12865 val
= read_uleb128 (p
, &len
, end
);
12867 printf (" Tag_ISA: ");
12871 case C6XABI_Tag_ISA_none
:
12872 printf (_("None\n"));
12874 case C6XABI_Tag_ISA_C62X
:
12877 case C6XABI_Tag_ISA_C67X
:
12880 case C6XABI_Tag_ISA_C67XP
:
12881 printf ("C67x+\n");
12883 case C6XABI_Tag_ISA_C64X
:
12886 case C6XABI_Tag_ISA_C64XP
:
12887 printf ("C64x+\n");
12889 case C6XABI_Tag_ISA_C674X
:
12890 printf ("C674x\n");
12893 printf ("??? (%d)\n", val
);
12898 case Tag_ABI_wchar_t
:
12899 val
= read_uleb128 (p
, &len
, end
);
12901 printf (" Tag_ABI_wchar_t: ");
12905 printf (_("Not used\n"));
12908 printf (_("2 bytes\n"));
12911 printf (_("4 bytes\n"));
12914 printf ("??? (%d)\n", val
);
12919 case Tag_ABI_stack_align_needed
:
12920 val
= read_uleb128 (p
, &len
, end
);
12922 printf (" Tag_ABI_stack_align_needed: ");
12926 printf (_("8-byte\n"));
12929 printf (_("16-byte\n"));
12932 printf ("??? (%d)\n", val
);
12937 case Tag_ABI_stack_align_preserved
:
12938 val
= read_uleb128 (p
, &len
, end
);
12940 printf (" Tag_ABI_stack_align_preserved: ");
12944 printf (_("8-byte\n"));
12947 printf (_("16-byte\n"));
12950 printf ("??? (%d)\n", val
);
12956 val
= read_uleb128 (p
, &len
, end
);
12958 printf (" Tag_ABI_DSBT: ");
12962 printf (_("DSBT addressing not used\n"));
12965 printf (_("DSBT addressing used\n"));
12968 printf ("??? (%d)\n", val
);
12974 val
= read_uleb128 (p
, &len
, end
);
12976 printf (" Tag_ABI_PID: ");
12980 printf (_("Data addressing position-dependent\n"));
12983 printf (_("Data addressing position-independent, GOT near DP\n"));
12986 printf (_("Data addressing position-independent, GOT far from DP\n"));
12989 printf ("??? (%d)\n", val
);
12995 val
= read_uleb128 (p
, &len
, end
);
12997 printf (" Tag_ABI_PIC: ");
13001 printf (_("Code addressing position-dependent\n"));
13004 printf (_("Code addressing position-independent\n"));
13007 printf ("??? (%d)\n", val
);
13012 case Tag_ABI_array_object_alignment
:
13013 val
= read_uleb128 (p
, &len
, end
);
13015 printf (" Tag_ABI_array_object_alignment: ");
13019 printf (_("8-byte\n"));
13022 printf (_("4-byte\n"));
13025 printf (_("16-byte\n"));
13028 printf ("??? (%d)\n", val
);
13033 case Tag_ABI_array_object_align_expected
:
13034 val
= read_uleb128 (p
, &len
, end
);
13036 printf (" Tag_ABI_array_object_align_expected: ");
13040 printf (_("8-byte\n"));
13043 printf (_("4-byte\n"));
13046 printf (_("16-byte\n"));
13049 printf ("??? (%d)\n", val
);
13054 case Tag_ABI_compatibility
:
13056 val
= read_uleb128 (p
, &len
, end
);
13058 printf (" Tag_ABI_compatibility: ");
13059 printf (_("flag = %d, vendor = "), val
);
13062 size_t maxlen
= (end
- p
) - 1;
13064 print_symbol ((int) maxlen
, (const char *) p
);
13065 p
+= strnlen ((char *) p
, maxlen
) + 1;
13069 printf (_("<corrupt>"));
13070 p
= (unsigned char *) end
;
13076 case Tag_ABI_conformance
:
13078 printf (" Tag_ABI_conformance: \"");
13081 size_t maxlen
= (end
- p
) - 1;
13083 print_symbol ((int) maxlen
, (const char *) p
);
13084 p
+= strnlen ((char *) p
, maxlen
) + 1;
13088 printf (_("<corrupt>"));
13089 p
= (unsigned char *) end
;
13096 return display_tag_value (tag
, p
, end
);
13100 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13102 unsigned long addr
= 0;
13103 size_t bytes
= end
- p
;
13110 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13112 printf (" 0x%8.8lx ", addr
);
13114 for (j
= 0; j
< 16; j
++)
13117 printf ("%2.2x", p
[j
]);
13125 for (j
= 0; j
< lbytes
; j
++)
13128 if (k
>= ' ' && k
< 0x7f)
13144 static unsigned char *
13145 display_msp430x_attribute (unsigned char * p
,
13146 const unsigned char * const end
)
13152 tag
= read_uleb128 (p
, & len
, end
);
13157 case OFBA_MSPABI_Tag_ISA
:
13158 val
= read_uleb128 (p
, &len
, end
);
13160 printf (" Tag_ISA: ");
13163 case 0: printf (_("None\n")); break;
13164 case 1: printf (_("MSP430\n")); break;
13165 case 2: printf (_("MSP430X\n")); break;
13166 default: printf ("??? (%d)\n", val
); break;
13170 case OFBA_MSPABI_Tag_Code_Model
:
13171 val
= read_uleb128 (p
, &len
, end
);
13173 printf (" Tag_Code_Model: ");
13176 case 0: printf (_("None\n")); break;
13177 case 1: printf (_("Small\n")); break;
13178 case 2: printf (_("Large\n")); break;
13179 default: printf ("??? (%d)\n", val
); break;
13183 case OFBA_MSPABI_Tag_Data_Model
:
13184 val
= read_uleb128 (p
, &len
, end
);
13186 printf (" Tag_Data_Model: ");
13189 case 0: printf (_("None\n")); break;
13190 case 1: printf (_("Small\n")); break;
13191 case 2: printf (_("Large\n")); break;
13192 case 3: printf (_("Restricted Large\n")); break;
13193 default: printf ("??? (%d)\n", val
); break;
13198 printf (_(" <unknown tag %d>: "), tag
);
13205 size_t maxlen
= (end
- p
) - 1;
13207 print_symbol ((int) maxlen
, (const char *) p
);
13208 p
+= strnlen ((char *) p
, maxlen
) + 1;
13212 printf (_("<corrupt>"));
13213 p
= (unsigned char *) end
;
13219 val
= read_uleb128 (p
, &len
, end
);
13221 printf ("%d (0x%x)\n", val
, val
);
13231 process_attributes (FILE * file
,
13232 const char * public_name
,
13233 unsigned int proc_type
,
13234 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13235 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13237 Elf_Internal_Shdr
* sect
;
13240 /* Find the section header so that we get the size. */
13241 for (i
= 0, sect
= section_headers
;
13242 i
< elf_header
.e_shnum
;
13245 unsigned char * contents
;
13248 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13251 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13252 sect
->sh_size
, _("attributes"));
13253 if (contents
== NULL
)
13259 bfd_vma section_len
;
13261 section_len
= sect
->sh_size
- 1;
13264 while (section_len
> 0)
13267 unsigned int namelen
;
13268 bfd_boolean public_section
;
13269 bfd_boolean gnu_section
;
13271 if (section_len
<= 4)
13273 error (_("Tag section ends prematurely\n"));
13276 attr_len
= byte_get (p
, 4);
13279 if (attr_len
> section_len
)
13281 error (_("Bad attribute length (%u > %u)\n"),
13282 (unsigned) attr_len
, (unsigned) section_len
);
13283 attr_len
= section_len
;
13285 /* PR 17531: file: 001-101425-0.004 */
13286 else if (attr_len
< 5)
13288 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13292 section_len
-= attr_len
;
13295 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13296 if (namelen
== 0 || namelen
>= attr_len
)
13298 error (_("Corrupt attribute section name\n"));
13302 printf (_("Attribute Section: "));
13303 print_symbol (INT_MAX
, (const char *) p
);
13306 if (public_name
&& streq ((char *) p
, public_name
))
13307 public_section
= TRUE
;
13309 public_section
= FALSE
;
13311 if (streq ((char *) p
, "gnu"))
13312 gnu_section
= TRUE
;
13314 gnu_section
= FALSE
;
13317 attr_len
-= namelen
;
13319 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13324 unsigned char * end
;
13326 /* PR binutils/17531: Safe handling of corrupt files. */
13329 error (_("Unused bytes at end of section\n"));
13335 size
= byte_get (p
, 4);
13336 if (size
> attr_len
)
13338 error (_("Bad subsection length (%u > %u)\n"),
13339 (unsigned) size
, (unsigned) attr_len
);
13342 /* PR binutils/17531: Safe handling of corrupt files. */
13345 error (_("Bad subsection length (%u < 6)\n"),
13352 end
= p
+ size
- 1;
13353 assert (end
<= contents
+ sect
->sh_size
);
13359 printf (_("File Attributes\n"));
13362 printf (_("Section Attributes:"));
13365 printf (_("Symbol Attributes:"));
13371 val
= read_uleb128 (p
, &j
, end
);
13375 printf (" %d", val
);
13380 printf (_("Unknown tag: %d\n"), tag
);
13381 public_section
= FALSE
;
13385 if (public_section
&& display_pub_attribute
!= NULL
)
13388 p
= display_pub_attribute (p
, end
);
13391 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13394 p
= display_gnu_attribute (p
,
13395 display_proc_gnu_attribute
,
13401 printf (_(" Unknown attribute:\n"));
13402 display_raw_attribute (p
, end
);
13411 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13419 process_arm_specific (FILE * file
)
13421 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13422 display_arm_attribute
, NULL
);
13426 process_power_specific (FILE * file
)
13428 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13429 display_power_gnu_attribute
);
13433 process_sparc_specific (FILE * file
)
13435 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13436 display_sparc_gnu_attribute
);
13440 process_tic6x_specific (FILE * file
)
13442 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13443 display_tic6x_attribute
, NULL
);
13447 process_msp430x_specific (FILE * file
)
13449 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13450 display_msp430x_attribute
, NULL
);
13453 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13454 Print the Address, Access and Initial fields of an entry at VMA ADDR
13455 and return the VMA of the next entry, or -1 if there was a problem.
13456 Does not read from DATA_END or beyond. */
13459 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13460 unsigned char * data_end
)
13463 print_vma (addr
, LONG_HEX
);
13465 if (addr
< pltgot
+ 0xfff0)
13466 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13468 printf ("%10s", "");
13471 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13475 unsigned char * from
= data
+ addr
- pltgot
;
13477 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13479 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13480 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13481 return (bfd_vma
) -1;
13485 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13486 print_vma (entry
, LONG_HEX
);
13489 return addr
+ (is_32bit_elf
? 4 : 8);
13492 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13493 PLTGOT. Print the Address and Initial fields of an entry at VMA
13494 ADDR and return the VMA of the next entry. */
13497 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13500 print_vma (addr
, LONG_HEX
);
13503 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13508 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13509 print_vma (entry
, LONG_HEX
);
13511 return addr
+ (is_32bit_elf
? 4 : 8);
13515 print_mips_ases (unsigned int mask
)
13517 if (mask
& AFL_ASE_DSP
)
13518 fputs ("\n\tDSP ASE", stdout
);
13519 if (mask
& AFL_ASE_DSPR2
)
13520 fputs ("\n\tDSP R2 ASE", stdout
);
13521 if (mask
& AFL_ASE_EVA
)
13522 fputs ("\n\tEnhanced VA Scheme", stdout
);
13523 if (mask
& AFL_ASE_MCU
)
13524 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13525 if (mask
& AFL_ASE_MDMX
)
13526 fputs ("\n\tMDMX ASE", stdout
);
13527 if (mask
& AFL_ASE_MIPS3D
)
13528 fputs ("\n\tMIPS-3D ASE", stdout
);
13529 if (mask
& AFL_ASE_MT
)
13530 fputs ("\n\tMT ASE", stdout
);
13531 if (mask
& AFL_ASE_SMARTMIPS
)
13532 fputs ("\n\tSmartMIPS ASE", stdout
);
13533 if (mask
& AFL_ASE_VIRT
)
13534 fputs ("\n\tVZ ASE", stdout
);
13535 if (mask
& AFL_ASE_MSA
)
13536 fputs ("\n\tMSA ASE", stdout
);
13537 if (mask
& AFL_ASE_MIPS16
)
13538 fputs ("\n\tMIPS16 ASE", stdout
);
13539 if (mask
& AFL_ASE_MICROMIPS
)
13540 fputs ("\n\tMICROMIPS ASE", stdout
);
13541 if (mask
& AFL_ASE_XPA
)
13542 fputs ("\n\tXPA ASE", stdout
);
13544 fprintf (stdout
, "\n\t%s", _("None"));
13545 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13546 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13550 print_mips_isa_ext (unsigned int isa_ext
)
13555 fputs (_("None"), stdout
);
13558 fputs ("RMI XLR", stdout
);
13560 case AFL_EXT_OCTEON3
:
13561 fputs ("Cavium Networks Octeon3", stdout
);
13563 case AFL_EXT_OCTEON2
:
13564 fputs ("Cavium Networks Octeon2", stdout
);
13566 case AFL_EXT_OCTEONP
:
13567 fputs ("Cavium Networks OcteonP", stdout
);
13569 case AFL_EXT_LOONGSON_3A
:
13570 fputs ("Loongson 3A", stdout
);
13572 case AFL_EXT_OCTEON
:
13573 fputs ("Cavium Networks Octeon", stdout
);
13576 fputs ("Toshiba R5900", stdout
);
13579 fputs ("MIPS R4650", stdout
);
13582 fputs ("LSI R4010", stdout
);
13585 fputs ("NEC VR4100", stdout
);
13588 fputs ("Toshiba R3900", stdout
);
13590 case AFL_EXT_10000
:
13591 fputs ("MIPS R10000", stdout
);
13594 fputs ("Broadcom SB-1", stdout
);
13597 fputs ("NEC VR4111/VR4181", stdout
);
13600 fputs ("NEC VR4120", stdout
);
13603 fputs ("NEC VR5400", stdout
);
13606 fputs ("NEC VR5500", stdout
);
13608 case AFL_EXT_LOONGSON_2E
:
13609 fputs ("ST Microelectronics Loongson 2E", stdout
);
13611 case AFL_EXT_LOONGSON_2F
:
13612 fputs ("ST Microelectronics Loongson 2F", stdout
);
13615 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13620 get_mips_reg_size (int reg_size
)
13622 return (reg_size
== AFL_REG_NONE
) ? 0
13623 : (reg_size
== AFL_REG_32
) ? 32
13624 : (reg_size
== AFL_REG_64
) ? 64
13625 : (reg_size
== AFL_REG_128
) ? 128
13630 process_mips_specific (FILE * file
)
13632 Elf_Internal_Dyn
* entry
;
13633 Elf_Internal_Shdr
*sect
= NULL
;
13634 size_t liblist_offset
= 0;
13635 size_t liblistno
= 0;
13636 size_t conflictsno
= 0;
13637 size_t options_offset
= 0;
13638 size_t conflicts_offset
= 0;
13639 size_t pltrelsz
= 0;
13641 bfd_vma pltgot
= 0;
13642 bfd_vma mips_pltgot
= 0;
13643 bfd_vma jmprel
= 0;
13644 bfd_vma local_gotno
= 0;
13645 bfd_vma gotsym
= 0;
13646 bfd_vma symtabno
= 0;
13648 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13649 display_mips_gnu_attribute
);
13651 sect
= find_section (".MIPS.abiflags");
13655 Elf_External_ABIFlags_v0
*abiflags_ext
;
13656 Elf_Internal_ABIFlags_v0 abiflags_in
;
13658 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13659 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13662 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13663 sect
->sh_size
, _("MIPS ABI Flags section"));
13666 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13667 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13668 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13669 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13670 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13671 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13672 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13673 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13674 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13675 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13676 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13678 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13679 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13680 if (abiflags_in
.isa_rev
> 1)
13681 printf ("r%d", abiflags_in
.isa_rev
);
13682 printf ("\nGPR size: %d",
13683 get_mips_reg_size (abiflags_in
.gpr_size
));
13684 printf ("\nCPR1 size: %d",
13685 get_mips_reg_size (abiflags_in
.cpr1_size
));
13686 printf ("\nCPR2 size: %d",
13687 get_mips_reg_size (abiflags_in
.cpr2_size
));
13688 fputs ("\nFP ABI: ", stdout
);
13689 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13690 fputs ("ISA Extension: ", stdout
);
13691 print_mips_isa_ext (abiflags_in
.isa_ext
);
13692 fputs ("\nASEs:", stdout
);
13693 print_mips_ases (abiflags_in
.ases
);
13694 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13695 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13696 fputc ('\n', stdout
);
13697 free (abiflags_ext
);
13702 /* We have a lot of special sections. Thanks SGI! */
13703 if (dynamic_section
== NULL
)
13704 /* No information available. */
13707 for (entry
= dynamic_section
;
13708 /* PR 17531 file: 012-50589-0.004. */
13709 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13711 switch (entry
->d_tag
)
13713 case DT_MIPS_LIBLIST
:
13715 = offset_from_vma (file
, entry
->d_un
.d_val
,
13716 liblistno
* sizeof (Elf32_External_Lib
));
13718 case DT_MIPS_LIBLISTNO
:
13719 liblistno
= entry
->d_un
.d_val
;
13721 case DT_MIPS_OPTIONS
:
13722 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13724 case DT_MIPS_CONFLICT
:
13726 = offset_from_vma (file
, entry
->d_un
.d_val
,
13727 conflictsno
* sizeof (Elf32_External_Conflict
));
13729 case DT_MIPS_CONFLICTNO
:
13730 conflictsno
= entry
->d_un
.d_val
;
13733 pltgot
= entry
->d_un
.d_ptr
;
13735 case DT_MIPS_LOCAL_GOTNO
:
13736 local_gotno
= entry
->d_un
.d_val
;
13738 case DT_MIPS_GOTSYM
:
13739 gotsym
= entry
->d_un
.d_val
;
13741 case DT_MIPS_SYMTABNO
:
13742 symtabno
= entry
->d_un
.d_val
;
13744 case DT_MIPS_PLTGOT
:
13745 mips_pltgot
= entry
->d_un
.d_ptr
;
13748 pltrel
= entry
->d_un
.d_val
;
13751 pltrelsz
= entry
->d_un
.d_val
;
13754 jmprel
= entry
->d_un
.d_ptr
;
13760 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13762 Elf32_External_Lib
* elib
;
13765 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13767 sizeof (Elf32_External_Lib
),
13768 _("liblist section data"));
13771 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13772 (unsigned long) liblistno
);
13773 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13776 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13783 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13784 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13785 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13786 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13787 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13789 tmp
= gmtime (&atime
);
13790 snprintf (timebuf
, sizeof (timebuf
),
13791 "%04u-%02u-%02uT%02u:%02u:%02u",
13792 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13793 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13795 printf ("%3lu: ", (unsigned long) cnt
);
13796 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13797 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13799 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13800 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13801 liblist
.l_version
);
13803 if (liblist
.l_flags
== 0)
13807 static const struct
13814 { " EXACT_MATCH", LL_EXACT_MATCH
},
13815 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13816 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13817 { " EXPORTS", LL_EXPORTS
},
13818 { " DELAY_LOAD", LL_DELAY_LOAD
},
13819 { " DELTA", LL_DELTA
}
13821 int flags
= liblist
.l_flags
;
13824 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13825 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13827 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13828 flags
^= l_flags_vals
[fcnt
].bit
;
13831 printf (" %#x", (unsigned int) flags
);
13841 if (options_offset
!= 0)
13843 Elf_External_Options
* eopt
;
13844 Elf_Internal_Options
* iopt
;
13845 Elf_Internal_Options
* option
;
13848 sect
= section_headers
;
13850 /* Find the section header so that we get the size. */
13851 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13852 /* PR 17533 file: 012-277276-0.004. */
13855 error (_("No MIPS_OPTIONS header found\n"));
13859 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13860 sect
->sh_size
, _("options"));
13863 iopt
= (Elf_Internal_Options
*)
13864 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13867 error (_("Out of memory allocatinf space for MIPS options\n"));
13874 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
13876 Elf_External_Options
* eoption
;
13878 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13880 option
->kind
= BYTE_GET (eoption
->kind
);
13881 option
->size
= BYTE_GET (eoption
->size
);
13882 option
->section
= BYTE_GET (eoption
->section
);
13883 option
->info
= BYTE_GET (eoption
->info
);
13885 /* PR 17531: file: ffa0fa3b. */
13886 if (option
->size
< sizeof (* eopt
)
13887 || offset
+ option
->size
> sect
->sh_size
)
13889 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
13892 offset
+= option
->size
;
13898 printf (_("\nSection '%s' contains %d entries:\n"),
13899 printable_section_name (sect
), cnt
);
13908 switch (option
->kind
)
13911 /* This shouldn't happen. */
13912 printf (" NULL %d %lx", option
->section
, option
->info
);
13915 printf (" REGINFO ");
13916 if (elf_header
.e_machine
== EM_MIPS
)
13919 Elf32_External_RegInfo
* ereg
;
13920 Elf32_RegInfo reginfo
;
13922 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13923 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13924 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13925 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13926 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13927 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13928 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13930 printf ("GPR %08lx GP 0x%lx\n",
13931 reginfo
.ri_gprmask
,
13932 (unsigned long) reginfo
.ri_gp_value
);
13933 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13934 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13935 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13940 Elf64_External_RegInfo
* ereg
;
13941 Elf64_Internal_RegInfo reginfo
;
13943 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13944 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13945 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13946 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13947 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13948 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13949 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13951 printf ("GPR %08lx GP 0x",
13952 reginfo
.ri_gprmask
);
13953 printf_vma (reginfo
.ri_gp_value
);
13956 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13957 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13958 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13962 case ODK_EXCEPTIONS
:
13963 fputs (" EXCEPTIONS fpe_min(", stdout
);
13964 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13965 fputs (") fpe_max(", stdout
);
13966 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13967 fputs (")", stdout
);
13969 if (option
->info
& OEX_PAGE0
)
13970 fputs (" PAGE0", stdout
);
13971 if (option
->info
& OEX_SMM
)
13972 fputs (" SMM", stdout
);
13973 if (option
->info
& OEX_FPDBUG
)
13974 fputs (" FPDBUG", stdout
);
13975 if (option
->info
& OEX_DISMISS
)
13976 fputs (" DISMISS", stdout
);
13979 fputs (" PAD ", stdout
);
13980 if (option
->info
& OPAD_PREFIX
)
13981 fputs (" PREFIX", stdout
);
13982 if (option
->info
& OPAD_POSTFIX
)
13983 fputs (" POSTFIX", stdout
);
13984 if (option
->info
& OPAD_SYMBOL
)
13985 fputs (" SYMBOL", stdout
);
13988 fputs (" HWPATCH ", stdout
);
13989 if (option
->info
& OHW_R4KEOP
)
13990 fputs (" R4KEOP", stdout
);
13991 if (option
->info
& OHW_R8KPFETCH
)
13992 fputs (" R8KPFETCH", stdout
);
13993 if (option
->info
& OHW_R5KEOP
)
13994 fputs (" R5KEOP", stdout
);
13995 if (option
->info
& OHW_R5KCVTL
)
13996 fputs (" R5KCVTL", stdout
);
13999 fputs (" FILL ", stdout
);
14000 /* XXX Print content of info word? */
14003 fputs (" TAGS ", stdout
);
14004 /* XXX Print content of info word? */
14007 fputs (" HWAND ", stdout
);
14008 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14009 fputs (" R4KEOP_CHECKED", stdout
);
14010 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14011 fputs (" R4KEOP_CLEAN", stdout
);
14014 fputs (" HWOR ", stdout
);
14015 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14016 fputs (" R4KEOP_CHECKED", stdout
);
14017 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14018 fputs (" R4KEOP_CLEAN", stdout
);
14021 printf (" GP_GROUP %#06lx self-contained %#06lx",
14022 option
->info
& OGP_GROUP
,
14023 (option
->info
& OGP_SELF
) >> 16);
14026 printf (" IDENT %#06lx self-contained %#06lx",
14027 option
->info
& OGP_GROUP
,
14028 (option
->info
& OGP_SELF
) >> 16);
14031 /* This shouldn't happen. */
14032 printf (" %3d ??? %d %lx",
14033 option
->kind
, option
->section
, option
->info
);
14037 len
= sizeof (* eopt
);
14038 while (len
< option
->size
)
14040 char datum
= * ((char *) eopt
+ offset
+ len
);
14042 if (ISPRINT (datum
))
14043 printf ("%c", datum
);
14045 printf ("\\%03o", datum
);
14048 fputs ("\n", stdout
);
14050 offset
+= option
->size
;
14058 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14060 Elf32_Conflict
* iconf
;
14063 if (dynamic_symbols
== NULL
)
14065 error (_("conflict list found without a dynamic symbol table\n"));
14069 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14072 error (_("Out of memory allocating space for dynamic conflicts\n"));
14078 Elf32_External_Conflict
* econf32
;
14080 econf32
= (Elf32_External_Conflict
*)
14081 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14082 sizeof (* econf32
), _("conflict"));
14086 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14087 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14093 Elf64_External_Conflict
* econf64
;
14095 econf64
= (Elf64_External_Conflict
*)
14096 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14097 sizeof (* econf64
), _("conflict"));
14101 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14102 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14107 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14108 (unsigned long) conflictsno
);
14109 puts (_(" Num: Index Value Name"));
14111 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14113 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14115 if (iconf
[cnt
] >= num_dynamic_syms
)
14116 printf (_("<corrupt symbol index>"));
14119 Elf_Internal_Sym
* psym
;
14121 psym
= & dynamic_symbols
[iconf
[cnt
]];
14122 print_vma (psym
->st_value
, FULL_HEX
);
14124 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14125 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14127 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14135 if (pltgot
!= 0 && local_gotno
!= 0)
14137 bfd_vma ent
, local_end
, global_end
;
14139 unsigned char * data
;
14140 unsigned char * data_end
;
14144 addr_size
= (is_32bit_elf
? 4 : 8);
14145 local_end
= pltgot
+ local_gotno
* addr_size
;
14147 /* PR binutils/17533 file: 012-111227-0.004 */
14148 if (symtabno
< gotsym
)
14150 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14151 (unsigned long) gotsym
, (unsigned long) symtabno
);
14155 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14156 /* PR 17531: file: 54c91a34. */
14157 if (global_end
< local_end
)
14159 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14163 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14164 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14165 global_end
- pltgot
, 1,
14166 _("Global Offset Table data"));
14169 data_end
= data
+ (global_end
- pltgot
);
14171 printf (_("\nPrimary GOT:\n"));
14172 printf (_(" Canonical gp value: "));
14173 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14176 printf (_(" Reserved entries:\n"));
14177 printf (_(" %*s %10s %*s Purpose\n"),
14178 addr_size
* 2, _("Address"), _("Access"),
14179 addr_size
* 2, _("Initial"));
14180 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14181 printf (_(" Lazy resolver\n"));
14182 if (ent
== (bfd_vma
) -1)
14183 goto got_print_fail
;
14185 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14186 >> (addr_size
* 8 - 1)) != 0)
14188 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14189 printf (_(" Module pointer (GNU extension)\n"));
14190 if (ent
== (bfd_vma
) -1)
14191 goto got_print_fail
;
14195 if (ent
< local_end
)
14197 printf (_(" Local entries:\n"));
14198 printf (" %*s %10s %*s\n",
14199 addr_size
* 2, _("Address"), _("Access"),
14200 addr_size
* 2, _("Initial"));
14201 while (ent
< local_end
)
14203 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14205 if (ent
== (bfd_vma
) -1)
14206 goto got_print_fail
;
14211 if (gotsym
< symtabno
)
14215 printf (_(" Global entries:\n"));
14216 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14217 addr_size
* 2, _("Address"),
14219 addr_size
* 2, _("Initial"),
14220 addr_size
* 2, _("Sym.Val."),
14222 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14223 _("Ndx"), _("Name"));
14225 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14227 for (i
= gotsym
; i
< symtabno
; i
++)
14229 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14232 if (dynamic_symbols
== NULL
)
14233 printf (_("<no dynamic symbols>"));
14234 else if (i
< num_dynamic_syms
)
14236 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14238 print_vma (psym
->st_value
, LONG_HEX
);
14239 printf (" %-7s %3s ",
14240 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14241 get_symbol_index_type (psym
->st_shndx
));
14243 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14244 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14246 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14249 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14250 (unsigned long) i
);
14253 if (ent
== (bfd_vma
) -1)
14264 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14267 size_t offset
, rel_offset
;
14268 unsigned long count
, i
;
14269 unsigned char * data
;
14270 int addr_size
, sym_width
;
14271 Elf_Internal_Rela
* rels
;
14273 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14274 if (pltrel
== DT_RELA
)
14276 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14281 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14286 addr_size
= (is_32bit_elf
? 4 : 8);
14287 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14289 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14290 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14291 1, _("Procedure Linkage Table data"));
14295 printf ("\nPLT GOT:\n\n");
14296 printf (_(" Reserved entries:\n"));
14297 printf (_(" %*s %*s Purpose\n"),
14298 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14299 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14300 printf (_(" PLT lazy resolver\n"));
14301 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14302 printf (_(" Module pointer\n"));
14305 printf (_(" Entries:\n"));
14306 printf (" %*s %*s %*s %-7s %3s %s\n",
14307 addr_size
* 2, _("Address"),
14308 addr_size
* 2, _("Initial"),
14309 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14310 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14311 for (i
= 0; i
< count
; i
++)
14313 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14315 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14318 if (idx
>= num_dynamic_syms
)
14319 printf (_("<corrupt symbol index: %lu>"), idx
);
14322 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14324 print_vma (psym
->st_value
, LONG_HEX
);
14325 printf (" %-7s %3s ",
14326 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14327 get_symbol_index_type (psym
->st_shndx
));
14328 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14329 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14331 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14346 process_nds32_specific (FILE * file
)
14348 Elf_Internal_Shdr
*sect
= NULL
;
14350 sect
= find_section (".nds32_e_flags");
14353 unsigned int *flag
;
14355 printf ("\nNDS32 elf flags section:\n");
14356 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14357 sect
->sh_size
, _("NDS32 elf flags section"));
14359 switch ((*flag
) & 0x3)
14362 printf ("(VEC_SIZE):\tNo entry.\n");
14365 printf ("(VEC_SIZE):\t4 bytes\n");
14368 printf ("(VEC_SIZE):\t16 bytes\n");
14371 printf ("(VEC_SIZE):\treserved\n");
14380 process_gnu_liblist (FILE * file
)
14382 Elf_Internal_Shdr
* section
;
14383 Elf_Internal_Shdr
* string_sec
;
14384 Elf32_External_Lib
* elib
;
14386 size_t strtab_size
;
14393 for (i
= 0, section
= section_headers
;
14394 i
< elf_header
.e_shnum
;
14397 switch (section
->sh_type
)
14399 case SHT_GNU_LIBLIST
:
14400 if (section
->sh_link
>= elf_header
.e_shnum
)
14403 elib
= (Elf32_External_Lib
*)
14404 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14405 _("liblist section data"));
14409 string_sec
= section_headers
+ section
->sh_link
;
14411 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14412 string_sec
->sh_size
,
14413 _("liblist string table"));
14415 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14421 strtab_size
= string_sec
->sh_size
;
14423 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14424 printable_section_name (section
),
14425 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14427 puts (_(" Library Time Stamp Checksum Version Flags"));
14429 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14437 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14438 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14439 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14440 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14441 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14443 tmp
= gmtime (&atime
);
14444 snprintf (timebuf
, sizeof (timebuf
),
14445 "%04u-%02u-%02uT%02u:%02u:%02u",
14446 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14447 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14449 printf ("%3lu: ", (unsigned long) cnt
);
14451 printf ("%-20s", liblist
.l_name
< strtab_size
14452 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14454 printf ("%-20.20s", liblist
.l_name
< strtab_size
14455 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14456 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14457 liblist
.l_version
, liblist
.l_flags
);
14468 static const char *
14469 get_note_type (unsigned e_type
)
14471 static char buff
[64];
14473 if (elf_header
.e_type
== ET_CORE
)
14477 return _("NT_AUXV (auxiliary vector)");
14479 return _("NT_PRSTATUS (prstatus structure)");
14481 return _("NT_FPREGSET (floating point registers)");
14483 return _("NT_PRPSINFO (prpsinfo structure)");
14484 case NT_TASKSTRUCT
:
14485 return _("NT_TASKSTRUCT (task structure)");
14487 return _("NT_PRXFPREG (user_xfpregs structure)");
14489 return _("NT_PPC_VMX (ppc Altivec registers)");
14491 return _("NT_PPC_VSX (ppc VSX registers)");
14493 return _("NT_386_TLS (x86 TLS information)");
14494 case NT_386_IOPERM
:
14495 return _("NT_386_IOPERM (x86 I/O permissions)");
14496 case NT_X86_XSTATE
:
14497 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14498 case NT_S390_HIGH_GPRS
:
14499 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14500 case NT_S390_TIMER
:
14501 return _("NT_S390_TIMER (s390 timer register)");
14502 case NT_S390_TODCMP
:
14503 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14504 case NT_S390_TODPREG
:
14505 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14507 return _("NT_S390_CTRS (s390 control registers)");
14508 case NT_S390_PREFIX
:
14509 return _("NT_S390_PREFIX (s390 prefix register)");
14510 case NT_S390_LAST_BREAK
:
14511 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14512 case NT_S390_SYSTEM_CALL
:
14513 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14515 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14517 return _("NT_ARM_VFP (arm VFP registers)");
14519 return _("NT_ARM_TLS (AArch TLS registers)");
14520 case NT_ARM_HW_BREAK
:
14521 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14522 case NT_ARM_HW_WATCH
:
14523 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14525 return _("NT_PSTATUS (pstatus structure)");
14527 return _("NT_FPREGS (floating point registers)");
14529 return _("NT_PSINFO (psinfo structure)");
14531 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14533 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14534 case NT_WIN32PSTATUS
:
14535 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14537 return _("NT_SIGINFO (siginfo_t data)");
14539 return _("NT_FILE (mapped files)");
14547 return _("NT_VERSION (version)");
14549 return _("NT_ARCH (architecture)");
14554 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14559 print_core_note (Elf_Internal_Note
*pnote
)
14561 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14562 bfd_vma count
, page_size
;
14563 unsigned char *descdata
, *filenames
, *descend
;
14565 if (pnote
->type
!= NT_FILE
)
14571 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14572 /* Still "successful". */
14577 if (pnote
->descsz
< 2 * addr_size
)
14579 printf (_(" Malformed note - too short for header\n"));
14583 descdata
= (unsigned char *) pnote
->descdata
;
14584 descend
= descdata
+ pnote
->descsz
;
14586 if (descdata
[pnote
->descsz
- 1] != '\0')
14588 printf (_(" Malformed note - does not end with \\0\n"));
14592 count
= byte_get (descdata
, addr_size
);
14593 descdata
+= addr_size
;
14595 page_size
= byte_get (descdata
, addr_size
);
14596 descdata
+= addr_size
;
14598 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14600 printf (_(" Malformed note - too short for supplied file count\n"));
14604 printf (_(" Page size: "));
14605 print_vma (page_size
, DEC
);
14608 printf (_(" %*s%*s%*s\n"),
14609 (int) (2 + 2 * addr_size
), _("Start"),
14610 (int) (4 + 2 * addr_size
), _("End"),
14611 (int) (4 + 2 * addr_size
), _("Page Offset"));
14612 filenames
= descdata
+ count
* 3 * addr_size
;
14613 while (--count
> 0)
14615 bfd_vma start
, end
, file_ofs
;
14617 if (filenames
== descend
)
14619 printf (_(" Malformed note - filenames end too early\n"));
14623 start
= byte_get (descdata
, addr_size
);
14624 descdata
+= addr_size
;
14625 end
= byte_get (descdata
, addr_size
);
14626 descdata
+= addr_size
;
14627 file_ofs
= byte_get (descdata
, addr_size
);
14628 descdata
+= addr_size
;
14631 print_vma (start
, FULL_HEX
);
14633 print_vma (end
, FULL_HEX
);
14635 print_vma (file_ofs
, FULL_HEX
);
14636 printf ("\n %s\n", filenames
);
14638 filenames
+= 1 + strlen ((char *) filenames
);
14644 static const char *
14645 get_gnu_elf_note_type (unsigned e_type
)
14647 static char buff
[64];
14651 case NT_GNU_ABI_TAG
:
14652 return _("NT_GNU_ABI_TAG (ABI version tag)");
14654 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14655 case NT_GNU_BUILD_ID
:
14656 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14657 case NT_GNU_GOLD_VERSION
:
14658 return _("NT_GNU_GOLD_VERSION (gold version)");
14663 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14668 print_gnu_note (Elf_Internal_Note
*pnote
)
14670 switch (pnote
->type
)
14672 case NT_GNU_BUILD_ID
:
14676 printf (_(" Build ID: "));
14677 for (i
= 0; i
< pnote
->descsz
; ++i
)
14678 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14683 case NT_GNU_ABI_TAG
:
14685 unsigned long os
, major
, minor
, subminor
;
14686 const char *osname
;
14688 /* PR 17531: file: 030-599401-0.004. */
14689 if (pnote
->descsz
< 16)
14691 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14695 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14696 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14697 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14698 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14702 case GNU_ABI_TAG_LINUX
:
14705 case GNU_ABI_TAG_HURD
:
14708 case GNU_ABI_TAG_SOLARIS
:
14709 osname
= "Solaris";
14711 case GNU_ABI_TAG_FREEBSD
:
14712 osname
= "FreeBSD";
14714 case GNU_ABI_TAG_NETBSD
:
14718 osname
= "Unknown";
14722 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14723 major
, minor
, subminor
);
14727 case NT_GNU_GOLD_VERSION
:
14731 printf (_(" Version: "));
14732 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14733 printf ("%c", pnote
->descdata
[i
]);
14742 static const char *
14743 get_netbsd_elfcore_note_type (unsigned e_type
)
14745 static char buff
[64];
14747 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14749 /* NetBSD core "procinfo" structure. */
14750 return _("NetBSD procinfo structure");
14753 /* As of Jan 2002 there are no other machine-independent notes
14754 defined for NetBSD core files. If the note type is less
14755 than the start of the machine-dependent note types, we don't
14758 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14760 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14764 switch (elf_header
.e_machine
)
14766 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14767 and PT_GETFPREGS == mach+2. */
14772 case EM_SPARC32PLUS
:
14776 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14777 return _("PT_GETREGS (reg structure)");
14778 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14779 return _("PT_GETFPREGS (fpreg structure)");
14785 /* On all other arch's, PT_GETREGS == mach+1 and
14786 PT_GETFPREGS == mach+3. */
14790 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14791 return _("PT_GETREGS (reg structure)");
14792 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14793 return _("PT_GETFPREGS (fpreg structure)");
14799 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14800 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14804 static const char *
14805 get_stapsdt_note_type (unsigned e_type
)
14807 static char buff
[64];
14812 return _("NT_STAPSDT (SystemTap probe descriptors)");
14818 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14823 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14825 int addr_size
= is_32bit_elf
? 4 : 8;
14826 char *data
= pnote
->descdata
;
14827 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14828 bfd_vma pc
, base_addr
, semaphore
;
14829 char *provider
, *probe
, *arg_fmt
;
14831 pc
= byte_get ((unsigned char *) data
, addr_size
);
14833 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14835 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14839 data
+= strlen (data
) + 1;
14841 data
+= strlen (data
) + 1;
14843 data
+= strlen (data
) + 1;
14845 printf (_(" Provider: %s\n"), provider
);
14846 printf (_(" Name: %s\n"), probe
);
14847 printf (_(" Location: "));
14848 print_vma (pc
, FULL_HEX
);
14849 printf (_(", Base: "));
14850 print_vma (base_addr
, FULL_HEX
);
14851 printf (_(", Semaphore: "));
14852 print_vma (semaphore
, FULL_HEX
);
14854 printf (_(" Arguments: %s\n"), arg_fmt
);
14856 return data
== data_end
;
14859 static const char *
14860 get_ia64_vms_note_type (unsigned e_type
)
14862 static char buff
[64];
14867 return _("NT_VMS_MHD (module header)");
14869 return _("NT_VMS_LNM (language name)");
14871 return _("NT_VMS_SRC (source files)");
14873 return "NT_VMS_TITLE";
14875 return _("NT_VMS_EIDC (consistency check)");
14876 case NT_VMS_FPMODE
:
14877 return _("NT_VMS_FPMODE (FP mode)");
14878 case NT_VMS_LINKTIME
:
14879 return "NT_VMS_LINKTIME";
14880 case NT_VMS_IMGNAM
:
14881 return _("NT_VMS_IMGNAM (image name)");
14883 return _("NT_VMS_IMGID (image id)");
14884 case NT_VMS_LINKID
:
14885 return _("NT_VMS_LINKID (link id)");
14886 case NT_VMS_IMGBID
:
14887 return _("NT_VMS_IMGBID (build id)");
14888 case NT_VMS_GSTNAM
:
14889 return _("NT_VMS_GSTNAM (sym table name)");
14890 case NT_VMS_ORIG_DYN
:
14891 return "NT_VMS_ORIG_DYN";
14892 case NT_VMS_PATCHTIME
:
14893 return "NT_VMS_PATCHTIME";
14895 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14901 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14903 switch (pnote
->type
)
14906 if (pnote
->descsz
> 36)
14908 size_t l
= strlen (pnote
->descdata
+ 34);
14909 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14910 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14911 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14912 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14915 printf (_(" Invalid size\n"));
14918 printf (_(" Language: %s\n"), pnote
->descdata
);
14921 case NT_VMS_FPMODE
:
14922 printf (_(" Floating Point mode: "));
14923 printf ("0x%016" BFD_VMA_FMT
"x\n",
14924 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14926 case NT_VMS_LINKTIME
:
14927 printf (_(" Link time: "));
14929 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14932 case NT_VMS_PATCHTIME
:
14933 printf (_(" Patch time: "));
14935 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14938 case NT_VMS_ORIG_DYN
:
14939 printf (_(" Major id: %u, minor id: %u\n"),
14940 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14941 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14942 printf (_(" Last modified : "));
14944 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14945 printf (_("\n Link flags : "));
14946 printf ("0x%016" BFD_VMA_FMT
"x\n",
14947 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14948 printf (_(" Header flags: 0x%08x\n"),
14949 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14950 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14953 case NT_VMS_IMGNAM
:
14954 printf (_(" Image name: %s\n"), pnote
->descdata
);
14956 case NT_VMS_GSTNAM
:
14957 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14960 printf (_(" Image id: %s\n"), pnote
->descdata
);
14962 case NT_VMS_LINKID
:
14963 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14971 /* Note that by the ELF standard, the name field is already null byte
14972 terminated, and namesz includes the terminating null byte.
14973 I.E. the value of namesz for the name "FSF" is 4.
14975 If the value of namesz is zero, there is no name present. */
14977 process_note (Elf_Internal_Note
* pnote
)
14979 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14982 if (pnote
->namesz
== 0)
14983 /* If there is no note name, then use the default set of
14984 note type strings. */
14985 nt
= get_note_type (pnote
->type
);
14987 else if (const_strneq (pnote
->namedata
, "GNU"))
14988 /* GNU-specific object file notes. */
14989 nt
= get_gnu_elf_note_type (pnote
->type
);
14991 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14992 /* NetBSD-specific core file notes. */
14993 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14995 else if (strneq (pnote
->namedata
, "SPU/", 4))
14997 /* SPU-specific core file notes. */
14998 nt
= pnote
->namedata
+ 4;
15002 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15003 /* VMS/ia64-specific file notes. */
15004 nt
= get_ia64_vms_note_type (pnote
->type
);
15006 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15007 nt
= get_stapsdt_note_type (pnote
->type
);
15010 /* Don't recognize this note name; just use the default set of
15011 note type strings. */
15012 nt
= get_note_type (pnote
->type
);
15014 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15016 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15017 return print_ia64_vms_note (pnote
);
15018 else if (const_strneq (pnote
->namedata
, "GNU"))
15019 return print_gnu_note (pnote
);
15020 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15021 return print_stapsdt_note (pnote
);
15022 else if (const_strneq (pnote
->namedata
, "CORE"))
15023 return print_core_note (pnote
);
15030 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15032 Elf_External_Note
* pnotes
;
15033 Elf_External_Note
* external
;
15039 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15041 if (pnotes
== NULL
)
15046 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15047 (unsigned long) offset
, (unsigned long) length
);
15048 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15050 while ((char *) external
< (char *) pnotes
+ length
)
15052 Elf_Internal_Note inote
;
15055 char * temp
= NULL
;
15056 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
15058 if (!is_ia64_vms ())
15060 /* PR binutils/15191
15061 Make sure that there is enough data to read. */
15062 min_notesz
= offsetof (Elf_External_Note
, name
);
15063 if (data_remaining
< min_notesz
)
15065 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15066 (int) data_remaining
);
15069 inote
.type
= BYTE_GET (external
->type
);
15070 inote
.namesz
= BYTE_GET (external
->namesz
);
15071 inote
.namedata
= external
->name
;
15072 inote
.descsz
= BYTE_GET (external
->descsz
);
15073 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15074 /* PR 17531: file: 3443835e. */
15075 if (inote
.descdata
< (char *) pnotes
)
15077 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15078 inote
.descdata
= inote
.namedata
;
15081 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15082 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15086 Elf64_External_VMS_Note
*vms_external
;
15088 /* PR binutils/15191
15089 Make sure that there is enough data to read. */
15090 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15091 if (data_remaining
< min_notesz
)
15093 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15094 (int) data_remaining
);
15098 vms_external
= (Elf64_External_VMS_Note
*) external
;
15099 inote
.type
= BYTE_GET (vms_external
->type
);
15100 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15101 inote
.namedata
= vms_external
->name
;
15102 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15103 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15104 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15105 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15108 if (inote
.descdata
< (char *) external
+ min_notesz
15109 || next
< (char *) external
+ min_notesz
15110 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15111 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15112 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15113 || data_remaining
< (size_t)(next
- (char *) external
))
15115 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15116 (unsigned long) ((char *) external
- (char *) pnotes
));
15117 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15118 inote
.type
, inote
.namesz
, inote
.descsz
);
15122 external
= (Elf_External_Note
*) next
;
15124 /* Verify that name is null terminated. It appears that at least
15125 one version of Linux (RedHat 6.0) generates corefiles that don't
15126 comply with the ELF spec by failing to include the null byte in
15128 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15130 temp
= (char *) malloc (inote
.namesz
+ 1);
15133 error (_("Out of memory allocating space for inote name\n"));
15138 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15139 temp
[inote
.namesz
] = 0;
15141 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15142 inote
.namedata
= temp
;
15145 res
&= process_note (& inote
);
15160 process_corefile_note_segments (FILE * file
)
15162 Elf_Internal_Phdr
* segment
;
15166 if (! get_program_headers (file
))
15169 for (i
= 0, segment
= program_headers
;
15170 i
< elf_header
.e_phnum
;
15173 if (segment
->p_type
== PT_NOTE
)
15174 res
&= process_corefile_note_segment (file
,
15175 (bfd_vma
) segment
->p_offset
,
15176 (bfd_vma
) segment
->p_filesz
);
15183 process_note_sections (FILE * file
)
15185 Elf_Internal_Shdr
* section
;
15190 for (i
= 0, section
= section_headers
;
15191 i
< elf_header
.e_shnum
&& section
!= NULL
;
15193 if (section
->sh_type
== SHT_NOTE
)
15195 res
&= process_corefile_note_segment (file
,
15196 (bfd_vma
) section
->sh_offset
,
15197 (bfd_vma
) section
->sh_size
);
15202 /* Try processing NOTE segments instead. */
15203 return process_corefile_note_segments (file
);
15209 process_notes (FILE * file
)
15211 /* If we have not been asked to display the notes then do nothing. */
15215 if (elf_header
.e_type
!= ET_CORE
)
15216 return process_note_sections (file
);
15218 /* No program headers means no NOTE segment. */
15219 if (elf_header
.e_phnum
> 0)
15220 return process_corefile_note_segments (file
);
15222 printf (_("No note segments present in the core file.\n"));
15227 process_arch_specific (FILE * file
)
15232 switch (elf_header
.e_machine
)
15235 return process_arm_specific (file
);
15237 case EM_MIPS_RS3_LE
:
15238 return process_mips_specific (file
);
15241 return process_nds32_specific (file
);
15244 return process_power_specific (file
);
15247 case EM_SPARC32PLUS
:
15249 return process_sparc_specific (file
);
15252 return process_tic6x_specific (file
);
15255 return process_msp430x_specific (file
);
15263 get_file_header (FILE * file
)
15265 /* Read in the identity array. */
15266 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15269 /* Determine how to read the rest of the header. */
15270 switch (elf_header
.e_ident
[EI_DATA
])
15272 default: /* fall through */
15273 case ELFDATANONE
: /* fall through */
15275 byte_get
= byte_get_little_endian
;
15276 byte_put
= byte_put_little_endian
;
15279 byte_get
= byte_get_big_endian
;
15280 byte_put
= byte_put_big_endian
;
15284 /* For now we only support 32 bit and 64 bit ELF files. */
15285 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15287 /* Read in the rest of the header. */
15290 Elf32_External_Ehdr ehdr32
;
15292 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15295 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15296 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15297 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15298 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15299 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15300 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15301 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15302 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15303 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15304 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15305 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15306 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15307 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15311 Elf64_External_Ehdr ehdr64
;
15313 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15314 we will not be able to cope with the 64bit data found in
15315 64 ELF files. Detect this now and abort before we start
15316 overwriting things. */
15317 if (sizeof (bfd_vma
) < 8)
15319 error (_("This instance of readelf has been built without support for a\n\
15320 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15324 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15327 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15328 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15329 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15330 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15331 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15332 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15333 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15334 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15335 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15336 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15337 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15338 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15339 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15342 if (elf_header
.e_shoff
)
15344 /* There may be some extensions in the first section header. Don't
15345 bomb if we can't read it. */
15347 get_32bit_section_headers (file
, TRUE
);
15349 get_64bit_section_headers (file
, TRUE
);
15355 /* Process one ELF object file according to the command line options.
15356 This file may actually be stored in an archive. The file is
15357 positioned at the start of the ELF object. */
15360 process_object (char * file_name
, FILE * file
)
15364 if (! get_file_header (file
))
15366 error (_("%s: Failed to read file header\n"), file_name
);
15370 /* Initialise per file variables. */
15371 for (i
= ARRAY_SIZE (version_info
); i
--;)
15372 version_info
[i
] = 0;
15374 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15375 dynamic_info
[i
] = 0;
15376 dynamic_info_DT_GNU_HASH
= 0;
15378 /* Process the file. */
15380 printf (_("\nFile: %s\n"), file_name
);
15382 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15383 Note we do this even if cmdline_dump_sects is empty because we
15384 must make sure that the dump_sets array is zeroed out before each
15385 object file is processed. */
15386 if (num_dump_sects
> num_cmdline_dump_sects
)
15387 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15389 if (num_cmdline_dump_sects
> 0)
15391 if (num_dump_sects
== 0)
15392 /* A sneaky way of allocating the dump_sects array. */
15393 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15395 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15396 memcpy (dump_sects
, cmdline_dump_sects
,
15397 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15400 if (! process_file_header ())
15403 if (! process_section_headers (file
))
15405 /* Without loaded section headers we cannot process lots of
15407 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15409 if (! do_using_dynamic
)
15410 do_syms
= do_dyn_syms
= do_reloc
= 0;
15413 if (! process_section_groups (file
))
15415 /* Without loaded section groups we cannot process unwind. */
15419 if (process_program_headers (file
))
15420 process_dynamic_section (file
);
15422 process_relocs (file
);
15424 process_unwind (file
);
15426 process_symbol_table (file
);
15428 process_syminfo (file
);
15430 process_version_sections (file
);
15432 process_section_contents (file
);
15434 process_notes (file
);
15436 process_gnu_liblist (file
);
15438 process_arch_specific (file
);
15440 if (program_headers
)
15442 free (program_headers
);
15443 program_headers
= NULL
;
15446 if (section_headers
)
15448 free (section_headers
);
15449 section_headers
= NULL
;
15454 free (string_table
);
15455 string_table
= NULL
;
15456 string_table_length
= 0;
15459 if (dynamic_strings
)
15461 free (dynamic_strings
);
15462 dynamic_strings
= NULL
;
15463 dynamic_strings_length
= 0;
15466 if (dynamic_symbols
)
15468 free (dynamic_symbols
);
15469 dynamic_symbols
= NULL
;
15470 num_dynamic_syms
= 0;
15473 if (dynamic_syminfo
)
15475 free (dynamic_syminfo
);
15476 dynamic_syminfo
= NULL
;
15479 if (dynamic_section
)
15481 free (dynamic_section
);
15482 dynamic_section
= NULL
;
15485 if (section_headers_groups
)
15487 free (section_headers_groups
);
15488 section_headers_groups
= NULL
;
15491 if (section_groups
)
15493 struct group_list
* g
;
15494 struct group_list
* next
;
15496 for (i
= 0; i
< group_count
; i
++)
15498 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15505 free (section_groups
);
15506 section_groups
= NULL
;
15509 free_debug_memory ();
15514 /* Process an ELF archive.
15515 On entry the file is positioned just after the ARMAG string. */
15518 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15520 struct archive_info arch
;
15521 struct archive_info nested_arch
;
15527 /* The ARCH structure is used to hold information about this archive. */
15528 arch
.file_name
= NULL
;
15530 arch
.index_array
= NULL
;
15531 arch
.sym_table
= NULL
;
15532 arch
.longnames
= NULL
;
15534 /* The NESTED_ARCH structure is used as a single-item cache of information
15535 about a nested archive (when members of a thin archive reside within
15536 another regular archive file). */
15537 nested_arch
.file_name
= NULL
;
15538 nested_arch
.file
= NULL
;
15539 nested_arch
.index_array
= NULL
;
15540 nested_arch
.sym_table
= NULL
;
15541 nested_arch
.longnames
= NULL
;
15543 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15549 if (do_archive_index
)
15551 if (arch
.sym_table
== NULL
)
15552 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15555 unsigned long i
, l
;
15556 unsigned long current_pos
;
15558 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15559 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15560 current_pos
= ftell (file
);
15562 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15564 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15566 char * member_name
;
15568 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15570 if (member_name
!= NULL
)
15572 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15574 if (qualified_name
!= NULL
)
15576 printf (_("Contents of binary %s at offset "), qualified_name
);
15577 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15579 free (qualified_name
);
15584 if (l
>= arch
.sym_size
)
15586 error (_("%s: end of the symbol table reached before the end of the index\n"),
15590 /* PR 17531: file: 0b6630b2. */
15591 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15592 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15595 if (arch
.uses_64bit_indicies
)
15600 if (l
< arch
.sym_size
)
15601 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15602 file_name
, arch
.sym_size
- l
);
15604 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15606 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15612 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15613 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15614 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15615 && !do_section_groups
&& !do_dyn_syms
)
15617 ret
= 0; /* Archive index only. */
15628 char * qualified_name
;
15630 /* Read the next archive header. */
15631 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15633 error (_("%s: failed to seek to next archive header\n"), file_name
);
15636 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15637 if (got
!= sizeof arch
.arhdr
)
15641 error (_("%s: failed to read archive header\n"), file_name
);
15645 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15647 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15652 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15654 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15655 if (archive_file_size
& 01)
15656 ++archive_file_size
;
15658 name
= get_archive_member_name (&arch
, &nested_arch
);
15661 error (_("%s: bad archive file name\n"), file_name
);
15665 namelen
= strlen (name
);
15667 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15668 if (qualified_name
== NULL
)
15670 error (_("%s: bad archive file name\n"), file_name
);
15675 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15677 /* This is a proxy for an external member of a thin archive. */
15678 FILE * member_file
;
15679 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15680 if (member_file_name
== NULL
)
15686 member_file
= fopen (member_file_name
, "rb");
15687 if (member_file
== NULL
)
15689 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15690 free (member_file_name
);
15695 archive_file_offset
= arch
.nested_member_origin
;
15697 ret
|= process_object (qualified_name
, member_file
);
15699 fclose (member_file
);
15700 free (member_file_name
);
15702 else if (is_thin_archive
)
15704 /* PR 15140: Allow for corrupt thin archives. */
15705 if (nested_arch
.file
== NULL
)
15707 error (_("%s: contains corrupt thin archive: %s\n"),
15713 /* This is a proxy for a member of a nested archive. */
15714 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15716 /* The nested archive file will have been opened and setup by
15717 get_archive_member_name. */
15718 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15720 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15725 ret
|= process_object (qualified_name
, nested_arch
.file
);
15729 archive_file_offset
= arch
.next_arhdr_offset
;
15730 arch
.next_arhdr_offset
+= archive_file_size
;
15732 ret
|= process_object (qualified_name
, file
);
15735 if (dump_sects
!= NULL
)
15739 num_dump_sects
= 0;
15742 free (qualified_name
);
15746 if (nested_arch
.file
!= NULL
)
15747 fclose (nested_arch
.file
);
15748 release_archive (&nested_arch
);
15749 release_archive (&arch
);
15755 process_file (char * file_name
)
15758 struct stat statbuf
;
15759 char armag
[SARMAG
];
15762 if (stat (file_name
, &statbuf
) < 0)
15764 if (errno
== ENOENT
)
15765 error (_("'%s': No such file\n"), file_name
);
15767 error (_("Could not locate '%s'. System error message: %s\n"),
15768 file_name
, strerror (errno
));
15772 if (! S_ISREG (statbuf
.st_mode
))
15774 error (_("'%s' is not an ordinary file\n"), file_name
);
15778 file
= fopen (file_name
, "rb");
15781 error (_("Input file '%s' is not readable.\n"), file_name
);
15785 if (fread (armag
, SARMAG
, 1, file
) != 1)
15787 error (_("%s: Failed to read file's magic number\n"), file_name
);
15792 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15794 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15795 ret
= process_archive (file_name
, file
, FALSE
);
15796 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15797 ret
= process_archive (file_name
, file
, TRUE
);
15800 if (do_archive_index
)
15801 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15805 archive_file_size
= archive_file_offset
= 0;
15806 ret
= process_object (file_name
, file
);
15811 current_file_size
= 0;
15815 #ifdef SUPPORT_DISASSEMBLY
15816 /* Needed by the i386 disassembler. For extra credit, someone could
15817 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15821 print_address (unsigned int addr
, FILE * outfile
)
15823 fprintf (outfile
,"0x%8.8x", addr
);
15826 /* Needed by the i386 disassembler. */
15828 db_task_printsym (unsigned int addr
)
15830 print_address (addr
, stderr
);
15835 main (int argc
, char ** argv
)
15839 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15840 setlocale (LC_MESSAGES
, "");
15842 #if defined (HAVE_SETLOCALE)
15843 setlocale (LC_CTYPE
, "");
15845 bindtextdomain (PACKAGE
, LOCALEDIR
);
15846 textdomain (PACKAGE
);
15848 expandargv (&argc
, &argv
);
15850 parse_args (argc
, argv
);
15852 if (num_dump_sects
> 0)
15854 /* Make a copy of the dump_sects array. */
15855 cmdline_dump_sects
= (dump_type
*)
15856 malloc (num_dump_sects
* sizeof (* dump_sects
));
15857 if (cmdline_dump_sects
== NULL
)
15858 error (_("Out of memory allocating dump request table.\n"));
15861 memcpy (cmdline_dump_sects
, dump_sects
,
15862 num_dump_sects
* sizeof (* dump_sects
));
15863 num_cmdline_dump_sects
= num_dump_sects
;
15867 if (optind
< (argc
- 1))
15871 while (optind
< argc
)
15872 err
|= process_file (argv
[optind
++]);
15874 if (dump_sects
!= NULL
)
15876 if (cmdline_dump_sects
!= NULL
)
15877 free (cmdline_dump_sects
);