1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #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 typedef struct elf_section_list
171 Elf_Internal_Shdr
* hdr
;
172 struct elf_section_list
* next
;
175 char * program_name
= "readelf";
176 static unsigned long archive_file_offset
;
177 static unsigned long archive_file_size
;
178 static bfd_size_type current_file_size
;
179 static unsigned long dynamic_addr
;
180 static bfd_size_type dynamic_size
;
181 static size_t dynamic_nent
;
182 static char * dynamic_strings
;
183 static unsigned long dynamic_strings_length
;
184 static char * string_table
;
185 static unsigned long string_table_length
;
186 static unsigned long num_dynamic_syms
;
187 static Elf_Internal_Sym
* dynamic_symbols
;
188 static Elf_Internal_Syminfo
* dynamic_syminfo
;
189 static unsigned long dynamic_syminfo_offset
;
190 static unsigned int dynamic_syminfo_nent
;
191 static char program_interpreter
[PATH_MAX
];
192 static bfd_vma dynamic_info
[DT_ENCODING
];
193 static bfd_vma dynamic_info_DT_GNU_HASH
;
194 static bfd_vma version_info
[16];
195 static Elf_Internal_Ehdr elf_header
;
196 static Elf_Internal_Shdr
* section_headers
;
197 static Elf_Internal_Phdr
* program_headers
;
198 static Elf_Internal_Dyn
* dynamic_section
;
199 static elf_section_list
* symtab_shndx_list
;
200 static int show_name
;
201 static int do_dynamic
;
203 static int do_dyn_syms
;
205 static int do_sections
;
206 static int do_section_groups
;
207 static int do_section_details
;
208 static int do_segments
;
209 static int do_unwind
;
210 static int do_using_dynamic
;
211 static int do_header
;
213 static int do_version
;
214 static int do_histogram
;
215 static int do_debugging
;
218 static int do_archive_index
;
219 static int is_32bit_elf
;
220 static int decompress_dumps
;
224 struct group_list
* next
;
225 unsigned int section_index
;
230 struct group_list
* root
;
231 unsigned int group_index
;
234 static size_t group_count
;
235 static struct group
* section_groups
;
236 static struct group
** section_headers_groups
;
239 /* Flag bits indicating particular types of dump. */
240 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
241 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
244 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
246 typedef unsigned char dump_type
;
248 /* A linked list of the section names for which dumps were requested. */
249 struct dump_list_entry
253 struct dump_list_entry
* next
;
255 static struct dump_list_entry
* dump_sects_byname
;
257 /* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259 static dump_type
* cmdline_dump_sects
= NULL
;
260 static unsigned int num_cmdline_dump_sects
= 0;
262 /* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
267 static dump_type
* dump_sects
= NULL
;
268 static unsigned int num_dump_sects
= 0;
271 /* How to print a vma value. */
272 typedef enum print_mode
284 /* Versioned symbol info. */
285 enum versioned_symbol_info
292 static const char *get_symbol_version_string
293 (FILE *file
, int is_dynsym
, const char *strtab
,
294 unsigned long int strtab_size
, unsigned int si
,
295 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
296 unsigned short *vna_other
);
300 #define SECTION_NAME(X) \
301 ((X) == NULL ? _("<none>") \
302 : string_table == NULL ? _("<no-name>") \
303 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
304 : string_table + (X)->sh_name))
306 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
308 #define GET_ELF_SYMBOLS(file, section, sym_count) \
309 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
310 : get_64bit_elf_symbols (file, section, sym_count))
312 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
313 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
314 already been called and verified that the string exists. */
315 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
317 #define REMOVE_ARCH_BITS(ADDR) \
320 if (elf_header.e_machine == EM_ARM) \
325 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
326 the offset of the current archive member, if we are examining an archive.
327 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
328 using malloc and fill that. In either case return the pointer to the start of
329 the retrieved data or NULL if something went wrong. If something does go wrong
330 and REASON is not NULL then emit an error message using REASON as part of the
334 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
335 bfd_size_type nmemb
, const char * reason
)
338 bfd_size_type amt
= size
* nmemb
;
340 if (size
== 0 || nmemb
== 0)
343 /* If the size_t type is smaller than the bfd_size_type, eg because
344 you are building a 32-bit tool on a 64-bit host, then make sure
345 that when the sizes are cast to (size_t) no information is lost. */
346 if (sizeof (size_t) < sizeof (bfd_size_type
)
347 && ( (bfd_size_type
) ((size_t) size
) != size
348 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
351 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
352 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
353 nmemb
, size
, reason
);
357 /* Check for size overflow. */
361 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
362 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
363 nmemb
, size
, reason
);
367 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
368 attempting to allocate memory when the read is bound to fail. */
369 if (amt
> current_file_size
370 || offset
+ archive_file_offset
+ amt
> current_file_size
)
373 error (_("Reading 0x%" BFD_VMA_FMT
"x"
374 " bytes extends past end of file for %s\n"),
379 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
382 error (_("Unable to seek to 0x%lx for %s\n"),
383 archive_file_offset
+ offset
, reason
);
390 /* Check for overflow. */
391 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
392 /* + 1 so that we can '\0' terminate invalid string table sections. */
393 mvar
= malloc ((size_t) amt
+ 1);
398 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
404 ((char *) mvar
)[amt
] = '\0';
407 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
410 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
420 /* Print a VMA value. */
423 print_vma (bfd_vma vma
, print_mode mode
)
436 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
443 return printf ("%5" BFD_VMA_FMT
"d", vma
);
451 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
454 return printf ("%" BFD_VMA_FMT
"d", vma
);
457 return printf ("%" BFD_VMA_FMT
"u", vma
);
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
477 #ifdef HAVE_MBSTATE_T
484 /* Keep the width positive. This also helps. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
695 static inline unsigned long
696 read_uleb128 (unsigned char *data
,
697 unsigned int *length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
833 warn (_("Don't know about relocations on this machine architecture\n"));
839 slurp_rela_relocs (FILE * file
,
840 unsigned long rel_offset
,
841 unsigned long rel_size
,
842 Elf_Internal_Rela
** relasp
,
843 unsigned long * nrelasp
)
845 Elf_Internal_Rela
* relas
;
851 Elf32_External_Rela
* erelas
;
853 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
854 rel_size
, _("32-bit relocation data"));
858 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
860 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
861 sizeof (Elf_Internal_Rela
));
866 error (_("out of memory parsing relocs\n"));
870 for (i
= 0; i
< nrelas
; i
++)
872 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
873 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
874 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
881 Elf64_External_Rela
* erelas
;
883 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
884 rel_size
, _("64-bit relocation data"));
888 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
890 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
891 sizeof (Elf_Internal_Rela
));
896 error (_("out of memory parsing relocs\n"));
900 for (i
= 0; i
< nrelas
; i
++)
902 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
903 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
904 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
906 /* The #ifdef BFD64 below is to prevent a compile time
907 warning. We know that if we do not have a 64 bit data
908 type that we will never execute this code anyway. */
910 if (elf_header
.e_machine
== EM_MIPS
911 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
913 /* In little-endian objects, r_info isn't really a
914 64-bit little-endian value: it has a 32-bit
915 little-endian symbol index followed by four
916 individual byte fields. Reorder INFO
918 bfd_vma inf
= relas
[i
].r_info
;
919 inf
= (((inf
& 0xffffffff) << 32)
920 | ((inf
>> 56) & 0xff)
921 | ((inf
>> 40) & 0xff00)
922 | ((inf
>> 24) & 0xff0000)
923 | ((inf
>> 8) & 0xff000000));
924 relas
[i
].r_info
= inf
;
937 slurp_rel_relocs (FILE * file
,
938 unsigned long rel_offset
,
939 unsigned long rel_size
,
940 Elf_Internal_Rela
** relsp
,
941 unsigned long * nrelsp
)
943 Elf_Internal_Rela
* rels
;
949 Elf32_External_Rel
* erels
;
951 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
952 rel_size
, _("32-bit relocation data"));
956 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
958 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
963 error (_("out of memory parsing relocs\n"));
967 for (i
= 0; i
< nrels
; i
++)
969 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
970 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
971 rels
[i
].r_addend
= 0;
978 Elf64_External_Rel
* erels
;
980 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
981 rel_size
, _("64-bit relocation data"));
985 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
987 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
992 error (_("out of memory parsing relocs\n"));
996 for (i
= 0; i
< nrels
; i
++)
998 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
999 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1000 rels
[i
].r_addend
= 0;
1002 /* The #ifdef BFD64 below is to prevent a compile time
1003 warning. We know that if we do not have a 64 bit data
1004 type that we will never execute this code anyway. */
1006 if (elf_header
.e_machine
== EM_MIPS
1007 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1009 /* In little-endian objects, r_info isn't really a
1010 64-bit little-endian value: it has a 32-bit
1011 little-endian symbol index followed by four
1012 individual byte fields. Reorder INFO
1014 bfd_vma inf
= rels
[i
].r_info
;
1015 inf
= (((inf
& 0xffffffff) << 32)
1016 | ((inf
>> 56) & 0xff)
1017 | ((inf
>> 40) & 0xff00)
1018 | ((inf
>> 24) & 0xff0000)
1019 | ((inf
>> 8) & 0xff000000));
1020 rels
[i
].r_info
= inf
;
1032 /* Returns the reloc type extracted from the reloc info field. */
1035 get_reloc_type (bfd_vma reloc_info
)
1038 return ELF32_R_TYPE (reloc_info
);
1040 switch (elf_header
.e_machine
)
1043 /* Note: We assume that reloc_info has already been adjusted for us. */
1044 return ELF64_MIPS_R_TYPE (reloc_info
);
1047 return ELF64_R_TYPE_ID (reloc_info
);
1050 return ELF64_R_TYPE (reloc_info
);
1054 /* Return the symbol index extracted from the reloc info field. */
1057 get_reloc_symindex (bfd_vma reloc_info
)
1059 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1062 static inline bfd_boolean
1063 uses_msp430x_relocs (void)
1066 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1067 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1068 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1069 /* TI compiler uses ELFOSABI_NONE. */
1070 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1073 /* Display the contents of the relocation data found at the specified
1077 dump_relocations (FILE * file
,
1078 unsigned long rel_offset
,
1079 unsigned long rel_size
,
1080 Elf_Internal_Sym
* symtab
,
1081 unsigned long nsyms
,
1083 unsigned long strtablen
,
1088 Elf_Internal_Rela
* rels
;
1090 if (is_rela
== UNKNOWN
)
1091 is_rela
= guess_is_rela (elf_header
.e_machine
);
1095 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1100 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1109 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1111 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1116 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1118 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1126 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1128 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1133 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1135 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1139 for (i
= 0; i
< rel_size
; i
++)
1144 bfd_vma symtab_index
;
1147 offset
= rels
[i
].r_offset
;
1148 inf
= rels
[i
].r_info
;
1150 type
= get_reloc_type (inf
);
1151 symtab_index
= get_reloc_symindex (inf
);
1155 printf ("%8.8lx %8.8lx ",
1156 (unsigned long) offset
& 0xffffffff,
1157 (unsigned long) inf
& 0xffffffff);
1161 #if BFD_HOST_64BIT_LONG
1163 ? "%16.16lx %16.16lx "
1164 : "%12.12lx %12.12lx ",
1166 #elif BFD_HOST_64BIT_LONG_LONG
1169 ? "%16.16llx %16.16llx "
1170 : "%12.12llx %12.12llx ",
1174 ? "%16.16I64x %16.16I64x "
1175 : "%12.12I64x %12.12I64x ",
1180 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1181 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1182 _bfd_int64_high (offset
),
1183 _bfd_int64_low (offset
),
1184 _bfd_int64_high (inf
),
1185 _bfd_int64_low (inf
));
1189 switch (elf_header
.e_machine
)
1196 rtype
= elf_aarch64_reloc_type (type
);
1200 case EM_CYGNUS_M32R
:
1201 rtype
= elf_m32r_reloc_type (type
);
1206 rtype
= elf_i386_reloc_type (type
);
1211 rtype
= elf_m68hc11_reloc_type (type
);
1215 rtype
= elf_m68k_reloc_type (type
);
1219 rtype
= elf_i960_reloc_type (type
);
1224 rtype
= elf_avr_reloc_type (type
);
1227 case EM_OLD_SPARCV9
:
1228 case EM_SPARC32PLUS
:
1231 rtype
= elf_sparc_reloc_type (type
);
1235 rtype
= elf_spu_reloc_type (type
);
1239 rtype
= v800_reloc_type (type
);
1242 case EM_CYGNUS_V850
:
1243 rtype
= v850_reloc_type (type
);
1247 case EM_CYGNUS_D10V
:
1248 rtype
= elf_d10v_reloc_type (type
);
1252 case EM_CYGNUS_D30V
:
1253 rtype
= elf_d30v_reloc_type (type
);
1257 rtype
= elf_dlx_reloc_type (type
);
1261 rtype
= elf_sh_reloc_type (type
);
1265 case EM_CYGNUS_MN10300
:
1266 rtype
= elf_mn10300_reloc_type (type
);
1270 case EM_CYGNUS_MN10200
:
1271 rtype
= elf_mn10200_reloc_type (type
);
1275 case EM_CYGNUS_FR30
:
1276 rtype
= elf_fr30_reloc_type (type
);
1280 rtype
= elf_frv_reloc_type (type
);
1284 rtype
= elf_ft32_reloc_type (type
);
1288 rtype
= elf_mcore_reloc_type (type
);
1292 rtype
= elf_mmix_reloc_type (type
);
1296 rtype
= elf_moxie_reloc_type (type
);
1300 if (uses_msp430x_relocs ())
1302 rtype
= elf_msp430x_reloc_type (type
);
1307 rtype
= elf_msp430_reloc_type (type
);
1311 rtype
= elf_nds32_reloc_type (type
);
1315 rtype
= elf_ppc_reloc_type (type
);
1319 rtype
= elf_ppc64_reloc_type (type
);
1323 case EM_MIPS_RS3_LE
:
1324 rtype
= elf_mips_reloc_type (type
);
1328 rtype
= elf_riscv_reloc_type (type
);
1332 rtype
= elf_alpha_reloc_type (type
);
1336 rtype
= elf_arm_reloc_type (type
);
1340 case EM_ARC_COMPACT
:
1341 case EM_ARC_COMPACT2
:
1342 rtype
= elf_arc_reloc_type (type
);
1346 rtype
= elf_hppa_reloc_type (type
);
1352 rtype
= elf_h8_reloc_type (type
);
1356 rtype
= elf_or1k_reloc_type (type
);
1361 rtype
= elf_pj_reloc_type (type
);
1364 rtype
= elf_ia64_reloc_type (type
);
1368 rtype
= elf_cris_reloc_type (type
);
1372 rtype
= elf_i860_reloc_type (type
);
1378 rtype
= elf_x86_64_reloc_type (type
);
1382 rtype
= i370_reloc_type (type
);
1387 rtype
= elf_s390_reloc_type (type
);
1391 rtype
= elf_score_reloc_type (type
);
1395 rtype
= elf_xstormy16_reloc_type (type
);
1399 rtype
= elf_crx_reloc_type (type
);
1403 rtype
= elf_vax_reloc_type (type
);
1407 rtype
= elf_visium_reloc_type (type
);
1410 case EM_ADAPTEVA_EPIPHANY
:
1411 rtype
= elf_epiphany_reloc_type (type
);
1416 rtype
= elf_ip2k_reloc_type (type
);
1420 rtype
= elf_iq2000_reloc_type (type
);
1425 rtype
= elf_xtensa_reloc_type (type
);
1428 case EM_LATTICEMICO32
:
1429 rtype
= elf_lm32_reloc_type (type
);
1434 rtype
= elf_m32c_reloc_type (type
);
1438 rtype
= elf_mt_reloc_type (type
);
1442 rtype
= elf_bfin_reloc_type (type
);
1446 rtype
= elf_mep_reloc_type (type
);
1450 rtype
= elf_cr16_reloc_type (type
);
1454 case EM_MICROBLAZE_OLD
:
1455 rtype
= elf_microblaze_reloc_type (type
);
1459 rtype
= elf_rl78_reloc_type (type
);
1463 rtype
= elf_rx_reloc_type (type
);
1467 rtype
= elf_metag_reloc_type (type
);
1472 rtype
= elf_xc16x_reloc_type (type
);
1476 rtype
= elf_tic6x_reloc_type (type
);
1480 rtype
= elf_tilegx_reloc_type (type
);
1484 rtype
= elf_tilepro_reloc_type (type
);
1488 rtype
= elf_xgate_reloc_type (type
);
1491 case EM_ALTERA_NIOS2
:
1492 rtype
= elf_nios2_reloc_type (type
);
1496 rtype
= elf_pru_reloc_type (type
);
1501 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1503 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1505 if (elf_header
.e_machine
== EM_ALPHA
1507 && streq (rtype
, "R_ALPHA_LITUSE")
1510 switch (rels
[i
].r_addend
)
1512 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1513 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1514 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1515 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1516 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1517 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1518 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1519 default: rtype
= NULL
;
1522 printf (" (%s)", rtype
);
1526 printf (_("<unknown addend: %lx>"),
1527 (unsigned long) rels
[i
].r_addend
);
1530 else if (symtab_index
)
1532 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1533 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1536 Elf_Internal_Sym
* psym
;
1537 const char * version_string
;
1538 enum versioned_symbol_info sym_info
;
1539 unsigned short vna_other
;
1541 psym
= symtab
+ symtab_index
;
1544 = get_symbol_version_string (file
, is_dynsym
,
1553 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1557 unsigned int width
= is_32bit_elf
? 8 : 14;
1559 /* Relocations against GNU_IFUNC symbols do not use the value
1560 of the symbol as the address to relocate against. Instead
1561 they invoke the function named by the symbol and use its
1562 result as the address for relocation.
1564 To indicate this to the user, do not display the value of
1565 the symbol in the "Symbols's Value" field. Instead show
1566 its name followed by () as a hint that the symbol is
1570 || psym
->st_name
== 0
1571 || psym
->st_name
>= strtablen
)
1574 name
= strtab
+ psym
->st_name
;
1576 len
= print_symbol (width
, name
);
1578 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1580 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1584 print_vma (psym
->st_value
, LONG_HEX
);
1586 printf (is_32bit_elf
? " " : " ");
1589 if (psym
->st_name
== 0)
1591 const char * sec_name
= "<null>";
1594 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1596 if (psym
->st_shndx
< elf_header
.e_shnum
)
1597 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1598 else if (psym
->st_shndx
== SHN_ABS
)
1600 else if (psym
->st_shndx
== SHN_COMMON
)
1601 sec_name
= "COMMON";
1602 else if ((elf_header
.e_machine
== EM_MIPS
1603 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1604 || (elf_header
.e_machine
== EM_TI_C6000
1605 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1606 sec_name
= "SCOMMON";
1607 else if (elf_header
.e_machine
== EM_MIPS
1608 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1609 sec_name
= "SUNDEF";
1610 else if ((elf_header
.e_machine
== EM_X86_64
1611 || elf_header
.e_machine
== EM_L1OM
1612 || elf_header
.e_machine
== EM_K1OM
)
1613 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1614 sec_name
= "LARGE_COMMON";
1615 else if (elf_header
.e_machine
== EM_IA_64
1616 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1617 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1618 sec_name
= "ANSI_COM";
1619 else if (is_ia64_vms ()
1620 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1621 sec_name
= "VMS_SYMVEC";
1624 sprintf (name_buf
, "<section 0x%x>",
1625 (unsigned int) psym
->st_shndx
);
1626 sec_name
= name_buf
;
1629 print_symbol (22, sec_name
);
1631 else if (strtab
== NULL
)
1632 printf (_("<string table index: %3ld>"), psym
->st_name
);
1633 else if (psym
->st_name
>= strtablen
)
1634 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1637 print_symbol (22, strtab
+ psym
->st_name
);
1639 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1645 bfd_vma off
= rels
[i
].r_addend
;
1647 if ((bfd_signed_vma
) off
< 0)
1648 printf (" - %" BFD_VMA_FMT
"x", - off
);
1650 printf (" + %" BFD_VMA_FMT
"x", off
);
1656 bfd_vma off
= rels
[i
].r_addend
;
1658 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1659 if ((bfd_signed_vma
) off
< 0)
1660 printf ("-%" BFD_VMA_FMT
"x", - off
);
1662 printf ("%" BFD_VMA_FMT
"x", off
);
1665 if (elf_header
.e_machine
== EM_SPARCV9
1667 && streq (rtype
, "R_SPARC_OLO10"))
1668 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1673 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1675 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1676 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1677 const char * rtype2
= elf_mips_reloc_type (type2
);
1678 const char * rtype3
= elf_mips_reloc_type (type3
);
1680 printf (" Type2: ");
1683 printf (_("unrecognized: %-7lx"),
1684 (unsigned long) type2
& 0xffffffff);
1686 printf ("%-17.17s", rtype2
);
1688 printf ("\n Type3: ");
1691 printf (_("unrecognized: %-7lx"),
1692 (unsigned long) type3
& 0xffffffff);
1694 printf ("%-17.17s", rtype3
);
1705 get_mips_dynamic_type (unsigned long type
)
1709 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1710 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1711 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1712 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1713 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1714 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1715 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1716 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1717 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1718 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1719 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1720 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1721 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1722 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1723 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1724 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1725 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1726 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1727 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1728 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1729 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1730 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1731 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1732 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1733 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1734 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1735 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1736 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1737 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1738 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1739 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1740 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1741 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1742 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1743 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1744 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1745 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1746 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1747 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1748 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1749 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1750 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1751 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1752 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1753 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1754 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1761 get_sparc64_dynamic_type (unsigned long type
)
1765 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1772 get_ppc_dynamic_type (unsigned long type
)
1776 case DT_PPC_GOT
: return "PPC_GOT";
1777 case DT_PPC_OPT
: return "PPC_OPT";
1784 get_ppc64_dynamic_type (unsigned long type
)
1788 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1789 case DT_PPC64_OPD
: return "PPC64_OPD";
1790 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1791 case DT_PPC64_OPT
: return "PPC64_OPT";
1798 get_parisc_dynamic_type (unsigned long type
)
1802 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1803 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1804 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1805 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1806 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1807 case DT_HP_PREINIT
: return "HP_PREINIT";
1808 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1809 case DT_HP_NEEDED
: return "HP_NEEDED";
1810 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1811 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1812 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1813 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1814 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1815 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1816 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1817 case DT_HP_FILTERED
: return "HP_FILTERED";
1818 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1819 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1820 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1821 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1822 case DT_PLT
: return "PLT";
1823 case DT_PLT_SIZE
: return "PLT_SIZE";
1824 case DT_DLT
: return "DLT";
1825 case DT_DLT_SIZE
: return "DLT_SIZE";
1832 get_ia64_dynamic_type (unsigned long type
)
1836 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1837 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1838 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1839 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1840 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1841 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1842 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1843 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1844 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1845 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1846 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1847 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1848 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1849 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1850 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1851 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1852 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1853 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1854 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1855 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1856 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1857 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1858 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1859 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1860 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1861 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1862 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1863 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1864 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1865 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1866 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1873 get_solaris_section_type (unsigned long type
)
1877 case 0x6fffffee: return "SUNW_ancillary";
1878 case 0x6fffffef: return "SUNW_capchain";
1879 case 0x6ffffff0: return "SUNW_capinfo";
1880 case 0x6ffffff1: return "SUNW_symsort";
1881 case 0x6ffffff2: return "SUNW_tlssort";
1882 case 0x6ffffff3: return "SUNW_LDYNSYM";
1883 case 0x6ffffff4: return "SUNW_dof";
1884 case 0x6ffffff5: return "SUNW_cap";
1885 case 0x6ffffff6: return "SUNW_SIGNATURE";
1886 case 0x6ffffff7: return "SUNW_ANNOTATE";
1887 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1888 case 0x6ffffff9: return "SUNW_DEBUG";
1889 case 0x6ffffffa: return "SUNW_move";
1890 case 0x6ffffffb: return "SUNW_COMDAT";
1891 case 0x6ffffffc: return "SUNW_syminfo";
1892 case 0x6ffffffd: return "SUNW_verdef";
1893 case 0x6ffffffe: return "SUNW_verneed";
1894 case 0x6fffffff: return "SUNW_versym";
1895 case 0x70000000: return "SPARC_GOTDATA";
1896 default: return NULL
;
1901 get_alpha_dynamic_type (unsigned long type
)
1905 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1912 get_score_dynamic_type (unsigned long type
)
1916 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1917 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1918 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1919 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1920 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1921 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1928 get_tic6x_dynamic_type (unsigned long type
)
1932 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1933 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1934 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1935 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1936 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1937 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1944 get_nios2_dynamic_type (unsigned long type
)
1948 case DT_NIOS2_GP
: return "NIOS2_GP";
1955 get_solaris_dynamic_type (unsigned long type
)
1959 case 0x6000000d: return "SUNW_AUXILIARY";
1960 case 0x6000000e: return "SUNW_RTLDINF";
1961 case 0x6000000f: return "SUNW_FILTER";
1962 case 0x60000010: return "SUNW_CAP";
1963 case 0x60000011: return "SUNW_SYMTAB";
1964 case 0x60000012: return "SUNW_SYMSZ";
1965 case 0x60000013: return "SUNW_SORTENT";
1966 case 0x60000014: return "SUNW_SYMSORT";
1967 case 0x60000015: return "SUNW_SYMSORTSZ";
1968 case 0x60000016: return "SUNW_TLSSORT";
1969 case 0x60000017: return "SUNW_TLSSORTSZ";
1970 case 0x60000018: return "SUNW_CAPINFO";
1971 case 0x60000019: return "SUNW_STRPAD";
1972 case 0x6000001a: return "SUNW_CAPCHAIN";
1973 case 0x6000001b: return "SUNW_LDMACH";
1974 case 0x6000001d: return "SUNW_CAPCHAINENT";
1975 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1976 case 0x60000021: return "SUNW_PARENT";
1977 case 0x60000023: return "SUNW_ASLR";
1978 case 0x60000025: return "SUNW_RELAX";
1979 case 0x60000029: return "SUNW_NXHEAP";
1980 case 0x6000002b: return "SUNW_NXSTACK";
1982 case 0x70000001: return "SPARC_REGISTER";
1983 case 0x7ffffffd: return "AUXILIARY";
1984 case 0x7ffffffe: return "USED";
1985 case 0x7fffffff: return "FILTER";
1987 default: return NULL
;
1992 get_dynamic_type (unsigned long type
)
1994 static char buff
[64];
1998 case DT_NULL
: return "NULL";
1999 case DT_NEEDED
: return "NEEDED";
2000 case DT_PLTRELSZ
: return "PLTRELSZ";
2001 case DT_PLTGOT
: return "PLTGOT";
2002 case DT_HASH
: return "HASH";
2003 case DT_STRTAB
: return "STRTAB";
2004 case DT_SYMTAB
: return "SYMTAB";
2005 case DT_RELA
: return "RELA";
2006 case DT_RELASZ
: return "RELASZ";
2007 case DT_RELAENT
: return "RELAENT";
2008 case DT_STRSZ
: return "STRSZ";
2009 case DT_SYMENT
: return "SYMENT";
2010 case DT_INIT
: return "INIT";
2011 case DT_FINI
: return "FINI";
2012 case DT_SONAME
: return "SONAME";
2013 case DT_RPATH
: return "RPATH";
2014 case DT_SYMBOLIC
: return "SYMBOLIC";
2015 case DT_REL
: return "REL";
2016 case DT_RELSZ
: return "RELSZ";
2017 case DT_RELENT
: return "RELENT";
2018 case DT_PLTREL
: return "PLTREL";
2019 case DT_DEBUG
: return "DEBUG";
2020 case DT_TEXTREL
: return "TEXTREL";
2021 case DT_JMPREL
: return "JMPREL";
2022 case DT_BIND_NOW
: return "BIND_NOW";
2023 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2024 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2025 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2026 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2027 case DT_RUNPATH
: return "RUNPATH";
2028 case DT_FLAGS
: return "FLAGS";
2030 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2031 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2032 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2034 case DT_CHECKSUM
: return "CHECKSUM";
2035 case DT_PLTPADSZ
: return "PLTPADSZ";
2036 case DT_MOVEENT
: return "MOVEENT";
2037 case DT_MOVESZ
: return "MOVESZ";
2038 case DT_FEATURE
: return "FEATURE";
2039 case DT_POSFLAG_1
: return "POSFLAG_1";
2040 case DT_SYMINSZ
: return "SYMINSZ";
2041 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2043 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2044 case DT_CONFIG
: return "CONFIG";
2045 case DT_DEPAUDIT
: return "DEPAUDIT";
2046 case DT_AUDIT
: return "AUDIT";
2047 case DT_PLTPAD
: return "PLTPAD";
2048 case DT_MOVETAB
: return "MOVETAB";
2049 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2051 case DT_VERSYM
: return "VERSYM";
2053 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2054 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2055 case DT_RELACOUNT
: return "RELACOUNT";
2056 case DT_RELCOUNT
: return "RELCOUNT";
2057 case DT_FLAGS_1
: return "FLAGS_1";
2058 case DT_VERDEF
: return "VERDEF";
2059 case DT_VERDEFNUM
: return "VERDEFNUM";
2060 case DT_VERNEED
: return "VERNEED";
2061 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2063 case DT_AUXILIARY
: return "AUXILIARY";
2064 case DT_USED
: return "USED";
2065 case DT_FILTER
: return "FILTER";
2067 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2068 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2069 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2070 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2071 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2072 case DT_GNU_HASH
: return "GNU_HASH";
2075 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2077 const char * result
;
2079 switch (elf_header
.e_machine
)
2082 case EM_MIPS_RS3_LE
:
2083 result
= get_mips_dynamic_type (type
);
2086 result
= get_sparc64_dynamic_type (type
);
2089 result
= get_ppc_dynamic_type (type
);
2092 result
= get_ppc64_dynamic_type (type
);
2095 result
= get_ia64_dynamic_type (type
);
2098 result
= get_alpha_dynamic_type (type
);
2101 result
= get_score_dynamic_type (type
);
2104 result
= get_tic6x_dynamic_type (type
);
2106 case EM_ALTERA_NIOS2
:
2107 result
= get_nios2_dynamic_type (type
);
2110 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2111 result
= get_solaris_dynamic_type (type
);
2120 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2122 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2123 || (elf_header
.e_machine
== EM_PARISC
2124 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2126 const char * result
;
2128 switch (elf_header
.e_machine
)
2131 result
= get_parisc_dynamic_type (type
);
2134 result
= get_ia64_dynamic_type (type
);
2137 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2138 result
= get_solaris_dynamic_type (type
);
2147 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2151 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2158 get_file_type (unsigned e_type
)
2160 static char buff
[32];
2164 case ET_NONE
: return _("NONE (None)");
2165 case ET_REL
: return _("REL (Relocatable file)");
2166 case ET_EXEC
: return _("EXEC (Executable file)");
2167 case ET_DYN
: return _("DYN (Shared object file)");
2168 case ET_CORE
: return _("CORE (Core file)");
2171 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2172 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2173 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2174 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2176 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2182 get_machine_name (unsigned e_machine
)
2184 static char buff
[64]; /* XXX */
2188 case EM_NONE
: return _("None");
2189 case EM_AARCH64
: return "AArch64";
2190 case EM_M32
: return "WE32100";
2191 case EM_SPARC
: return "Sparc";
2192 case EM_SPU
: return "SPU";
2193 case EM_386
: return "Intel 80386";
2194 case EM_68K
: return "MC68000";
2195 case EM_88K
: return "MC88000";
2196 case EM_IAMCU
: return "Intel MCU";
2197 case EM_860
: return "Intel 80860";
2198 case EM_MIPS
: return "MIPS R3000";
2199 case EM_S370
: return "IBM System/370";
2200 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2201 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2202 case EM_PARISC
: return "HPPA";
2203 case EM_PPC_OLD
: return "Power PC (old)";
2204 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2205 case EM_960
: return "Intel 90860";
2206 case EM_PPC
: return "PowerPC";
2207 case EM_PPC64
: return "PowerPC64";
2208 case EM_FR20
: return "Fujitsu FR20";
2209 case EM_FT32
: return "FTDI FT32";
2210 case EM_RH32
: return "TRW RH32";
2211 case EM_MCORE
: return "MCORE";
2212 case EM_ARM
: return "ARM";
2213 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2214 case EM_SH
: return "Renesas / SuperH SH";
2215 case EM_SPARCV9
: return "Sparc v9";
2216 case EM_TRICORE
: return "Siemens Tricore";
2217 case EM_ARC
: return "ARC";
2218 case EM_ARC_COMPACT
: return "ARCompact";
2219 case EM_ARC_COMPACT2
: return "ARCv2";
2220 case EM_H8_300
: return "Renesas H8/300";
2221 case EM_H8_300H
: return "Renesas H8/300H";
2222 case EM_H8S
: return "Renesas H8S";
2223 case EM_H8_500
: return "Renesas H8/500";
2224 case EM_IA_64
: return "Intel IA-64";
2225 case EM_MIPS_X
: return "Stanford MIPS-X";
2226 case EM_COLDFIRE
: return "Motorola Coldfire";
2227 case EM_ALPHA
: return "Alpha";
2228 case EM_CYGNUS_D10V
:
2229 case EM_D10V
: return "d10v";
2230 case EM_CYGNUS_D30V
:
2231 case EM_D30V
: return "d30v";
2232 case EM_CYGNUS_M32R
:
2233 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2234 case EM_CYGNUS_V850
:
2235 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2236 case EM_V850
: return "Renesas V850";
2237 case EM_CYGNUS_MN10300
:
2238 case EM_MN10300
: return "mn10300";
2239 case EM_CYGNUS_MN10200
:
2240 case EM_MN10200
: return "mn10200";
2241 case EM_MOXIE
: return "Moxie";
2242 case EM_CYGNUS_FR30
:
2243 case EM_FR30
: return "Fujitsu FR30";
2244 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2246 case EM_PJ
: return "picoJava";
2247 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2248 case EM_PCP
: return "Siemens PCP";
2249 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2250 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2251 case EM_STARCORE
: return "Motorola Star*Core processor";
2252 case EM_ME16
: return "Toyota ME16 processor";
2253 case EM_ST100
: return "STMicroelectronics ST100 processor";
2254 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2255 case EM_PDSP
: return "Sony DSP processor";
2256 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2257 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2258 case EM_FX66
: return "Siemens FX66 microcontroller";
2259 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2260 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2261 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2262 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2263 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2264 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2265 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2266 case EM_SVX
: return "Silicon Graphics SVx";
2267 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2268 case EM_VAX
: return "Digital VAX";
2269 case EM_VISIUM
: return "CDS VISIUMcore processor";
2271 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2272 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2273 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2274 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2275 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2276 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2277 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2278 case EM_PRISM
: return "Vitesse Prism";
2279 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2280 case EM_L1OM
: return "Intel L1OM";
2281 case EM_K1OM
: return "Intel K1OM";
2283 case EM_S390
: return "IBM S/390";
2284 case EM_SCORE
: return "SUNPLUS S+Core";
2285 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2286 case EM_OR1K
: return "OpenRISC 1000";
2287 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2288 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2289 case EM_DLX
: return "OpenDLX";
2291 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2292 case EM_IQ2000
: return "Vitesse IQ2000";
2294 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2295 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2296 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2297 case EM_NS32K
: return "National Semiconductor 32000 series";
2298 case EM_TPC
: return "Tenor Network TPC processor";
2299 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2300 case EM_MAX
: return "MAX Processor";
2301 case EM_CR
: return "National Semiconductor CompactRISC";
2302 case EM_F2MC16
: return "Fujitsu F2MC16";
2303 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2304 case EM_LATTICEMICO32
: return "Lattice Mico32";
2306 case EM_M32C
: return "Renesas M32c";
2307 case EM_MT
: return "Morpho Techologies MT processor";
2308 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2309 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2310 case EM_SEP
: return "Sharp embedded microprocessor";
2311 case EM_ARCA
: return "Arca RISC microprocessor";
2312 case EM_UNICORE
: return "Unicore";
2313 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2314 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2315 case EM_NIOS32
: return "Altera Nios";
2316 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2318 case EM_XC16X
: return "Infineon Technologies xc16x";
2319 case EM_M16C
: return "Renesas M16C series microprocessors";
2320 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2321 case EM_CE
: return "Freescale Communication Engine RISC core";
2322 case EM_TSK3000
: return "Altium TSK3000 core";
2323 case EM_RS08
: return "Freescale RS08 embedded processor";
2324 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2325 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2326 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2327 case EM_SE_C17
: return "Seiko Epson C17 family";
2328 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2329 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2330 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2331 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2332 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2333 case EM_R32C
: return "Renesas R32C series microprocessors";
2334 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2335 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2336 case EM_8051
: return "Intel 8051 and variants";
2337 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2338 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2339 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2340 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2341 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2342 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2343 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2344 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2347 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2348 case EM_RISCV
: return "RISC-V";
2349 case EM_RL78
: return "Renesas RL78";
2350 case EM_RX
: return "Renesas RX";
2351 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2352 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2353 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2354 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2355 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2356 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2357 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2358 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2359 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2360 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2361 case EM_CUDA
: return "NVIDIA CUDA architecture";
2362 case EM_XGATE
: return "Motorola XGATE embedded processor";
2363 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2364 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2365 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2366 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2367 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2368 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2369 case EM_BA1
: return "Beyond BA1 CPU architecture";
2370 case EM_BA2
: return "Beyond BA2 CPU architecture";
2371 case EM_XCORE
: return "XMOS xCORE processor family";
2372 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2373 case EM_KM32
: return "KM211 KM32 32-bit processor";
2374 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2375 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2376 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2377 case EM_KVARC
: return "KM211 KVARC processor";
2378 case EM_CDP
: return "Paneve CDP architecture family";
2379 case EM_COGE
: return "Cognitive Smart Memory Processor";
2380 case EM_COOL
: return "Bluechip Systems CoolEngine";
2381 case EM_NORC
: return "Nanoradio Optimized RISC";
2382 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2383 case EM_Z80
: return "Zilog Z80";
2384 case EM_AMDGPU
: return "AMD GPU architecture";
2385 case EM_TI_PRU
: return "TI PRU I/O processor";
2387 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2393 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2395 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2396 other compilers don't a specific architecture type in the e_flags, and
2397 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2398 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2401 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2402 but also sets a specific architecture type in the e_flags field.
2404 However, when decoding the flags we don't worry if we see an
2405 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2406 ARCEM architecture type. */
2408 switch (e_flags
& EF_ARC_MACH_MSK
)
2410 /* We only expect these to occur for EM_ARC_COMPACT2. */
2411 case EF_ARC_CPU_ARCV2EM
:
2412 strcat (buf
, ", ARC EM");
2414 case EF_ARC_CPU_ARCV2HS
:
2415 strcat (buf
, ", ARC HS");
2418 /* We only expect these to occur for EM_ARC_COMPACT. */
2419 case E_ARC_MACH_ARC600
:
2420 strcat (buf
, ", ARC600");
2422 case E_ARC_MACH_ARC601
:
2423 strcat (buf
, ", ARC601");
2425 case E_ARC_MACH_ARC700
:
2426 strcat (buf
, ", ARC700");
2429 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2430 new ELF with new architecture being read by an old version of
2431 readelf, or (c) An ELF built with non-GNU compiler that does not
2432 set the architecture in the e_flags. */
2434 if (e_machine
== EM_ARC_COMPACT
)
2435 strcat (buf
, ", Unknown ARCompact");
2437 strcat (buf
, ", Unknown ARC");
2441 switch (e_flags
& EF_ARC_OSABI_MSK
)
2443 case E_ARC_OSABI_ORIG
:
2444 strcat (buf
, ", (ABI:legacy)");
2446 case E_ARC_OSABI_V2
:
2447 strcat (buf
, ", (ABI:v2)");
2449 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2450 case E_ARC_OSABI_V3
:
2451 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2454 strcat (buf
, ", unrecognised ARC OSABI flag");
2460 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2465 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2466 e_flags
&= ~ EF_ARM_EABIMASK
;
2468 /* Handle "generic" ARM flags. */
2469 if (e_flags
& EF_ARM_RELEXEC
)
2471 strcat (buf
, ", relocatable executable");
2472 e_flags
&= ~ EF_ARM_RELEXEC
;
2475 /* Now handle EABI specific flags. */
2479 strcat (buf
, ", <unrecognized EABI>");
2484 case EF_ARM_EABI_VER1
:
2485 strcat (buf
, ", Version1 EABI");
2490 /* Process flags one bit at a time. */
2491 flag
= e_flags
& - e_flags
;
2496 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2497 strcat (buf
, ", sorted symbol tables");
2507 case EF_ARM_EABI_VER2
:
2508 strcat (buf
, ", Version2 EABI");
2513 /* Process flags one bit at a time. */
2514 flag
= e_flags
& - e_flags
;
2519 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2520 strcat (buf
, ", sorted symbol tables");
2523 case EF_ARM_DYNSYMSUSESEGIDX
:
2524 strcat (buf
, ", dynamic symbols use segment index");
2527 case EF_ARM_MAPSYMSFIRST
:
2528 strcat (buf
, ", mapping symbols precede others");
2538 case EF_ARM_EABI_VER3
:
2539 strcat (buf
, ", Version3 EABI");
2542 case EF_ARM_EABI_VER4
:
2543 strcat (buf
, ", Version4 EABI");
2548 /* Process flags one bit at a time. */
2549 flag
= e_flags
& - e_flags
;
2555 strcat (buf
, ", BE8");
2559 strcat (buf
, ", LE8");
2570 case EF_ARM_EABI_VER5
:
2571 strcat (buf
, ", Version5 EABI");
2576 /* Process flags one bit at a time. */
2577 flag
= e_flags
& - e_flags
;
2583 strcat (buf
, ", BE8");
2587 strcat (buf
, ", LE8");
2590 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2591 strcat (buf
, ", soft-float ABI");
2594 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2595 strcat (buf
, ", hard-float ABI");
2605 case EF_ARM_EABI_UNKNOWN
:
2606 strcat (buf
, ", GNU EABI");
2611 /* Process flags one bit at a time. */
2612 flag
= e_flags
& - e_flags
;
2617 case EF_ARM_INTERWORK
:
2618 strcat (buf
, ", interworking enabled");
2621 case EF_ARM_APCS_26
:
2622 strcat (buf
, ", uses APCS/26");
2625 case EF_ARM_APCS_FLOAT
:
2626 strcat (buf
, ", uses APCS/float");
2630 strcat (buf
, ", position independent");
2634 strcat (buf
, ", 8 bit structure alignment");
2637 case EF_ARM_NEW_ABI
:
2638 strcat (buf
, ", uses new ABI");
2641 case EF_ARM_OLD_ABI
:
2642 strcat (buf
, ", uses old ABI");
2645 case EF_ARM_SOFT_FLOAT
:
2646 strcat (buf
, ", software FP");
2649 case EF_ARM_VFP_FLOAT
:
2650 strcat (buf
, ", VFP");
2653 case EF_ARM_MAVERICK_FLOAT
:
2654 strcat (buf
, ", Maverick FP");
2665 strcat (buf
,_(", <unknown>"));
2669 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2671 --size
; /* Leave space for null terminator. */
2673 switch (e_flags
& EF_AVR_MACH
)
2675 case E_AVR_MACH_AVR1
:
2676 strncat (buf
, ", avr:1", size
);
2678 case E_AVR_MACH_AVR2
:
2679 strncat (buf
, ", avr:2", size
);
2681 case E_AVR_MACH_AVR25
:
2682 strncat (buf
, ", avr:25", size
);
2684 case E_AVR_MACH_AVR3
:
2685 strncat (buf
, ", avr:3", size
);
2687 case E_AVR_MACH_AVR31
:
2688 strncat (buf
, ", avr:31", size
);
2690 case E_AVR_MACH_AVR35
:
2691 strncat (buf
, ", avr:35", size
);
2693 case E_AVR_MACH_AVR4
:
2694 strncat (buf
, ", avr:4", size
);
2696 case E_AVR_MACH_AVR5
:
2697 strncat (buf
, ", avr:5", size
);
2699 case E_AVR_MACH_AVR51
:
2700 strncat (buf
, ", avr:51", size
);
2702 case E_AVR_MACH_AVR6
:
2703 strncat (buf
, ", avr:6", size
);
2705 case E_AVR_MACH_AVRTINY
:
2706 strncat (buf
, ", avr:100", size
);
2708 case E_AVR_MACH_XMEGA1
:
2709 strncat (buf
, ", avr:101", size
);
2711 case E_AVR_MACH_XMEGA2
:
2712 strncat (buf
, ", avr:102", size
);
2714 case E_AVR_MACH_XMEGA3
:
2715 strncat (buf
, ", avr:103", size
);
2717 case E_AVR_MACH_XMEGA4
:
2718 strncat (buf
, ", avr:104", size
);
2720 case E_AVR_MACH_XMEGA5
:
2721 strncat (buf
, ", avr:105", size
);
2723 case E_AVR_MACH_XMEGA6
:
2724 strncat (buf
, ", avr:106", size
);
2726 case E_AVR_MACH_XMEGA7
:
2727 strncat (buf
, ", avr:107", size
);
2730 strncat (buf
, ", avr:<unknown>", size
);
2734 size
-= strlen (buf
);
2735 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2736 strncat (buf
, ", link-relax", size
);
2740 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2749 static const char *ABI_STRINGS
[] =
2751 "ABI v0", /* use r5 as return register; only used in N1213HC */
2752 "ABI v1", /* use r0 as return register */
2753 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2754 "ABI v2fp", /* for FPU */
2758 static const char *VER_STRINGS
[] =
2760 "Andes ELF V1.3 or older",
2764 static const char *ARCH_STRINGS
[] =
2773 abi
= EF_NDS_ABI
& e_flags
;
2774 arch
= EF_NDS_ARCH
& e_flags
;
2775 config
= EF_NDS_INST
& e_flags
;
2776 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2778 memset (buf
, 0, size
);
2785 case E_NDS_ABI_V2FP
:
2786 case E_NDS_ABI_AABI
:
2787 case E_NDS_ABI_V2FP_PLUS
:
2788 /* In case there are holes in the array. */
2789 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2793 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2799 case E_NDS32_ELF_VER_1_2
:
2800 case E_NDS32_ELF_VER_1_3
:
2801 case E_NDS32_ELF_VER_1_4
:
2802 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2806 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2810 if (E_NDS_ABI_V0
== abi
)
2812 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2813 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2814 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2815 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2821 case E_NDS_ARCH_STAR_V1_0
:
2822 case E_NDS_ARCH_STAR_V2_0
:
2823 case E_NDS_ARCH_STAR_V3_0
:
2824 case E_NDS_ARCH_STAR_V3_M
:
2825 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2829 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2830 /* ARCH version determines how the e_flags are interpreted.
2831 If it is unknown, we cannot proceed. */
2835 /* Newer ABI; Now handle architecture specific flags. */
2836 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2838 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2839 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2841 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2842 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2844 if (config
& E_NDS32_HAS_DIV_INST
)
2845 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2847 if (config
& E_NDS32_HAS_16BIT_INST
)
2848 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2852 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2854 if (version
<= E_NDS32_ELF_VER_1_3
)
2855 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2857 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2860 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2861 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2863 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2864 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2866 if (config
& E_NDS32_HAS_16BIT_INST
)
2868 if (version
<= E_NDS32_ELF_VER_1_3
)
2869 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2871 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2875 if (config
& E_NDS32_HAS_EXT_INST
)
2876 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2878 if (config
& E_NDS32_HAS_EXT2_INST
)
2879 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2881 if (config
& E_NDS32_HAS_FPU_INST
)
2884 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2887 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2890 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2893 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2901 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2903 case E_NDS32_FPU_REG_8SP_4DP
:
2904 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2906 case E_NDS32_FPU_REG_16SP_8DP
:
2907 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2909 case E_NDS32_FPU_REG_32SP_16DP
:
2910 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2912 case E_NDS32_FPU_REG_32SP_32DP
:
2913 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2918 if (config
& E_NDS32_HAS_AUDIO_INST
)
2919 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2921 if (config
& E_NDS32_HAS_STRING_INST
)
2922 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2924 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2925 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2927 if (config
& E_NDS32_HAS_VIDEO_INST
)
2929 if (version
<= E_NDS32_ELF_VER_1_3
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2932 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2935 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2938 if (config
& E_NDS32_HAS_L2C_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2943 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2945 static char buf
[1024];
2956 case EM_ARC_COMPACT2
:
2957 case EM_ARC_COMPACT
:
2958 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2962 decode_ARM_machine_flags (e_flags
, buf
);
2966 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2970 if (e_flags
& EF_BFIN_PIC
)
2971 strcat (buf
, ", PIC");
2973 if (e_flags
& EF_BFIN_FDPIC
)
2974 strcat (buf
, ", FDPIC");
2976 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2977 strcat (buf
, ", code in L1");
2979 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2980 strcat (buf
, ", data in L1");
2985 switch (e_flags
& EF_FRV_CPU_MASK
)
2987 case EF_FRV_CPU_GENERIC
:
2991 strcat (buf
, ", fr???");
2994 case EF_FRV_CPU_FR300
:
2995 strcat (buf
, ", fr300");
2998 case EF_FRV_CPU_FR400
:
2999 strcat (buf
, ", fr400");
3001 case EF_FRV_CPU_FR405
:
3002 strcat (buf
, ", fr405");
3005 case EF_FRV_CPU_FR450
:
3006 strcat (buf
, ", fr450");
3009 case EF_FRV_CPU_FR500
:
3010 strcat (buf
, ", fr500");
3012 case EF_FRV_CPU_FR550
:
3013 strcat (buf
, ", fr550");
3016 case EF_FRV_CPU_SIMPLE
:
3017 strcat (buf
, ", simple");
3019 case EF_FRV_CPU_TOMCAT
:
3020 strcat (buf
, ", tomcat");
3026 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3027 strcat (buf
, ", m68000");
3028 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3029 strcat (buf
, ", cpu32");
3030 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3031 strcat (buf
, ", fido_a");
3034 char const * isa
= _("unknown");
3035 char const * mac
= _("unknown mac");
3036 char const * additional
= NULL
;
3038 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3040 case EF_M68K_CF_ISA_A_NODIV
:
3042 additional
= ", nodiv";
3044 case EF_M68K_CF_ISA_A
:
3047 case EF_M68K_CF_ISA_A_PLUS
:
3050 case EF_M68K_CF_ISA_B_NOUSP
:
3052 additional
= ", nousp";
3054 case EF_M68K_CF_ISA_B
:
3057 case EF_M68K_CF_ISA_C
:
3060 case EF_M68K_CF_ISA_C_NODIV
:
3062 additional
= ", nodiv";
3065 strcat (buf
, ", cf, isa ");
3068 strcat (buf
, additional
);
3069 if (e_flags
& EF_M68K_CF_FLOAT
)
3070 strcat (buf
, ", float");
3071 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3076 case EF_M68K_CF_MAC
:
3079 case EF_M68K_CF_EMAC
:
3082 case EF_M68K_CF_EMAC_B
:
3095 switch (e_flags
& EF_MEP_CPU_MASK
)
3097 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3098 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3099 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3100 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3101 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3102 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3103 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3106 switch (e_flags
& EF_MEP_COP_MASK
)
3108 case EF_MEP_COP_NONE
: break;
3109 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3110 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3111 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3112 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3113 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3116 if (e_flags
& EF_MEP_LIBRARY
)
3117 strcat (buf
, ", Built for Library");
3119 if (e_flags
& EF_MEP_INDEX_MASK
)
3120 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3121 e_flags
& EF_MEP_INDEX_MASK
);
3123 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3124 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3125 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3129 if (e_flags
& EF_PPC_EMB
)
3130 strcat (buf
, ", emb");
3132 if (e_flags
& EF_PPC_RELOCATABLE
)
3133 strcat (buf
, _(", relocatable"));
3135 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3136 strcat (buf
, _(", relocatable-lib"));
3140 if (e_flags
& EF_PPC64_ABI
)
3142 char abi
[] = ", abiv0";
3144 abi
[6] += e_flags
& EF_PPC64_ABI
;
3150 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3151 strcat (buf
, ", RH850 ABI");
3153 if (e_flags
& EF_V800_850E3
)
3154 strcat (buf
, ", V3 architecture");
3156 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3157 strcat (buf
, ", FPU not used");
3159 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3160 strcat (buf
, ", regmode: COMMON");
3162 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3163 strcat (buf
, ", r4 not used");
3165 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3166 strcat (buf
, ", r30 not used");
3168 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3169 strcat (buf
, ", r5 not used");
3171 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3172 strcat (buf
, ", r2 not used");
3174 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3176 switch (e_flags
& - e_flags
)
3178 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3179 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3180 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3181 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3182 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3183 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3184 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3185 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3186 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3187 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3188 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3189 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3196 case EM_CYGNUS_V850
:
3197 switch (e_flags
& EF_V850_ARCH
)
3199 case E_V850E3V5_ARCH
:
3200 strcat (buf
, ", v850e3v5");
3202 case E_V850E2V3_ARCH
:
3203 strcat (buf
, ", v850e2v3");
3206 strcat (buf
, ", v850e2");
3209 strcat (buf
, ", v850e1");
3212 strcat (buf
, ", v850e");
3215 strcat (buf
, ", v850");
3218 strcat (buf
, _(", unknown v850 architecture variant"));
3224 case EM_CYGNUS_M32R
:
3225 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3226 strcat (buf
, ", m32r");
3230 case EM_MIPS_RS3_LE
:
3231 if (e_flags
& EF_MIPS_NOREORDER
)
3232 strcat (buf
, ", noreorder");
3234 if (e_flags
& EF_MIPS_PIC
)
3235 strcat (buf
, ", pic");
3237 if (e_flags
& EF_MIPS_CPIC
)
3238 strcat (buf
, ", cpic");
3240 if (e_flags
& EF_MIPS_UCODE
)
3241 strcat (buf
, ", ugen_reserved");
3243 if (e_flags
& EF_MIPS_ABI2
)
3244 strcat (buf
, ", abi2");
3246 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3247 strcat (buf
, ", odk first");
3249 if (e_flags
& EF_MIPS_32BITMODE
)
3250 strcat (buf
, ", 32bitmode");
3252 if (e_flags
& EF_MIPS_NAN2008
)
3253 strcat (buf
, ", nan2008");
3255 if (e_flags
& EF_MIPS_FP64
)
3256 strcat (buf
, ", fp64");
3258 switch ((e_flags
& EF_MIPS_MACH
))
3260 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3261 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3262 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3263 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3264 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3265 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3266 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3267 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3268 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3269 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3270 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3271 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3272 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3273 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3274 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3275 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3276 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3278 /* We simply ignore the field in this case to avoid confusion:
3279 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3282 default: strcat (buf
, _(", unknown CPU")); break;
3285 switch ((e_flags
& EF_MIPS_ABI
))
3287 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3288 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3289 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3290 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3292 /* We simply ignore the field in this case to avoid confusion:
3293 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3294 This means it is likely to be an o32 file, but not for
3297 default: strcat (buf
, _(", unknown ABI")); break;
3300 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3301 strcat (buf
, ", mdmx");
3303 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3304 strcat (buf
, ", mips16");
3306 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3307 strcat (buf
, ", micromips");
3309 switch ((e_flags
& EF_MIPS_ARCH
))
3311 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3312 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3313 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3314 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3315 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3316 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3317 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3318 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3319 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3320 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3321 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3322 default: strcat (buf
, _(", unknown ISA")); break;
3327 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3331 if (e_flags
& EF_RISCV_RVC
)
3332 strcat (buf
, ", RVC");
3334 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3336 case EF_RISCV_FLOAT_ABI_SOFT
:
3337 strcat (buf
, ", soft-float ABI");
3340 case EF_RISCV_FLOAT_ABI_SINGLE
:
3341 strcat (buf
, ", single-float ABI");
3344 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3345 strcat (buf
, ", double-float ABI");
3348 case EF_RISCV_FLOAT_ABI_QUAD
:
3349 strcat (buf
, ", quad-float ABI");
3355 switch ((e_flags
& EF_SH_MACH_MASK
))
3357 case EF_SH1
: strcat (buf
, ", sh1"); break;
3358 case EF_SH2
: strcat (buf
, ", sh2"); break;
3359 case EF_SH3
: strcat (buf
, ", sh3"); break;
3360 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3361 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3362 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3363 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3364 case EF_SH4
: strcat (buf
, ", sh4"); break;
3365 case EF_SH5
: strcat (buf
, ", sh5"); break;
3366 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3367 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3368 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3369 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3370 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3371 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3372 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3373 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3374 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3375 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3376 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3377 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3378 default: strcat (buf
, _(", unknown ISA")); break;
3381 if (e_flags
& EF_SH_PIC
)
3382 strcat (buf
, ", pic");
3384 if (e_flags
& EF_SH_FDPIC
)
3385 strcat (buf
, ", fdpic");
3389 if (e_flags
& EF_OR1K_NODELAY
)
3390 strcat (buf
, ", no delay");
3394 if (e_flags
& EF_SPARC_32PLUS
)
3395 strcat (buf
, ", v8+");
3397 if (e_flags
& EF_SPARC_SUN_US1
)
3398 strcat (buf
, ", ultrasparcI");
3400 if (e_flags
& EF_SPARC_SUN_US3
)
3401 strcat (buf
, ", ultrasparcIII");
3403 if (e_flags
& EF_SPARC_HAL_R1
)
3404 strcat (buf
, ", halr1");
3406 if (e_flags
& EF_SPARC_LEDATA
)
3407 strcat (buf
, ", ledata");
3409 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3410 strcat (buf
, ", tso");
3412 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3413 strcat (buf
, ", pso");
3415 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3416 strcat (buf
, ", rmo");
3420 switch (e_flags
& EF_PARISC_ARCH
)
3422 case EFA_PARISC_1_0
:
3423 strcpy (buf
, ", PA-RISC 1.0");
3425 case EFA_PARISC_1_1
:
3426 strcpy (buf
, ", PA-RISC 1.1");
3428 case EFA_PARISC_2_0
:
3429 strcpy (buf
, ", PA-RISC 2.0");
3434 if (e_flags
& EF_PARISC_TRAPNIL
)
3435 strcat (buf
, ", trapnil");
3436 if (e_flags
& EF_PARISC_EXT
)
3437 strcat (buf
, ", ext");
3438 if (e_flags
& EF_PARISC_LSB
)
3439 strcat (buf
, ", lsb");
3440 if (e_flags
& EF_PARISC_WIDE
)
3441 strcat (buf
, ", wide");
3442 if (e_flags
& EF_PARISC_NO_KABP
)
3443 strcat (buf
, ", no kabp");
3444 if (e_flags
& EF_PARISC_LAZYSWAP
)
3445 strcat (buf
, ", lazyswap");
3450 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3451 strcat (buf
, ", new calling convention");
3453 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3454 strcat (buf
, ", gnu calling convention");
3458 if ((e_flags
& EF_IA_64_ABI64
))
3459 strcat (buf
, ", 64-bit");
3461 strcat (buf
, ", 32-bit");
3462 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3463 strcat (buf
, ", reduced fp model");
3464 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3465 strcat (buf
, ", no function descriptors, constant gp");
3466 else if ((e_flags
& EF_IA_64_CONS_GP
))
3467 strcat (buf
, ", constant gp");
3468 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3469 strcat (buf
, ", absolute");
3470 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3472 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3473 strcat (buf
, ", vms_linkages");
3474 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3476 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3478 case EF_IA_64_VMS_COMCOD_WARNING
:
3479 strcat (buf
, ", warning");
3481 case EF_IA_64_VMS_COMCOD_ERROR
:
3482 strcat (buf
, ", error");
3484 case EF_IA_64_VMS_COMCOD_ABORT
:
3485 strcat (buf
, ", abort");
3488 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3489 e_flags
& EF_IA_64_VMS_COMCOD
);
3490 strcat (buf
, ", <unknown>");
3496 if ((e_flags
& EF_VAX_NONPIC
))
3497 strcat (buf
, ", non-PIC");
3498 if ((e_flags
& EF_VAX_DFLOAT
))
3499 strcat (buf
, ", D-Float");
3500 if ((e_flags
& EF_VAX_GFLOAT
))
3501 strcat (buf
, ", G-Float");
3505 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3506 strcat (buf
, ", mcm");
3507 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3508 strcat (buf
, ", mcm24");
3509 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3510 strcat (buf
, ", gr6");
3514 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3516 case E_FLAG_RL78_ANY_CPU
: break;
3517 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3518 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3519 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3521 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3522 strcat (buf
, ", 64-bit doubles");
3526 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3527 strcat (buf
, ", 64-bit doubles");
3528 if (e_flags
& E_FLAG_RX_DSP
)
3529 strcat (buf
, ", dsp");
3530 if (e_flags
& E_FLAG_RX_PID
)
3531 strcat (buf
, ", pid");
3532 if (e_flags
& E_FLAG_RX_ABI
)
3533 strcat (buf
, ", RX ABI");
3534 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3535 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3536 ? ", uses String instructions" : ", bans String instructions");
3537 if (e_flags
& E_FLAG_RX_V2
)
3538 strcat (buf
, ", V2");
3542 if (e_flags
& EF_S390_HIGH_GPRS
)
3543 strcat (buf
, ", highgprs");
3547 if ((e_flags
& EF_C6000_REL
))
3548 strcat (buf
, ", relocatable module");
3552 strcat (buf
, _(": architecture variant: "));
3553 switch (e_flags
& EF_MSP430_MACH
)
3555 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3556 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3557 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3558 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3559 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3560 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3561 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3562 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3563 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3564 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3565 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3566 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3567 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3568 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3569 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3571 strcat (buf
, _(": unknown")); break;
3574 if (e_flags
& ~ EF_MSP430_MACH
)
3575 strcat (buf
, _(": unknown extra flag bits also present"));
3583 get_osabi_name (unsigned int osabi
)
3585 static char buff
[32];
3589 case ELFOSABI_NONE
: return "UNIX - System V";
3590 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3591 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3592 case ELFOSABI_GNU
: return "UNIX - GNU";
3593 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3594 case ELFOSABI_AIX
: return "UNIX - AIX";
3595 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3596 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3597 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3598 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3599 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3600 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3601 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3602 case ELFOSABI_AROS
: return "AROS";
3603 case ELFOSABI_FENIXOS
: return "FenixOS";
3604 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3605 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3608 switch (elf_header
.e_machine
)
3613 case ELFOSABI_ARM
: return "ARM";
3624 case ELFOSABI_STANDALONE
: return _("Standalone App");
3633 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3634 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3643 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3649 get_aarch64_segment_type (unsigned long type
)
3653 case PT_AARCH64_ARCHEXT
:
3654 return "AARCH64_ARCHEXT";
3663 get_arm_segment_type (unsigned long type
)
3677 get_mips_segment_type (unsigned long type
)
3681 case PT_MIPS_REGINFO
:
3683 case PT_MIPS_RTPROC
:
3685 case PT_MIPS_OPTIONS
:
3687 case PT_MIPS_ABIFLAGS
:
3697 get_parisc_segment_type (unsigned long type
)
3701 case PT_HP_TLS
: return "HP_TLS";
3702 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3703 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3704 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3705 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3706 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3707 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3708 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3709 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3710 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3711 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3712 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3713 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3714 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3715 case PT_HP_STACK
: return "HP_STACK";
3716 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3717 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3718 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3719 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3728 get_ia64_segment_type (unsigned long type
)
3732 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3733 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3734 case PT_HP_TLS
: return "HP_TLS";
3735 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3736 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3737 case PT_IA_64_HP_STACK
: return "HP_STACK";
3746 get_tic6x_segment_type (unsigned long type
)
3750 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3759 get_solaris_segment_type (unsigned long type
)
3763 case 0x6464e550: return "PT_SUNW_UNWIND";
3764 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3765 case 0x6ffffff7: return "PT_LOSUNW";
3766 case 0x6ffffffa: return "PT_SUNWBSS";
3767 case 0x6ffffffb: return "PT_SUNWSTACK";
3768 case 0x6ffffffc: return "PT_SUNWDTRACE";
3769 case 0x6ffffffd: return "PT_SUNWCAP";
3770 case 0x6fffffff: return "PT_HISUNW";
3771 default: return NULL
;
3776 get_segment_type (unsigned long p_type
)
3778 static char buff
[32];
3782 case PT_NULL
: return "NULL";
3783 case PT_LOAD
: return "LOAD";
3784 case PT_DYNAMIC
: return "DYNAMIC";
3785 case PT_INTERP
: return "INTERP";
3786 case PT_NOTE
: return "NOTE";
3787 case PT_SHLIB
: return "SHLIB";
3788 case PT_PHDR
: return "PHDR";
3789 case PT_TLS
: return "TLS";
3791 case PT_GNU_EH_FRAME
:
3792 return "GNU_EH_FRAME";
3793 case PT_GNU_STACK
: return "GNU_STACK";
3794 case PT_GNU_RELRO
: return "GNU_RELRO";
3797 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3799 const char * result
;
3801 switch (elf_header
.e_machine
)
3804 result
= get_aarch64_segment_type (p_type
);
3807 result
= get_arm_segment_type (p_type
);
3810 case EM_MIPS_RS3_LE
:
3811 result
= get_mips_segment_type (p_type
);
3814 result
= get_parisc_segment_type (p_type
);
3817 result
= get_ia64_segment_type (p_type
);
3820 result
= get_tic6x_segment_type (p_type
);
3830 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3832 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3834 const char * result
;
3836 switch (elf_header
.e_machine
)
3839 result
= get_parisc_segment_type (p_type
);
3842 result
= get_ia64_segment_type (p_type
);
3845 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3846 result
= get_solaris_segment_type (p_type
);
3855 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3858 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3865 get_mips_section_type_name (unsigned int sh_type
)
3869 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3870 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3871 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3872 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3873 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3874 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3875 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3876 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3877 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3878 case SHT_MIPS_RELD
: return "MIPS_RELD";
3879 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3880 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3881 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3882 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3883 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3884 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3885 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3886 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3887 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3888 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3889 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3890 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3891 case SHT_MIPS_LINE
: return "MIPS_LINE";
3892 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3893 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3894 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3895 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3896 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3897 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3898 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3899 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3900 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3901 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3902 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3903 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3904 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3905 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3906 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3907 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3908 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3916 get_parisc_section_type_name (unsigned int sh_type
)
3920 case SHT_PARISC_EXT
: return "PARISC_EXT";
3921 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3922 case SHT_PARISC_DOC
: return "PARISC_DOC";
3923 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3924 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3925 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3926 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3934 get_ia64_section_type_name (unsigned int sh_type
)
3936 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3937 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3938 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3942 case SHT_IA_64_EXT
: return "IA_64_EXT";
3943 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3944 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3945 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3946 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3947 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3948 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3949 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3950 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3951 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3959 get_x86_64_section_type_name (unsigned int sh_type
)
3963 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3971 get_aarch64_section_type_name (unsigned int sh_type
)
3975 case SHT_AARCH64_ATTRIBUTES
:
3976 return "AARCH64_ATTRIBUTES";
3984 get_arm_section_type_name (unsigned int sh_type
)
3988 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3989 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3990 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3991 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3992 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4000 get_tic6x_section_type_name (unsigned int sh_type
)
4004 case SHT_C6000_UNWIND
:
4005 return "C6000_UNWIND";
4006 case SHT_C6000_PREEMPTMAP
:
4007 return "C6000_PREEMPTMAP";
4008 case SHT_C6000_ATTRIBUTES
:
4009 return "C6000_ATTRIBUTES";
4014 case SHT_TI_HANDLER
:
4015 return "TI_HANDLER";
4016 case SHT_TI_INITINFO
:
4017 return "TI_INITINFO";
4018 case SHT_TI_PHATTRS
:
4019 return "TI_PHATTRS";
4027 get_msp430x_section_type_name (unsigned int sh_type
)
4031 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4032 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4033 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4034 default: return NULL
;
4039 get_v850_section_type_name (unsigned int sh_type
)
4043 case SHT_V850_SCOMMON
: return "V850 Small Common";
4044 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4045 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4046 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4047 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4048 default: return NULL
;
4053 get_section_type_name (unsigned int sh_type
)
4055 static char buff
[32];
4056 const char * result
;
4060 case SHT_NULL
: return "NULL";
4061 case SHT_PROGBITS
: return "PROGBITS";
4062 case SHT_SYMTAB
: return "SYMTAB";
4063 case SHT_STRTAB
: return "STRTAB";
4064 case SHT_RELA
: return "RELA";
4065 case SHT_HASH
: return "HASH";
4066 case SHT_DYNAMIC
: return "DYNAMIC";
4067 case SHT_NOTE
: return "NOTE";
4068 case SHT_NOBITS
: return "NOBITS";
4069 case SHT_REL
: return "REL";
4070 case SHT_SHLIB
: return "SHLIB";
4071 case SHT_DYNSYM
: return "DYNSYM";
4072 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4073 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4074 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4075 case SHT_GNU_HASH
: return "GNU_HASH";
4076 case SHT_GROUP
: return "GROUP";
4077 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4078 case SHT_GNU_verdef
: return "VERDEF";
4079 case SHT_GNU_verneed
: return "VERNEED";
4080 case SHT_GNU_versym
: return "VERSYM";
4081 case 0x6ffffff0: return "VERSYM";
4082 case 0x6ffffffc: return "VERDEF";
4083 case 0x7ffffffd: return "AUXILIARY";
4084 case 0x7fffffff: return "FILTER";
4085 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4088 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4090 switch (elf_header
.e_machine
)
4093 case EM_MIPS_RS3_LE
:
4094 result
= get_mips_section_type_name (sh_type
);
4097 result
= get_parisc_section_type_name (sh_type
);
4100 result
= get_ia64_section_type_name (sh_type
);
4105 result
= get_x86_64_section_type_name (sh_type
);
4108 result
= get_aarch64_section_type_name (sh_type
);
4111 result
= get_arm_section_type_name (sh_type
);
4114 result
= get_tic6x_section_type_name (sh_type
);
4117 result
= get_msp430x_section_type_name (sh_type
);
4121 case EM_CYGNUS_V850
:
4122 result
= get_v850_section_type_name (sh_type
);
4132 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4134 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4136 switch (elf_header
.e_machine
)
4139 result
= get_ia64_section_type_name (sh_type
);
4142 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4143 result
= get_solaris_section_type (sh_type
);
4148 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4149 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4150 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4151 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4163 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4165 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4167 switch (elf_header
.e_machine
)
4171 case EM_CYGNUS_V850
:
4172 result
= get_v850_section_type_name (sh_type
);
4182 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4185 /* This message is probably going to be displayed in a 15
4186 character wide field, so put the hex value first. */
4187 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4193 #define OPTION_DEBUG_DUMP 512
4194 #define OPTION_DYN_SYMS 513
4195 #define OPTION_DWARF_DEPTH 514
4196 #define OPTION_DWARF_START 515
4197 #define OPTION_DWARF_CHECK 516
4199 static struct option options
[] =
4201 {"all", no_argument
, 0, 'a'},
4202 {"file-header", no_argument
, 0, 'h'},
4203 {"program-headers", no_argument
, 0, 'l'},
4204 {"headers", no_argument
, 0, 'e'},
4205 {"histogram", no_argument
, 0, 'I'},
4206 {"segments", no_argument
, 0, 'l'},
4207 {"sections", no_argument
, 0, 'S'},
4208 {"section-headers", no_argument
, 0, 'S'},
4209 {"section-groups", no_argument
, 0, 'g'},
4210 {"section-details", no_argument
, 0, 't'},
4211 {"full-section-name",no_argument
, 0, 'N'},
4212 {"symbols", no_argument
, 0, 's'},
4213 {"syms", no_argument
, 0, 's'},
4214 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4215 {"relocs", no_argument
, 0, 'r'},
4216 {"notes", no_argument
, 0, 'n'},
4217 {"dynamic", no_argument
, 0, 'd'},
4218 {"arch-specific", no_argument
, 0, 'A'},
4219 {"version-info", no_argument
, 0, 'V'},
4220 {"use-dynamic", no_argument
, 0, 'D'},
4221 {"unwind", no_argument
, 0, 'u'},
4222 {"archive-index", no_argument
, 0, 'c'},
4223 {"hex-dump", required_argument
, 0, 'x'},
4224 {"relocated-dump", required_argument
, 0, 'R'},
4225 {"string-dump", required_argument
, 0, 'p'},
4226 {"decompress", no_argument
, 0, 'z'},
4227 #ifdef SUPPORT_DISASSEMBLY
4228 {"instruction-dump", required_argument
, 0, 'i'},
4230 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4232 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4233 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4234 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4236 {"version", no_argument
, 0, 'v'},
4237 {"wide", no_argument
, 0, 'W'},
4238 {"help", no_argument
, 0, 'H'},
4239 {0, no_argument
, 0, 0}
4243 usage (FILE * stream
)
4245 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4246 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4247 fprintf (stream
, _(" Options are:\n\
4248 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4249 -h --file-header Display the ELF file header\n\
4250 -l --program-headers Display the program headers\n\
4251 --segments An alias for --program-headers\n\
4252 -S --section-headers Display the sections' header\n\
4253 --sections An alias for --section-headers\n\
4254 -g --section-groups Display the section groups\n\
4255 -t --section-details Display the section details\n\
4256 -e --headers Equivalent to: -h -l -S\n\
4257 -s --syms Display the symbol table\n\
4258 --symbols An alias for --syms\n\
4259 --dyn-syms Display the dynamic symbol table\n\
4260 -n --notes Display the core notes (if present)\n\
4261 -r --relocs Display the relocations (if present)\n\
4262 -u --unwind Display the unwind info (if present)\n\
4263 -d --dynamic Display the dynamic section (if present)\n\
4264 -V --version-info Display the version sections (if present)\n\
4265 -A --arch-specific Display architecture specific information (if any)\n\
4266 -c --archive-index Display the symbol/file index in an archive\n\
4267 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4268 -x --hex-dump=<number|name>\n\
4269 Dump the contents of section <number|name> as bytes\n\
4270 -p --string-dump=<number|name>\n\
4271 Dump the contents of section <number|name> as strings\n\
4272 -R --relocated-dump=<number|name>\n\
4273 Dump the contents of section <number|name> as relocated bytes\n\
4274 -z --decompress Decompress section before dumping it\n\
4275 -w[lLiaprmfFsoRt] or\n\
4276 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4277 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4278 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4280 Display the contents of DWARF2 debug sections\n"));
4281 fprintf (stream
, _("\
4282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4285 #ifdef SUPPORT_DISASSEMBLY
4286 fprintf (stream
, _("\
4287 -i --instruction-dump=<number|name>\n\
4288 Disassemble the contents of section <number|name>\n"));
4290 fprintf (stream
, _("\
4291 -I --histogram Display histogram of bucket list lengths\n\
4292 -W --wide Allow output width to exceed 80 characters\n\
4293 @<file> Read options from <file>\n\
4294 -H --help Display this information\n\
4295 -v --version Display the version number of readelf\n"));
4297 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4298 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4300 exit (stream
== stdout
? 0 : 1);
4303 /* Record the fact that the user wants the contents of section number
4304 SECTION to be displayed using the method(s) encoded as flags bits
4305 in TYPE. Note, TYPE can be zero if we are creating the array for
4309 request_dump_bynumber (unsigned int section
, dump_type type
)
4311 if (section
>= num_dump_sects
)
4313 dump_type
* new_dump_sects
;
4315 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4316 sizeof (* dump_sects
));
4318 if (new_dump_sects
== NULL
)
4319 error (_("Out of memory allocating dump request table.\n"));
4324 /* Copy current flag settings. */
4325 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4330 dump_sects
= new_dump_sects
;
4331 num_dump_sects
= section
+ 1;
4336 dump_sects
[section
] |= type
;
4341 /* Request a dump by section name. */
4344 request_dump_byname (const char * section
, dump_type type
)
4346 struct dump_list_entry
* new_request
;
4348 new_request
= (struct dump_list_entry
*)
4349 malloc (sizeof (struct dump_list_entry
));
4351 error (_("Out of memory allocating dump request table.\n"));
4353 new_request
->name
= strdup (section
);
4354 if (!new_request
->name
)
4355 error (_("Out of memory allocating dump request table.\n"));
4357 new_request
->type
= type
;
4359 new_request
->next
= dump_sects_byname
;
4360 dump_sects_byname
= new_request
;
4364 request_dump (dump_type type
)
4370 section
= strtoul (optarg
, & cp
, 0);
4372 if (! *cp
&& section
>= 0)
4373 request_dump_bynumber (section
, type
);
4375 request_dump_byname (optarg
, type
);
4380 parse_args (int argc
, char ** argv
)
4387 while ((c
= getopt_long
4388 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4406 do_section_groups
++;
4414 do_section_groups
++;
4419 do_section_details
++;
4463 request_dump (HEX_DUMP
);
4466 request_dump (STRING_DUMP
);
4469 request_dump (RELOC_DUMP
);
4479 dwarf_select_sections_all ();
4484 dwarf_select_sections_by_letters (optarg
);
4487 case OPTION_DEBUG_DUMP
:
4494 dwarf_select_sections_by_names (optarg
);
4497 case OPTION_DWARF_DEPTH
:
4501 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4504 case OPTION_DWARF_START
:
4508 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4511 case OPTION_DWARF_CHECK
:
4514 case OPTION_DYN_SYMS
:
4517 #ifdef SUPPORT_DISASSEMBLY
4519 request_dump (DISASS_DUMP
);
4523 print_version (program_name
);
4532 /* xgettext:c-format */
4533 error (_("Invalid option '-%c'\n"), c
);
4540 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4541 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4542 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4543 && !do_section_groups
&& !do_archive_index
4549 get_elf_class (unsigned int elf_class
)
4551 static char buff
[32];
4555 case ELFCLASSNONE
: return _("none");
4556 case ELFCLASS32
: return "ELF32";
4557 case ELFCLASS64
: return "ELF64";
4559 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4565 get_data_encoding (unsigned int encoding
)
4567 static char buff
[32];
4571 case ELFDATANONE
: return _("none");
4572 case ELFDATA2LSB
: return _("2's complement, little endian");
4573 case ELFDATA2MSB
: return _("2's complement, big endian");
4575 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4580 /* Decode the data held in 'elf_header'. */
4583 process_file_header (void)
4585 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4586 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4587 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4588 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4591 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4595 init_dwarf_regnames (elf_header
.e_machine
);
4601 printf (_("ELF Header:\n"));
4602 printf (_(" Magic: "));
4603 for (i
= 0; i
< EI_NIDENT
; i
++)
4604 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4606 printf (_(" Class: %s\n"),
4607 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4608 printf (_(" Data: %s\n"),
4609 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4610 printf (_(" Version: %d %s\n"),
4611 elf_header
.e_ident
[EI_VERSION
],
4612 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4614 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4615 ? _("<unknown: %lx>")
4617 printf (_(" OS/ABI: %s\n"),
4618 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4619 printf (_(" ABI Version: %d\n"),
4620 elf_header
.e_ident
[EI_ABIVERSION
]);
4621 printf (_(" Type: %s\n"),
4622 get_file_type (elf_header
.e_type
));
4623 printf (_(" Machine: %s\n"),
4624 get_machine_name (elf_header
.e_machine
));
4625 printf (_(" Version: 0x%lx\n"),
4626 (unsigned long) elf_header
.e_version
);
4628 printf (_(" Entry point address: "));
4629 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4630 printf (_("\n Start of program headers: "));
4631 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4632 printf (_(" (bytes into file)\n Start of section headers: "));
4633 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4634 printf (_(" (bytes into file)\n"));
4636 printf (_(" Flags: 0x%lx%s\n"),
4637 (unsigned long) elf_header
.e_flags
,
4638 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4639 printf (_(" Size of this header: %ld (bytes)\n"),
4640 (long) elf_header
.e_ehsize
);
4641 printf (_(" Size of program headers: %ld (bytes)\n"),
4642 (long) elf_header
.e_phentsize
);
4643 printf (_(" Number of program headers: %ld"),
4644 (long) elf_header
.e_phnum
);
4645 if (section_headers
!= NULL
4646 && elf_header
.e_phnum
== PN_XNUM
4647 && section_headers
[0].sh_info
!= 0)
4648 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4649 putc ('\n', stdout
);
4650 printf (_(" Size of section headers: %ld (bytes)\n"),
4651 (long) elf_header
.e_shentsize
);
4652 printf (_(" Number of section headers: %ld"),
4653 (long) elf_header
.e_shnum
);
4654 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4655 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4656 putc ('\n', stdout
);
4657 printf (_(" Section header string table index: %ld"),
4658 (long) elf_header
.e_shstrndx
);
4659 if (section_headers
!= NULL
4660 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4661 printf (" (%u)", section_headers
[0].sh_link
);
4662 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4663 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4664 printf (_(" <corrupt: out of range>"));
4665 putc ('\n', stdout
);
4668 if (section_headers
!= NULL
)
4670 if (elf_header
.e_phnum
== PN_XNUM
4671 && section_headers
[0].sh_info
!= 0)
4672 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4673 if (elf_header
.e_shnum
== SHN_UNDEF
)
4674 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4675 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4676 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4677 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4678 elf_header
.e_shstrndx
= SHN_UNDEF
;
4679 free (section_headers
);
4680 section_headers
= NULL
;
4687 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4689 Elf32_External_Phdr
* phdrs
;
4690 Elf32_External_Phdr
* external
;
4691 Elf_Internal_Phdr
* internal
;
4693 unsigned int size
= elf_header
.e_phentsize
;
4694 unsigned int num
= elf_header
.e_phnum
;
4696 /* PR binutils/17531: Cope with unexpected section header sizes. */
4697 if (size
== 0 || num
== 0)
4699 if (size
< sizeof * phdrs
)
4701 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4704 if (size
> sizeof * phdrs
)
4705 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4707 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4708 size
, num
, _("program headers"));
4712 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4713 i
< elf_header
.e_phnum
;
4714 i
++, internal
++, external
++)
4716 internal
->p_type
= BYTE_GET (external
->p_type
);
4717 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4718 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4719 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4720 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4721 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4722 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4723 internal
->p_align
= BYTE_GET (external
->p_align
);
4731 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4733 Elf64_External_Phdr
* phdrs
;
4734 Elf64_External_Phdr
* external
;
4735 Elf_Internal_Phdr
* internal
;
4737 unsigned int size
= elf_header
.e_phentsize
;
4738 unsigned int num
= elf_header
.e_phnum
;
4740 /* PR binutils/17531: Cope with unexpected section header sizes. */
4741 if (size
== 0 || num
== 0)
4743 if (size
< sizeof * phdrs
)
4745 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4748 if (size
> sizeof * phdrs
)
4749 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4751 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4752 size
, num
, _("program headers"));
4756 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4757 i
< elf_header
.e_phnum
;
4758 i
++, internal
++, external
++)
4760 internal
->p_type
= BYTE_GET (external
->p_type
);
4761 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4762 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4763 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4764 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4765 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4766 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4767 internal
->p_align
= BYTE_GET (external
->p_align
);
4774 /* Returns 1 if the program headers were read into `program_headers'. */
4777 get_program_headers (FILE * file
)
4779 Elf_Internal_Phdr
* phdrs
;
4781 /* Check cache of prior read. */
4782 if (program_headers
!= NULL
)
4785 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4786 sizeof (Elf_Internal_Phdr
));
4790 error (_("Out of memory reading %u program headers\n"),
4791 elf_header
.e_phnum
);
4796 ? get_32bit_program_headers (file
, phdrs
)
4797 : get_64bit_program_headers (file
, phdrs
))
4799 program_headers
= phdrs
;
4807 /* Returns 1 if the program headers were loaded. */
4810 process_program_headers (FILE * file
)
4812 Elf_Internal_Phdr
* segment
;
4814 Elf_Internal_Phdr
* previous_load
= NULL
;
4816 if (elf_header
.e_phnum
== 0)
4818 /* PR binutils/12467. */
4819 if (elf_header
.e_phoff
!= 0)
4820 warn (_("possibly corrupt ELF header - it has a non-zero program"
4821 " header offset, but no program headers\n"));
4822 else if (do_segments
)
4823 printf (_("\nThere are no program headers in this file.\n"));
4827 if (do_segments
&& !do_header
)
4829 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4830 printf (_("Entry point "));
4831 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4832 printf (_("\nThere are %d program headers, starting at offset "),
4833 elf_header
.e_phnum
);
4834 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4838 if (! get_program_headers (file
))
4843 if (elf_header
.e_phnum
> 1)
4844 printf (_("\nProgram Headers:\n"));
4846 printf (_("\nProgram Headers:\n"));
4850 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4853 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4857 (_(" Type Offset VirtAddr PhysAddr\n"));
4859 (_(" FileSiz MemSiz Flags Align\n"));
4866 for (i
= 0, segment
= program_headers
;
4867 i
< elf_header
.e_phnum
;
4872 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4876 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4877 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4878 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4879 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4880 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4882 (segment
->p_flags
& PF_R
? 'R' : ' '),
4883 (segment
->p_flags
& PF_W
? 'W' : ' '),
4884 (segment
->p_flags
& PF_X
? 'E' : ' '));
4885 printf ("%#lx", (unsigned long) segment
->p_align
);
4889 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4890 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4893 print_vma (segment
->p_offset
, FULL_HEX
);
4897 print_vma (segment
->p_vaddr
, FULL_HEX
);
4899 print_vma (segment
->p_paddr
, FULL_HEX
);
4902 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4903 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4906 print_vma (segment
->p_filesz
, FULL_HEX
);
4910 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4911 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4914 print_vma (segment
->p_memsz
, FULL_HEX
);
4918 (segment
->p_flags
& PF_R
? 'R' : ' '),
4919 (segment
->p_flags
& PF_W
? 'W' : ' '),
4920 (segment
->p_flags
& PF_X
? 'E' : ' '));
4922 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4923 printf ("%#lx", (unsigned long) segment
->p_align
);
4926 print_vma (segment
->p_align
, PREFIX_HEX
);
4931 print_vma (segment
->p_offset
, FULL_HEX
);
4933 print_vma (segment
->p_vaddr
, FULL_HEX
);
4935 print_vma (segment
->p_paddr
, FULL_HEX
);
4937 print_vma (segment
->p_filesz
, FULL_HEX
);
4939 print_vma (segment
->p_memsz
, FULL_HEX
);
4941 (segment
->p_flags
& PF_R
? 'R' : ' '),
4942 (segment
->p_flags
& PF_W
? 'W' : ' '),
4943 (segment
->p_flags
& PF_X
? 'E' : ' '));
4944 print_vma (segment
->p_align
, PREFIX_HEX
);
4947 putc ('\n', stdout
);
4950 switch (segment
->p_type
)
4953 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4954 required by the ELF standard, several programs, including the Linux
4955 kernel, make use of non-ordered segments. */
4957 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4958 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4960 if (segment
->p_memsz
< segment
->p_filesz
)
4961 error (_("the segment's file size is larger than its memory size\n"));
4962 previous_load
= segment
;
4966 /* PR 20815 - Verify that the program header is loaded into memory. */
4967 if (i
> 0 && previous_load
!= NULL
)
4968 error (_("the PHDR segment must occur before any LOAD segment\n"));
4969 if (elf_header
.e_machine
!= EM_PARISC
)
4973 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4974 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4975 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4976 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4978 if (j
== elf_header
.e_phnum
)
4979 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4985 error (_("more than one dynamic segment\n"));
4987 /* By default, assume that the .dynamic section is the first
4988 section in the DYNAMIC segment. */
4989 dynamic_addr
= segment
->p_offset
;
4990 dynamic_size
= segment
->p_filesz
;
4991 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4992 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4994 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4995 dynamic_addr
= dynamic_size
= 0;
4998 /* Try to locate the .dynamic section. If there is
4999 a section header table, we can easily locate it. */
5000 if (section_headers
!= NULL
)
5002 Elf_Internal_Shdr
* sec
;
5004 sec
= find_section (".dynamic");
5005 if (sec
== NULL
|| sec
->sh_size
== 0)
5007 /* A corresponding .dynamic section is expected, but on
5008 IA-64/OpenVMS it is OK for it to be missing. */
5009 if (!is_ia64_vms ())
5010 error (_("no .dynamic section in the dynamic segment\n"));
5014 if (sec
->sh_type
== SHT_NOBITS
)
5020 dynamic_addr
= sec
->sh_offset
;
5021 dynamic_size
= sec
->sh_size
;
5023 if (dynamic_addr
< segment
->p_offset
5024 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5025 warn (_("the .dynamic section is not contained"
5026 " within the dynamic segment\n"));
5027 else if (dynamic_addr
> segment
->p_offset
)
5028 warn (_("the .dynamic section is not the first section"
5029 " in the dynamic segment.\n"));
5034 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5036 error (_("Unable to find program interpreter name\n"));
5040 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5042 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5043 error (_("Internal error: failed to create format string to display program interpreter\n"));
5045 program_interpreter
[0] = 0;
5046 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5047 error (_("Unable to read program interpreter name\n"));
5050 printf (_(" [Requesting program interpreter: %s]\n"),
5051 program_interpreter
);
5057 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5059 printf (_("\n Section to Segment mapping:\n"));
5060 printf (_(" Segment Sections...\n"));
5062 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5065 Elf_Internal_Shdr
* section
;
5067 segment
= program_headers
+ i
;
5068 section
= section_headers
+ 1;
5070 printf (" %2.2d ", i
);
5072 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5074 if (!ELF_TBSS_SPECIAL (section
, segment
)
5075 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5076 printf ("%s ", printable_section_name (section
));
5087 /* Find the file offset corresponding to VMA by using the program headers. */
5090 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5092 Elf_Internal_Phdr
* seg
;
5094 if (! get_program_headers (file
))
5096 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5100 for (seg
= program_headers
;
5101 seg
< program_headers
+ elf_header
.e_phnum
;
5104 if (seg
->p_type
!= PT_LOAD
)
5107 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5108 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5109 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5112 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5113 (unsigned long) vma
);
5118 /* Allocate memory and load the sections headers into the global pointer
5119 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5120 generate any error messages if the load fails. */
5123 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5125 Elf32_External_Shdr
* shdrs
;
5126 Elf_Internal_Shdr
* internal
;
5128 unsigned int size
= elf_header
.e_shentsize
;
5129 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5131 /* PR binutils/17531: Cope with unexpected section header sizes. */
5132 if (size
== 0 || num
== 0)
5134 if (size
< sizeof * shdrs
)
5137 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5140 if (!probe
&& size
> sizeof * shdrs
)
5141 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5143 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5145 probe
? NULL
: _("section headers"));
5149 if (section_headers
!= NULL
)
5150 free (section_headers
);
5151 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5152 sizeof (Elf_Internal_Shdr
));
5153 if (section_headers
== NULL
)
5156 error (_("Out of memory reading %u section headers\n"), num
);
5160 for (i
= 0, internal
= section_headers
;
5164 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5165 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5166 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5167 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5168 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5169 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5170 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5171 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5172 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5173 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5174 if (!probe
&& internal
->sh_link
> num
)
5175 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5176 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5177 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5185 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5187 Elf64_External_Shdr
* shdrs
;
5188 Elf_Internal_Shdr
* internal
;
5190 unsigned int size
= elf_header
.e_shentsize
;
5191 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5193 /* PR binutils/17531: Cope with unexpected section header sizes. */
5194 if (size
== 0 || num
== 0)
5196 if (size
< sizeof * shdrs
)
5199 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5202 if (! probe
&& size
> sizeof * shdrs
)
5203 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5205 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5207 probe
? NULL
: _("section headers"));
5211 if (section_headers
!= NULL
)
5212 free (section_headers
);
5213 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5214 sizeof (Elf_Internal_Shdr
));
5215 if (section_headers
== NULL
)
5218 error (_("Out of memory reading %u section headers\n"), num
);
5222 for (i
= 0, internal
= section_headers
;
5226 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5227 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5228 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5229 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5230 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5231 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5232 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5233 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5234 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5235 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5236 if (!probe
&& internal
->sh_link
> num
)
5237 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5238 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5239 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5246 static Elf_Internal_Sym
*
5247 get_32bit_elf_symbols (FILE * file
,
5248 Elf_Internal_Shdr
* section
,
5249 unsigned long * num_syms_return
)
5251 unsigned long number
= 0;
5252 Elf32_External_Sym
* esyms
= NULL
;
5253 Elf_External_Sym_Shndx
* shndx
= NULL
;
5254 Elf_Internal_Sym
* isyms
= NULL
;
5255 Elf_Internal_Sym
* psym
;
5258 if (section
->sh_size
== 0)
5260 if (num_syms_return
!= NULL
)
5261 * num_syms_return
= 0;
5265 /* Run some sanity checks first. */
5266 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5268 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5269 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5273 if (section
->sh_size
> current_file_size
)
5275 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5276 printable_section_name (section
), (unsigned long) section
->sh_size
);
5280 number
= section
->sh_size
/ section
->sh_entsize
;
5282 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5284 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5285 (unsigned long) section
->sh_size
,
5286 printable_section_name (section
),
5287 (unsigned long) section
->sh_entsize
);
5291 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5292 section
->sh_size
, _("symbols"));
5297 elf_section_list
* entry
;
5300 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5301 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5303 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5304 entry
->hdr
->sh_offset
,
5305 1, entry
->hdr
->sh_size
,
5306 _("symbol table section indicies"));
5309 /* PR17531: file: heap-buffer-overflow */
5310 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5312 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5313 printable_section_name (entry
->hdr
),
5314 (unsigned long) entry
->hdr
->sh_size
,
5315 (unsigned long) section
->sh_size
);
5321 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5325 error (_("Out of memory reading %lu symbols\n"),
5326 (unsigned long) number
);
5330 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5332 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5333 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5334 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5335 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5336 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5338 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5339 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5340 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5341 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5342 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5351 if (num_syms_return
!= NULL
)
5352 * num_syms_return
= isyms
== NULL
? 0 : number
;
5357 static Elf_Internal_Sym
*
5358 get_64bit_elf_symbols (FILE * file
,
5359 Elf_Internal_Shdr
* section
,
5360 unsigned long * num_syms_return
)
5362 unsigned long number
= 0;
5363 Elf64_External_Sym
* esyms
= NULL
;
5364 Elf_External_Sym_Shndx
* shndx
= NULL
;
5365 Elf_Internal_Sym
* isyms
= NULL
;
5366 Elf_Internal_Sym
* psym
;
5369 if (section
->sh_size
== 0)
5371 if (num_syms_return
!= NULL
)
5372 * num_syms_return
= 0;
5376 /* Run some sanity checks first. */
5377 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5379 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5380 printable_section_name (section
),
5381 (unsigned long) section
->sh_entsize
);
5385 if (section
->sh_size
> current_file_size
)
5387 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5388 printable_section_name (section
),
5389 (unsigned long) section
->sh_size
);
5393 number
= section
->sh_size
/ section
->sh_entsize
;
5395 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5397 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5398 (unsigned long) section
->sh_size
,
5399 printable_section_name (section
),
5400 (unsigned long) section
->sh_entsize
);
5404 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5405 section
->sh_size
, _("symbols"));
5410 elf_section_list
* entry
;
5413 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5414 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5416 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5417 entry
->hdr
->sh_offset
,
5418 1, entry
->hdr
->sh_size
,
5419 _("symbol table section indicies"));
5422 /* PR17531: file: heap-buffer-overflow */
5423 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5425 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5426 printable_section_name (entry
->hdr
),
5427 (unsigned long) entry
->hdr
->sh_size
,
5428 (unsigned long) section
->sh_size
);
5434 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5438 error (_("Out of memory reading %lu symbols\n"),
5439 (unsigned long) number
);
5443 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5445 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5446 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5447 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5448 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5450 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5452 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5453 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5454 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5456 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5457 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5466 if (num_syms_return
!= NULL
)
5467 * num_syms_return
= isyms
== NULL
? 0 : number
;
5473 get_elf_section_flags (bfd_vma sh_flags
)
5475 static char buff
[1024];
5477 int field_size
= is_32bit_elf
? 8 : 16;
5479 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5480 bfd_vma os_flags
= 0;
5481 bfd_vma proc_flags
= 0;
5482 bfd_vma unknown_flags
= 0;
5490 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5491 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5492 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5493 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5494 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5495 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5496 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5497 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5498 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5499 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5500 /* IA-64 specific. */
5501 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5502 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5503 /* IA-64 OpenVMS specific. */
5504 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5505 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5506 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5507 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5508 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5509 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5511 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5512 /* SPARC specific. */
5513 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5514 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5516 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5517 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5518 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5521 if (do_section_details
)
5523 sprintf (buff
, "[%*.*lx]: ",
5524 field_size
, field_size
, (unsigned long) sh_flags
);
5525 p
+= field_size
+ 4;
5532 flag
= sh_flags
& - sh_flags
;
5535 if (do_section_details
)
5539 case SHF_WRITE
: sindex
= 0; break;
5540 case SHF_ALLOC
: sindex
= 1; break;
5541 case SHF_EXECINSTR
: sindex
= 2; break;
5542 case SHF_MERGE
: sindex
= 3; break;
5543 case SHF_STRINGS
: sindex
= 4; break;
5544 case SHF_INFO_LINK
: sindex
= 5; break;
5545 case SHF_LINK_ORDER
: sindex
= 6; break;
5546 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5547 case SHF_GROUP
: sindex
= 8; break;
5548 case SHF_TLS
: sindex
= 9; break;
5549 case SHF_EXCLUDE
: sindex
= 18; break;
5550 case SHF_COMPRESSED
: sindex
= 20; break;
5554 switch (elf_header
.e_machine
)
5557 if (flag
== SHF_IA_64_SHORT
)
5559 else if (flag
== SHF_IA_64_NORECOV
)
5562 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5565 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5566 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5567 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5568 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5569 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5570 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5581 case EM_OLD_SPARCV9
:
5582 case EM_SPARC32PLUS
:
5585 if (flag
== SHF_ORDERED
)
5592 case SHF_ENTRYSECT
: sindex
= 21; break;
5593 case SHF_ARM_PURECODE
: sindex
= 22; break;
5594 case SHF_COMDEF
: sindex
= 23; break;
5606 if (p
!= buff
+ field_size
+ 4)
5608 if (size
< (10 + 2))
5610 warn (_("Internal error: not enough buffer room for section flag info"));
5611 return _("<unknown>");
5618 size
-= flags
[sindex
].len
;
5619 p
= stpcpy (p
, flags
[sindex
].str
);
5621 else if (flag
& SHF_MASKOS
)
5623 else if (flag
& SHF_MASKPROC
)
5626 unknown_flags
|= flag
;
5632 case SHF_WRITE
: *p
= 'W'; break;
5633 case SHF_ALLOC
: *p
= 'A'; break;
5634 case SHF_EXECINSTR
: *p
= 'X'; break;
5635 case SHF_MERGE
: *p
= 'M'; break;
5636 case SHF_STRINGS
: *p
= 'S'; break;
5637 case SHF_INFO_LINK
: *p
= 'I'; break;
5638 case SHF_LINK_ORDER
: *p
= 'L'; break;
5639 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5640 case SHF_GROUP
: *p
= 'G'; break;
5641 case SHF_TLS
: *p
= 'T'; break;
5642 case SHF_EXCLUDE
: *p
= 'E'; break;
5643 case SHF_COMPRESSED
: *p
= 'C'; break;
5646 if ((elf_header
.e_machine
== EM_X86_64
5647 || elf_header
.e_machine
== EM_L1OM
5648 || elf_header
.e_machine
== EM_K1OM
)
5649 && flag
== SHF_X86_64_LARGE
)
5651 else if (elf_header
.e_machine
== EM_ARM
5652 && flag
== SHF_ARM_PURECODE
)
5654 else if (flag
& SHF_MASKOS
)
5657 sh_flags
&= ~ SHF_MASKOS
;
5659 else if (flag
& SHF_MASKPROC
)
5662 sh_flags
&= ~ SHF_MASKPROC
;
5672 if (do_section_details
)
5676 size
-= 5 + field_size
;
5677 if (p
!= buff
+ field_size
+ 4)
5681 warn (_("Internal error: not enough buffer room for section flag info"));
5682 return _("<unknown>");
5688 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5689 (unsigned long) os_flags
);
5690 p
+= 5 + field_size
;
5694 size
-= 7 + field_size
;
5695 if (p
!= buff
+ field_size
+ 4)
5699 warn (_("Internal error: not enough buffer room for section flag info"));
5700 return _("<unknown>");
5706 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5707 (unsigned long) proc_flags
);
5708 p
+= 7 + field_size
;
5712 size
-= 10 + field_size
;
5713 if (p
!= buff
+ field_size
+ 4)
5717 warn (_("Internal error: not enough buffer room for section flag info"));
5718 return _("<unknown>");
5724 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5725 (unsigned long) unknown_flags
);
5726 p
+= 10 + field_size
;
5735 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5739 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5741 if (size
< sizeof (* echdr
))
5743 error (_("Compressed section is too small even for a compression header\n"));
5747 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5748 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5749 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5750 return sizeof (*echdr
);
5754 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5756 if (size
< sizeof (* echdr
))
5758 error (_("Compressed section is too small even for a compression header\n"));
5762 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5763 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5764 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5765 return sizeof (*echdr
);
5770 process_section_headers (FILE * file
)
5772 Elf_Internal_Shdr
* section
;
5775 section_headers
= NULL
;
5777 if (elf_header
.e_shnum
== 0)
5779 /* PR binutils/12467. */
5780 if (elf_header
.e_shoff
!= 0)
5781 warn (_("possibly corrupt ELF file header - it has a non-zero"
5782 " section header offset, but no section headers\n"));
5783 else if (do_sections
)
5784 printf (_("\nThere are no sections in this file.\n"));
5789 if (do_sections
&& !do_header
)
5790 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5791 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5795 if (! get_32bit_section_headers (file
, FALSE
))
5798 else if (! get_64bit_section_headers (file
, FALSE
))
5801 /* Read in the string table, so that we have names to display. */
5802 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5803 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5805 section
= section_headers
+ elf_header
.e_shstrndx
;
5807 if (section
->sh_size
!= 0)
5809 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5810 1, section
->sh_size
,
5813 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5817 /* Scan the sections for the dynamic symbol table
5818 and dynamic string table and debug sections. */
5819 dynamic_symbols
= NULL
;
5820 dynamic_strings
= NULL
;
5821 dynamic_syminfo
= NULL
;
5822 symtab_shndx_list
= NULL
;
5824 eh_addr_size
= is_32bit_elf
? 4 : 8;
5825 switch (elf_header
.e_machine
)
5828 case EM_MIPS_RS3_LE
:
5829 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5830 FDE addresses. However, the ABI also has a semi-official ILP32
5831 variant for which the normal FDE address size rules apply.
5833 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5834 section, where XX is the size of longs in bits. Unfortunately,
5835 earlier compilers provided no way of distinguishing ILP32 objects
5836 from LP64 objects, so if there's any doubt, we should assume that
5837 the official LP64 form is being used. */
5838 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5839 && find_section (".gcc_compiled_long32") == NULL
)
5845 switch (elf_header
.e_flags
& EF_H8_MACH
)
5847 case E_H8_MACH_H8300
:
5848 case E_H8_MACH_H8300HN
:
5849 case E_H8_MACH_H8300SN
:
5850 case E_H8_MACH_H8300SXN
:
5853 case E_H8_MACH_H8300H
:
5854 case E_H8_MACH_H8300S
:
5855 case E_H8_MACH_H8300SX
:
5863 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5865 case EF_M32C_CPU_M16C
:
5872 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5875 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5876 if (section->sh_entsize != expected_entsize) \
5879 sprintf_vma (buf, section->sh_entsize); \
5880 /* Note: coded this way so that there is a single string for \
5882 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5883 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5884 (unsigned) expected_entsize); \
5885 section->sh_entsize = expected_entsize; \
5890 #define CHECK_ENTSIZE(section, i, type) \
5891 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5892 sizeof (Elf64_External_##type))
5894 for (i
= 0, section
= section_headers
;
5895 i
< elf_header
.e_shnum
;
5898 char * name
= SECTION_NAME (section
);
5900 if (section
->sh_type
== SHT_DYNSYM
)
5902 if (dynamic_symbols
!= NULL
)
5904 error (_("File contains multiple dynamic symbol tables\n"));
5908 CHECK_ENTSIZE (section
, i
, Sym
);
5909 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5911 else if (section
->sh_type
== SHT_STRTAB
5912 && streq (name
, ".dynstr"))
5914 if (dynamic_strings
!= NULL
)
5916 error (_("File contains multiple dynamic string tables\n"));
5920 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5921 1, section
->sh_size
,
5922 _("dynamic strings"));
5923 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5925 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5927 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5928 entry
->hdr
= section
;
5929 entry
->next
= symtab_shndx_list
;
5930 symtab_shndx_list
= entry
;
5932 else if (section
->sh_type
== SHT_SYMTAB
)
5933 CHECK_ENTSIZE (section
, i
, Sym
);
5934 else if (section
->sh_type
== SHT_GROUP
)
5935 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5936 else if (section
->sh_type
== SHT_REL
)
5937 CHECK_ENTSIZE (section
, i
, Rel
);
5938 else if (section
->sh_type
== SHT_RELA
)
5939 CHECK_ENTSIZE (section
, i
, Rela
);
5940 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5941 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5942 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5943 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5944 || do_debug_addr
|| do_debug_cu_index
)
5945 && (const_strneq (name
, ".debug_")
5946 || const_strneq (name
, ".zdebug_")))
5949 name
+= sizeof (".zdebug_") - 1;
5951 name
+= sizeof (".debug_") - 1;
5954 || (do_debug_info
&& const_strneq (name
, "info"))
5955 || (do_debug_info
&& const_strneq (name
, "types"))
5956 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5957 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5958 || (do_debug_lines
&& const_strneq (name
, "line."))
5959 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5960 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5961 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5962 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5963 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5964 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5965 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
5966 || (do_debug_frames
&& const_strneq (name
, "frame"))
5967 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5968 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5969 || (do_debug_str
&& const_strneq (name
, "str"))
5970 || (do_debug_loc
&& const_strneq (name
, "loc"))
5971 || (do_debug_loc
&& const_strneq (name
, "loclists"))
5972 || (do_debug_addr
&& const_strneq (name
, "addr"))
5973 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5974 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5976 request_dump_bynumber (i
, DEBUG_DUMP
);
5978 /* Linkonce section to be combined with .debug_info at link time. */
5979 else if ((do_debugging
|| do_debug_info
)
5980 && const_strneq (name
, ".gnu.linkonce.wi."))
5981 request_dump_bynumber (i
, DEBUG_DUMP
);
5982 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5983 request_dump_bynumber (i
, DEBUG_DUMP
);
5984 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5985 request_dump_bynumber (i
, DEBUG_DUMP
);
5986 /* Trace sections for Itanium VMS. */
5987 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5988 || do_trace_aranges
)
5989 && const_strneq (name
, ".trace_"))
5991 name
+= sizeof (".trace_") - 1;
5994 || (do_trace_info
&& streq (name
, "info"))
5995 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5996 || (do_trace_aranges
&& streq (name
, "aranges"))
5998 request_dump_bynumber (i
, DEBUG_DUMP
);
6005 if (elf_header
.e_shnum
> 1)
6006 printf (_("\nSection Headers:\n"));
6008 printf (_("\nSection Header:\n"));
6012 if (do_section_details
)
6014 printf (_(" [Nr] Name\n"));
6015 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6019 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6023 if (do_section_details
)
6025 printf (_(" [Nr] Name\n"));
6026 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6030 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6034 if (do_section_details
)
6036 printf (_(" [Nr] Name\n"));
6037 printf (_(" Type Address Offset Link\n"));
6038 printf (_(" Size EntSize Info Align\n"));
6042 printf (_(" [Nr] Name Type Address Offset\n"));
6043 printf (_(" Size EntSize Flags Link Info Align\n"));
6047 if (do_section_details
)
6048 printf (_(" Flags\n"));
6050 for (i
= 0, section
= section_headers
;
6051 i
< elf_header
.e_shnum
;
6054 /* Run some sanity checks on the section header. */
6056 /* Check the sh_link field. */
6057 switch (section
->sh_type
)
6059 case SHT_SYMTAB_SHNDX
:
6063 case SHT_GNU_versym
:
6066 if (section
->sh_link
< 1
6067 || section
->sh_link
>= elf_header
.e_shnum
6068 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6069 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6070 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6071 i
, section
->sh_link
);
6077 case SHT_GNU_verneed
:
6078 case SHT_GNU_verdef
:
6079 case SHT_GNU_LIBLIST
:
6080 if (section
->sh_link
< 1
6081 || section
->sh_link
>= elf_header
.e_shnum
6082 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6083 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6084 i
, section
->sh_link
);
6087 case SHT_INIT_ARRAY
:
6088 case SHT_FINI_ARRAY
:
6089 case SHT_PREINIT_ARRAY
:
6090 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6091 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6092 i
, section
->sh_link
);
6096 /* FIXME: Add support for target specific section types. */
6097 #if 0 /* Currently we do not check other section types as there are too
6098 many special cases. Stab sections for example have a type
6099 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6101 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6102 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6103 i
, section
->sh_link
);
6108 /* Check the sh_info field. */
6109 switch (section
->sh_type
)
6113 if (section
->sh_info
< 1
6114 || section
->sh_info
>= elf_header
.e_shnum
6115 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6116 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6117 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6118 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6119 /* FIXME: Are other section types valid ? */
6120 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6122 if (section
->sh_info
== 0
6123 && (streq (SECTION_NAME (section
), ".rel.dyn")
6124 || streq (SECTION_NAME (section
), ".rela.dyn")))
6125 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6126 of zero. The relocations in these sections may apply
6127 to many different sections. */
6130 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6131 i
, section
->sh_info
);
6137 case SHT_SYMTAB_SHNDX
:
6138 case SHT_INIT_ARRAY
:
6139 case SHT_FINI_ARRAY
:
6140 case SHT_PREINIT_ARRAY
:
6141 if (section
->sh_info
!= 0)
6142 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6143 i
, section
->sh_info
);
6149 /* A symbol index - we assume that it is valid. */
6153 /* FIXME: Add support for target specific section types. */
6154 if (section
->sh_type
== SHT_NOBITS
)
6155 /* NOBITS section headers with non-zero sh_info fields can be
6156 created when a binary is stripped of everything but its debug
6157 information. The stripped sections have their headers
6158 preserved but their types set to SHT_NOBITS. So do not check
6159 this type of section. */
6161 else if (section
->sh_flags
& SHF_INFO_LINK
)
6163 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6164 warn (_("[%2u]: Expected link to another section in info field"), i
);
6166 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6167 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6168 i
, section
->sh_info
);
6172 printf (" [%2u] ", i
);
6173 if (do_section_details
)
6174 printf ("%s\n ", printable_section_name (section
));
6176 print_symbol (-17, SECTION_NAME (section
));
6178 printf (do_wide
? " %-15s " : " %-15.15s ",
6179 get_section_type_name (section
->sh_type
));
6183 const char * link_too_big
= NULL
;
6185 print_vma (section
->sh_addr
, LONG_HEX
);
6187 printf ( " %6.6lx %6.6lx %2.2lx",
6188 (unsigned long) section
->sh_offset
,
6189 (unsigned long) section
->sh_size
,
6190 (unsigned long) section
->sh_entsize
);
6192 if (do_section_details
)
6193 fputs (" ", stdout
);
6195 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6197 if (section
->sh_link
>= elf_header
.e_shnum
)
6200 /* The sh_link value is out of range. Normally this indicates
6201 an error but it can have special values in Solaris binaries. */
6202 switch (elf_header
.e_machine
)
6209 case EM_OLD_SPARCV9
:
6210 case EM_SPARC32PLUS
:
6213 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6214 link_too_big
= "BEFORE";
6215 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6216 link_too_big
= "AFTER";
6223 if (do_section_details
)
6225 if (link_too_big
!= NULL
&& * link_too_big
)
6226 printf ("<%s> ", link_too_big
);
6228 printf ("%2u ", section
->sh_link
);
6229 printf ("%3u %2lu\n", section
->sh_info
,
6230 (unsigned long) section
->sh_addralign
);
6233 printf ("%2u %3u %2lu\n",
6236 (unsigned long) section
->sh_addralign
);
6238 if (link_too_big
&& ! * link_too_big
)
6239 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6240 i
, section
->sh_link
);
6244 print_vma (section
->sh_addr
, LONG_HEX
);
6246 if ((long) section
->sh_offset
== section
->sh_offset
)
6247 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6251 print_vma (section
->sh_offset
, LONG_HEX
);
6254 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6255 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6259 print_vma (section
->sh_size
, LONG_HEX
);
6262 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6263 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6267 print_vma (section
->sh_entsize
, LONG_HEX
);
6270 if (do_section_details
)
6271 fputs (" ", stdout
);
6273 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6275 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6277 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6278 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6281 print_vma (section
->sh_addralign
, DEC
);
6285 else if (do_section_details
)
6287 printf (" %-15.15s ",
6288 get_section_type_name (section
->sh_type
));
6289 print_vma (section
->sh_addr
, LONG_HEX
);
6290 if ((long) section
->sh_offset
== section
->sh_offset
)
6291 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6295 print_vma (section
->sh_offset
, LONG_HEX
);
6297 printf (" %u\n ", section
->sh_link
);
6298 print_vma (section
->sh_size
, LONG_HEX
);
6300 print_vma (section
->sh_entsize
, LONG_HEX
);
6302 printf (" %-16u %lu\n",
6304 (unsigned long) section
->sh_addralign
);
6309 print_vma (section
->sh_addr
, LONG_HEX
);
6310 if ((long) section
->sh_offset
== section
->sh_offset
)
6311 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6315 print_vma (section
->sh_offset
, LONG_HEX
);
6318 print_vma (section
->sh_size
, LONG_HEX
);
6320 print_vma (section
->sh_entsize
, LONG_HEX
);
6322 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6324 printf (" %2u %3u %lu\n",
6327 (unsigned long) section
->sh_addralign
);
6330 if (do_section_details
)
6332 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6333 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6335 /* Minimum section size is 12 bytes for 32-bit compression
6336 header + 12 bytes for compressed data header. */
6337 unsigned char buf
[24];
6339 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6340 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6341 sizeof (buf
), _("compression header")))
6343 Elf_Internal_Chdr chdr
;
6345 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6347 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6350 printf (_(" [<unknown>: 0x%x], "),
6352 print_vma (chdr
.ch_size
, LONG_HEX
);
6353 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6359 if (!do_section_details
)
6361 /* The ordering of the letters shown here matches the ordering of the
6362 corresponding SHF_xxx values, and hence the order in which these
6363 letters will be displayed to the user. */
6364 printf (_("Key to Flags:\n\
6365 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6366 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6367 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6368 if (elf_header
.e_machine
== EM_X86_64
6369 || elf_header
.e_machine
== EM_L1OM
6370 || elf_header
.e_machine
== EM_K1OM
)
6371 printf (_("l (large), "));
6372 else if (elf_header
.e_machine
== EM_ARM
)
6373 printf (_("y (purecode), "));
6374 printf ("p (processor specific)\n");
6381 get_group_flags (unsigned int flags
)
6383 static char buff
[128];
6387 else if (flags
== GRP_COMDAT
)
6390 snprintf (buff
, 14, _("[0x%x: "), flags
);
6392 flags
&= ~ GRP_COMDAT
;
6393 if (flags
& GRP_MASKOS
)
6395 strcat (buff
, "<OS specific>");
6396 flags
&= ~ GRP_MASKOS
;
6399 if (flags
& GRP_MASKPROC
)
6401 strcat (buff
, "<PROC specific>");
6402 flags
&= ~ GRP_MASKPROC
;
6406 strcat (buff
, "<unknown>");
6413 process_section_groups (FILE * file
)
6415 Elf_Internal_Shdr
* section
;
6417 struct group
* group
;
6418 Elf_Internal_Shdr
* symtab_sec
;
6419 Elf_Internal_Shdr
* strtab_sec
;
6420 Elf_Internal_Sym
* symtab
;
6421 unsigned long num_syms
;
6425 /* Don't process section groups unless needed. */
6426 if (!do_unwind
&& !do_section_groups
)
6429 if (elf_header
.e_shnum
== 0)
6431 if (do_section_groups
)
6432 printf (_("\nThere are no sections to group in this file.\n"));
6437 if (section_headers
== NULL
)
6439 error (_("Section headers are not available!\n"));
6440 /* PR 13622: This can happen with a corrupt ELF header. */
6444 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6445 sizeof (struct group
*));
6447 if (section_headers_groups
== NULL
)
6449 error (_("Out of memory reading %u section group headers\n"),
6450 elf_header
.e_shnum
);
6454 /* Scan the sections for the group section. */
6456 for (i
= 0, section
= section_headers
;
6457 i
< elf_header
.e_shnum
;
6459 if (section
->sh_type
== SHT_GROUP
)
6462 if (group_count
== 0)
6464 if (do_section_groups
)
6465 printf (_("\nThere are no section groups in this file.\n"));
6470 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6472 if (section_groups
== NULL
)
6474 error (_("Out of memory reading %lu groups\n"),
6475 (unsigned long) group_count
);
6485 for (i
= 0, section
= section_headers
, group
= section_groups
;
6486 i
< elf_header
.e_shnum
;
6489 if (section
->sh_type
== SHT_GROUP
)
6491 const char * name
= printable_section_name (section
);
6492 const char * group_name
;
6493 unsigned char * start
;
6494 unsigned char * indices
;
6495 unsigned int entry
, j
, size
;
6496 Elf_Internal_Shdr
* sec
;
6497 Elf_Internal_Sym
* sym
;
6499 /* Get the symbol table. */
6500 if (section
->sh_link
>= elf_header
.e_shnum
6501 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6504 error (_("Bad sh_link in group section `%s'\n"), name
);
6508 if (symtab_sec
!= sec
)
6513 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6518 error (_("Corrupt header in group section `%s'\n"), name
);
6522 if (section
->sh_info
>= num_syms
)
6524 error (_("Bad sh_info in group section `%s'\n"), name
);
6528 sym
= symtab
+ section
->sh_info
;
6530 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6532 if (sym
->st_shndx
== 0
6533 || sym
->st_shndx
>= elf_header
.e_shnum
)
6535 error (_("Bad sh_info in group section `%s'\n"), name
);
6539 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6548 /* Get the string table. */
6549 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6558 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6564 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6565 1, strtab_sec
->sh_size
,
6567 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6569 group_name
= sym
->st_name
< strtab_size
6570 ? strtab
+ sym
->st_name
: _("<corrupt>");
6573 /* PR 17531: file: loop. */
6574 if (section
->sh_entsize
> section
->sh_size
)
6576 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6577 printable_section_name (section
),
6578 (unsigned long) section
->sh_entsize
,
6579 (unsigned long) section
->sh_size
);
6583 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6584 1, section
->sh_size
,
6590 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6591 entry
= byte_get (indices
, 4);
6594 if (do_section_groups
)
6596 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6597 get_group_flags (entry
), i
, name
, group_name
, size
);
6599 printf (_(" [Index] Name\n"));
6602 group
->group_index
= i
;
6604 for (j
= 0; j
< size
; j
++)
6606 struct group_list
* g
;
6608 entry
= byte_get (indices
, 4);
6611 if (entry
>= elf_header
.e_shnum
)
6613 static unsigned num_group_errors
= 0;
6615 if (num_group_errors
++ < 10)
6617 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6618 entry
, i
, elf_header
.e_shnum
- 1);
6619 if (num_group_errors
== 10)
6620 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6625 if (section_headers_groups
[entry
] != NULL
)
6629 static unsigned num_errs
= 0;
6631 if (num_errs
++ < 10)
6633 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6635 section_headers_groups
[entry
]->group_index
);
6637 warn (_("Further error messages about already contained group sections suppressed\n"));
6643 /* Intel C/C++ compiler may put section 0 in a
6644 section group. We just warn it the first time
6645 and ignore it afterwards. */
6646 static int warned
= 0;
6649 error (_("section 0 in group section [%5u]\n"),
6650 section_headers_groups
[entry
]->group_index
);
6656 section_headers_groups
[entry
] = group
;
6658 if (do_section_groups
)
6660 sec
= section_headers
+ entry
;
6661 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6664 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6665 g
->section_index
= entry
;
6666 g
->next
= group
->root
;
6684 /* Data used to display dynamic fixups. */
6686 struct ia64_vms_dynfixup
6688 bfd_vma needed_ident
; /* Library ident number. */
6689 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6690 bfd_vma fixup_needed
; /* Index of the library. */
6691 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6692 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6695 /* Data used to display dynamic relocations. */
6697 struct ia64_vms_dynimgrela
6699 bfd_vma img_rela_cnt
; /* Number of relocations. */
6700 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6703 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6707 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6708 const char *strtab
, unsigned int strtab_sz
)
6710 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6712 const char *lib_name
;
6714 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6715 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6716 _("dynamic section image fixups"));
6720 if (fixup
->needed
< strtab_sz
)
6721 lib_name
= strtab
+ fixup
->needed
;
6724 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6725 (unsigned long) fixup
->needed
);
6728 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6729 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6731 (_("Seg Offset Type SymVec DataType\n"));
6733 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6738 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6739 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6740 type
= BYTE_GET (imfs
[i
].type
);
6741 rtype
= elf_ia64_reloc_type (type
);
6743 printf (" 0x%08x ", type
);
6745 printf (" %-32s ", rtype
);
6746 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6747 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6753 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6756 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6758 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6761 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6762 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6763 _("dynamic section image relocations"));
6767 printf (_("\nImage relocs\n"));
6769 (_("Seg Offset Type Addend Seg Sym Off\n"));
6771 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6776 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6777 printf ("%08" BFD_VMA_FMT
"x ",
6778 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6779 type
= BYTE_GET (imrs
[i
].type
);
6780 rtype
= elf_ia64_reloc_type (type
);
6782 printf ("0x%08x ", type
);
6784 printf ("%-31s ", rtype
);
6785 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6786 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6787 printf ("%08" BFD_VMA_FMT
"x\n",
6788 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6794 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6797 process_ia64_vms_dynamic_relocs (FILE *file
)
6799 struct ia64_vms_dynfixup fixup
;
6800 struct ia64_vms_dynimgrela imgrela
;
6801 Elf_Internal_Dyn
*entry
;
6803 bfd_vma strtab_off
= 0;
6804 bfd_vma strtab_sz
= 0;
6805 char *strtab
= NULL
;
6807 memset (&fixup
, 0, sizeof (fixup
));
6808 memset (&imgrela
, 0, sizeof (imgrela
));
6810 /* Note: the order of the entries is specified by the OpenVMS specs. */
6811 for (entry
= dynamic_section
;
6812 entry
< dynamic_section
+ dynamic_nent
;
6815 switch (entry
->d_tag
)
6817 case DT_IA_64_VMS_STRTAB_OFFSET
:
6818 strtab_off
= entry
->d_un
.d_val
;
6821 strtab_sz
= entry
->d_un
.d_val
;
6823 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6824 1, strtab_sz
, _("dynamic string section"));
6827 case DT_IA_64_VMS_NEEDED_IDENT
:
6828 fixup
.needed_ident
= entry
->d_un
.d_val
;
6831 fixup
.needed
= entry
->d_un
.d_val
;
6833 case DT_IA_64_VMS_FIXUP_NEEDED
:
6834 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6836 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6837 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6839 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6840 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6842 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6845 case DT_IA_64_VMS_IMG_RELA_CNT
:
6846 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6848 case DT_IA_64_VMS_IMG_RELA_OFF
:
6849 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6851 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6871 } dynamic_relocations
[] =
6873 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6874 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6875 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6878 /* Process the reloc section. */
6881 process_relocs (FILE * file
)
6883 unsigned long rel_size
;
6884 unsigned long rel_offset
;
6890 if (do_using_dynamic
)
6894 int has_dynamic_reloc
;
6897 has_dynamic_reloc
= 0;
6899 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6901 is_rela
= dynamic_relocations
[i
].rela
;
6902 name
= dynamic_relocations
[i
].name
;
6903 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6904 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6906 has_dynamic_reloc
|= rel_size
;
6908 if (is_rela
== UNKNOWN
)
6910 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6911 switch (dynamic_info
[DT_PLTREL
])
6925 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6926 name
, rel_offset
, rel_size
);
6928 dump_relocations (file
,
6929 offset_from_vma (file
, rel_offset
, rel_size
),
6931 dynamic_symbols
, num_dynamic_syms
,
6932 dynamic_strings
, dynamic_strings_length
,
6938 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6940 if (! has_dynamic_reloc
)
6941 printf (_("\nThere are no dynamic relocations in this file.\n"));
6945 Elf_Internal_Shdr
* section
;
6949 for (i
= 0, section
= section_headers
;
6950 i
< elf_header
.e_shnum
;
6953 if ( section
->sh_type
!= SHT_RELA
6954 && section
->sh_type
!= SHT_REL
)
6957 rel_offset
= section
->sh_offset
;
6958 rel_size
= section
->sh_size
;
6962 Elf_Internal_Shdr
* strsec
;
6965 printf (_("\nRelocation section "));
6967 if (string_table
== NULL
)
6968 printf ("%d", section
->sh_name
);
6970 printf ("'%s'", printable_section_name (section
));
6972 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6973 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6975 is_rela
= section
->sh_type
== SHT_RELA
;
6977 if (section
->sh_link
!= 0
6978 && section
->sh_link
< elf_header
.e_shnum
)
6980 Elf_Internal_Shdr
* symsec
;
6981 Elf_Internal_Sym
* symtab
;
6982 unsigned long nsyms
;
6983 unsigned long strtablen
= 0;
6984 char * strtab
= NULL
;
6986 symsec
= section_headers
+ section
->sh_link
;
6987 if (symsec
->sh_type
!= SHT_SYMTAB
6988 && symsec
->sh_type
!= SHT_DYNSYM
)
6991 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6996 if (symsec
->sh_link
!= 0
6997 && symsec
->sh_link
< elf_header
.e_shnum
)
6999 strsec
= section_headers
+ symsec
->sh_link
;
7001 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7004 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7007 dump_relocations (file
, rel_offset
, rel_size
,
7008 symtab
, nsyms
, strtab
, strtablen
,
7010 symsec
->sh_type
== SHT_DYNSYM
);
7016 dump_relocations (file
, rel_offset
, rel_size
,
7017 NULL
, 0, NULL
, 0, is_rela
, 0);
7024 printf (_("\nThere are no relocations in this file.\n"));
7030 /* An absolute address consists of a section and an offset. If the
7031 section is NULL, the offset itself is the address, otherwise, the
7032 address equals to LOAD_ADDRESS(section) + offset. */
7036 unsigned short section
;
7040 #define ABSADDR(a) \
7042 ? section_headers [(a).section].sh_addr + (a).offset \
7045 /* Find the nearest symbol at or below ADDR. Returns the symbol
7046 name, if found, and the offset from the symbol to ADDR. */
7049 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7050 unsigned long nsyms
,
7051 const char * strtab
,
7052 unsigned long strtab_size
,
7053 struct absaddr addr
,
7054 const char ** symname
,
7057 bfd_vma dist
= 0x100000;
7058 Elf_Internal_Sym
* sym
;
7059 Elf_Internal_Sym
* beg
;
7060 Elf_Internal_Sym
* end
;
7061 Elf_Internal_Sym
* best
= NULL
;
7063 REMOVE_ARCH_BITS (addr
.offset
);
7065 end
= symtab
+ nsyms
;
7071 sym
= beg
+ (end
- beg
) / 2;
7073 value
= sym
->st_value
;
7074 REMOVE_ARCH_BITS (value
);
7076 if (sym
->st_name
!= 0
7077 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7078 && addr
.offset
>= value
7079 && addr
.offset
- value
< dist
)
7082 dist
= addr
.offset
- value
;
7087 if (addr
.offset
< value
)
7095 *symname
= (best
->st_name
>= strtab_size
7096 ? _("<corrupt>") : strtab
+ best
->st_name
);
7102 *offset
= addr
.offset
;
7106 symcmp (const void *p
, const void *q
)
7108 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7109 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7111 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7114 /* Process the unwind section. */
7116 #include "unwind-ia64.h"
7118 struct ia64_unw_table_entry
7120 struct absaddr start
;
7122 struct absaddr info
;
7125 struct ia64_unw_aux_info
7127 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7128 unsigned long table_len
; /* Length of unwind table. */
7129 unsigned char * info
; /* Unwind info. */
7130 unsigned long info_size
; /* Size of unwind info. */
7131 bfd_vma info_addr
; /* Starting address of unwind info. */
7132 bfd_vma seg_base
; /* Starting address of segment. */
7133 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7134 unsigned long nsyms
; /* Number of symbols. */
7135 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7136 unsigned long nfuns
; /* Number of entries in funtab. */
7137 char * strtab
; /* The string table. */
7138 unsigned long strtab_size
; /* Size of string table. */
7142 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7144 struct ia64_unw_table_entry
* tp
;
7145 unsigned long j
, nfuns
;
7148 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7149 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7150 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7151 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7153 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7155 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7159 const unsigned char * dp
;
7160 const unsigned char * head
;
7161 const unsigned char * end
;
7162 const char * procname
;
7164 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7165 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7167 fputs ("\n<", stdout
);
7171 fputs (procname
, stdout
);
7174 printf ("+%lx", (unsigned long) offset
);
7177 fputs (">: [", stdout
);
7178 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7179 fputc ('-', stdout
);
7180 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7181 printf ("], info at +0x%lx\n",
7182 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7184 /* PR 17531: file: 86232b32. */
7185 if (aux
->info
== NULL
)
7188 /* PR 17531: file: 0997b4d1. */
7189 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7191 warn (_("Invalid offset %lx in table entry %ld\n"),
7192 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7196 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7197 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7199 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7200 (unsigned) UNW_VER (stamp
),
7201 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7202 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7203 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7204 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7206 if (UNW_VER (stamp
) != 1)
7208 printf (_("\tUnknown version.\n"));
7213 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7214 /* PR 17531: file: 16ceda89. */
7215 if (end
> aux
->info
+ aux
->info_size
)
7216 end
= aux
->info
+ aux
->info_size
;
7217 for (dp
= head
+ 8; dp
< end
;)
7218 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7225 slurp_ia64_unwind_table (FILE * file
,
7226 struct ia64_unw_aux_info
* aux
,
7227 Elf_Internal_Shdr
* sec
)
7229 unsigned long size
, nrelas
, i
;
7230 Elf_Internal_Phdr
* seg
;
7231 struct ia64_unw_table_entry
* tep
;
7232 Elf_Internal_Shdr
* relsec
;
7233 Elf_Internal_Rela
* rela
;
7234 Elf_Internal_Rela
* rp
;
7235 unsigned char * table
;
7237 Elf_Internal_Sym
* sym
;
7238 const char * relname
;
7242 /* First, find the starting address of the segment that includes
7245 if (elf_header
.e_phnum
)
7247 if (! get_program_headers (file
))
7250 for (seg
= program_headers
;
7251 seg
< program_headers
+ elf_header
.e_phnum
;
7254 if (seg
->p_type
!= PT_LOAD
)
7257 if (sec
->sh_addr
>= seg
->p_vaddr
7258 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7260 aux
->seg_base
= seg
->p_vaddr
;
7266 /* Second, build the unwind table from the contents of the unwind section: */
7267 size
= sec
->sh_size
;
7268 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7273 aux
->table_len
= size
/ (3 * eh_addr_size
);
7274 aux
->table
= (struct ia64_unw_table_entry
*)
7275 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7278 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7280 tep
->start
.section
= SHN_UNDEF
;
7281 tep
->end
.section
= SHN_UNDEF
;
7282 tep
->info
.section
= SHN_UNDEF
;
7283 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7284 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7285 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7286 tep
->start
.offset
+= aux
->seg_base
;
7287 tep
->end
.offset
+= aux
->seg_base
;
7288 tep
->info
.offset
+= aux
->seg_base
;
7292 /* Third, apply any relocations to the unwind table: */
7293 for (relsec
= section_headers
;
7294 relsec
< section_headers
+ elf_header
.e_shnum
;
7297 if (relsec
->sh_type
!= SHT_RELA
7298 || relsec
->sh_info
>= elf_header
.e_shnum
7299 || section_headers
+ relsec
->sh_info
!= sec
)
7302 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7311 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7313 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7314 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7316 /* PR 17531: file: 9fa67536. */
7317 if (relname
== NULL
)
7319 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7323 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7325 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7329 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7331 /* PR 17531: file: 5bc8d9bf. */
7332 if (i
>= aux
->table_len
)
7334 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7338 switch (rp
->r_offset
/ eh_addr_size
% 3)
7341 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7342 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7345 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7346 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7349 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7350 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7364 ia64_process_unwind (FILE * file
)
7366 Elf_Internal_Shdr
* sec
;
7367 Elf_Internal_Shdr
* unwsec
= NULL
;
7368 Elf_Internal_Shdr
* strsec
;
7369 unsigned long i
, unwcount
= 0, unwstart
= 0;
7370 struct ia64_unw_aux_info aux
;
7372 memset (& aux
, 0, sizeof (aux
));
7374 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7376 if (sec
->sh_type
== SHT_SYMTAB
7377 && sec
->sh_link
< elf_header
.e_shnum
)
7379 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7381 strsec
= section_headers
+ sec
->sh_link
;
7382 if (aux
.strtab
!= NULL
)
7384 error (_("Multiple auxillary string tables encountered\n"));
7387 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7390 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7392 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7397 printf (_("\nThere are no unwind sections in this file.\n"));
7399 while (unwcount
-- > 0)
7404 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7405 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7406 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7411 /* We have already counted the number of SHT_IA64_UNWIND
7412 sections so the loop above should never fail. */
7413 assert (unwsec
!= NULL
);
7416 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7418 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7420 /* We need to find which section group it is in. */
7421 struct group_list
* g
;
7423 if (section_headers_groups
== NULL
7424 || section_headers_groups
[i
] == NULL
)
7425 i
= elf_header
.e_shnum
;
7428 g
= section_headers_groups
[i
]->root
;
7430 for (; g
!= NULL
; g
= g
->next
)
7432 sec
= section_headers
+ g
->section_index
;
7434 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7439 i
= elf_header
.e_shnum
;
7442 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7444 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7445 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7446 suffix
= SECTION_NAME (unwsec
) + len
;
7447 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7449 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7450 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7455 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7456 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7457 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7458 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7460 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7461 suffix
= SECTION_NAME (unwsec
) + len
;
7462 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7464 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7465 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7469 if (i
== elf_header
.e_shnum
)
7471 printf (_("\nCould not find unwind info section for "));
7473 if (string_table
== NULL
)
7474 printf ("%d", unwsec
->sh_name
);
7476 printf ("'%s'", printable_section_name (unwsec
));
7480 aux
.info_addr
= sec
->sh_addr
;
7481 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7484 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7486 printf (_("\nUnwind section "));
7488 if (string_table
== NULL
)
7489 printf ("%d", unwsec
->sh_name
);
7491 printf ("'%s'", printable_section_name (unwsec
));
7493 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7494 (unsigned long) unwsec
->sh_offset
,
7495 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7497 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7498 && aux
.table_len
> 0)
7499 dump_ia64_unwind (& aux
);
7502 free ((char *) aux
.table
);
7504 free ((char *) aux
.info
);
7513 free ((char *) aux
.strtab
);
7516 struct hppa_unw_table_entry
7518 struct absaddr start
;
7520 unsigned int Cannot_unwind
:1; /* 0 */
7521 unsigned int Millicode
:1; /* 1 */
7522 unsigned int Millicode_save_sr0
:1; /* 2 */
7523 unsigned int Region_description
:2; /* 3..4 */
7524 unsigned int reserved1
:1; /* 5 */
7525 unsigned int Entry_SR
:1; /* 6 */
7526 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7527 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7528 unsigned int Args_stored
:1; /* 16 */
7529 unsigned int Variable_Frame
:1; /* 17 */
7530 unsigned int Separate_Package_Body
:1; /* 18 */
7531 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7532 unsigned int Stack_Overflow_Check
:1; /* 20 */
7533 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7534 unsigned int Ada_Region
:1; /* 22 */
7535 unsigned int cxx_info
:1; /* 23 */
7536 unsigned int cxx_try_catch
:1; /* 24 */
7537 unsigned int sched_entry_seq
:1; /* 25 */
7538 unsigned int reserved2
:1; /* 26 */
7539 unsigned int Save_SP
:1; /* 27 */
7540 unsigned int Save_RP
:1; /* 28 */
7541 unsigned int Save_MRP_in_frame
:1; /* 29 */
7542 unsigned int extn_ptr_defined
:1; /* 30 */
7543 unsigned int Cleanup_defined
:1; /* 31 */
7545 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7546 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7547 unsigned int Large_frame
:1; /* 2 */
7548 unsigned int Pseudo_SP_Set
:1; /* 3 */
7549 unsigned int reserved4
:1; /* 4 */
7550 unsigned int Total_frame_size
:27; /* 5..31 */
7553 struct hppa_unw_aux_info
7555 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7556 unsigned long table_len
; /* Length of unwind table. */
7557 bfd_vma seg_base
; /* Starting address of segment. */
7558 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7559 unsigned long nsyms
; /* Number of symbols. */
7560 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7561 unsigned long nfuns
; /* Number of entries in funtab. */
7562 char * strtab
; /* The string table. */
7563 unsigned long strtab_size
; /* Size of string table. */
7567 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7569 struct hppa_unw_table_entry
* tp
;
7570 unsigned long j
, nfuns
;
7572 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7573 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7574 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7575 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7577 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7579 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7582 const char * procname
;
7584 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7585 aux
->strtab_size
, tp
->start
, &procname
,
7588 fputs ("\n<", stdout
);
7592 fputs (procname
, stdout
);
7595 printf ("+%lx", (unsigned long) offset
);
7598 fputs (">: [", stdout
);
7599 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7600 fputc ('-', stdout
);
7601 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7604 #define PF(_m) if (tp->_m) printf (#_m " ");
7605 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7608 PF(Millicode_save_sr0
);
7609 /* PV(Region_description); */
7615 PF(Separate_Package_Body
);
7616 PF(Frame_Extension_Millicode
);
7617 PF(Stack_Overflow_Check
);
7618 PF(Two_Instruction_SP_Increment
);
7622 PF(sched_entry_seq
);
7625 PF(Save_MRP_in_frame
);
7626 PF(extn_ptr_defined
);
7627 PF(Cleanup_defined
);
7628 PF(MPE_XL_interrupt_marker
);
7629 PF(HP_UX_interrupt_marker
);
7632 PV(Total_frame_size
);
7643 slurp_hppa_unwind_table (FILE * file
,
7644 struct hppa_unw_aux_info
* aux
,
7645 Elf_Internal_Shdr
* sec
)
7647 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7648 Elf_Internal_Phdr
* seg
;
7649 struct hppa_unw_table_entry
* tep
;
7650 Elf_Internal_Shdr
* relsec
;
7651 Elf_Internal_Rela
* rela
;
7652 Elf_Internal_Rela
* rp
;
7653 unsigned char * table
;
7655 Elf_Internal_Sym
* sym
;
7656 const char * relname
;
7658 /* First, find the starting address of the segment that includes
7661 if (elf_header
.e_phnum
)
7663 if (! get_program_headers (file
))
7666 for (seg
= program_headers
;
7667 seg
< program_headers
+ elf_header
.e_phnum
;
7670 if (seg
->p_type
!= PT_LOAD
)
7673 if (sec
->sh_addr
>= seg
->p_vaddr
7674 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7676 aux
->seg_base
= seg
->p_vaddr
;
7682 /* Second, build the unwind table from the contents of the unwind
7684 size
= sec
->sh_size
;
7685 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7691 nentries
= size
/ unw_ent_size
;
7692 size
= unw_ent_size
* nentries
;
7694 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7695 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7697 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7699 unsigned int tmp1
, tmp2
;
7701 tep
->start
.section
= SHN_UNDEF
;
7702 tep
->end
.section
= SHN_UNDEF
;
7704 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7705 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7706 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7707 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7709 tep
->start
.offset
+= aux
->seg_base
;
7710 tep
->end
.offset
+= aux
->seg_base
;
7712 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7713 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7714 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7715 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7716 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7717 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7718 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7719 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7720 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7721 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7722 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7723 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7724 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7725 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7726 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7727 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7728 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7729 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7730 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7731 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7732 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7733 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7734 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7735 tep
->Cleanup_defined
= tmp1
& 0x1;
7737 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7738 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7739 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7740 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7741 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7742 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7746 /* Third, apply any relocations to the unwind table. */
7747 for (relsec
= section_headers
;
7748 relsec
< section_headers
+ elf_header
.e_shnum
;
7751 if (relsec
->sh_type
!= SHT_RELA
7752 || relsec
->sh_info
>= elf_header
.e_shnum
7753 || section_headers
+ relsec
->sh_info
!= sec
)
7756 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7760 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7762 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7763 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7765 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7766 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7768 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7772 i
= rp
->r_offset
/ unw_ent_size
;
7774 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7777 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7778 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7781 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7782 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7792 aux
->table_len
= nentries
;
7798 hppa_process_unwind (FILE * file
)
7800 struct hppa_unw_aux_info aux
;
7801 Elf_Internal_Shdr
* unwsec
= NULL
;
7802 Elf_Internal_Shdr
* strsec
;
7803 Elf_Internal_Shdr
* sec
;
7806 if (string_table
== NULL
)
7809 memset (& aux
, 0, sizeof (aux
));
7811 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7813 if (sec
->sh_type
== SHT_SYMTAB
7814 && sec
->sh_link
< elf_header
.e_shnum
)
7816 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7818 strsec
= section_headers
+ sec
->sh_link
;
7819 if (aux
.strtab
!= NULL
)
7821 error (_("Multiple auxillary string tables encountered\n"));
7824 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7827 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7829 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7834 printf (_("\nThere are no unwind sections in this file.\n"));
7836 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7838 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7840 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7841 printable_section_name (sec
),
7842 (unsigned long) sec
->sh_offset
,
7843 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7845 slurp_hppa_unwind_table (file
, &aux
, sec
);
7846 if (aux
.table_len
> 0)
7847 dump_hppa_unwind (&aux
);
7850 free ((char *) aux
.table
);
7858 free ((char *) aux
.strtab
);
7863 unsigned char * data
; /* The unwind data. */
7864 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7865 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7866 unsigned long nrelas
; /* The number of relocations. */
7867 unsigned int rel_type
; /* REL or RELA ? */
7868 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7871 struct arm_unw_aux_info
7873 FILE * file
; /* The file containing the unwind sections. */
7874 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7875 unsigned long nsyms
; /* Number of symbols. */
7876 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7877 unsigned long nfuns
; /* Number of these symbols. */
7878 char * strtab
; /* The file's string table. */
7879 unsigned long strtab_size
; /* Size of string table. */
7883 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7884 bfd_vma fn
, struct absaddr addr
)
7886 const char *procname
;
7889 if (addr
.section
== SHN_UNDEF
)
7892 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7893 aux
->strtab_size
, addr
, &procname
,
7896 print_vma (fn
, PREFIX_HEX
);
7900 fputs (" <", stdout
);
7901 fputs (procname
, stdout
);
7904 printf ("+0x%lx", (unsigned long) sym_offset
);
7905 fputc ('>', stdout
);
7912 arm_free_section (struct arm_section
*arm_sec
)
7914 if (arm_sec
->data
!= NULL
)
7915 free (arm_sec
->data
);
7917 if (arm_sec
->rela
!= NULL
)
7918 free (arm_sec
->rela
);
7921 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7922 cached section and install SEC instead.
7923 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7924 and return its valued in * WORDP, relocating if necessary.
7925 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7926 relocation's offset in ADDR.
7927 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7928 into the string table of the symbol associated with the reloc. If no
7929 reloc was applied store -1 there.
7930 5) Return TRUE upon success, FALSE otherwise. */
7933 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7934 struct arm_section
* arm_sec
,
7935 Elf_Internal_Shdr
* sec
,
7936 bfd_vma word_offset
,
7937 unsigned int * wordp
,
7938 struct absaddr
* addr
,
7941 Elf_Internal_Rela
*rp
;
7942 Elf_Internal_Sym
*sym
;
7943 const char * relname
;
7945 bfd_boolean wrapped
;
7947 if (sec
== NULL
|| arm_sec
== NULL
)
7950 addr
->section
= SHN_UNDEF
;
7953 if (sym_name
!= NULL
)
7954 *sym_name
= (bfd_vma
) -1;
7956 /* If necessary, update the section cache. */
7957 if (sec
!= arm_sec
->sec
)
7959 Elf_Internal_Shdr
*relsec
;
7961 arm_free_section (arm_sec
);
7964 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7965 sec
->sh_size
, _("unwind data"));
7966 arm_sec
->rela
= NULL
;
7967 arm_sec
->nrelas
= 0;
7969 for (relsec
= section_headers
;
7970 relsec
< section_headers
+ elf_header
.e_shnum
;
7973 if (relsec
->sh_info
>= elf_header
.e_shnum
7974 || section_headers
+ relsec
->sh_info
!= sec
7975 /* PR 15745: Check the section type as well. */
7976 || (relsec
->sh_type
!= SHT_REL
7977 && relsec
->sh_type
!= SHT_RELA
))
7980 arm_sec
->rel_type
= relsec
->sh_type
;
7981 if (relsec
->sh_type
== SHT_REL
)
7983 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7985 & arm_sec
->rela
, & arm_sec
->nrelas
))
7988 else /* relsec->sh_type == SHT_RELA */
7990 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7992 & arm_sec
->rela
, & arm_sec
->nrelas
))
7998 arm_sec
->next_rela
= arm_sec
->rela
;
8001 /* If there is no unwind data we can do nothing. */
8002 if (arm_sec
->data
== NULL
)
8005 /* If the offset is invalid then fail. */
8006 if (word_offset
> (sec
->sh_size
- 4)
8008 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
8009 || ((bfd_signed_vma
) word_offset
) < 0)
8012 /* Get the word at the required offset. */
8013 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8015 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8016 if (arm_sec
->rela
== NULL
)
8022 /* Look through the relocs to find the one that applies to the provided offset. */
8024 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8026 bfd_vma prelval
, offset
;
8028 if (rp
->r_offset
> word_offset
&& !wrapped
)
8033 if (rp
->r_offset
> word_offset
)
8036 if (rp
->r_offset
& 3)
8038 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8039 (unsigned long) rp
->r_offset
);
8043 if (rp
->r_offset
< word_offset
)
8046 /* PR 17531: file: 027-161405-0.004 */
8047 if (aux
->symtab
== NULL
)
8050 if (arm_sec
->rel_type
== SHT_REL
)
8052 offset
= word
& 0x7fffffff;
8053 if (offset
& 0x40000000)
8054 offset
|= ~ (bfd_vma
) 0x7fffffff;
8056 else if (arm_sec
->rel_type
== SHT_RELA
)
8057 offset
= rp
->r_addend
;
8060 error (_("Unknown section relocation type %d encountered\n"),
8065 /* PR 17531 file: 027-1241568-0.004. */
8066 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8068 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8069 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8073 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8074 offset
+= sym
->st_value
;
8075 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8077 /* Check that we are processing the expected reloc type. */
8078 if (elf_header
.e_machine
== EM_ARM
)
8080 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8081 if (relname
== NULL
)
8083 warn (_("Skipping unknown ARM relocation type: %d\n"),
8084 (int) ELF32_R_TYPE (rp
->r_info
));
8088 if (streq (relname
, "R_ARM_NONE"))
8091 if (! streq (relname
, "R_ARM_PREL31"))
8093 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8097 else if (elf_header
.e_machine
== EM_TI_C6000
)
8099 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8100 if (relname
== NULL
)
8102 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8103 (int) ELF32_R_TYPE (rp
->r_info
));
8107 if (streq (relname
, "R_C6000_NONE"))
8110 if (! streq (relname
, "R_C6000_PREL31"))
8112 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8120 /* This function currently only supports ARM and TI unwinders. */
8121 warn (_("Only TI and ARM unwinders are currently supported\n"));
8125 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8126 addr
->section
= sym
->st_shndx
;
8127 addr
->offset
= offset
;
8130 * sym_name
= sym
->st_name
;
8135 arm_sec
->next_rela
= rp
;
8140 static const char *tic6x_unwind_regnames
[16] =
8142 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8143 "A14", "A13", "A12", "A11", "A10",
8144 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8148 decode_tic6x_unwind_regmask (unsigned int mask
)
8152 for (i
= 12; mask
; mask
>>= 1, i
--)
8156 fputs (tic6x_unwind_regnames
[i
], stdout
);
8158 fputs (", ", stdout
);
8164 if (remaining == 0 && more_words) \
8167 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8168 data_offset, & word, & addr, NULL)) \
8174 #define GET_OP(OP) \
8179 (OP) = word >> 24; \
8184 printf (_("[Truncated opcode]\n")); \
8187 printf ("0x%02x ", OP)
8190 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8192 unsigned int remaining
,
8193 unsigned int more_words
,
8194 bfd_vma data_offset
,
8195 Elf_Internal_Shdr
* data_sec
,
8196 struct arm_section
* data_arm_sec
)
8198 struct absaddr addr
;
8200 /* Decode the unwinding instructions. */
8203 unsigned int op
, op2
;
8212 printf (" 0x%02x ", op
);
8214 if ((op
& 0xc0) == 0x00)
8216 int offset
= ((op
& 0x3f) << 2) + 4;
8218 printf (" vsp = vsp + %d", offset
);
8220 else if ((op
& 0xc0) == 0x40)
8222 int offset
= ((op
& 0x3f) << 2) + 4;
8224 printf (" vsp = vsp - %d", offset
);
8226 else if ((op
& 0xf0) == 0x80)
8229 if (op
== 0x80 && op2
== 0)
8230 printf (_("Refuse to unwind"));
8233 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8238 for (i
= 0; i
< 12; i
++)
8239 if (mask
& (1 << i
))
8245 printf ("r%d", 4 + i
);
8250 else if ((op
& 0xf0) == 0x90)
8252 if (op
== 0x9d || op
== 0x9f)
8253 printf (_(" [Reserved]"));
8255 printf (" vsp = r%d", op
& 0x0f);
8257 else if ((op
& 0xf0) == 0xa0)
8259 int end
= 4 + (op
& 0x07);
8264 for (i
= 4; i
<= end
; i
++)
8280 else if (op
== 0xb0)
8281 printf (_(" finish"));
8282 else if (op
== 0xb1)
8285 if (op2
== 0 || (op2
& 0xf0) != 0)
8286 printf (_("[Spare]"));
8289 unsigned int mask
= op2
& 0x0f;
8294 for (i
= 0; i
< 12; i
++)
8295 if (mask
& (1 << i
))
8306 else if (op
== 0xb2)
8308 unsigned char buf
[9];
8309 unsigned int i
, len
;
8310 unsigned long offset
;
8312 for (i
= 0; i
< sizeof (buf
); i
++)
8315 if ((buf
[i
] & 0x80) == 0)
8318 if (i
== sizeof (buf
))
8319 printf (_("corrupt change to vsp"));
8322 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8323 assert (len
== i
+ 1);
8324 offset
= offset
* 4 + 0x204;
8325 printf ("vsp = vsp + %ld", offset
);
8328 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8330 unsigned int first
, last
;
8337 printf ("pop {D%d", first
);
8339 printf ("-D%d", first
+ last
);
8342 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8344 unsigned int count
= op
& 0x07;
8348 printf ("-D%d", 8 + count
);
8351 else if (op
>= 0xc0 && op
<= 0xc5)
8353 unsigned int count
= op
& 0x07;
8355 printf (" pop {wR10");
8357 printf ("-wR%d", 10 + count
);
8360 else if (op
== 0xc6)
8362 unsigned int first
, last
;
8367 printf ("pop {wR%d", first
);
8369 printf ("-wR%d", first
+ last
);
8372 else if (op
== 0xc7)
8375 if (op2
== 0 || (op2
& 0xf0) != 0)
8376 printf (_("[Spare]"));
8379 unsigned int mask
= op2
& 0x0f;
8384 for (i
= 0; i
< 4; i
++)
8385 if (mask
& (1 << i
))
8391 printf ("wCGR%d", i
);
8397 printf (_(" [unsupported opcode]"));
8403 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8405 unsigned int remaining
,
8406 unsigned int more_words
,
8407 bfd_vma data_offset
,
8408 Elf_Internal_Shdr
* data_sec
,
8409 struct arm_section
* data_arm_sec
)
8411 struct absaddr addr
;
8413 /* Decode the unwinding instructions. */
8416 unsigned int op
, op2
;
8425 printf (" 0x%02x ", op
);
8427 if ((op
& 0xc0) == 0x00)
8429 int offset
= ((op
& 0x3f) << 3) + 8;
8430 printf (" sp = sp + %d", offset
);
8432 else if ((op
& 0xc0) == 0x80)
8435 if (op
== 0x80 && op2
== 0)
8436 printf (_("Refuse to unwind"));
8439 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8441 printf ("pop compact {");
8445 decode_tic6x_unwind_regmask (mask
);
8449 else if ((op
& 0xf0) == 0xc0)
8457 unsigned int offset
;
8461 /* Scan entire instruction first so that GET_OP output is not
8462 interleaved with disassembly. */
8464 for (i
= 0; nregs
< (op
& 0xf); i
++)
8470 regpos
[nregs
].offset
= i
* 2;
8471 regpos
[nregs
].reg
= reg
;
8478 regpos
[nregs
].offset
= i
* 2 + 1;
8479 regpos
[nregs
].reg
= reg
;
8484 printf (_("pop frame {"));
8486 for (i
= i
* 2; i
> 0; i
--)
8488 if (regpos
[reg
].offset
== i
- 1)
8490 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8497 fputs (name
, stdout
);
8504 else if (op
== 0xd0)
8505 printf (" MOV FP, SP");
8506 else if (op
== 0xd1)
8507 printf (" __c6xabi_pop_rts");
8508 else if (op
== 0xd2)
8510 unsigned char buf
[9];
8511 unsigned int i
, len
;
8512 unsigned long offset
;
8514 for (i
= 0; i
< sizeof (buf
); i
++)
8517 if ((buf
[i
] & 0x80) == 0)
8520 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8521 if (i
== sizeof (buf
))
8523 printf ("<corrupt sp adjust>\n");
8524 warn (_("Corrupt stack pointer adjustment detected\n"));
8528 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8529 assert (len
== i
+ 1);
8530 offset
= offset
* 8 + 0x408;
8531 printf (_("sp = sp + %ld"), offset
);
8533 else if ((op
& 0xf0) == 0xe0)
8535 if ((op
& 0x0f) == 7)
8538 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8542 printf (_(" [unsupported opcode]"));
8549 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8553 offset
= word
& 0x7fffffff;
8554 if (offset
& 0x40000000)
8555 offset
|= ~ (bfd_vma
) 0x7fffffff;
8557 if (elf_header
.e_machine
== EM_TI_C6000
)
8560 return offset
+ where
;
8564 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8566 unsigned int remaining
,
8567 bfd_vma data_offset
,
8568 Elf_Internal_Shdr
* data_sec
,
8569 struct arm_section
* data_arm_sec
)
8572 unsigned int more_words
= 0;
8573 struct absaddr addr
;
8574 bfd_vma sym_name
= (bfd_vma
) -1;
8578 /* Fetch the first word.
8579 Note - when decoding an object file the address extracted
8580 here will always be 0. So we also pass in the sym_name
8581 parameter so that we can find the symbol associated with
8582 the personality routine. */
8583 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8584 & word
, & addr
, & sym_name
))
8590 if ((word
& 0x80000000) == 0)
8592 /* Expand prel31 for personality routine. */
8594 const char *procname
;
8596 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8597 printf (_(" Personality routine: "));
8599 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8600 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8602 procname
= aux
->strtab
+ sym_name
;
8603 print_vma (fn
, PREFIX_HEX
);
8606 fputs (" <", stdout
);
8607 fputs (procname
, stdout
);
8608 fputc ('>', stdout
);
8612 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8613 fputc ('\n', stdout
);
8615 /* The GCC personality routines use the standard compact
8616 encoding, starting with one byte giving the number of
8618 if (procname
!= NULL
8619 && (const_strneq (procname
, "__gcc_personality_v0")
8620 || const_strneq (procname
, "__gxx_personality_v0")
8621 || const_strneq (procname
, "__gcj_personality_v0")
8622 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8629 printf (_(" [Truncated data]\n"));
8632 more_words
= word
>> 24;
8642 /* ARM EHABI Section 6.3:
8644 An exception-handling table entry for the compact model looks like:
8648 1 0 index Data for personalityRoutine[index] */
8650 if (elf_header
.e_machine
== EM_ARM
8651 && (word
& 0x70000000))
8652 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8654 per_index
= (word
>> 24) & 0x7f;
8655 printf (_(" Compact model index: %d\n"), per_index
);
8662 else if (per_index
< 3)
8664 more_words
= (word
>> 16) & 0xff;
8670 switch (elf_header
.e_machine
)
8675 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8676 data_offset
, data_sec
, data_arm_sec
);
8680 warn (_("Unknown ARM compact model index encountered\n"));
8681 printf (_(" [reserved]\n"));
8688 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8689 data_offset
, data_sec
, data_arm_sec
);
8691 else if (per_index
< 5)
8693 if (((word
>> 17) & 0x7f) == 0x7f)
8694 printf (_(" Restore stack from frame pointer\n"));
8696 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8697 printf (_(" Registers restored: "));
8699 printf (" (compact) ");
8700 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8702 printf (_(" Return register: %s\n"),
8703 tic6x_unwind_regnames
[word
& 0xf]);
8706 printf (_(" [reserved (%d)]\n"), per_index
);
8710 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8711 elf_header
.e_machine
);
8714 /* Decode the descriptors. Not implemented. */
8718 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8720 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8721 unsigned int i
, exidx_len
;
8722 unsigned long j
, nfuns
;
8724 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8725 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8726 exidx_len
= exidx_sec
->sh_size
/ 8;
8728 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8729 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8730 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8731 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8733 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8735 for (i
= 0; i
< exidx_len
; i
++)
8737 unsigned int exidx_fn
, exidx_entry
;
8738 struct absaddr fn_addr
, entry_addr
;
8741 fputc ('\n', stdout
);
8743 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8744 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8745 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8746 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8749 arm_free_section (& exidx_arm_sec
);
8750 arm_free_section (& extab_arm_sec
);
8754 /* ARM EHABI, Section 5:
8755 An index table entry consists of 2 words.
8756 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8757 if (exidx_fn
& 0x80000000)
8758 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8760 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8762 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8763 fputs (": ", stdout
);
8765 if (exidx_entry
== 1)
8767 print_vma (exidx_entry
, PREFIX_HEX
);
8768 fputs (" [cantunwind]\n", stdout
);
8770 else if (exidx_entry
& 0x80000000)
8772 print_vma (exidx_entry
, PREFIX_HEX
);
8773 fputc ('\n', stdout
);
8774 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8778 bfd_vma table
, table_offset
= 0;
8779 Elf_Internal_Shdr
*table_sec
;
8781 fputs ("@", stdout
);
8782 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8783 print_vma (table
, PREFIX_HEX
);
8786 /* Locate the matching .ARM.extab. */
8787 if (entry_addr
.section
!= SHN_UNDEF
8788 && entry_addr
.section
< elf_header
.e_shnum
)
8790 table_sec
= section_headers
+ entry_addr
.section
;
8791 table_offset
= entry_addr
.offset
;
8793 if (table_offset
> table_sec
->sh_size
8794 || ((bfd_signed_vma
) table_offset
) < 0)
8796 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8797 (unsigned long) table_offset
,
8798 printable_section_name (table_sec
));
8804 table_sec
= find_section_by_address (table
);
8805 if (table_sec
!= NULL
)
8806 table_offset
= table
- table_sec
->sh_addr
;
8808 if (table_sec
== NULL
)
8810 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8811 (unsigned long) table
);
8814 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8822 arm_free_section (&exidx_arm_sec
);
8823 arm_free_section (&extab_arm_sec
);
8826 /* Used for both ARM and C6X unwinding tables. */
8829 arm_process_unwind (FILE *file
)
8831 struct arm_unw_aux_info aux
;
8832 Elf_Internal_Shdr
*unwsec
= NULL
;
8833 Elf_Internal_Shdr
*strsec
;
8834 Elf_Internal_Shdr
*sec
;
8836 unsigned int sec_type
;
8838 switch (elf_header
.e_machine
)
8841 sec_type
= SHT_ARM_EXIDX
;
8845 sec_type
= SHT_C6000_UNWIND
;
8849 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8850 elf_header
.e_machine
);
8854 if (string_table
== NULL
)
8857 memset (& aux
, 0, sizeof (aux
));
8860 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8862 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8864 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8866 strsec
= section_headers
+ sec
->sh_link
;
8868 /* PR binutils/17531 file: 011-12666-0.004. */
8869 if (aux
.strtab
!= NULL
)
8871 error (_("Multiple string tables found in file.\n"));
8874 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8875 1, strsec
->sh_size
, _("string table"));
8876 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8878 else if (sec
->sh_type
== sec_type
)
8883 printf (_("\nThere are no unwind sections in this file.\n"));
8885 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8887 if (sec
->sh_type
== sec_type
)
8889 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8890 printable_section_name (sec
),
8891 (unsigned long) sec
->sh_offset
,
8892 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8894 dump_arm_unwind (&aux
, sec
);
8901 free ((char *) aux
.strtab
);
8905 process_unwind (FILE * file
)
8907 struct unwind_handler
8910 void (* handler
)(FILE *);
8913 { EM_ARM
, arm_process_unwind
},
8914 { EM_IA_64
, ia64_process_unwind
},
8915 { EM_PARISC
, hppa_process_unwind
},
8916 { EM_TI_C6000
, arm_process_unwind
},
8924 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8925 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8927 handlers
[i
].handler (file
);
8931 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8932 get_machine_name (elf_header
.e_machine
));
8936 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8938 switch (entry
->d_tag
)
8941 if (entry
->d_un
.d_val
== 0)
8945 static const char * opts
[] =
8947 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8948 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8949 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8950 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8956 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8957 if (entry
->d_un
.d_val
& (1 << cnt
))
8959 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8965 case DT_MIPS_IVERSION
:
8966 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8967 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8971 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8972 /* Note: coded this way so that there is a single string for translation. */
8973 printf (_("<corrupt: %s>"), buf
);
8977 case DT_MIPS_TIME_STAMP
:
8981 time_t atime
= entry
->d_un
.d_val
;
8983 tmp
= gmtime (&atime
);
8984 /* PR 17531: file: 6accc532. */
8986 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8988 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8989 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8990 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8991 printf (_("Time Stamp: %s"), timebuf
);
8995 case DT_MIPS_RLD_VERSION
:
8996 case DT_MIPS_LOCAL_GOTNO
:
8997 case DT_MIPS_CONFLICTNO
:
8998 case DT_MIPS_LIBLISTNO
:
8999 case DT_MIPS_SYMTABNO
:
9000 case DT_MIPS_UNREFEXTNO
:
9001 case DT_MIPS_HIPAGENO
:
9002 case DT_MIPS_DELTA_CLASS_NO
:
9003 case DT_MIPS_DELTA_INSTANCE_NO
:
9004 case DT_MIPS_DELTA_RELOC_NO
:
9005 case DT_MIPS_DELTA_SYM_NO
:
9006 case DT_MIPS_DELTA_CLASSSYM_NO
:
9007 case DT_MIPS_COMPACT_SIZE
:
9008 print_vma (entry
->d_un
.d_val
, DEC
);
9012 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9018 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9020 switch (entry
->d_tag
)
9022 case DT_HP_DLD_FLAGS
:
9031 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9032 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9033 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9034 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9035 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9036 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9037 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9038 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9039 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9040 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9041 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9042 { DT_HP_GST
, "HP_GST" },
9043 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9044 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9045 { DT_HP_NODELETE
, "HP_NODELETE" },
9046 { DT_HP_GROUP
, "HP_GROUP" },
9047 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9051 bfd_vma val
= entry
->d_un
.d_val
;
9053 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9054 if (val
& flags
[cnt
].bit
)
9058 fputs (flags
[cnt
].str
, stdout
);
9060 val
^= flags
[cnt
].bit
;
9063 if (val
!= 0 || first
)
9067 print_vma (val
, HEX
);
9073 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9081 /* VMS vs Unix time offset and factor. */
9083 #define VMS_EPOCH_OFFSET 35067168000000000LL
9084 #define VMS_GRANULARITY_FACTOR 10000000
9086 /* Display a VMS time in a human readable format. */
9089 print_vms_time (bfd_int64_t vmstime
)
9094 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9095 tm
= gmtime (&unxtime
);
9096 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9097 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9098 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9103 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9105 switch (entry
->d_tag
)
9107 case DT_IA_64_PLT_RESERVE
:
9108 /* First 3 slots reserved. */
9109 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9111 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9114 case DT_IA_64_VMS_LINKTIME
:
9116 print_vms_time (entry
->d_un
.d_val
);
9120 case DT_IA_64_VMS_LNKFLAGS
:
9121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9122 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9123 printf (" CALL_DEBUG");
9124 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9125 printf (" NOP0BUFS");
9126 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9127 printf (" P0IMAGE");
9128 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9129 printf (" MKTHREADS");
9130 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9131 printf (" UPCALLS");
9132 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9134 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9135 printf (" INITIALIZE");
9136 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9138 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9139 printf (" EXE_INIT");
9140 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9141 printf (" TBK_IN_IMG");
9142 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9143 printf (" DBG_IN_IMG");
9144 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9145 printf (" TBK_IN_DSF");
9146 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9147 printf (" DBG_IN_DSF");
9148 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9149 printf (" SIGNATURES");
9150 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9151 printf (" REL_SEG_OFF");
9155 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9162 get_32bit_dynamic_section (FILE * file
)
9164 Elf32_External_Dyn
* edyn
;
9165 Elf32_External_Dyn
* ext
;
9166 Elf_Internal_Dyn
* entry
;
9168 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9169 dynamic_size
, _("dynamic section"));
9173 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9174 might not have the luxury of section headers. Look for the DT_NULL
9175 terminator to determine the number of entries. */
9176 for (ext
= edyn
, dynamic_nent
= 0;
9177 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9181 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9185 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9187 if (dynamic_section
== NULL
)
9189 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9190 (unsigned long) dynamic_nent
);
9195 for (ext
= edyn
, entry
= dynamic_section
;
9196 entry
< dynamic_section
+ dynamic_nent
;
9199 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9200 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9209 get_64bit_dynamic_section (FILE * file
)
9211 Elf64_External_Dyn
* edyn
;
9212 Elf64_External_Dyn
* ext
;
9213 Elf_Internal_Dyn
* entry
;
9215 /* Read in the data. */
9216 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9217 dynamic_size
, _("dynamic section"));
9221 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9222 might not have the luxury of section headers. Look for the DT_NULL
9223 terminator to determine the number of entries. */
9224 for (ext
= edyn
, dynamic_nent
= 0;
9225 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9226 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9230 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9234 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9236 if (dynamic_section
== NULL
)
9238 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9239 (unsigned long) dynamic_nent
);
9244 /* Convert from external to internal formats. */
9245 for (ext
= edyn
, entry
= dynamic_section
;
9246 entry
< dynamic_section
+ dynamic_nent
;
9249 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9250 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9259 print_dynamic_flags (bfd_vma flags
)
9267 flag
= flags
& - flags
;
9277 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9278 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9279 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9280 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9281 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9282 default: fputs (_("unknown"), stdout
); break;
9288 /* Parse and display the contents of the dynamic section. */
9291 process_dynamic_section (FILE * file
)
9293 Elf_Internal_Dyn
* entry
;
9295 if (dynamic_size
== 0)
9298 printf (_("\nThere is no dynamic section in this file.\n"));
9305 if (! get_32bit_dynamic_section (file
))
9308 else if (! get_64bit_dynamic_section (file
))
9311 /* Find the appropriate symbol table. */
9312 if (dynamic_symbols
== NULL
)
9314 for (entry
= dynamic_section
;
9315 entry
< dynamic_section
+ dynamic_nent
;
9318 Elf_Internal_Shdr section
;
9320 if (entry
->d_tag
!= DT_SYMTAB
)
9323 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9325 /* Since we do not know how big the symbol table is,
9326 we default to reading in the entire file (!) and
9327 processing that. This is overkill, I know, but it
9329 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9331 if (archive_file_offset
!= 0)
9332 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9335 if (fseek (file
, 0, SEEK_END
))
9336 error (_("Unable to seek to end of file!\n"));
9338 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9342 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9344 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9345 section
.sh_name
= string_table_length
;
9347 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9348 if (num_dynamic_syms
< 1)
9350 error (_("Unable to determine the number of symbols to load\n"));
9356 /* Similarly find a string table. */
9357 if (dynamic_strings
== NULL
)
9359 for (entry
= dynamic_section
;
9360 entry
< dynamic_section
+ dynamic_nent
;
9363 unsigned long offset
;
9366 if (entry
->d_tag
!= DT_STRTAB
)
9369 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9371 /* Since we do not know how big the string table is,
9372 we default to reading in the entire file (!) and
9373 processing that. This is overkill, I know, but it
9376 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9378 if (archive_file_offset
!= 0)
9379 str_tab_len
= archive_file_size
- offset
;
9382 if (fseek (file
, 0, SEEK_END
))
9383 error (_("Unable to seek to end of file\n"));
9384 str_tab_len
= ftell (file
) - offset
;
9387 if (str_tab_len
< 1)
9390 (_("Unable to determine the length of the dynamic string table\n"));
9394 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9396 _("dynamic string table"));
9397 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9402 /* And find the syminfo section if available. */
9403 if (dynamic_syminfo
== NULL
)
9405 unsigned long syminsz
= 0;
9407 for (entry
= dynamic_section
;
9408 entry
< dynamic_section
+ dynamic_nent
;
9411 if (entry
->d_tag
== DT_SYMINENT
)
9413 /* Note: these braces are necessary to avoid a syntax
9414 error from the SunOS4 C compiler. */
9415 /* PR binutils/17531: A corrupt file can trigger this test.
9416 So do not use an assert, instead generate an error message. */
9417 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9418 error (_("Bad value (%d) for SYMINENT entry\n"),
9419 (int) entry
->d_un
.d_val
);
9421 else if (entry
->d_tag
== DT_SYMINSZ
)
9422 syminsz
= entry
->d_un
.d_val
;
9423 else if (entry
->d_tag
== DT_SYMINFO
)
9424 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9428 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9430 Elf_External_Syminfo
* extsyminfo
;
9431 Elf_External_Syminfo
* extsym
;
9432 Elf_Internal_Syminfo
* syminfo
;
9434 /* There is a syminfo section. Read the data. */
9435 extsyminfo
= (Elf_External_Syminfo
*)
9436 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9437 _("symbol information"));
9441 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9442 if (dynamic_syminfo
== NULL
)
9444 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9445 (unsigned long) syminsz
);
9449 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9450 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9451 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9452 ++syminfo
, ++extsym
)
9454 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9455 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9462 if (do_dynamic
&& dynamic_addr
)
9463 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9464 dynamic_addr
, (unsigned long) dynamic_nent
);
9466 printf (_(" Tag Type Name/Value\n"));
9468 for (entry
= dynamic_section
;
9469 entry
< dynamic_section
+ dynamic_nent
;
9477 print_vma (entry
->d_tag
, FULL_HEX
);
9478 dtype
= get_dynamic_type (entry
->d_tag
);
9479 printf (" (%s)%*s", dtype
,
9480 ((is_32bit_elf
? 27 : 19)
9481 - (int) strlen (dtype
)),
9485 switch (entry
->d_tag
)
9489 print_dynamic_flags (entry
->d_un
.d_val
);
9499 switch (entry
->d_tag
)
9502 printf (_("Auxiliary library"));
9506 printf (_("Filter library"));
9510 printf (_("Configuration file"));
9514 printf (_("Dependency audit library"));
9518 printf (_("Audit library"));
9522 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9523 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9527 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9536 printf (_("Flags:"));
9538 if (entry
->d_un
.d_val
== 0)
9539 printf (_(" None\n"));
9542 unsigned long int val
= entry
->d_un
.d_val
;
9544 if (val
& DTF_1_PARINIT
)
9546 printf (" PARINIT");
9547 val
^= DTF_1_PARINIT
;
9549 if (val
& DTF_1_CONFEXP
)
9551 printf (" CONFEXP");
9552 val
^= DTF_1_CONFEXP
;
9555 printf (" %lx", val
);
9564 printf (_("Flags:"));
9566 if (entry
->d_un
.d_val
== 0)
9567 printf (_(" None\n"));
9570 unsigned long int val
= entry
->d_un
.d_val
;
9572 if (val
& DF_P1_LAZYLOAD
)
9574 printf (" LAZYLOAD");
9575 val
^= DF_P1_LAZYLOAD
;
9577 if (val
& DF_P1_GROUPPERM
)
9579 printf (" GROUPPERM");
9580 val
^= DF_P1_GROUPPERM
;
9583 printf (" %lx", val
);
9592 printf (_("Flags:"));
9593 if (entry
->d_un
.d_val
== 0)
9594 printf (_(" None\n"));
9597 unsigned long int val
= entry
->d_un
.d_val
;
9604 if (val
& DF_1_GLOBAL
)
9609 if (val
& DF_1_GROUP
)
9614 if (val
& DF_1_NODELETE
)
9616 printf (" NODELETE");
9617 val
^= DF_1_NODELETE
;
9619 if (val
& DF_1_LOADFLTR
)
9621 printf (" LOADFLTR");
9622 val
^= DF_1_LOADFLTR
;
9624 if (val
& DF_1_INITFIRST
)
9626 printf (" INITFIRST");
9627 val
^= DF_1_INITFIRST
;
9629 if (val
& DF_1_NOOPEN
)
9634 if (val
& DF_1_ORIGIN
)
9639 if (val
& DF_1_DIRECT
)
9644 if (val
& DF_1_TRANS
)
9649 if (val
& DF_1_INTERPOSE
)
9651 printf (" INTERPOSE");
9652 val
^= DF_1_INTERPOSE
;
9654 if (val
& DF_1_NODEFLIB
)
9656 printf (" NODEFLIB");
9657 val
^= DF_1_NODEFLIB
;
9659 if (val
& DF_1_NODUMP
)
9664 if (val
& DF_1_CONFALT
)
9666 printf (" CONFALT");
9667 val
^= DF_1_CONFALT
;
9669 if (val
& DF_1_ENDFILTEE
)
9671 printf (" ENDFILTEE");
9672 val
^= DF_1_ENDFILTEE
;
9674 if (val
& DF_1_DISPRELDNE
)
9676 printf (" DISPRELDNE");
9677 val
^= DF_1_DISPRELDNE
;
9679 if (val
& DF_1_DISPRELPND
)
9681 printf (" DISPRELPND");
9682 val
^= DF_1_DISPRELPND
;
9684 if (val
& DF_1_NODIRECT
)
9686 printf (" NODIRECT");
9687 val
^= DF_1_NODIRECT
;
9689 if (val
& DF_1_IGNMULDEF
)
9691 printf (" IGNMULDEF");
9692 val
^= DF_1_IGNMULDEF
;
9694 if (val
& DF_1_NOKSYMS
)
9696 printf (" NOKSYMS");
9697 val
^= DF_1_NOKSYMS
;
9699 if (val
& DF_1_NOHDR
)
9704 if (val
& DF_1_EDITED
)
9709 if (val
& DF_1_NORELOC
)
9711 printf (" NORELOC");
9712 val
^= DF_1_NORELOC
;
9714 if (val
& DF_1_SYMINTPOSE
)
9716 printf (" SYMINTPOSE");
9717 val
^= DF_1_SYMINTPOSE
;
9719 if (val
& DF_1_GLOBAUDIT
)
9721 printf (" GLOBAUDIT");
9722 val
^= DF_1_GLOBAUDIT
;
9724 if (val
& DF_1_SINGLETON
)
9726 printf (" SINGLETON");
9727 val
^= DF_1_SINGLETON
;
9729 if (val
& DF_1_STUB
)
9740 printf (" %lx", val
);
9747 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9749 puts (get_dynamic_type (entry
->d_un
.d_val
));
9769 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9775 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9776 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9782 switch (entry
->d_tag
)
9785 printf (_("Shared library: [%s]"), name
);
9787 if (streq (name
, program_interpreter
))
9788 printf (_(" program interpreter"));
9792 printf (_("Library soname: [%s]"), name
);
9796 printf (_("Library rpath: [%s]"), name
);
9800 printf (_("Library runpath: [%s]"), name
);
9804 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9809 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9822 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9827 case DT_INIT_ARRAYSZ
:
9828 case DT_FINI_ARRAYSZ
:
9829 case DT_GNU_CONFLICTSZ
:
9830 case DT_GNU_LIBLISTSZ
:
9833 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9834 printf (_(" (bytes)\n"));
9844 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9857 if (entry
->d_tag
== DT_USED
9858 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9860 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9864 printf (_("Not needed object: [%s]\n"), name
);
9869 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9875 /* The value of this entry is ignored. */
9880 case DT_GNU_PRELINKED
:
9884 time_t atime
= entry
->d_un
.d_val
;
9886 tmp
= gmtime (&atime
);
9887 /* PR 17533 file: 041-1244816-0.004. */
9889 printf (_("<corrupt time val: %lx"),
9890 (unsigned long) atime
);
9892 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9893 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9894 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9900 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9903 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9909 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9910 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9915 switch (elf_header
.e_machine
)
9918 case EM_MIPS_RS3_LE
:
9919 dynamic_section_mips_val (entry
);
9922 dynamic_section_parisc_val (entry
);
9925 dynamic_section_ia64_val (entry
);
9928 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9940 get_ver_flags (unsigned int flags
)
9942 static char buff
[32];
9949 if (flags
& VER_FLG_BASE
)
9950 strcat (buff
, "BASE ");
9952 if (flags
& VER_FLG_WEAK
)
9954 if (flags
& VER_FLG_BASE
)
9955 strcat (buff
, "| ");
9957 strcat (buff
, "WEAK ");
9960 if (flags
& VER_FLG_INFO
)
9962 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9963 strcat (buff
, "| ");
9965 strcat (buff
, "INFO ");
9968 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9969 strcat (buff
, _("| <unknown>"));
9974 /* Display the contents of the version sections. */
9977 process_version_sections (FILE * file
)
9979 Elf_Internal_Shdr
* section
;
9986 for (i
= 0, section
= section_headers
;
9987 i
< elf_header
.e_shnum
;
9990 switch (section
->sh_type
)
9992 case SHT_GNU_verdef
:
9994 Elf_External_Verdef
* edefs
;
10002 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10003 printable_section_name (section
),
10006 printf (_(" Addr: 0x"));
10007 printf_vma (section
->sh_addr
);
10008 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10009 (unsigned long) section
->sh_offset
, section
->sh_link
,
10010 printable_section_name_from_index (section
->sh_link
));
10012 edefs
= (Elf_External_Verdef
*)
10013 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10014 _("version definition section"));
10017 endbuf
= (char *) edefs
+ section
->sh_size
;
10019 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10020 end
= (section
->sh_info
< section
->sh_size
10021 ? section
->sh_info
: section
->sh_size
);
10022 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10025 Elf_External_Verdef
* edef
;
10026 Elf_Internal_Verdef ent
;
10027 Elf_External_Verdaux
* eaux
;
10028 Elf_Internal_Verdaux aux
;
10032 /* Check for very large indices. */
10033 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10036 vstart
= ((char *) edefs
) + idx
;
10037 if (vstart
+ sizeof (*edef
) > endbuf
)
10040 edef
= (Elf_External_Verdef
*) vstart
;
10042 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10043 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10044 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10045 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10046 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10047 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10048 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10050 printf (_(" %#06x: Rev: %d Flags: %s"),
10051 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10053 printf (_(" Index: %d Cnt: %d "),
10054 ent
.vd_ndx
, ent
.vd_cnt
);
10056 /* Check for overflow. */
10057 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10060 vstart
+= ent
.vd_aux
;
10062 eaux
= (Elf_External_Verdaux
*) vstart
;
10064 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10065 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10067 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10068 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10070 printf (_("Name index: %ld\n"), aux
.vda_name
);
10072 isum
= idx
+ ent
.vd_aux
;
10074 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10076 /* Check for overflow. */
10077 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10080 isum
+= aux
.vda_next
;
10081 vstart
+= aux
.vda_next
;
10083 eaux
= (Elf_External_Verdaux
*) vstart
;
10084 if (vstart
+ sizeof (*eaux
) > endbuf
)
10087 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10088 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10090 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10091 printf (_(" %#06x: Parent %d: %s\n"),
10092 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10094 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10095 isum
, j
, aux
.vda_name
);
10098 if (j
< ent
.vd_cnt
)
10099 printf (_(" Version def aux past end of section\n"));
10102 file: id:000001,src:000172+005151,op:splice,rep:2. */
10103 if (idx
+ ent
.vd_next
< idx
)
10106 idx
+= ent
.vd_next
;
10109 if (cnt
< section
->sh_info
)
10110 printf (_(" Version definition past end of section\n"));
10116 case SHT_GNU_verneed
:
10118 Elf_External_Verneed
* eneed
;
10125 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10126 printable_section_name (section
), section
->sh_info
);
10128 printf (_(" Addr: 0x"));
10129 printf_vma (section
->sh_addr
);
10130 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10131 (unsigned long) section
->sh_offset
, section
->sh_link
,
10132 printable_section_name_from_index (section
->sh_link
));
10134 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10135 section
->sh_offset
, 1,
10137 _("Version Needs section"));
10140 endbuf
= (char *) eneed
+ section
->sh_size
;
10142 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10144 Elf_External_Verneed
* entry
;
10145 Elf_Internal_Verneed ent
;
10150 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10153 vstart
= ((char *) eneed
) + idx
;
10154 if (vstart
+ sizeof (*entry
) > endbuf
)
10157 entry
= (Elf_External_Verneed
*) vstart
;
10159 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10160 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10161 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10162 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10163 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10165 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10167 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10168 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10170 printf (_(" File: %lx"), ent
.vn_file
);
10172 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10174 /* Check for overflow. */
10175 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10177 vstart
+= ent
.vn_aux
;
10179 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10181 Elf_External_Vernaux
* eaux
;
10182 Elf_Internal_Vernaux aux
;
10184 if (vstart
+ sizeof (*eaux
) > endbuf
)
10186 eaux
= (Elf_External_Vernaux
*) vstart
;
10188 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10189 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10190 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10191 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10192 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10194 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10195 printf (_(" %#06x: Name: %s"),
10196 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10198 printf (_(" %#06x: Name index: %lx"),
10199 isum
, aux
.vna_name
);
10201 printf (_(" Flags: %s Version: %d\n"),
10202 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10204 /* Check for overflow. */
10205 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10206 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10208 warn (_("Invalid vna_next field of %lx\n"),
10213 isum
+= aux
.vna_next
;
10214 vstart
+= aux
.vna_next
;
10217 if (j
< ent
.vn_cnt
)
10218 warn (_("Missing Version Needs auxillary information\n"));
10220 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10222 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10223 cnt
= section
->sh_info
;
10226 idx
+= ent
.vn_next
;
10229 if (cnt
< section
->sh_info
)
10230 warn (_("Missing Version Needs information\n"));
10236 case SHT_GNU_versym
:
10238 Elf_Internal_Shdr
* link_section
;
10241 unsigned char * edata
;
10242 unsigned short * data
;
10244 Elf_Internal_Sym
* symbols
;
10245 Elf_Internal_Shdr
* string_sec
;
10246 unsigned long num_syms
;
10249 if (section
->sh_link
>= elf_header
.e_shnum
)
10252 link_section
= section_headers
+ section
->sh_link
;
10253 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10255 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10260 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10261 if (symbols
== NULL
)
10264 string_sec
= section_headers
+ link_section
->sh_link
;
10266 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10267 string_sec
->sh_size
,
10268 _("version string table"));
10275 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10276 printable_section_name (section
), (unsigned long) total
);
10278 printf (_(" Addr: "));
10279 printf_vma (section
->sh_addr
);
10280 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10281 (unsigned long) section
->sh_offset
, section
->sh_link
,
10282 printable_section_name (link_section
));
10284 off
= offset_from_vma (file
,
10285 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10286 total
* sizeof (short));
10287 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10289 _("version symbol data"));
10297 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10299 for (cnt
= total
; cnt
--;)
10300 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10305 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10309 char *invalid
= _("*invalid*");
10311 printf (" %03x:", cnt
);
10313 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10314 switch (data
[cnt
+ j
])
10317 fputs (_(" 0 (*local*) "), stdout
);
10321 fputs (_(" 1 (*global*) "), stdout
);
10325 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10326 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10328 /* If this index value is greater than the size of the symbols
10329 array, break to avoid an out-of-bounds read. */
10330 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10332 warn (_("invalid index into symbol array\n"));
10337 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10339 Elf_Internal_Verneed ivn
;
10340 unsigned long offset
;
10342 offset
= offset_from_vma
10343 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10344 sizeof (Elf_External_Verneed
));
10348 Elf_Internal_Vernaux ivna
;
10349 Elf_External_Verneed evn
;
10350 Elf_External_Vernaux evna
;
10351 unsigned long a_off
;
10353 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10354 _("version need")) == NULL
)
10357 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10358 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10360 a_off
= offset
+ ivn
.vn_aux
;
10364 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10365 1, _("version need aux (2)")) == NULL
)
10368 ivna
.vna_other
= 0;
10372 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10373 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10376 a_off
+= ivna
.vna_next
;
10378 while (ivna
.vna_other
!= data
[cnt
+ j
]
10379 && ivna
.vna_next
!= 0);
10381 if (ivna
.vna_other
== data
[cnt
+ j
])
10383 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10385 if (ivna
.vna_name
>= string_sec
->sh_size
)
10388 name
= strtab
+ ivna
.vna_name
;
10392 offset
+= ivn
.vn_next
;
10394 while (ivn
.vn_next
);
10397 if (data
[cnt
+ j
] != 0x8001
10398 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10400 Elf_Internal_Verdef ivd
;
10401 Elf_External_Verdef evd
;
10402 unsigned long offset
;
10404 offset
= offset_from_vma
10405 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10410 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10411 _("version def")) == NULL
)
10414 /* PR 17531: file: 046-1082287-0.004. */
10415 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10420 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10421 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10424 offset
+= ivd
.vd_next
;
10426 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10427 && ivd
.vd_next
!= 0);
10429 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10431 Elf_External_Verdaux evda
;
10432 Elf_Internal_Verdaux ivda
;
10434 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10436 if (get_data (&evda
, file
,
10437 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10439 _("version def aux")) == NULL
)
10442 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10444 if (ivda
.vda_name
>= string_sec
->sh_size
)
10446 else if (name
!= NULL
&& name
!= invalid
)
10447 name
= _("*both*");
10449 name
= strtab
+ ivda
.vda_name
;
10453 nn
+= printf ("(%s%-*s",
10455 12 - (int) strlen (name
),
10459 printf ("%*c", 18 - nn
, ' ');
10477 printf (_("\nNo version information found in this file.\n"));
10482 static const char *
10483 get_symbol_binding (unsigned int binding
)
10485 static char buff
[32];
10489 case STB_LOCAL
: return "LOCAL";
10490 case STB_GLOBAL
: return "GLOBAL";
10491 case STB_WEAK
: return "WEAK";
10493 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10494 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10496 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10498 if (binding
== STB_GNU_UNIQUE
10499 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10500 /* GNU is still using the default value 0. */
10501 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10503 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10506 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10511 static const char *
10512 get_symbol_type (unsigned int type
)
10514 static char buff
[32];
10518 case STT_NOTYPE
: return "NOTYPE";
10519 case STT_OBJECT
: return "OBJECT";
10520 case STT_FUNC
: return "FUNC";
10521 case STT_SECTION
: return "SECTION";
10522 case STT_FILE
: return "FILE";
10523 case STT_COMMON
: return "COMMON";
10524 case STT_TLS
: return "TLS";
10525 case STT_RELC
: return "RELC";
10526 case STT_SRELC
: return "SRELC";
10528 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10530 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10531 return "THUMB_FUNC";
10533 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10536 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10537 return "PARISC_MILLI";
10539 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10541 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10543 if (elf_header
.e_machine
== EM_PARISC
)
10545 if (type
== STT_HP_OPAQUE
)
10546 return "HP_OPAQUE";
10547 if (type
== STT_HP_STUB
)
10551 if (type
== STT_GNU_IFUNC
10552 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10553 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10554 /* GNU is still using the default value 0. */
10555 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10558 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10561 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10566 static const char *
10567 get_symbol_visibility (unsigned int visibility
)
10569 switch (visibility
)
10571 case STV_DEFAULT
: return "DEFAULT";
10572 case STV_INTERNAL
: return "INTERNAL";
10573 case STV_HIDDEN
: return "HIDDEN";
10574 case STV_PROTECTED
: return "PROTECTED";
10576 error (_("Unrecognized visibility value: %u"), visibility
);
10577 return _("<unknown>");
10581 static const char *
10582 get_solaris_symbol_visibility (unsigned int visibility
)
10584 switch (visibility
)
10586 case 4: return "EXPORTED";
10587 case 5: return "SINGLETON";
10588 case 6: return "ELIMINATE";
10589 default: return get_symbol_visibility (visibility
);
10593 static const char *
10594 get_mips_symbol_other (unsigned int other
)
10604 case STO_MICROMIPS
:
10605 return "MICROMIPS";
10606 case STO_MICROMIPS
| STO_MIPS_PIC
:
10607 return "MICROMIPS, MIPS PIC";
10615 static const char *
10616 get_ia64_symbol_other (unsigned int other
)
10618 if (is_ia64_vms ())
10620 static char res
[32];
10624 /* Function types is for images and .STB files only. */
10625 switch (elf_header
.e_type
)
10629 switch (VMS_ST_FUNC_TYPE (other
))
10631 case VMS_SFT_CODE_ADDR
:
10632 strcat (res
, " CA");
10634 case VMS_SFT_SYMV_IDX
:
10635 strcat (res
, " VEC");
10638 strcat (res
, " FD");
10640 case VMS_SFT_RESERVE
:
10641 strcat (res
, " RSV");
10644 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10645 VMS_ST_FUNC_TYPE (other
));
10646 strcat (res
, " <unknown>");
10653 switch (VMS_ST_LINKAGE (other
))
10655 case VMS_STL_IGNORE
:
10656 strcat (res
, " IGN");
10658 case VMS_STL_RESERVE
:
10659 strcat (res
, " RSV");
10662 strcat (res
, " STD");
10665 strcat (res
, " LNK");
10668 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10669 VMS_ST_LINKAGE (other
));
10670 strcat (res
, " <unknown>");
10682 static const char *
10683 get_ppc64_symbol_other (unsigned int other
)
10685 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10687 static char buf
[32];
10688 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10689 PPC64_LOCAL_ENTRY_OFFSET (other
));
10695 static const char *
10696 get_symbol_other (unsigned int other
)
10698 const char * result
= NULL
;
10699 static char buff
[32];
10704 switch (elf_header
.e_machine
)
10707 result
= get_mips_symbol_other (other
);
10710 result
= get_ia64_symbol_other (other
);
10713 result
= get_ppc64_symbol_other (other
);
10723 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10727 static const char *
10728 get_symbol_index_type (unsigned int type
)
10730 static char buff
[32];
10734 case SHN_UNDEF
: return "UND";
10735 case SHN_ABS
: return "ABS";
10736 case SHN_COMMON
: return "COM";
10738 if (type
== SHN_IA_64_ANSI_COMMON
10739 && elf_header
.e_machine
== EM_IA_64
10740 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10742 else if ((elf_header
.e_machine
== EM_X86_64
10743 || elf_header
.e_machine
== EM_L1OM
10744 || elf_header
.e_machine
== EM_K1OM
)
10745 && type
== SHN_X86_64_LCOMMON
)
10746 return "LARGE_COM";
10747 else if ((type
== SHN_MIPS_SCOMMON
10748 && elf_header
.e_machine
== EM_MIPS
)
10749 || (type
== SHN_TIC6X_SCOMMON
10750 && elf_header
.e_machine
== EM_TI_C6000
))
10752 else if (type
== SHN_MIPS_SUNDEFINED
10753 && elf_header
.e_machine
== EM_MIPS
)
10755 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10756 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10757 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10758 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10759 else if (type
>= SHN_LORESERVE
)
10760 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10761 else if (type
>= elf_header
.e_shnum
)
10762 sprintf (buff
, _("bad section index[%3d]"), type
);
10764 sprintf (buff
, "%3d", type
);
10772 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10774 unsigned char * e_data
;
10777 /* If the size_t type is smaller than the bfd_size_type, eg because
10778 you are building a 32-bit tool on a 64-bit host, then make sure
10779 that when (number) is cast to (size_t) no information is lost. */
10780 if (sizeof (size_t) < sizeof (bfd_size_type
)
10781 && (bfd_size_type
) ((size_t) number
) != number
)
10783 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10784 " elements of size %u\n"),
10789 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10790 attempting to allocate memory when the read is bound to fail. */
10791 if (ent_size
* number
> current_file_size
)
10793 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10798 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10799 if (e_data
== NULL
)
10801 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10806 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10808 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10809 number
* ent_size
);
10814 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10815 if (i_data
== NULL
)
10817 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10818 " dynamic entries\n"),
10825 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10833 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10835 Elf_Internal_Sym
* psym
;
10838 n
= print_vma (si
, DEC_5
);
10840 fputs (&" "[n
], stdout
);
10841 printf (" %3lu: ", hn
);
10843 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10845 printf (_("<No info available for dynamic symbol number %lu>\n"),
10846 (unsigned long) si
);
10850 psym
= dynamic_symbols
+ si
;
10851 print_vma (psym
->st_value
, LONG_HEX
);
10853 print_vma (psym
->st_size
, DEC_5
);
10855 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10856 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10858 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10859 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10862 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10864 printf (" %-7s", get_symbol_visibility (vis
));
10865 /* Check to see if any other bits in the st_other field are set.
10866 Note - displaying this information disrupts the layout of the
10867 table being generated, but for the moment this case is very
10869 if (psym
->st_other
^ vis
)
10870 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10873 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10874 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10875 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10877 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10881 static const char *
10882 get_symbol_version_string (FILE * file
,
10883 bfd_boolean is_dynsym
,
10884 const char * strtab
,
10885 unsigned long int strtab_size
,
10887 Elf_Internal_Sym
* psym
,
10888 enum versioned_symbol_info
* sym_info
,
10889 unsigned short * vna_other
)
10891 unsigned char data
[2];
10892 unsigned short vers_data
;
10893 unsigned long offset
;
10896 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10899 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10900 sizeof data
+ si
* sizeof (vers_data
));
10902 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10903 sizeof (data
), 1, _("version data")) == NULL
)
10906 vers_data
= byte_get (data
, 2);
10908 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10911 /* Usually we'd only see verdef for defined symbols, and verneed for
10912 undefined symbols. However, symbols defined by the linker in
10913 .dynbss for variables copied from a shared library in order to
10914 avoid text relocations are defined yet have verneed. We could
10915 use a heuristic to detect the special case, for example, check
10916 for verneed first on symbols defined in SHT_NOBITS sections, but
10917 it is simpler and more reliable to just look for both verdef and
10918 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10920 if (psym
->st_shndx
!= SHN_UNDEF
10921 && vers_data
!= 0x8001
10922 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10924 Elf_Internal_Verdef ivd
;
10925 Elf_Internal_Verdaux ivda
;
10926 Elf_External_Verdaux evda
;
10929 off
= offset_from_vma (file
,
10930 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10931 sizeof (Elf_External_Verdef
));
10935 Elf_External_Verdef evd
;
10937 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10938 _("version def")) == NULL
)
10946 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10947 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10948 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10951 off
+= ivd
.vd_next
;
10953 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10955 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10957 off
-= ivd
.vd_next
;
10960 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10961 _("version def aux")) != NULL
)
10963 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10965 if (psym
->st_name
!= ivda
.vda_name
)
10967 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10968 ? symbol_hidden
: symbol_public
);
10969 return (ivda
.vda_name
< strtab_size
10970 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10976 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10978 Elf_External_Verneed evn
;
10979 Elf_Internal_Verneed ivn
;
10980 Elf_Internal_Vernaux ivna
;
10982 offset
= offset_from_vma (file
,
10983 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10987 unsigned long vna_off
;
10989 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10990 _("version need")) == NULL
)
10993 ivna
.vna_other
= 0;
10998 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10999 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11001 vna_off
= offset
+ ivn
.vn_aux
;
11005 Elf_External_Vernaux evna
;
11007 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11008 _("version need aux (3)")) == NULL
)
11011 ivna
.vna_other
= 0;
11016 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11017 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11018 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11021 vna_off
+= ivna
.vna_next
;
11023 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11025 if (ivna
.vna_other
== vers_data
)
11028 offset
+= ivn
.vn_next
;
11030 while (ivn
.vn_next
!= 0);
11032 if (ivna
.vna_other
== vers_data
)
11034 *sym_info
= symbol_undefined
;
11035 *vna_other
= ivna
.vna_other
;
11036 return (ivna
.vna_name
< strtab_size
11037 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11043 /* Dump the symbol table. */
11045 process_symbol_table (FILE * file
)
11047 Elf_Internal_Shdr
* section
;
11048 bfd_size_type nbuckets
= 0;
11049 bfd_size_type nchains
= 0;
11050 bfd_vma
* buckets
= NULL
;
11051 bfd_vma
* chains
= NULL
;
11052 bfd_vma ngnubuckets
= 0;
11053 bfd_vma
* gnubuckets
= NULL
;
11054 bfd_vma
* gnuchains
= NULL
;
11055 bfd_vma gnusymidx
= 0;
11056 bfd_size_type ngnuchains
= 0;
11058 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11061 if (dynamic_info
[DT_HASH
]
11063 || (do_using_dynamic
11065 && dynamic_strings
!= NULL
)))
11067 unsigned char nb
[8];
11068 unsigned char nc
[8];
11069 unsigned int hash_ent_size
= 4;
11071 if ((elf_header
.e_machine
== EM_ALPHA
11072 || elf_header
.e_machine
== EM_S390
11073 || elf_header
.e_machine
== EM_S390_OLD
)
11074 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11078 (archive_file_offset
11079 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11080 sizeof nb
+ sizeof nc
)),
11083 error (_("Unable to seek to start of dynamic information\n"));
11087 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11089 error (_("Failed to read in number of buckets\n"));
11093 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11095 error (_("Failed to read in number of chains\n"));
11099 nbuckets
= byte_get (nb
, hash_ent_size
);
11100 nchains
= byte_get (nc
, hash_ent_size
);
11102 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11103 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11106 if (buckets
== NULL
|| chains
== NULL
)
11108 if (do_using_dynamic
)
11119 if (dynamic_info_DT_GNU_HASH
11121 || (do_using_dynamic
11123 && dynamic_strings
!= NULL
)))
11125 unsigned char nb
[16];
11126 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11127 bfd_vma buckets_vma
;
11130 (archive_file_offset
11131 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11135 error (_("Unable to seek to start of dynamic information\n"));
11139 if (fread (nb
, 16, 1, file
) != 1)
11141 error (_("Failed to read in number of buckets\n"));
11145 ngnubuckets
= byte_get (nb
, 4);
11146 gnusymidx
= byte_get (nb
+ 4, 4);
11147 bitmaskwords
= byte_get (nb
+ 8, 4);
11148 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11150 buckets_vma
+= bitmaskwords
* 4;
11152 buckets_vma
+= bitmaskwords
* 8;
11155 (archive_file_offset
11156 + offset_from_vma (file
, buckets_vma
, 4)),
11159 error (_("Unable to seek to start of dynamic information\n"));
11163 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11165 if (gnubuckets
== NULL
)
11168 for (i
= 0; i
< ngnubuckets
; i
++)
11169 if (gnubuckets
[i
] != 0)
11171 if (gnubuckets
[i
] < gnusymidx
)
11174 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11175 maxchain
= gnubuckets
[i
];
11178 if (maxchain
== 0xffffffff)
11181 maxchain
-= gnusymidx
;
11184 (archive_file_offset
11185 + offset_from_vma (file
, buckets_vma
11186 + 4 * (ngnubuckets
+ maxchain
), 4)),
11189 error (_("Unable to seek to start of dynamic information\n"));
11195 if (fread (nb
, 4, 1, file
) != 1)
11197 error (_("Failed to determine last chain length\n"));
11201 if (maxchain
+ 1 == 0)
11206 while ((byte_get (nb
, 4) & 1) == 0);
11209 (archive_file_offset
11210 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11213 error (_("Unable to seek to start of dynamic information\n"));
11217 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11218 ngnuchains
= maxchain
;
11221 if (gnuchains
== NULL
)
11226 if (do_using_dynamic
)
11231 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11233 && do_using_dynamic
11234 && dynamic_strings
!= NULL
11235 && dynamic_symbols
!= NULL
)
11239 if (dynamic_info
[DT_HASH
])
11243 printf (_("\nSymbol table for image:\n"));
11245 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11247 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11249 for (hn
= 0; hn
< nbuckets
; hn
++)
11254 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11255 print_dynamic_symbol (si
, hn
);
11259 if (dynamic_info_DT_GNU_HASH
)
11261 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11263 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11265 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11267 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11268 if (gnubuckets
[hn
] != 0)
11270 bfd_vma si
= gnubuckets
[hn
];
11271 bfd_vma off
= si
- gnusymidx
;
11275 print_dynamic_symbol (si
, hn
);
11278 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11282 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11283 && section_headers
!= NULL
)
11287 for (i
= 0, section
= section_headers
;
11288 i
< elf_header
.e_shnum
;
11292 char * strtab
= NULL
;
11293 unsigned long int strtab_size
= 0;
11294 Elf_Internal_Sym
* symtab
;
11295 Elf_Internal_Sym
* psym
;
11296 unsigned long num_syms
;
11298 if ((section
->sh_type
!= SHT_SYMTAB
11299 && section
->sh_type
!= SHT_DYNSYM
)
11301 && section
->sh_type
== SHT_SYMTAB
))
11304 if (section
->sh_entsize
== 0)
11306 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11307 printable_section_name (section
));
11311 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11312 printable_section_name (section
),
11313 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11316 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11318 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11320 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11321 if (symtab
== NULL
)
11324 if (section
->sh_link
== elf_header
.e_shstrndx
)
11326 strtab
= string_table
;
11327 strtab_size
= string_table_length
;
11329 else if (section
->sh_link
< elf_header
.e_shnum
)
11331 Elf_Internal_Shdr
* string_sec
;
11333 string_sec
= section_headers
+ section
->sh_link
;
11335 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11336 1, string_sec
->sh_size
,
11337 _("string table"));
11338 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11341 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11343 const char *version_string
;
11344 enum versioned_symbol_info sym_info
;
11345 unsigned short vna_other
;
11347 printf ("%6d: ", si
);
11348 print_vma (psym
->st_value
, LONG_HEX
);
11350 print_vma (psym
->st_size
, DEC_5
);
11351 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11352 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11353 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11354 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11357 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11359 printf (" %-7s", get_symbol_visibility (vis
));
11360 /* Check to see if any other bits in the st_other field are set.
11361 Note - displaying this information disrupts the layout of the
11362 table being generated, but for the moment this case is very rare. */
11363 if (psym
->st_other
^ vis
)
11364 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11366 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11367 print_symbol (25, psym
->st_name
< strtab_size
11368 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11371 = get_symbol_version_string (file
,
11372 section
->sh_type
== SHT_DYNSYM
,
11373 strtab
, strtab_size
, si
,
11374 psym
, &sym_info
, &vna_other
);
11375 if (version_string
)
11377 if (sym_info
== symbol_undefined
)
11378 printf ("@%s (%d)", version_string
, vna_other
);
11380 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11386 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11387 && si
>= section
->sh_info
11388 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11389 && elf_header
.e_machine
!= EM_MIPS
11390 /* Solaris binaries have been found to violate this requirement as
11391 well. Not sure if this is a bug or an ABI requirement. */
11392 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11393 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11394 si
, printable_section_name (section
), section
->sh_info
);
11398 if (strtab
!= string_table
)
11404 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11406 if (do_histogram
&& buckets
!= NULL
)
11408 unsigned long * lengths
;
11409 unsigned long * counts
;
11412 unsigned long maxlength
= 0;
11413 unsigned long nzero_counts
= 0;
11414 unsigned long nsyms
= 0;
11415 unsigned long chained
;
11417 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11418 (unsigned long) nbuckets
);
11420 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11421 if (lengths
== NULL
)
11423 error (_("Out of memory allocating space for histogram buckets\n"));
11427 printf (_(" Length Number %% of total Coverage\n"));
11428 for (hn
= 0; hn
< nbuckets
; ++hn
)
11430 for (si
= buckets
[hn
], chained
= 0;
11431 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11432 si
= chains
[si
], ++chained
)
11435 if (maxlength
< ++lengths
[hn
])
11439 /* PR binutils/17531: A corrupt binary could contain broken
11440 histogram data. Do not go into an infinite loop trying
11442 if (chained
> nchains
)
11444 error (_("histogram chain is corrupt\n"));
11449 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11450 if (counts
== NULL
)
11453 error (_("Out of memory allocating space for histogram counts\n"));
11457 for (hn
= 0; hn
< nbuckets
; ++hn
)
11458 ++counts
[lengths
[hn
]];
11463 printf (" 0 %-10lu (%5.1f%%)\n",
11464 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11465 for (i
= 1; i
<= maxlength
; ++i
)
11467 nzero_counts
+= counts
[i
] * i
;
11468 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11469 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11470 (nzero_counts
* 100.0) / nsyms
);
11478 if (buckets
!= NULL
)
11484 if (do_histogram
&& gnubuckets
!= NULL
)
11486 unsigned long * lengths
;
11487 unsigned long * counts
;
11489 unsigned long maxlength
= 0;
11490 unsigned long nzero_counts
= 0;
11491 unsigned long nsyms
= 0;
11493 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11494 (unsigned long) ngnubuckets
);
11496 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11497 if (lengths
== NULL
)
11499 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11503 printf (_(" Length Number %% of total Coverage\n"));
11505 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11506 if (gnubuckets
[hn
] != 0)
11508 bfd_vma off
, length
= 1;
11510 for (off
= gnubuckets
[hn
] - gnusymidx
;
11511 /* PR 17531 file: 010-77222-0.004. */
11512 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11515 lengths
[hn
] = length
;
11516 if (length
> maxlength
)
11517 maxlength
= length
;
11521 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11522 if (counts
== NULL
)
11525 error (_("Out of memory allocating space for gnu histogram counts\n"));
11529 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11530 ++counts
[lengths
[hn
]];
11532 if (ngnubuckets
> 0)
11535 printf (" 0 %-10lu (%5.1f%%)\n",
11536 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11537 for (j
= 1; j
<= maxlength
; ++j
)
11539 nzero_counts
+= counts
[j
] * j
;
11540 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11541 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11542 (nzero_counts
* 100.0) / nsyms
);
11556 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11560 if (dynamic_syminfo
== NULL
11562 /* No syminfo, this is ok. */
11565 /* There better should be a dynamic symbol section. */
11566 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11570 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11571 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11573 printf (_(" Num: Name BoundTo Flags\n"));
11574 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11576 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11578 printf ("%4d: ", i
);
11579 if (i
>= num_dynamic_syms
)
11580 printf (_("<corrupt index>"));
11581 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11582 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11584 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11587 switch (dynamic_syminfo
[i
].si_boundto
)
11589 case SYMINFO_BT_SELF
:
11590 fputs ("SELF ", stdout
);
11592 case SYMINFO_BT_PARENT
:
11593 fputs ("PARENT ", stdout
);
11596 if (dynamic_syminfo
[i
].si_boundto
> 0
11597 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11598 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11600 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11604 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11608 if (flags
& SYMINFO_FLG_DIRECT
)
11609 printf (" DIRECT");
11610 if (flags
& SYMINFO_FLG_PASSTHRU
)
11611 printf (" PASSTHRU");
11612 if (flags
& SYMINFO_FLG_COPY
)
11614 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11615 printf (" LAZYLOAD");
11623 #define IN_RANGE(START,END,ADDR,OFF) \
11624 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11626 /* Check to see if the given reloc needs to be handled in a target specific
11627 manner. If so then process the reloc and return TRUE otherwise return
11630 If called with reloc == NULL, then this is a signal that reloc processing
11631 for the current section has finished, and any saved state should be
11635 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11636 unsigned char * start
,
11637 unsigned char * end
,
11638 Elf_Internal_Sym
* symtab
,
11639 unsigned long num_syms
)
11641 unsigned int reloc_type
= 0;
11642 unsigned long sym_index
= 0;
11646 reloc_type
= get_reloc_type (reloc
->r_info
);
11647 sym_index
= get_reloc_symindex (reloc
->r_info
);
11650 switch (elf_header
.e_machine
)
11653 case EM_MSP430_OLD
:
11655 static Elf_Internal_Sym
* saved_sym
= NULL
;
11663 switch (reloc_type
)
11665 case 10: /* R_MSP430_SYM_DIFF */
11666 if (uses_msp430x_relocs ())
11668 /* Fall through. */
11669 case 21: /* R_MSP430X_SYM_DIFF */
11671 if (sym_index
>= num_syms
)
11672 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11675 saved_sym
= symtab
+ sym_index
;
11678 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11679 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11680 goto handle_sym_diff
;
11682 case 5: /* R_MSP430_16_BYTE */
11683 case 9: /* R_MSP430_8 */
11684 if (uses_msp430x_relocs ())
11686 goto handle_sym_diff
;
11688 case 2: /* R_MSP430_ABS16 */
11689 case 15: /* R_MSP430X_ABS16 */
11690 if (! uses_msp430x_relocs ())
11692 goto handle_sym_diff
;
11695 if (saved_sym
!= NULL
)
11697 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11700 if (sym_index
>= num_syms
)
11701 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11705 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11706 - saved_sym
->st_value
);
11708 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11709 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11712 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11713 (long) reloc
->r_offset
);
11722 if (saved_sym
!= NULL
)
11723 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11730 case EM_CYGNUS_MN10300
:
11732 static Elf_Internal_Sym
* saved_sym
= NULL
;
11740 switch (reloc_type
)
11742 case 34: /* R_MN10300_ALIGN */
11744 case 33: /* R_MN10300_SYM_DIFF */
11745 if (sym_index
>= num_syms
)
11746 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11749 saved_sym
= symtab
+ sym_index
;
11752 case 1: /* R_MN10300_32 */
11753 case 2: /* R_MN10300_16 */
11754 if (saved_sym
!= NULL
)
11756 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11759 if (sym_index
>= num_syms
)
11760 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11764 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11765 - saved_sym
->st_value
);
11767 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11768 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11770 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11771 (long) reloc
->r_offset
);
11779 if (saved_sym
!= NULL
)
11780 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11788 static bfd_vma saved_sym1
= 0;
11789 static bfd_vma saved_sym2
= 0;
11790 static bfd_vma value
;
11794 saved_sym1
= saved_sym2
= 0;
11798 switch (reloc_type
)
11800 case 0x80: /* R_RL78_SYM. */
11801 saved_sym1
= saved_sym2
;
11802 if (sym_index
>= num_syms
)
11803 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11807 saved_sym2
= symtab
[sym_index
].st_value
;
11808 saved_sym2
+= reloc
->r_addend
;
11812 case 0x83: /* R_RL78_OPsub. */
11813 value
= saved_sym1
- saved_sym2
;
11814 saved_sym2
= saved_sym1
= 0;
11818 case 0x41: /* R_RL78_ABS32. */
11819 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11820 byte_put (start
+ reloc
->r_offset
, value
, 4);
11822 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11823 (long) reloc
->r_offset
);
11827 case 0x43: /* R_RL78_ABS16. */
11828 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11829 byte_put (start
+ reloc
->r_offset
, value
, 2);
11831 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11832 (long) reloc
->r_offset
);
11846 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11847 DWARF debug sections. This is a target specific test. Note - we do not
11848 go through the whole including-target-headers-multiple-times route, (as
11849 we have already done with <elf/h8.h>) because this would become very
11850 messy and even then this function would have to contain target specific
11851 information (the names of the relocs instead of their numeric values).
11852 FIXME: This is not the correct way to solve this problem. The proper way
11853 is to have target specific reloc sizing and typing functions created by
11854 the reloc-macros.h header, in the same way that it already creates the
11855 reloc naming functions. */
11858 is_32bit_abs_reloc (unsigned int reloc_type
)
11860 /* Please keep this table alpha-sorted for ease of visual lookup. */
11861 switch (elf_header
.e_machine
)
11865 return reloc_type
== 1; /* R_386_32. */
11867 return reloc_type
== 1; /* R_68K_32. */
11869 return reloc_type
== 1; /* R_860_32. */
11871 return reloc_type
== 2; /* R_960_32. */
11873 return (reloc_type
== 258
11874 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11875 case EM_ADAPTEVA_EPIPHANY
:
11876 return reloc_type
== 3;
11878 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11880 return reloc_type
== 1; /* R_ARC_32. */
11881 case EM_ARC_COMPACT
:
11882 case EM_ARC_COMPACT2
:
11883 return reloc_type
== 4; /* R_ARC_32. */
11885 return reloc_type
== 2; /* R_ARM_ABS32 */
11888 return reloc_type
== 1;
11890 return reloc_type
== 0x12; /* R_byte4_data. */
11892 return reloc_type
== 3; /* R_CRIS_32. */
11894 return reloc_type
== 3; /* R_CR16_NUM32. */
11896 return reloc_type
== 15; /* R_CRX_NUM32. */
11897 case EM_CYGNUS_FRV
:
11898 return reloc_type
== 1;
11899 case EM_CYGNUS_D10V
:
11901 return reloc_type
== 6; /* R_D10V_32. */
11902 case EM_CYGNUS_D30V
:
11904 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11906 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11907 case EM_CYGNUS_FR30
:
11909 return reloc_type
== 3; /* R_FR30_32. */
11911 return reloc_type
== 1; /* R_FT32_32. */
11915 return reloc_type
== 1; /* R_H8_DIR32. */
11917 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11918 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11921 return reloc_type
== 2; /* R_IP2K_32. */
11923 return reloc_type
== 2; /* R_IQ2000_32. */
11924 case EM_LATTICEMICO32
:
11925 return reloc_type
== 3; /* R_LM32_32. */
11928 return reloc_type
== 3; /* R_M32C_32. */
11930 return reloc_type
== 34; /* R_M32R_32_RELA. */
11933 return reloc_type
== 6; /* R_M68HC11_32. */
11935 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11936 case EM_CYGNUS_MEP
:
11937 return reloc_type
== 4; /* R_MEP_32. */
11939 return reloc_type
== 2; /* R_METAG_ADDR32. */
11940 case EM_MICROBLAZE
:
11941 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11943 return reloc_type
== 2; /* R_MIPS_32. */
11945 return reloc_type
== 4; /* R_MMIX_32. */
11946 case EM_CYGNUS_MN10200
:
11948 return reloc_type
== 1; /* R_MN10200_32. */
11949 case EM_CYGNUS_MN10300
:
11951 return reloc_type
== 1; /* R_MN10300_32. */
11953 return reloc_type
== 1; /* R_MOXIE_32. */
11954 case EM_MSP430_OLD
:
11956 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11958 return reloc_type
== 2; /* R_MT_32. */
11960 return reloc_type
== 20; /* R_NDS32_RELA. */
11961 case EM_ALTERA_NIOS2
:
11962 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11964 return reloc_type
== 1; /* R_NIOS_32. */
11966 return reloc_type
== 1; /* R_OR1K_32. */
11968 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11969 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11972 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11974 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11976 return reloc_type
== 1; /* R_PPC_ADDR32. */
11978 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
11980 return reloc_type
== 1; /* R_RISCV_32. */
11982 return reloc_type
== 1; /* R_RL78_DIR32. */
11984 return reloc_type
== 1; /* R_RX_DIR32. */
11986 return reloc_type
== 1; /* R_I370_ADDR31. */
11989 return reloc_type
== 4; /* R_S390_32. */
11991 return reloc_type
== 8; /* R_SCORE_ABS32. */
11993 return reloc_type
== 1; /* R_SH_DIR32. */
11994 case EM_SPARC32PLUS
:
11997 return reloc_type
== 3 /* R_SPARC_32. */
11998 || reloc_type
== 23; /* R_SPARC_UA32. */
12000 return reloc_type
== 6; /* R_SPU_ADDR32 */
12002 return reloc_type
== 1; /* R_C6000_ABS32. */
12004 return reloc_type
== 2; /* R_TILEGX_32. */
12006 return reloc_type
== 1; /* R_TILEPRO_32. */
12007 case EM_CYGNUS_V850
:
12009 return reloc_type
== 6; /* R_V850_ABS32. */
12011 return reloc_type
== 0x33; /* R_V810_WORD. */
12013 return reloc_type
== 1; /* R_VAX_32. */
12015 return reloc_type
== 3; /* R_VISIUM_32. */
12019 return reloc_type
== 10; /* R_X86_64_32. */
12022 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12024 return reloc_type
== 4; /* R_XGATE_32. */
12026 return reloc_type
== 1; /* R_XSTROMY16_32. */
12027 case EM_XTENSA_OLD
:
12029 return reloc_type
== 1; /* R_XTENSA_32. */
12032 static unsigned int prev_warn
= 0;
12034 /* Avoid repeating the same warning multiple times. */
12035 if (prev_warn
!= elf_header
.e_machine
)
12036 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12037 elf_header
.e_machine
);
12038 prev_warn
= elf_header
.e_machine
;
12044 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12045 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12048 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12050 switch (elf_header
.e_machine
)
12051 /* Please keep this table alpha-sorted for ease of visual lookup. */
12055 return reloc_type
== 2; /* R_386_PC32. */
12057 return reloc_type
== 4; /* R_68K_PC32. */
12059 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12060 case EM_ADAPTEVA_EPIPHANY
:
12061 return reloc_type
== 6;
12063 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12064 case EM_ARC_COMPACT
:
12065 case EM_ARC_COMPACT2
:
12066 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12068 return reloc_type
== 3; /* R_ARM_REL32 */
12071 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12072 case EM_MICROBLAZE
:
12073 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12075 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12077 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12079 return reloc_type
== 26; /* R_PPC_REL32. */
12081 return reloc_type
== 26; /* R_PPC64_REL32. */
12084 return reloc_type
== 5; /* R_390_PC32. */
12086 return reloc_type
== 2; /* R_SH_REL32. */
12087 case EM_SPARC32PLUS
:
12090 return reloc_type
== 6; /* R_SPARC_DISP32. */
12092 return reloc_type
== 13; /* R_SPU_REL32. */
12094 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12096 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12098 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12102 return reloc_type
== 2; /* R_X86_64_PC32. */
12103 case EM_XTENSA_OLD
:
12105 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12107 /* Do not abort or issue an error message here. Not all targets use
12108 pc-relative 32-bit relocs in their DWARF debug information and we
12109 have already tested for target coverage in is_32bit_abs_reloc. A
12110 more helpful warning message will be generated by apply_relocations
12111 anyway, so just return. */
12116 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12117 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12120 is_64bit_abs_reloc (unsigned int reloc_type
)
12122 switch (elf_header
.e_machine
)
12125 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12127 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12129 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12131 return reloc_type
== 80; /* R_PARISC_DIR64. */
12133 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12135 return reloc_type
== 2; /* R_RISCV_64. */
12136 case EM_SPARC32PLUS
:
12139 return reloc_type
== 54; /* R_SPARC_UA64. */
12143 return reloc_type
== 1; /* R_X86_64_64. */
12146 return reloc_type
== 22; /* R_S390_64. */
12148 return reloc_type
== 1; /* R_TILEGX_64. */
12150 return reloc_type
== 18; /* R_MIPS_64. */
12156 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12157 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12160 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12162 switch (elf_header
.e_machine
)
12165 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12167 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12169 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12171 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12173 return reloc_type
== 44; /* R_PPC64_REL64. */
12174 case EM_SPARC32PLUS
:
12177 return reloc_type
== 46; /* R_SPARC_DISP64. */
12181 return reloc_type
== 24; /* R_X86_64_PC64. */
12184 return reloc_type
== 23; /* R_S390_PC64. */
12186 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12192 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12193 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12196 is_24bit_abs_reloc (unsigned int reloc_type
)
12198 switch (elf_header
.e_machine
)
12200 case EM_CYGNUS_MN10200
:
12202 return reloc_type
== 4; /* R_MN10200_24. */
12204 return reloc_type
== 5; /* R_FT32_20. */
12210 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12211 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12214 is_16bit_abs_reloc (unsigned int reloc_type
)
12216 /* Please keep this table alpha-sorted for ease of visual lookup. */
12217 switch (elf_header
.e_machine
)
12220 case EM_ARC_COMPACT
:
12221 case EM_ARC_COMPACT2
:
12222 return reloc_type
== 2; /* R_ARC_16. */
12223 case EM_ADAPTEVA_EPIPHANY
:
12224 return reloc_type
== 5;
12227 return reloc_type
== 4; /* R_AVR_16. */
12228 case EM_CYGNUS_D10V
:
12230 return reloc_type
== 3; /* R_D10V_16. */
12234 return reloc_type
== R_H8_DIR16
;
12237 return reloc_type
== 1; /* R_IP2K_16. */
12240 return reloc_type
== 1; /* R_M32C_16 */
12241 case EM_CYGNUS_MN10200
:
12243 return reloc_type
== 2; /* R_MN10200_16. */
12244 case EM_CYGNUS_MN10300
:
12246 return reloc_type
== 2; /* R_MN10300_16. */
12248 if (uses_msp430x_relocs ())
12249 return reloc_type
== 2; /* R_MSP430_ABS16. */
12250 /* Fall through. */
12251 case EM_MSP430_OLD
:
12252 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12254 return reloc_type
== 19; /* R_NDS32_RELA. */
12255 case EM_ALTERA_NIOS2
:
12256 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12258 return reloc_type
== 9; /* R_NIOS_16. */
12260 return reloc_type
== 2; /* R_OR1K_16. */
12262 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12264 return reloc_type
== 2; /* R_C6000_ABS16. */
12266 return reloc_type
== 2; /* R_VISIUM_16. */
12269 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12271 return reloc_type
== 3; /* R_XGATE_16. */
12277 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12278 relocation entries (possibly formerly used for SHT_GROUP sections). */
12281 is_none_reloc (unsigned int reloc_type
)
12283 switch (elf_header
.e_machine
)
12285 case EM_386
: /* R_386_NONE. */
12286 case EM_68K
: /* R_68K_NONE. */
12287 case EM_ADAPTEVA_EPIPHANY
:
12288 case EM_ALPHA
: /* R_ALPHA_NONE. */
12289 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12290 case EM_ARC
: /* R_ARC_NONE. */
12291 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12292 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12293 case EM_ARM
: /* R_ARM_NONE. */
12294 case EM_C166
: /* R_XC16X_NONE. */
12295 case EM_CRIS
: /* R_CRIS_NONE. */
12296 case EM_FT32
: /* R_FT32_NONE. */
12297 case EM_IA_64
: /* R_IA64_NONE. */
12298 case EM_K1OM
: /* R_X86_64_NONE. */
12299 case EM_L1OM
: /* R_X86_64_NONE. */
12300 case EM_M32R
: /* R_M32R_NONE. */
12301 case EM_MIPS
: /* R_MIPS_NONE. */
12302 case EM_MN10300
: /* R_MN10300_NONE. */
12303 case EM_MOXIE
: /* R_MOXIE_NONE. */
12304 case EM_NIOS32
: /* R_NIOS_NONE. */
12305 case EM_OR1K
: /* R_OR1K_NONE. */
12306 case EM_PARISC
: /* R_PARISC_NONE. */
12307 case EM_PPC64
: /* R_PPC64_NONE. */
12308 case EM_PPC
: /* R_PPC_NONE. */
12309 case EM_RISCV
: /* R_RISCV_NONE. */
12310 case EM_S390
: /* R_390_NONE. */
12312 case EM_SH
: /* R_SH_NONE. */
12313 case EM_SPARC32PLUS
:
12314 case EM_SPARC
: /* R_SPARC_NONE. */
12316 case EM_TILEGX
: /* R_TILEGX_NONE. */
12317 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12318 case EM_TI_C6000
:/* R_C6000_NONE. */
12319 case EM_X86_64
: /* R_X86_64_NONE. */
12321 return reloc_type
== 0;
12324 return reloc_type
== 0 || reloc_type
== 256;
12327 return (reloc_type
== 0 /* R_AVR_NONE. */
12328 || reloc_type
== 30 /* R_AVR_DIFF8. */
12329 || reloc_type
== 31 /* R_AVR_DIFF16. */
12330 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12332 return reloc_type
== 3; /* R_METAG_NONE. */
12334 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12335 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12336 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12337 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12338 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12340 return (reloc_type
== 0 /* R_PRU_NONE. */
12341 || reloc_type
== 65 /* R_PRU_DIFF8. */
12342 || reloc_type
== 66 /* R_PRU_DIFF16. */
12343 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12344 case EM_XTENSA_OLD
:
12346 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12347 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12348 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12349 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12354 /* Returns TRUE if there is a relocation against
12355 section NAME at OFFSET bytes. */
12358 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12360 Elf_Internal_Rela
* relocs
;
12361 Elf_Internal_Rela
* rp
;
12363 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12366 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12368 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12369 if (rp
->r_offset
== offset
)
12375 /* Apply relocations to a section.
12376 Note: So far support has been added only for those relocations
12377 which can be found in debug sections.
12378 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12379 loaded relocs. It is then the caller's responsibility to free them.
12380 FIXME: Add support for more relocations ? */
12383 apply_relocations (void * file
,
12384 const Elf_Internal_Shdr
* section
,
12385 unsigned char * start
,
12386 bfd_size_type size
,
12387 void ** relocs_return
,
12388 unsigned long * num_relocs_return
)
12390 Elf_Internal_Shdr
* relsec
;
12391 unsigned char * end
= start
+ size
;
12393 if (relocs_return
!= NULL
)
12395 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12396 * num_relocs_return
= 0;
12399 if (elf_header
.e_type
!= ET_REL
)
12402 /* Find the reloc section associated with the section. */
12403 for (relsec
= section_headers
;
12404 relsec
< section_headers
+ elf_header
.e_shnum
;
12407 bfd_boolean is_rela
;
12408 unsigned long num_relocs
;
12409 Elf_Internal_Rela
* relocs
;
12410 Elf_Internal_Rela
* rp
;
12411 Elf_Internal_Shdr
* symsec
;
12412 Elf_Internal_Sym
* symtab
;
12413 unsigned long num_syms
;
12414 Elf_Internal_Sym
* sym
;
12416 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12417 || relsec
->sh_info
>= elf_header
.e_shnum
12418 || section_headers
+ relsec
->sh_info
!= section
12419 || relsec
->sh_size
== 0
12420 || relsec
->sh_link
>= elf_header
.e_shnum
)
12423 is_rela
= relsec
->sh_type
== SHT_RELA
;
12427 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12428 relsec
->sh_size
, & relocs
, & num_relocs
))
12433 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12434 relsec
->sh_size
, & relocs
, & num_relocs
))
12438 /* SH uses RELA but uses in place value instead of the addend field. */
12439 if (elf_header
.e_machine
== EM_SH
)
12442 symsec
= section_headers
+ relsec
->sh_link
;
12443 if (symsec
->sh_type
!= SHT_SYMTAB
12444 && symsec
->sh_type
!= SHT_DYNSYM
)
12446 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12448 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12451 unsigned int reloc_type
;
12452 unsigned int reloc_size
;
12453 unsigned char * rloc
;
12454 unsigned long sym_index
;
12456 reloc_type
= get_reloc_type (rp
->r_info
);
12458 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12460 else if (is_none_reloc (reloc_type
))
12462 else if (is_32bit_abs_reloc (reloc_type
)
12463 || is_32bit_pcrel_reloc (reloc_type
))
12465 else if (is_64bit_abs_reloc (reloc_type
)
12466 || is_64bit_pcrel_reloc (reloc_type
))
12468 else if (is_24bit_abs_reloc (reloc_type
))
12470 else if (is_16bit_abs_reloc (reloc_type
))
12474 static unsigned int prev_reloc
= 0;
12475 if (reloc_type
!= prev_reloc
)
12476 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12477 reloc_type
, printable_section_name (section
));
12478 prev_reloc
= reloc_type
;
12482 rloc
= start
+ rp
->r_offset
;
12483 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12485 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12486 (unsigned long) rp
->r_offset
,
12487 printable_section_name (section
));
12491 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12492 if (sym_index
>= num_syms
)
12494 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12495 sym_index
, printable_section_name (section
));
12498 sym
= symtab
+ sym_index
;
12500 /* If the reloc has a symbol associated with it,
12501 make sure that it is of an appropriate type.
12503 Relocations against symbols without type can happen.
12504 Gcc -feliminate-dwarf2-dups may generate symbols
12505 without type for debug info.
12507 Icc generates relocations against function symbols
12508 instead of local labels.
12510 Relocations against object symbols can happen, eg when
12511 referencing a global array. For an example of this see
12512 the _clz.o binary in libgcc.a. */
12514 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12515 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12517 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12518 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12519 (long int)(rp
- relocs
),
12520 printable_section_name (relsec
));
12526 addend
+= rp
->r_addend
;
12527 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12528 partial_inplace. */
12530 || (elf_header
.e_machine
== EM_XTENSA
12531 && reloc_type
== 1)
12532 || ((elf_header
.e_machine
== EM_PJ
12533 || elf_header
.e_machine
== EM_PJ_OLD
)
12534 && reloc_type
== 1)
12535 || ((elf_header
.e_machine
== EM_D30V
12536 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12537 && reloc_type
== 12))
12538 addend
+= byte_get (rloc
, reloc_size
);
12540 if (is_32bit_pcrel_reloc (reloc_type
)
12541 || is_64bit_pcrel_reloc (reloc_type
))
12543 /* On HPPA, all pc-relative relocations are biased by 8. */
12544 if (elf_header
.e_machine
== EM_PARISC
)
12546 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12550 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12554 /* Let the target specific reloc processing code know that
12555 we have finished with these relocs. */
12556 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12560 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12561 * num_relocs_return
= num_relocs
;
12570 #ifdef SUPPORT_DISASSEMBLY
12572 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12574 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12576 /* FIXME: XXX -- to be done --- XXX */
12582 /* Reads in the contents of SECTION from FILE, returning a pointer
12583 to a malloc'ed buffer or NULL if something went wrong. */
12586 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12588 bfd_size_type num_bytes
;
12590 num_bytes
= section
->sh_size
;
12592 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12594 printf (_("\nSection '%s' has no data to dump.\n"),
12595 printable_section_name (section
));
12599 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12600 _("section contents"));
12603 /* Uncompresses a section that was compressed using zlib, in place. */
12606 uncompress_section_contents (unsigned char **buffer
,
12607 dwarf_size_type uncompressed_size
,
12608 dwarf_size_type
*size
)
12610 dwarf_size_type compressed_size
= *size
;
12611 unsigned char * compressed_buffer
= *buffer
;
12612 unsigned char * uncompressed_buffer
;
12616 /* It is possible the section consists of several compressed
12617 buffers concatenated together, so we uncompress in a loop. */
12618 /* PR 18313: The state field in the z_stream structure is supposed
12619 to be invisible to the user (ie us), but some compilers will
12620 still complain about it being used without initialisation. So
12621 we first zero the entire z_stream structure and then set the fields
12623 memset (& strm
, 0, sizeof strm
);
12624 strm
.avail_in
= compressed_size
;
12625 strm
.next_in
= (Bytef
*) compressed_buffer
;
12626 strm
.avail_out
= uncompressed_size
;
12627 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12629 rc
= inflateInit (& strm
);
12630 while (strm
.avail_in
> 0)
12634 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12635 + (uncompressed_size
- strm
.avail_out
));
12636 rc
= inflate (&strm
, Z_FINISH
);
12637 if (rc
!= Z_STREAM_END
)
12639 rc
= inflateReset (& strm
);
12641 rc
= inflateEnd (& strm
);
12643 || strm
.avail_out
!= 0)
12646 *buffer
= uncompressed_buffer
;
12647 *size
= uncompressed_size
;
12651 free (uncompressed_buffer
);
12652 /* Indicate decompression failure. */
12658 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12660 Elf_Internal_Shdr
* relsec
;
12661 bfd_size_type num_bytes
;
12662 unsigned char * data
;
12663 unsigned char * end
;
12664 unsigned char * real_start
;
12665 unsigned char * start
;
12666 bfd_boolean some_strings_shown
;
12668 real_start
= start
= (unsigned char *) get_section_contents (section
,
12672 num_bytes
= section
->sh_size
;
12674 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12676 if (decompress_dumps
)
12678 dwarf_size_type new_size
= num_bytes
;
12679 dwarf_size_type uncompressed_size
= 0;
12681 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12683 Elf_Internal_Chdr chdr
;
12684 unsigned int compression_header_size
12685 = get_compression_header (& chdr
, (unsigned char *) start
,
12688 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12690 warn (_("section '%s' has unsupported compress type: %d\n"),
12691 printable_section_name (section
), chdr
.ch_type
);
12694 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12696 warn (_("compressed section '%s' is corrupted\n"),
12697 printable_section_name (section
));
12700 uncompressed_size
= chdr
.ch_size
;
12701 start
+= compression_header_size
;
12702 new_size
-= compression_header_size
;
12704 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12706 /* Read the zlib header. In this case, it should be "ZLIB"
12707 followed by the uncompressed section size, 8 bytes in
12708 big-endian order. */
12709 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12710 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12711 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12712 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12713 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12714 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12715 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12716 uncompressed_size
+= start
[11];
12721 if (uncompressed_size
)
12723 if (uncompress_section_contents (& start
,
12724 uncompressed_size
, & new_size
))
12725 num_bytes
= new_size
;
12728 error (_("Unable to decompress section %s\n"),
12729 printable_section_name (section
));
12734 start
= real_start
;
12737 /* If the section being dumped has relocations against it the user might
12738 be expecting these relocations to have been applied. Check for this
12739 case and issue a warning message in order to avoid confusion.
12740 FIXME: Maybe we ought to have an option that dumps a section with
12741 relocs applied ? */
12742 for (relsec
= section_headers
;
12743 relsec
< section_headers
+ elf_header
.e_shnum
;
12746 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12747 || relsec
->sh_info
>= elf_header
.e_shnum
12748 || section_headers
+ relsec
->sh_info
!= section
12749 || relsec
->sh_size
== 0
12750 || relsec
->sh_link
>= elf_header
.e_shnum
)
12753 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12758 end
= start
+ num_bytes
;
12759 some_strings_shown
= FALSE
;
12763 while (!ISPRINT (* data
))
12764 if (++ data
>= end
)
12769 size_t maxlen
= end
- data
;
12772 /* PR 11128: Use two separate invocations in order to work
12773 around bugs in the Solaris 8 implementation of printf. */
12774 printf (" [%6tx] ", data
- start
);
12776 printf (" [%6Ix] ", (size_t) (data
- start
));
12780 print_symbol ((int) maxlen
, (const char *) data
);
12782 data
+= strnlen ((const char *) data
, maxlen
);
12786 printf (_("<corrupt>\n"));
12789 some_strings_shown
= TRUE
;
12793 if (! some_strings_shown
)
12794 printf (_(" No strings found in this section."));
12802 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12804 bfd_boolean relocate
)
12806 Elf_Internal_Shdr
* relsec
;
12807 bfd_size_type bytes
;
12808 bfd_size_type section_size
;
12810 unsigned char * data
;
12811 unsigned char * real_start
;
12812 unsigned char * start
;
12814 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12817 section_size
= section
->sh_size
;
12819 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12821 if (decompress_dumps
)
12823 dwarf_size_type new_size
= section_size
;
12824 dwarf_size_type uncompressed_size
= 0;
12826 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12828 Elf_Internal_Chdr chdr
;
12829 unsigned int compression_header_size
12830 = get_compression_header (& chdr
, start
, section_size
);
12832 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12834 warn (_("section '%s' has unsupported compress type: %d\n"),
12835 printable_section_name (section
), chdr
.ch_type
);
12838 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12840 warn (_("compressed section '%s' is corrupted\n"),
12841 printable_section_name (section
));
12844 uncompressed_size
= chdr
.ch_size
;
12845 start
+= compression_header_size
;
12846 new_size
-= compression_header_size
;
12848 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12850 /* Read the zlib header. In this case, it should be "ZLIB"
12851 followed by the uncompressed section size, 8 bytes in
12852 big-endian order. */
12853 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12854 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12855 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12856 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12857 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12858 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12859 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12860 uncompressed_size
+= start
[11];
12865 if (uncompressed_size
)
12867 if (uncompress_section_contents (& start
, uncompressed_size
,
12870 section_size
= new_size
;
12874 error (_("Unable to decompress section %s\n"),
12875 printable_section_name (section
));
12876 /* FIXME: Print the section anyway ? */
12881 start
= real_start
;
12886 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12890 /* If the section being dumped has relocations against it the user might
12891 be expecting these relocations to have been applied. Check for this
12892 case and issue a warning message in order to avoid confusion.
12893 FIXME: Maybe we ought to have an option that dumps a section with
12894 relocs applied ? */
12895 for (relsec
= section_headers
;
12896 relsec
< section_headers
+ elf_header
.e_shnum
;
12899 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12900 || relsec
->sh_info
>= elf_header
.e_shnum
12901 || section_headers
+ relsec
->sh_info
!= section
12902 || relsec
->sh_size
== 0
12903 || relsec
->sh_link
>= elf_header
.e_shnum
)
12906 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12911 addr
= section
->sh_addr
;
12912 bytes
= section_size
;
12921 lbytes
= (bytes
> 16 ? 16 : bytes
);
12923 printf (" 0x%8.8lx ", (unsigned long) addr
);
12925 for (j
= 0; j
< 16; j
++)
12928 printf ("%2.2x", data
[j
]);
12936 for (j
= 0; j
< lbytes
; j
++)
12939 if (k
>= ' ' && k
< 0x7f)
12958 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12959 const Elf_Internal_Shdr
* sec
, void * file
)
12961 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12964 /* If it is already loaded, do nothing. */
12965 if (section
->start
!= NULL
)
12968 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12969 section
->address
= sec
->sh_addr
;
12970 section
->user_data
= NULL
;
12971 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12973 sec
->sh_size
, buf
);
12974 if (section
->start
== NULL
)
12978 unsigned char *start
= section
->start
;
12979 dwarf_size_type size
= sec
->sh_size
;
12980 dwarf_size_type uncompressed_size
= 0;
12982 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12984 Elf_Internal_Chdr chdr
;
12985 unsigned int compression_header_size
;
12987 if (size
< (is_32bit_elf
12988 ? sizeof (Elf32_External_Chdr
)
12989 : sizeof (Elf64_External_Chdr
)))
12991 warn (_("compressed section %s is too small to contain a compression header"),
12996 compression_header_size
= get_compression_header (&chdr
, start
, size
);
12998 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13000 warn (_("section '%s' has unsupported compress type: %d\n"),
13001 section
->name
, chdr
.ch_type
);
13004 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13006 warn (_("compressed section '%s' is corrupted\n"),
13010 uncompressed_size
= chdr
.ch_size
;
13011 start
+= compression_header_size
;
13012 size
-= compression_header_size
;
13014 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13016 /* Read the zlib header. In this case, it should be "ZLIB"
13017 followed by the uncompressed section size, 8 bytes in
13018 big-endian order. */
13019 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13020 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13021 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13022 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13023 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13024 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13025 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13026 uncompressed_size
+= start
[11];
13031 if (uncompressed_size
)
13033 if (uncompress_section_contents (&start
, uncompressed_size
,
13036 /* Free the compressed buffer, update the section buffer
13037 and the section size if uncompress is successful. */
13038 free (section
->start
);
13039 section
->start
= start
;
13043 error (_("Unable to decompress section %s\n"),
13044 printable_section_name (sec
));
13049 section
->size
= size
;
13052 if (section
->start
== NULL
)
13055 if (debug_displays
[debug
].relocate
)
13056 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13057 & section
->reloc_info
, & section
->num_relocs
);
13060 section
->reloc_info
= NULL
;
13061 section
->num_relocs
= 0;
13067 /* If this is not NULL, load_debug_section will only look for sections
13068 within the list of sections given here. */
13069 unsigned int *section_subset
= NULL
;
13072 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13074 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13075 Elf_Internal_Shdr
* sec
;
13077 /* Locate the debug section. */
13078 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13080 section
->name
= section
->uncompressed_name
;
13083 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13085 section
->name
= section
->compressed_name
;
13090 /* If we're loading from a subset of sections, and we've loaded
13091 a section matching this name before, it's likely that it's a
13093 if (section_subset
!= NULL
)
13094 free_debug_section (debug
);
13096 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13100 free_debug_section (enum dwarf_section_display_enum debug
)
13102 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13104 if (section
->start
== NULL
)
13107 free ((char *) section
->start
);
13108 section
->start
= NULL
;
13109 section
->address
= 0;
13114 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13116 char * name
= SECTION_NAME (section
);
13117 const char * print_name
= printable_section_name (section
);
13118 bfd_size_type length
;
13122 length
= section
->sh_size
;
13125 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13128 if (section
->sh_type
== SHT_NOBITS
)
13130 /* There is no point in dumping the contents of a debugging section
13131 which has the NOBITS type - the bits in the file will be random.
13132 This can happen when a file containing a .eh_frame section is
13133 stripped with the --only-keep-debug command line option. */
13134 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13139 if (const_strneq (name
, ".gnu.linkonce.wi."))
13140 name
= ".debug_info";
13142 /* See if we know how to display the contents of this section. */
13143 for (i
= 0; i
< max
; i
++)
13144 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13145 || (i
== line
&& const_strneq (name
, ".debug_line."))
13146 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13148 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13149 int secondary
= (section
!= find_section (name
));
13152 free_debug_section ((enum dwarf_section_display_enum
) i
);
13154 if (i
== line
&& const_strneq (name
, ".debug_line."))
13156 else if (streq (sec
->uncompressed_name
, name
))
13157 sec
->name
= sec
->uncompressed_name
;
13159 sec
->name
= sec
->compressed_name
;
13160 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13163 /* If this debug section is part of a CU/TU set in a .dwp file,
13164 restrict load_debug_section to the sections in that set. */
13165 section_subset
= find_cu_tu_set (file
, shndx
);
13167 result
&= debug_displays
[i
].display (sec
, file
);
13169 section_subset
= NULL
;
13171 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13172 free_debug_section ((enum dwarf_section_display_enum
) i
);
13180 printf (_("Unrecognized debug section: %s\n"), print_name
);
13187 /* Set DUMP_SECTS for all sections where dumps were requested
13188 based on section name. */
13191 initialise_dumps_byname (void)
13193 struct dump_list_entry
* cur
;
13195 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13200 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13201 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13203 request_dump_bynumber (i
, cur
->type
);
13208 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13214 process_section_contents (FILE * file
)
13216 Elf_Internal_Shdr
* section
;
13222 initialise_dumps_byname ();
13224 for (i
= 0, section
= section_headers
;
13225 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13228 #ifdef SUPPORT_DISASSEMBLY
13229 if (dump_sects
[i
] & DISASS_DUMP
)
13230 disassemble_section (section
, file
);
13232 if (dump_sects
[i
] & HEX_DUMP
)
13233 dump_section_as_bytes (section
, file
, FALSE
);
13235 if (dump_sects
[i
] & RELOC_DUMP
)
13236 dump_section_as_bytes (section
, file
, TRUE
);
13238 if (dump_sects
[i
] & STRING_DUMP
)
13239 dump_section_as_strings (section
, file
);
13241 if (dump_sects
[i
] & DEBUG_DUMP
)
13242 display_debug_section (i
, section
, file
);
13245 /* Check to see if the user requested a
13246 dump of a section that does not exist. */
13247 while (i
< num_dump_sects
)
13250 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13256 process_mips_fpe_exception (int mask
)
13261 if (mask
& OEX_FPU_INEX
)
13262 fputs ("INEX", stdout
), first
= 0;
13263 if (mask
& OEX_FPU_UFLO
)
13264 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13265 if (mask
& OEX_FPU_OFLO
)
13266 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13267 if (mask
& OEX_FPU_DIV0
)
13268 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13269 if (mask
& OEX_FPU_INVAL
)
13270 printf ("%sINVAL", first
? "" : "|");
13273 fputs ("0", stdout
);
13276 /* Display's the value of TAG at location P. If TAG is
13277 greater than 0 it is assumed to be an unknown tag, and
13278 a message is printed to this effect. Otherwise it is
13279 assumed that a message has already been printed.
13281 If the bottom bit of TAG is set it assumed to have a
13282 string value, otherwise it is assumed to have an integer
13285 Returns an updated P pointing to the first unread byte
13286 beyond the end of TAG's value.
13288 Reads at or beyond END will not be made. */
13290 static unsigned char *
13291 display_tag_value (signed int tag
,
13293 const unsigned char * const end
)
13298 printf (" Tag_unknown_%d: ", tag
);
13302 warn (_("<corrupt tag>\n"));
13306 /* PR 17531 file: 027-19978-0.004. */
13307 size_t maxlen
= (end
- p
) - 1;
13312 print_symbol ((int) maxlen
, (const char *) p
);
13313 p
+= strnlen ((char *) p
, maxlen
) + 1;
13317 printf (_("<corrupt string tag>"));
13318 p
= (unsigned char *) end
;
13326 val
= read_uleb128 (p
, &len
, end
);
13328 printf ("%ld (0x%lx)\n", val
, val
);
13335 /* ARM EABI attributes section. */
13340 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13342 const char ** table
;
13343 } arm_attr_public_tag
;
13345 static const char * arm_attr_tag_CPU_arch
[] =
13346 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13347 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13349 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13350 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13351 {"No", "Thumb-1", "Thumb-2", "Yes"};
13352 static const char * arm_attr_tag_FP_arch
[] =
13353 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13354 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13355 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13356 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13357 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13358 "NEON for ARMv8.1"};
13359 static const char * arm_attr_tag_PCS_config
[] =
13360 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13361 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13362 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13363 {"V6", "SB", "TLS", "Unused"};
13364 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13365 {"Absolute", "PC-relative", "SB-relative", "None"};
13366 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13367 {"Absolute", "PC-relative", "None"};
13368 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13369 {"None", "direct", "GOT-indirect"};
13370 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13371 {"None", "??? 1", "2", "??? 3", "4"};
13372 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13373 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13374 {"Unused", "Needed", "Sign only"};
13375 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13376 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13377 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13378 {"Unused", "Finite", "RTABI", "IEEE 754"};
13379 static const char * arm_attr_tag_ABI_enum_size
[] =
13380 {"Unused", "small", "int", "forced to int"};
13381 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13382 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13383 static const char * arm_attr_tag_ABI_VFP_args
[] =
13384 {"AAPCS", "VFP registers", "custom", "compatible"};
13385 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13386 {"AAPCS", "WMMX registers", "custom"};
13387 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13388 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13389 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13390 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13391 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13392 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13393 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13394 static const char * arm_attr_tag_FP_HP_extension
[] =
13395 {"Not Allowed", "Allowed"};
13396 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13397 {"None", "IEEE 754", "Alternative Format"};
13398 static const char * arm_attr_tag_DSP_extension
[] =
13399 {"Follow architecture", "Allowed"};
13400 static const char * arm_attr_tag_MPextension_use
[] =
13401 {"Not Allowed", "Allowed"};
13402 static const char * arm_attr_tag_DIV_use
[] =
13403 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13404 "Allowed in v7-A with integer division extension"};
13405 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13406 static const char * arm_attr_tag_Virtualization_use
[] =
13407 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13408 "TrustZone and Virtualization Extensions"};
13409 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13410 {"Not Allowed", "Allowed"};
13412 #define LOOKUP(id, name) \
13413 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13414 static arm_attr_public_tag arm_attr_public_tags
[] =
13416 {4, "CPU_raw_name", 1, NULL
},
13417 {5, "CPU_name", 1, NULL
},
13418 LOOKUP(6, CPU_arch
),
13419 {7, "CPU_arch_profile", 0, NULL
},
13420 LOOKUP(8, ARM_ISA_use
),
13421 LOOKUP(9, THUMB_ISA_use
),
13422 LOOKUP(10, FP_arch
),
13423 LOOKUP(11, WMMX_arch
),
13424 LOOKUP(12, Advanced_SIMD_arch
),
13425 LOOKUP(13, PCS_config
),
13426 LOOKUP(14, ABI_PCS_R9_use
),
13427 LOOKUP(15, ABI_PCS_RW_data
),
13428 LOOKUP(16, ABI_PCS_RO_data
),
13429 LOOKUP(17, ABI_PCS_GOT_use
),
13430 LOOKUP(18, ABI_PCS_wchar_t
),
13431 LOOKUP(19, ABI_FP_rounding
),
13432 LOOKUP(20, ABI_FP_denormal
),
13433 LOOKUP(21, ABI_FP_exceptions
),
13434 LOOKUP(22, ABI_FP_user_exceptions
),
13435 LOOKUP(23, ABI_FP_number_model
),
13436 {24, "ABI_align_needed", 0, NULL
},
13437 {25, "ABI_align_preserved", 0, NULL
},
13438 LOOKUP(26, ABI_enum_size
),
13439 LOOKUP(27, ABI_HardFP_use
),
13440 LOOKUP(28, ABI_VFP_args
),
13441 LOOKUP(29, ABI_WMMX_args
),
13442 LOOKUP(30, ABI_optimization_goals
),
13443 LOOKUP(31, ABI_FP_optimization_goals
),
13444 {32, "compatibility", 0, NULL
},
13445 LOOKUP(34, CPU_unaligned_access
),
13446 LOOKUP(36, FP_HP_extension
),
13447 LOOKUP(38, ABI_FP_16bit_format
),
13448 LOOKUP(42, MPextension_use
),
13449 LOOKUP(44, DIV_use
),
13450 LOOKUP(46, DSP_extension
),
13451 {64, "nodefaults", 0, NULL
},
13452 {65, "also_compatible_with", 0, NULL
},
13453 LOOKUP(66, T2EE_use
),
13454 {67, "conformance", 1, NULL
},
13455 LOOKUP(68, Virtualization_use
),
13456 LOOKUP(70, MPextension_use_legacy
)
13460 static unsigned char *
13461 display_arm_attribute (unsigned char * p
,
13462 const unsigned char * const end
)
13467 arm_attr_public_tag
* attr
;
13471 tag
= read_uleb128 (p
, &len
, end
);
13474 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13476 if (arm_attr_public_tags
[i
].tag
== tag
)
13478 attr
= &arm_attr_public_tags
[i
];
13485 printf (" Tag_%s: ", attr
->name
);
13486 switch (attr
->type
)
13491 case 7: /* Tag_CPU_arch_profile. */
13492 val
= read_uleb128 (p
, &len
, end
);
13496 case 0: printf (_("None\n")); break;
13497 case 'A': printf (_("Application\n")); break;
13498 case 'R': printf (_("Realtime\n")); break;
13499 case 'M': printf (_("Microcontroller\n")); break;
13500 case 'S': printf (_("Application or Realtime\n")); break;
13501 default: printf ("??? (%d)\n", val
); break;
13505 case 24: /* Tag_align_needed. */
13506 val
= read_uleb128 (p
, &len
, end
);
13510 case 0: printf (_("None\n")); break;
13511 case 1: printf (_("8-byte\n")); break;
13512 case 2: printf (_("4-byte\n")); break;
13513 case 3: printf ("??? 3\n"); break;
13516 printf (_("8-byte and up to %d-byte extended\n"),
13519 printf ("??? (%d)\n", val
);
13524 case 25: /* Tag_align_preserved. */
13525 val
= read_uleb128 (p
, &len
, end
);
13529 case 0: printf (_("None\n")); break;
13530 case 1: printf (_("8-byte, except leaf SP\n")); break;
13531 case 2: printf (_("8-byte\n")); break;
13532 case 3: printf ("??? 3\n"); break;
13535 printf (_("8-byte and up to %d-byte extended\n"),
13538 printf ("??? (%d)\n", val
);
13543 case 32: /* Tag_compatibility. */
13545 val
= read_uleb128 (p
, &len
, end
);
13547 printf (_("flag = %d, vendor = "), val
);
13550 size_t maxlen
= (end
- p
) - 1;
13552 print_symbol ((int) maxlen
, (const char *) p
);
13553 p
+= strnlen ((char *) p
, maxlen
) + 1;
13557 printf (_("<corrupt>"));
13558 p
= (unsigned char *) end
;
13564 case 64: /* Tag_nodefaults. */
13565 /* PR 17531: file: 001-505008-0.01. */
13568 printf (_("True\n"));
13571 case 65: /* Tag_also_compatible_with. */
13572 val
= read_uleb128 (p
, &len
, end
);
13574 if (val
== 6 /* Tag_CPU_arch. */)
13576 val
= read_uleb128 (p
, &len
, end
);
13578 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13579 printf ("??? (%d)\n", val
);
13581 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13585 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13590 printf (_("<unknown: %d>\n"), tag
);
13596 return display_tag_value (-1, p
, end
);
13598 return display_tag_value (0, p
, end
);
13601 assert (attr
->type
& 0x80);
13602 val
= read_uleb128 (p
, &len
, end
);
13604 type
= attr
->type
& 0x7f;
13606 printf ("??? (%d)\n", val
);
13608 printf ("%s\n", attr
->table
[val
]);
13613 return display_tag_value (tag
, p
, end
);
13616 static unsigned char *
13617 display_gnu_attribute (unsigned char * p
,
13618 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13619 const unsigned char * const end
)
13625 tag
= read_uleb128 (p
, &len
, end
);
13628 /* Tag_compatibility is the only generic GNU attribute defined at
13632 val
= read_uleb128 (p
, &len
, end
);
13635 printf (_("flag = %d, vendor = "), val
);
13638 printf (_("<corrupt>\n"));
13639 warn (_("corrupt vendor attribute\n"));
13645 size_t maxlen
= (end
- p
) - 1;
13647 print_symbol ((int) maxlen
, (const char *) p
);
13648 p
+= strnlen ((char *) p
, maxlen
) + 1;
13652 printf (_("<corrupt>"));
13653 p
= (unsigned char *) end
;
13660 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13661 return display_proc_gnu_attribute (p
, tag
, end
);
13663 return display_tag_value (tag
, p
, end
);
13666 static unsigned char *
13667 display_power_gnu_attribute (unsigned char * p
,
13669 const unsigned char * const end
)
13674 if (tag
== Tag_GNU_Power_ABI_FP
)
13676 val
= read_uleb128 (p
, &len
, end
);
13678 printf (" Tag_GNU_Power_ABI_FP: ");
13681 printf (_("<corrupt>\n"));
13686 printf ("(%#x), ", val
);
13691 printf (_("unspecified hard/soft float, "));
13694 printf (_("hard float, "));
13697 printf (_("soft float, "));
13700 printf (_("single-precision hard float, "));
13707 printf (_("unspecified long double\n"));
13710 printf (_("128-bit IBM long double\n"));
13713 printf (_("64-bit long double\n"));
13716 printf (_("128-bit IEEE long double\n"));
13722 if (tag
== Tag_GNU_Power_ABI_Vector
)
13724 val
= read_uleb128 (p
, &len
, end
);
13726 printf (" Tag_GNU_Power_ABI_Vector: ");
13729 printf (_("<corrupt>\n"));
13734 printf ("(%#x), ", val
);
13739 printf (_("unspecified\n"));
13742 printf (_("generic\n"));
13745 printf ("AltiVec\n");
13754 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13756 val
= read_uleb128 (p
, &len
, end
);
13758 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13761 printf (_("<corrupt>\n"));
13766 printf ("(%#x), ", val
);
13771 printf (_("unspecified\n"));
13774 printf ("r3/r4\n");
13777 printf (_("memory\n"));
13786 return display_tag_value (tag
& 1, p
, end
);
13789 static unsigned char *
13790 display_s390_gnu_attribute (unsigned char * p
,
13792 const unsigned char * const end
)
13797 if (tag
== Tag_GNU_S390_ABI_Vector
)
13799 val
= read_uleb128 (p
, &len
, end
);
13801 printf (" Tag_GNU_S390_ABI_Vector: ");
13806 printf (_("any\n"));
13809 printf (_("software\n"));
13812 printf (_("hardware\n"));
13815 printf ("??? (%d)\n", val
);
13821 return display_tag_value (tag
& 1, p
, end
);
13825 display_sparc_hwcaps (unsigned int mask
)
13831 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13832 fputs ("mul32", stdout
), first
= 0;
13833 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13834 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13835 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13836 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13837 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13838 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13839 if (mask
& ELF_SPARC_HWCAP_POPC
)
13840 printf ("%spopc", first
? "" : "|"), first
= 0;
13841 if (mask
& ELF_SPARC_HWCAP_VIS
)
13842 printf ("%svis", first
? "" : "|"), first
= 0;
13843 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13844 printf ("%svis2", first
? "" : "|"), first
= 0;
13845 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13846 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13847 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13848 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13849 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13850 printf ("%svis3", first
? "" : "|"), first
= 0;
13851 if (mask
& ELF_SPARC_HWCAP_HPC
)
13852 printf ("%shpc", first
? "" : "|"), first
= 0;
13853 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13854 printf ("%srandom", first
? "" : "|"), first
= 0;
13855 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13856 printf ("%strans", first
? "" : "|"), first
= 0;
13857 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13858 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13859 if (mask
& ELF_SPARC_HWCAP_IMA
)
13860 printf ("%sima", first
? "" : "|"), first
= 0;
13861 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13862 printf ("%scspare", first
? "" : "|"), first
= 0;
13865 fputc ('0', stdout
);
13866 fputc ('\n', stdout
);
13870 display_sparc_hwcaps2 (unsigned int mask
)
13876 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13877 fputs ("fjathplus", stdout
), first
= 0;
13878 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13879 printf ("%svis3b", first
? "" : "|"), first
= 0;
13880 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13881 printf ("%sadp", first
? "" : "|"), first
= 0;
13882 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13883 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13884 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13885 printf ("%smwait", first
? "" : "|"), first
= 0;
13886 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13887 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13888 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13889 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13890 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13891 printf ("%snsec", first
? "" : "|"), first
= 0;
13892 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13893 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13894 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13895 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13896 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13897 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13900 fputc ('0', stdout
);
13901 fputc ('\n', stdout
);
13904 static unsigned char *
13905 display_sparc_gnu_attribute (unsigned char * p
,
13907 const unsigned char * const end
)
13912 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13914 val
= read_uleb128 (p
, &len
, end
);
13916 printf (" Tag_GNU_Sparc_HWCAPS: ");
13917 display_sparc_hwcaps (val
);
13920 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13922 val
= read_uleb128 (p
, &len
, end
);
13924 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13925 display_sparc_hwcaps2 (val
);
13929 return display_tag_value (tag
, p
, end
);
13933 print_mips_fp_abi_value (int val
)
13937 case Val_GNU_MIPS_ABI_FP_ANY
:
13938 printf (_("Hard or soft float\n"));
13940 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13941 printf (_("Hard float (double precision)\n"));
13943 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13944 printf (_("Hard float (single precision)\n"));
13946 case Val_GNU_MIPS_ABI_FP_SOFT
:
13947 printf (_("Soft float\n"));
13949 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13950 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13952 case Val_GNU_MIPS_ABI_FP_XX
:
13953 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13955 case Val_GNU_MIPS_ABI_FP_64
:
13956 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13958 case Val_GNU_MIPS_ABI_FP_64A
:
13959 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13961 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13962 printf (_("NaN 2008 compatibility\n"));
13965 printf ("??? (%d)\n", val
);
13970 static unsigned char *
13971 display_mips_gnu_attribute (unsigned char * p
,
13973 const unsigned char * const end
)
13975 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13980 val
= read_uleb128 (p
, &len
, end
);
13982 printf (" Tag_GNU_MIPS_ABI_FP: ");
13984 print_mips_fp_abi_value (val
);
13989 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13994 val
= read_uleb128 (p
, &len
, end
);
13996 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14000 case Val_GNU_MIPS_ABI_MSA_ANY
:
14001 printf (_("Any MSA or not\n"));
14003 case Val_GNU_MIPS_ABI_MSA_128
:
14004 printf (_("128-bit MSA\n"));
14007 printf ("??? (%d)\n", val
);
14013 return display_tag_value (tag
& 1, p
, end
);
14016 static unsigned char *
14017 display_tic6x_attribute (unsigned char * p
,
14018 const unsigned char * const end
)
14024 tag
= read_uleb128 (p
, &len
, end
);
14030 val
= read_uleb128 (p
, &len
, end
);
14032 printf (" Tag_ISA: ");
14036 case C6XABI_Tag_ISA_none
:
14037 printf (_("None\n"));
14039 case C6XABI_Tag_ISA_C62X
:
14042 case C6XABI_Tag_ISA_C67X
:
14045 case C6XABI_Tag_ISA_C67XP
:
14046 printf ("C67x+\n");
14048 case C6XABI_Tag_ISA_C64X
:
14051 case C6XABI_Tag_ISA_C64XP
:
14052 printf ("C64x+\n");
14054 case C6XABI_Tag_ISA_C674X
:
14055 printf ("C674x\n");
14058 printf ("??? (%d)\n", val
);
14063 case Tag_ABI_wchar_t
:
14064 val
= read_uleb128 (p
, &len
, end
);
14066 printf (" Tag_ABI_wchar_t: ");
14070 printf (_("Not used\n"));
14073 printf (_("2 bytes\n"));
14076 printf (_("4 bytes\n"));
14079 printf ("??? (%d)\n", val
);
14084 case Tag_ABI_stack_align_needed
:
14085 val
= read_uleb128 (p
, &len
, end
);
14087 printf (" Tag_ABI_stack_align_needed: ");
14091 printf (_("8-byte\n"));
14094 printf (_("16-byte\n"));
14097 printf ("??? (%d)\n", val
);
14102 case Tag_ABI_stack_align_preserved
:
14103 val
= read_uleb128 (p
, &len
, end
);
14105 printf (" Tag_ABI_stack_align_preserved: ");
14109 printf (_("8-byte\n"));
14112 printf (_("16-byte\n"));
14115 printf ("??? (%d)\n", val
);
14121 val
= read_uleb128 (p
, &len
, end
);
14123 printf (" Tag_ABI_DSBT: ");
14127 printf (_("DSBT addressing not used\n"));
14130 printf (_("DSBT addressing used\n"));
14133 printf ("??? (%d)\n", val
);
14139 val
= read_uleb128 (p
, &len
, end
);
14141 printf (" Tag_ABI_PID: ");
14145 printf (_("Data addressing position-dependent\n"));
14148 printf (_("Data addressing position-independent, GOT near DP\n"));
14151 printf (_("Data addressing position-independent, GOT far from DP\n"));
14154 printf ("??? (%d)\n", val
);
14160 val
= read_uleb128 (p
, &len
, end
);
14162 printf (" Tag_ABI_PIC: ");
14166 printf (_("Code addressing position-dependent\n"));
14169 printf (_("Code addressing position-independent\n"));
14172 printf ("??? (%d)\n", val
);
14177 case Tag_ABI_array_object_alignment
:
14178 val
= read_uleb128 (p
, &len
, end
);
14180 printf (" Tag_ABI_array_object_alignment: ");
14184 printf (_("8-byte\n"));
14187 printf (_("4-byte\n"));
14190 printf (_("16-byte\n"));
14193 printf ("??? (%d)\n", val
);
14198 case Tag_ABI_array_object_align_expected
:
14199 val
= read_uleb128 (p
, &len
, end
);
14201 printf (" Tag_ABI_array_object_align_expected: ");
14205 printf (_("8-byte\n"));
14208 printf (_("4-byte\n"));
14211 printf (_("16-byte\n"));
14214 printf ("??? (%d)\n", val
);
14219 case Tag_ABI_compatibility
:
14221 val
= read_uleb128 (p
, &len
, end
);
14223 printf (" Tag_ABI_compatibility: ");
14224 printf (_("flag = %d, vendor = "), val
);
14227 size_t maxlen
= (end
- p
) - 1;
14229 print_symbol ((int) maxlen
, (const char *) p
);
14230 p
+= strnlen ((char *) p
, maxlen
) + 1;
14234 printf (_("<corrupt>"));
14235 p
= (unsigned char *) end
;
14241 case Tag_ABI_conformance
:
14243 printf (" Tag_ABI_conformance: \"");
14246 size_t maxlen
= (end
- p
) - 1;
14248 print_symbol ((int) maxlen
, (const char *) p
);
14249 p
+= strnlen ((char *) p
, maxlen
) + 1;
14253 printf (_("<corrupt>"));
14254 p
= (unsigned char *) end
;
14261 return display_tag_value (tag
, p
, end
);
14265 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14267 unsigned long addr
= 0;
14268 size_t bytes
= end
- p
;
14275 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14277 printf (" 0x%8.8lx ", addr
);
14279 for (j
= 0; j
< 16; j
++)
14282 printf ("%2.2x", p
[j
]);
14290 for (j
= 0; j
< lbytes
; j
++)
14293 if (k
>= ' ' && k
< 0x7f)
14309 static unsigned char *
14310 display_msp430x_attribute (unsigned char * p
,
14311 const unsigned char * const end
)
14317 tag
= read_uleb128 (p
, & len
, end
);
14322 case OFBA_MSPABI_Tag_ISA
:
14323 val
= read_uleb128 (p
, &len
, end
);
14325 printf (" Tag_ISA: ");
14328 case 0: printf (_("None\n")); break;
14329 case 1: printf (_("MSP430\n")); break;
14330 case 2: printf (_("MSP430X\n")); break;
14331 default: printf ("??? (%d)\n", val
); break;
14335 case OFBA_MSPABI_Tag_Code_Model
:
14336 val
= read_uleb128 (p
, &len
, end
);
14338 printf (" Tag_Code_Model: ");
14341 case 0: printf (_("None\n")); break;
14342 case 1: printf (_("Small\n")); break;
14343 case 2: printf (_("Large\n")); break;
14344 default: printf ("??? (%d)\n", val
); break;
14348 case OFBA_MSPABI_Tag_Data_Model
:
14349 val
= read_uleb128 (p
, &len
, end
);
14351 printf (" Tag_Data_Model: ");
14354 case 0: printf (_("None\n")); break;
14355 case 1: printf (_("Small\n")); break;
14356 case 2: printf (_("Large\n")); break;
14357 case 3: printf (_("Restricted Large\n")); break;
14358 default: printf ("??? (%d)\n", val
); break;
14363 printf (_(" <unknown tag %d>: "), tag
);
14370 size_t maxlen
= (end
- p
) - 1;
14372 print_symbol ((int) maxlen
, (const char *) p
);
14373 p
+= strnlen ((char *) p
, maxlen
) + 1;
14377 printf (_("<corrupt>"));
14378 p
= (unsigned char *) end
;
14384 val
= read_uleb128 (p
, &len
, end
);
14386 printf ("%d (0x%x)\n", val
, val
);
14396 process_attributes (FILE * file
,
14397 const char * public_name
,
14398 unsigned int proc_type
,
14399 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14400 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14402 Elf_Internal_Shdr
* sect
;
14405 /* Find the section header so that we get the size. */
14406 for (i
= 0, sect
= section_headers
;
14407 i
< elf_header
.e_shnum
;
14410 unsigned char * contents
;
14413 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14416 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14417 sect
->sh_size
, _("attributes"));
14418 if (contents
== NULL
)
14422 /* The first character is the version of the attributes.
14423 Currently only version 1, (aka 'A') is recognised here. */
14425 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14428 bfd_vma section_len
;
14430 section_len
= sect
->sh_size
- 1;
14433 while (section_len
> 0)
14436 unsigned int namelen
;
14437 bfd_boolean public_section
;
14438 bfd_boolean gnu_section
;
14440 if (section_len
<= 4)
14442 error (_("Tag section ends prematurely\n"));
14445 attr_len
= byte_get (p
, 4);
14448 if (attr_len
> section_len
)
14450 error (_("Bad attribute length (%u > %u)\n"),
14451 (unsigned) attr_len
, (unsigned) section_len
);
14452 attr_len
= section_len
;
14454 /* PR 17531: file: 001-101425-0.004 */
14455 else if (attr_len
< 5)
14457 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14461 section_len
-= attr_len
;
14464 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14465 if (namelen
== 0 || namelen
>= attr_len
)
14467 error (_("Corrupt attribute section name\n"));
14471 printf (_("Attribute Section: "));
14472 print_symbol (INT_MAX
, (const char *) p
);
14475 if (public_name
&& streq ((char *) p
, public_name
))
14476 public_section
= TRUE
;
14478 public_section
= FALSE
;
14480 if (streq ((char *) p
, "gnu"))
14481 gnu_section
= TRUE
;
14483 gnu_section
= FALSE
;
14486 attr_len
-= namelen
;
14488 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14493 unsigned char * end
;
14495 /* PR binutils/17531: Safe handling of corrupt files. */
14498 error (_("Unused bytes at end of section\n"));
14504 size
= byte_get (p
, 4);
14505 if (size
> attr_len
)
14507 error (_("Bad subsection length (%u > %u)\n"),
14508 (unsigned) size
, (unsigned) attr_len
);
14511 /* PR binutils/17531: Safe handling of corrupt files. */
14514 error (_("Bad subsection length (%u < 6)\n"),
14521 end
= p
+ size
- 1;
14522 assert (end
<= contents
+ sect
->sh_size
);
14528 printf (_("File Attributes\n"));
14531 printf (_("Section Attributes:"));
14534 printf (_("Symbol Attributes:"));
14535 /* Fall through. */
14541 val
= read_uleb128 (p
, &j
, end
);
14545 printf (" %d", val
);
14550 printf (_("Unknown tag: %d\n"), tag
);
14551 public_section
= FALSE
;
14555 if (public_section
&& display_pub_attribute
!= NULL
)
14558 p
= display_pub_attribute (p
, end
);
14561 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14564 p
= display_gnu_attribute (p
,
14565 display_proc_gnu_attribute
,
14571 printf (_(" Unknown attribute:\n"));
14572 display_raw_attribute (p
, end
);
14586 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14587 Print the Address, Access and Initial fields of an entry at VMA ADDR
14588 and return the VMA of the next entry, or -1 if there was a problem.
14589 Does not read from DATA_END or beyond. */
14592 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14593 unsigned char * data_end
)
14596 print_vma (addr
, LONG_HEX
);
14598 if (addr
< pltgot
+ 0xfff0)
14599 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14601 printf ("%10s", "");
14604 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14608 unsigned char * from
= data
+ addr
- pltgot
;
14610 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14612 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14613 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14614 return (bfd_vma
) -1;
14618 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14619 print_vma (entry
, LONG_HEX
);
14622 return addr
+ (is_32bit_elf
? 4 : 8);
14625 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14626 PLTGOT. Print the Address and Initial fields of an entry at VMA
14627 ADDR and return the VMA of the next entry. */
14630 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14633 print_vma (addr
, LONG_HEX
);
14636 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14641 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14642 print_vma (entry
, LONG_HEX
);
14644 return addr
+ (is_32bit_elf
? 4 : 8);
14648 print_mips_ases (unsigned int mask
)
14650 if (mask
& AFL_ASE_DSP
)
14651 fputs ("\n\tDSP ASE", stdout
);
14652 if (mask
& AFL_ASE_DSPR2
)
14653 fputs ("\n\tDSP R2 ASE", stdout
);
14654 if (mask
& AFL_ASE_DSPR3
)
14655 fputs ("\n\tDSP R3 ASE", stdout
);
14656 if (mask
& AFL_ASE_EVA
)
14657 fputs ("\n\tEnhanced VA Scheme", stdout
);
14658 if (mask
& AFL_ASE_MCU
)
14659 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14660 if (mask
& AFL_ASE_MDMX
)
14661 fputs ("\n\tMDMX ASE", stdout
);
14662 if (mask
& AFL_ASE_MIPS3D
)
14663 fputs ("\n\tMIPS-3D ASE", stdout
);
14664 if (mask
& AFL_ASE_MT
)
14665 fputs ("\n\tMT ASE", stdout
);
14666 if (mask
& AFL_ASE_SMARTMIPS
)
14667 fputs ("\n\tSmartMIPS ASE", stdout
);
14668 if (mask
& AFL_ASE_VIRT
)
14669 fputs ("\n\tVZ ASE", stdout
);
14670 if (mask
& AFL_ASE_MSA
)
14671 fputs ("\n\tMSA ASE", stdout
);
14672 if (mask
& AFL_ASE_MIPS16
)
14673 fputs ("\n\tMIPS16 ASE", stdout
);
14674 if (mask
& AFL_ASE_MICROMIPS
)
14675 fputs ("\n\tMICROMIPS ASE", stdout
);
14676 if (mask
& AFL_ASE_XPA
)
14677 fputs ("\n\tXPA ASE", stdout
);
14679 fprintf (stdout
, "\n\t%s", _("None"));
14680 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14681 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14685 print_mips_isa_ext (unsigned int isa_ext
)
14690 fputs (_("None"), stdout
);
14693 fputs ("RMI XLR", stdout
);
14695 case AFL_EXT_OCTEON3
:
14696 fputs ("Cavium Networks Octeon3", stdout
);
14698 case AFL_EXT_OCTEON2
:
14699 fputs ("Cavium Networks Octeon2", stdout
);
14701 case AFL_EXT_OCTEONP
:
14702 fputs ("Cavium Networks OcteonP", stdout
);
14704 case AFL_EXT_LOONGSON_3A
:
14705 fputs ("Loongson 3A", stdout
);
14707 case AFL_EXT_OCTEON
:
14708 fputs ("Cavium Networks Octeon", stdout
);
14711 fputs ("Toshiba R5900", stdout
);
14714 fputs ("MIPS R4650", stdout
);
14717 fputs ("LSI R4010", stdout
);
14720 fputs ("NEC VR4100", stdout
);
14723 fputs ("Toshiba R3900", stdout
);
14725 case AFL_EXT_10000
:
14726 fputs ("MIPS R10000", stdout
);
14729 fputs ("Broadcom SB-1", stdout
);
14732 fputs ("NEC VR4111/VR4181", stdout
);
14735 fputs ("NEC VR4120", stdout
);
14738 fputs ("NEC VR5400", stdout
);
14741 fputs ("NEC VR5500", stdout
);
14743 case AFL_EXT_LOONGSON_2E
:
14744 fputs ("ST Microelectronics Loongson 2E", stdout
);
14746 case AFL_EXT_LOONGSON_2F
:
14747 fputs ("ST Microelectronics Loongson 2F", stdout
);
14750 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14755 get_mips_reg_size (int reg_size
)
14757 return (reg_size
== AFL_REG_NONE
) ? 0
14758 : (reg_size
== AFL_REG_32
) ? 32
14759 : (reg_size
== AFL_REG_64
) ? 64
14760 : (reg_size
== AFL_REG_128
) ? 128
14765 process_mips_specific (FILE * file
)
14767 Elf_Internal_Dyn
* entry
;
14768 Elf_Internal_Shdr
*sect
= NULL
;
14769 size_t liblist_offset
= 0;
14770 size_t liblistno
= 0;
14771 size_t conflictsno
= 0;
14772 size_t options_offset
= 0;
14773 size_t conflicts_offset
= 0;
14774 size_t pltrelsz
= 0;
14776 bfd_vma pltgot
= 0;
14777 bfd_vma mips_pltgot
= 0;
14778 bfd_vma jmprel
= 0;
14779 bfd_vma local_gotno
= 0;
14780 bfd_vma gotsym
= 0;
14781 bfd_vma symtabno
= 0;
14783 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14784 display_mips_gnu_attribute
);
14786 sect
= find_section (".MIPS.abiflags");
14790 Elf_External_ABIFlags_v0
*abiflags_ext
;
14791 Elf_Internal_ABIFlags_v0 abiflags_in
;
14793 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14794 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14797 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14798 sect
->sh_size
, _("MIPS ABI Flags section"));
14801 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14802 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14803 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14804 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14805 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14806 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14807 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14808 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14809 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14810 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14811 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14813 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14814 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14815 if (abiflags_in
.isa_rev
> 1)
14816 printf ("r%d", abiflags_in
.isa_rev
);
14817 printf ("\nGPR size: %d",
14818 get_mips_reg_size (abiflags_in
.gpr_size
));
14819 printf ("\nCPR1 size: %d",
14820 get_mips_reg_size (abiflags_in
.cpr1_size
));
14821 printf ("\nCPR2 size: %d",
14822 get_mips_reg_size (abiflags_in
.cpr2_size
));
14823 fputs ("\nFP ABI: ", stdout
);
14824 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14825 fputs ("ISA Extension: ", stdout
);
14826 print_mips_isa_ext (abiflags_in
.isa_ext
);
14827 fputs ("\nASEs:", stdout
);
14828 print_mips_ases (abiflags_in
.ases
);
14829 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14830 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14831 fputc ('\n', stdout
);
14832 free (abiflags_ext
);
14837 /* We have a lot of special sections. Thanks SGI! */
14838 if (dynamic_section
== NULL
)
14839 /* No information available. */
14842 for (entry
= dynamic_section
;
14843 /* PR 17531 file: 012-50589-0.004. */
14844 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14846 switch (entry
->d_tag
)
14848 case DT_MIPS_LIBLIST
:
14850 = offset_from_vma (file
, entry
->d_un
.d_val
,
14851 liblistno
* sizeof (Elf32_External_Lib
));
14853 case DT_MIPS_LIBLISTNO
:
14854 liblistno
= entry
->d_un
.d_val
;
14856 case DT_MIPS_OPTIONS
:
14857 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14859 case DT_MIPS_CONFLICT
:
14861 = offset_from_vma (file
, entry
->d_un
.d_val
,
14862 conflictsno
* sizeof (Elf32_External_Conflict
));
14864 case DT_MIPS_CONFLICTNO
:
14865 conflictsno
= entry
->d_un
.d_val
;
14868 pltgot
= entry
->d_un
.d_ptr
;
14870 case DT_MIPS_LOCAL_GOTNO
:
14871 local_gotno
= entry
->d_un
.d_val
;
14873 case DT_MIPS_GOTSYM
:
14874 gotsym
= entry
->d_un
.d_val
;
14876 case DT_MIPS_SYMTABNO
:
14877 symtabno
= entry
->d_un
.d_val
;
14879 case DT_MIPS_PLTGOT
:
14880 mips_pltgot
= entry
->d_un
.d_ptr
;
14883 pltrel
= entry
->d_un
.d_val
;
14886 pltrelsz
= entry
->d_un
.d_val
;
14889 jmprel
= entry
->d_un
.d_ptr
;
14895 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14897 Elf32_External_Lib
* elib
;
14900 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14902 sizeof (Elf32_External_Lib
),
14903 _("liblist section data"));
14906 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14907 (unsigned long) liblistno
);
14908 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14911 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14918 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14919 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14920 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14921 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14922 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14924 tmp
= gmtime (&atime
);
14925 snprintf (timebuf
, sizeof (timebuf
),
14926 "%04u-%02u-%02uT%02u:%02u:%02u",
14927 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14928 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14930 printf ("%3lu: ", (unsigned long) cnt
);
14931 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14932 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14934 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14935 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14936 liblist
.l_version
);
14938 if (liblist
.l_flags
== 0)
14942 static const struct
14949 { " EXACT_MATCH", LL_EXACT_MATCH
},
14950 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14951 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14952 { " EXPORTS", LL_EXPORTS
},
14953 { " DELAY_LOAD", LL_DELAY_LOAD
},
14954 { " DELTA", LL_DELTA
}
14956 int flags
= liblist
.l_flags
;
14959 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14960 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14962 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14963 flags
^= l_flags_vals
[fcnt
].bit
;
14966 printf (" %#x", (unsigned int) flags
);
14976 if (options_offset
!= 0)
14978 Elf_External_Options
* eopt
;
14979 Elf_Internal_Options
* iopt
;
14980 Elf_Internal_Options
* option
;
14983 sect
= section_headers
;
14985 /* Find the section header so that we get the size. */
14986 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14987 /* PR 17533 file: 012-277276-0.004. */
14990 error (_("No MIPS_OPTIONS header found\n"));
14994 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14995 sect
->sh_size
, _("options"));
14998 iopt
= (Elf_Internal_Options
*)
14999 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15002 error (_("Out of memory allocating space for MIPS options\n"));
15009 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15011 Elf_External_Options
* eoption
;
15013 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15015 option
->kind
= BYTE_GET (eoption
->kind
);
15016 option
->size
= BYTE_GET (eoption
->size
);
15017 option
->section
= BYTE_GET (eoption
->section
);
15018 option
->info
= BYTE_GET (eoption
->info
);
15020 /* PR 17531: file: ffa0fa3b. */
15021 if (option
->size
< sizeof (* eopt
)
15022 || offset
+ option
->size
> sect
->sh_size
)
15024 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15027 offset
+= option
->size
;
15033 printf (_("\nSection '%s' contains %d entries:\n"),
15034 printable_section_name (sect
), cnt
);
15043 switch (option
->kind
)
15046 /* This shouldn't happen. */
15047 printf (" NULL %d %lx", option
->section
, option
->info
);
15050 printf (" REGINFO ");
15051 if (elf_header
.e_machine
== EM_MIPS
)
15054 Elf32_External_RegInfo
* ereg
;
15055 Elf32_RegInfo reginfo
;
15057 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15058 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15059 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15060 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15061 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15062 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15063 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15065 printf ("GPR %08lx GP 0x%lx\n",
15066 reginfo
.ri_gprmask
,
15067 (unsigned long) reginfo
.ri_gp_value
);
15068 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15069 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15070 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15075 Elf64_External_RegInfo
* ereg
;
15076 Elf64_Internal_RegInfo reginfo
;
15078 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15079 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15080 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15081 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15082 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15083 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15084 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15086 printf ("GPR %08lx GP 0x",
15087 reginfo
.ri_gprmask
);
15088 printf_vma (reginfo
.ri_gp_value
);
15091 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15092 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15093 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15097 case ODK_EXCEPTIONS
:
15098 fputs (" EXCEPTIONS fpe_min(", stdout
);
15099 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15100 fputs (") fpe_max(", stdout
);
15101 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15102 fputs (")", stdout
);
15104 if (option
->info
& OEX_PAGE0
)
15105 fputs (" PAGE0", stdout
);
15106 if (option
->info
& OEX_SMM
)
15107 fputs (" SMM", stdout
);
15108 if (option
->info
& OEX_FPDBUG
)
15109 fputs (" FPDBUG", stdout
);
15110 if (option
->info
& OEX_DISMISS
)
15111 fputs (" DISMISS", stdout
);
15114 fputs (" PAD ", stdout
);
15115 if (option
->info
& OPAD_PREFIX
)
15116 fputs (" PREFIX", stdout
);
15117 if (option
->info
& OPAD_POSTFIX
)
15118 fputs (" POSTFIX", stdout
);
15119 if (option
->info
& OPAD_SYMBOL
)
15120 fputs (" SYMBOL", stdout
);
15123 fputs (" HWPATCH ", stdout
);
15124 if (option
->info
& OHW_R4KEOP
)
15125 fputs (" R4KEOP", stdout
);
15126 if (option
->info
& OHW_R8KPFETCH
)
15127 fputs (" R8KPFETCH", stdout
);
15128 if (option
->info
& OHW_R5KEOP
)
15129 fputs (" R5KEOP", stdout
);
15130 if (option
->info
& OHW_R5KCVTL
)
15131 fputs (" R5KCVTL", stdout
);
15134 fputs (" FILL ", stdout
);
15135 /* XXX Print content of info word? */
15138 fputs (" TAGS ", stdout
);
15139 /* XXX Print content of info word? */
15142 fputs (" HWAND ", stdout
);
15143 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15144 fputs (" R4KEOP_CHECKED", stdout
);
15145 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15146 fputs (" R4KEOP_CLEAN", stdout
);
15149 fputs (" HWOR ", stdout
);
15150 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15151 fputs (" R4KEOP_CHECKED", stdout
);
15152 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15153 fputs (" R4KEOP_CLEAN", stdout
);
15156 printf (" GP_GROUP %#06lx self-contained %#06lx",
15157 option
->info
& OGP_GROUP
,
15158 (option
->info
& OGP_SELF
) >> 16);
15161 printf (" IDENT %#06lx self-contained %#06lx",
15162 option
->info
& OGP_GROUP
,
15163 (option
->info
& OGP_SELF
) >> 16);
15166 /* This shouldn't happen. */
15167 printf (" %3d ??? %d %lx",
15168 option
->kind
, option
->section
, option
->info
);
15172 len
= sizeof (* eopt
);
15173 while (len
< option
->size
)
15175 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15177 if (ISPRINT (datum
))
15178 printf ("%c", datum
);
15180 printf ("\\%03o", datum
);
15183 fputs ("\n", stdout
);
15185 offset
+= option
->size
;
15193 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15195 Elf32_Conflict
* iconf
;
15198 if (dynamic_symbols
== NULL
)
15200 error (_("conflict list found without a dynamic symbol table\n"));
15204 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15207 error (_("Out of memory allocating space for dynamic conflicts\n"));
15213 Elf32_External_Conflict
* econf32
;
15215 econf32
= (Elf32_External_Conflict
*)
15216 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15217 sizeof (* econf32
), _("conflict"));
15221 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15222 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15228 Elf64_External_Conflict
* econf64
;
15230 econf64
= (Elf64_External_Conflict
*)
15231 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15232 sizeof (* econf64
), _("conflict"));
15236 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15237 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15242 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15243 (unsigned long) conflictsno
);
15244 puts (_(" Num: Index Value Name"));
15246 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15248 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15250 if (iconf
[cnt
] >= num_dynamic_syms
)
15251 printf (_("<corrupt symbol index>"));
15254 Elf_Internal_Sym
* psym
;
15256 psym
= & dynamic_symbols
[iconf
[cnt
]];
15257 print_vma (psym
->st_value
, FULL_HEX
);
15259 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15260 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15262 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15270 if (pltgot
!= 0 && local_gotno
!= 0)
15272 bfd_vma ent
, local_end
, global_end
;
15274 unsigned char * data
;
15275 unsigned char * data_end
;
15279 addr_size
= (is_32bit_elf
? 4 : 8);
15280 local_end
= pltgot
+ local_gotno
* addr_size
;
15282 /* PR binutils/17533 file: 012-111227-0.004 */
15283 if (symtabno
< gotsym
)
15285 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15286 (unsigned long) gotsym
, (unsigned long) symtabno
);
15290 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15291 /* PR 17531: file: 54c91a34. */
15292 if (global_end
< local_end
)
15294 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15298 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15299 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15300 global_end
- pltgot
, 1,
15301 _("Global Offset Table data"));
15304 data_end
= data
+ (global_end
- pltgot
);
15306 printf (_("\nPrimary GOT:\n"));
15307 printf (_(" Canonical gp value: "));
15308 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15311 printf (_(" Reserved entries:\n"));
15312 printf (_(" %*s %10s %*s Purpose\n"),
15313 addr_size
* 2, _("Address"), _("Access"),
15314 addr_size
* 2, _("Initial"));
15315 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15316 printf (_(" Lazy resolver\n"));
15317 if (ent
== (bfd_vma
) -1)
15318 goto got_print_fail
;
15320 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15321 >> (addr_size
* 8 - 1)) != 0)
15323 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15324 printf (_(" Module pointer (GNU extension)\n"));
15325 if (ent
== (bfd_vma
) -1)
15326 goto got_print_fail
;
15330 if (ent
< local_end
)
15332 printf (_(" Local entries:\n"));
15333 printf (" %*s %10s %*s\n",
15334 addr_size
* 2, _("Address"), _("Access"),
15335 addr_size
* 2, _("Initial"));
15336 while (ent
< local_end
)
15338 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15340 if (ent
== (bfd_vma
) -1)
15341 goto got_print_fail
;
15346 if (gotsym
< symtabno
)
15350 printf (_(" Global entries:\n"));
15351 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15352 addr_size
* 2, _("Address"),
15354 addr_size
* 2, _("Initial"),
15355 addr_size
* 2, _("Sym.Val."),
15357 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15358 _("Ndx"), _("Name"));
15360 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15362 for (i
= gotsym
; i
< symtabno
; i
++)
15364 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15367 if (dynamic_symbols
== NULL
)
15368 printf (_("<no dynamic symbols>"));
15369 else if (i
< num_dynamic_syms
)
15371 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15373 print_vma (psym
->st_value
, LONG_HEX
);
15374 printf (" %-7s %3s ",
15375 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15376 get_symbol_index_type (psym
->st_shndx
));
15378 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15379 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15381 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15384 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15385 (unsigned long) i
);
15388 if (ent
== (bfd_vma
) -1)
15399 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15402 size_t offset
, rel_offset
;
15403 unsigned long count
, i
;
15404 unsigned char * data
;
15405 int addr_size
, sym_width
;
15406 Elf_Internal_Rela
* rels
;
15408 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15409 if (pltrel
== DT_RELA
)
15411 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15416 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15421 addr_size
= (is_32bit_elf
? 4 : 8);
15422 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15424 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15425 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15426 1, _("Procedure Linkage Table data"));
15430 printf ("\nPLT GOT:\n\n");
15431 printf (_(" Reserved entries:\n"));
15432 printf (_(" %*s %*s Purpose\n"),
15433 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15434 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15435 printf (_(" PLT lazy resolver\n"));
15436 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15437 printf (_(" Module pointer\n"));
15440 printf (_(" Entries:\n"));
15441 printf (" %*s %*s %*s %-7s %3s %s\n",
15442 addr_size
* 2, _("Address"),
15443 addr_size
* 2, _("Initial"),
15444 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15445 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15446 for (i
= 0; i
< count
; i
++)
15448 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15450 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15453 if (idx
>= num_dynamic_syms
)
15454 printf (_("<corrupt symbol index: %lu>"), idx
);
15457 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15459 print_vma (psym
->st_value
, LONG_HEX
);
15460 printf (" %-7s %3s ",
15461 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15462 get_symbol_index_type (psym
->st_shndx
));
15463 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15464 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15466 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15481 process_nds32_specific (FILE * file
)
15483 Elf_Internal_Shdr
*sect
= NULL
;
15485 sect
= find_section (".nds32_e_flags");
15488 unsigned int *flag
;
15490 printf ("\nNDS32 elf flags section:\n");
15491 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15492 sect
->sh_size
, _("NDS32 elf flags section"));
15494 switch ((*flag
) & 0x3)
15497 printf ("(VEC_SIZE):\tNo entry.\n");
15500 printf ("(VEC_SIZE):\t4 bytes\n");
15503 printf ("(VEC_SIZE):\t16 bytes\n");
15506 printf ("(VEC_SIZE):\treserved\n");
15515 process_gnu_liblist (FILE * file
)
15517 Elf_Internal_Shdr
* section
;
15518 Elf_Internal_Shdr
* string_sec
;
15519 Elf32_External_Lib
* elib
;
15521 size_t strtab_size
;
15528 for (i
= 0, section
= section_headers
;
15529 i
< elf_header
.e_shnum
;
15532 switch (section
->sh_type
)
15534 case SHT_GNU_LIBLIST
:
15535 if (section
->sh_link
>= elf_header
.e_shnum
)
15538 elib
= (Elf32_External_Lib
*)
15539 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15540 _("liblist section data"));
15544 string_sec
= section_headers
+ section
->sh_link
;
15546 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15547 string_sec
->sh_size
,
15548 _("liblist string table"));
15550 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15556 strtab_size
= string_sec
->sh_size
;
15558 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15559 printable_section_name (section
),
15560 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15562 puts (_(" Library Time Stamp Checksum Version Flags"));
15564 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15572 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15573 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15574 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15575 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15576 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15578 tmp
= gmtime (&atime
);
15579 snprintf (timebuf
, sizeof (timebuf
),
15580 "%04u-%02u-%02uT%02u:%02u:%02u",
15581 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15582 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15584 printf ("%3lu: ", (unsigned long) cnt
);
15586 printf ("%-20s", liblist
.l_name
< strtab_size
15587 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15589 printf ("%-20.20s", liblist
.l_name
< strtab_size
15590 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15591 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15592 liblist
.l_version
, liblist
.l_flags
);
15603 static const char *
15604 get_note_type (unsigned e_type
)
15606 static char buff
[64];
15608 if (elf_header
.e_type
== ET_CORE
)
15612 return _("NT_AUXV (auxiliary vector)");
15614 return _("NT_PRSTATUS (prstatus structure)");
15616 return _("NT_FPREGSET (floating point registers)");
15618 return _("NT_PRPSINFO (prpsinfo structure)");
15619 case NT_TASKSTRUCT
:
15620 return _("NT_TASKSTRUCT (task structure)");
15622 return _("NT_PRXFPREG (user_xfpregs structure)");
15624 return _("NT_PPC_VMX (ppc Altivec registers)");
15626 return _("NT_PPC_VSX (ppc VSX registers)");
15628 return _("NT_386_TLS (x86 TLS information)");
15629 case NT_386_IOPERM
:
15630 return _("NT_386_IOPERM (x86 I/O permissions)");
15631 case NT_X86_XSTATE
:
15632 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15633 case NT_S390_HIGH_GPRS
:
15634 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15635 case NT_S390_TIMER
:
15636 return _("NT_S390_TIMER (s390 timer register)");
15637 case NT_S390_TODCMP
:
15638 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15639 case NT_S390_TODPREG
:
15640 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15642 return _("NT_S390_CTRS (s390 control registers)");
15643 case NT_S390_PREFIX
:
15644 return _("NT_S390_PREFIX (s390 prefix register)");
15645 case NT_S390_LAST_BREAK
:
15646 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15647 case NT_S390_SYSTEM_CALL
:
15648 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15650 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15651 case NT_S390_VXRS_LOW
:
15652 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15653 case NT_S390_VXRS_HIGH
:
15654 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15656 return _("NT_ARM_VFP (arm VFP registers)");
15658 return _("NT_ARM_TLS (AArch TLS registers)");
15659 case NT_ARM_HW_BREAK
:
15660 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15661 case NT_ARM_HW_WATCH
:
15662 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15664 return _("NT_PSTATUS (pstatus structure)");
15666 return _("NT_FPREGS (floating point registers)");
15668 return _("NT_PSINFO (psinfo structure)");
15670 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15672 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15673 case NT_WIN32PSTATUS
:
15674 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15676 return _("NT_SIGINFO (siginfo_t data)");
15678 return _("NT_FILE (mapped files)");
15686 return _("NT_VERSION (version)");
15688 return _("NT_ARCH (architecture)");
15693 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15698 print_core_note (Elf_Internal_Note
*pnote
)
15700 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15701 bfd_vma count
, page_size
;
15702 unsigned char *descdata
, *filenames
, *descend
;
15704 if (pnote
->type
!= NT_FILE
)
15710 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15711 /* Still "successful". */
15716 if (pnote
->descsz
< 2 * addr_size
)
15718 printf (_(" Malformed note - too short for header\n"));
15722 descdata
= (unsigned char *) pnote
->descdata
;
15723 descend
= descdata
+ pnote
->descsz
;
15725 if (descdata
[pnote
->descsz
- 1] != '\0')
15727 printf (_(" Malformed note - does not end with \\0\n"));
15731 count
= byte_get (descdata
, addr_size
);
15732 descdata
+= addr_size
;
15734 page_size
= byte_get (descdata
, addr_size
);
15735 descdata
+= addr_size
;
15737 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15739 printf (_(" Malformed note - too short for supplied file count\n"));
15743 printf (_(" Page size: "));
15744 print_vma (page_size
, DEC
);
15747 printf (_(" %*s%*s%*s\n"),
15748 (int) (2 + 2 * addr_size
), _("Start"),
15749 (int) (4 + 2 * addr_size
), _("End"),
15750 (int) (4 + 2 * addr_size
), _("Page Offset"));
15751 filenames
= descdata
+ count
* 3 * addr_size
;
15752 while (count
-- > 0)
15754 bfd_vma start
, end
, file_ofs
;
15756 if (filenames
== descend
)
15758 printf (_(" Malformed note - filenames end too early\n"));
15762 start
= byte_get (descdata
, addr_size
);
15763 descdata
+= addr_size
;
15764 end
= byte_get (descdata
, addr_size
);
15765 descdata
+= addr_size
;
15766 file_ofs
= byte_get (descdata
, addr_size
);
15767 descdata
+= addr_size
;
15770 print_vma (start
, FULL_HEX
);
15772 print_vma (end
, FULL_HEX
);
15774 print_vma (file_ofs
, FULL_HEX
);
15775 printf ("\n %s\n", filenames
);
15777 filenames
+= 1 + strlen ((char *) filenames
);
15783 static const char *
15784 get_gnu_elf_note_type (unsigned e_type
)
15786 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15789 case NT_GNU_ABI_TAG
:
15790 return _("NT_GNU_ABI_TAG (ABI version tag)");
15792 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15793 case NT_GNU_BUILD_ID
:
15794 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15795 case NT_GNU_GOLD_VERSION
:
15796 return _("NT_GNU_GOLD_VERSION (gold version)");
15799 static char buff
[64];
15801 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15808 print_gnu_note (Elf_Internal_Note
*pnote
)
15810 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15811 switch (pnote
->type
)
15813 case NT_GNU_BUILD_ID
:
15817 printf (_(" Build ID: "));
15818 for (i
= 0; i
< pnote
->descsz
; ++i
)
15819 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15824 case NT_GNU_ABI_TAG
:
15826 unsigned long os
, major
, minor
, subminor
;
15827 const char *osname
;
15829 /* PR 17531: file: 030-599401-0.004. */
15830 if (pnote
->descsz
< 16)
15832 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15836 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15837 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15838 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15839 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15843 case GNU_ABI_TAG_LINUX
:
15846 case GNU_ABI_TAG_HURD
:
15849 case GNU_ABI_TAG_SOLARIS
:
15850 osname
= "Solaris";
15852 case GNU_ABI_TAG_FREEBSD
:
15853 osname
= "FreeBSD";
15855 case GNU_ABI_TAG_NETBSD
:
15858 case GNU_ABI_TAG_SYLLABLE
:
15859 osname
= "Syllable";
15861 case GNU_ABI_TAG_NACL
:
15865 osname
= "Unknown";
15869 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15870 major
, minor
, subminor
);
15874 case NT_GNU_GOLD_VERSION
:
15878 printf (_(" Version: "));
15879 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15880 printf ("%c", pnote
->descdata
[i
]);
15887 unsigned long num_entries
, mask
;
15889 /* Hardware capabilities information. Word 0 is the number of entries.
15890 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15891 is a series of entries, where each entry is a single byte followed
15892 by a nul terminated string. The byte gives the bit number to test
15893 if enabled in the bitmask. */
15894 printf (_(" Hardware Capabilities: "));
15895 if (pnote
->descsz
< 8)
15897 printf (_("<corrupt GNU_HWCAP>\n"));
15900 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15901 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15902 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15903 /* FIXME: Add code to display the entries... */
15908 /* Handle unrecognised types. An error message should have already been
15909 created by get_gnu_elf_note_type(), so all that we need to do is to
15910 display the data. */
15914 printf (_(" Description data: "));
15915 for (i
= 0; i
< pnote
->descsz
; ++i
)
15916 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15925 static const char *
15926 get_v850_elf_note_type (enum v850_notes n_type
)
15928 static char buff
[64];
15932 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15933 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15934 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15935 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15936 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15937 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15939 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15945 print_v850_note (Elf_Internal_Note
* pnote
)
15949 if (pnote
->descsz
!= 4)
15951 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15955 printf (_("not set\n"));
15959 switch (pnote
->type
)
15961 case V850_NOTE_ALIGNMENT
:
15964 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15965 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15969 case V850_NOTE_DATA_SIZE
:
15972 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15973 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15977 case V850_NOTE_FPU_INFO
:
15980 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15981 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15985 case V850_NOTE_MMU_INFO
:
15986 case V850_NOTE_CACHE_INFO
:
15987 case V850_NOTE_SIMD_INFO
:
15988 if (val
== EF_RH850_SIMD
)
15990 printf (_("yes\n"));
15996 /* An 'unknown note type' message will already have been displayed. */
16000 printf (_("unknown value: %x\n"), val
);
16005 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16007 unsigned int version
;
16009 switch (pnote
->type
)
16011 case NT_NETBSD_IDENT
:
16012 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16013 if ((version
/ 10000) % 100)
16014 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16015 version
, version
/ 100000000, (version
/ 1000000) % 100,
16016 (version
/ 10000) % 100 > 26 ? "Z" : "",
16017 'A' + (version
/ 10000) % 26);
16019 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16020 version
, version
/ 100000000, (version
/ 1000000) % 100,
16021 (version
/ 100) % 100);
16024 case NT_NETBSD_MARCH
:
16025 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16033 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16038 static const char *
16039 get_freebsd_elfcore_note_type (unsigned e_type
)
16043 case NT_FREEBSD_THRMISC
:
16044 return _("NT_THRMISC (thrmisc structure)");
16045 case NT_FREEBSD_PROCSTAT_PROC
:
16046 return _("NT_PROCSTAT_PROC (proc data)");
16047 case NT_FREEBSD_PROCSTAT_FILES
:
16048 return _("NT_PROCSTAT_FILES (files data)");
16049 case NT_FREEBSD_PROCSTAT_VMMAP
:
16050 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16051 case NT_FREEBSD_PROCSTAT_GROUPS
:
16052 return _("NT_PROCSTAT_GROUPS (groups data)");
16053 case NT_FREEBSD_PROCSTAT_UMASK
:
16054 return _("NT_PROCSTAT_UMASK (umask data)");
16055 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16056 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16057 case NT_FREEBSD_PROCSTAT_OSREL
:
16058 return _("NT_PROCSTAT_OSREL (osreldate data)");
16059 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16060 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16061 case NT_FREEBSD_PROCSTAT_AUXV
:
16062 return _("NT_PROCSTAT_AUXV (auxv data)");
16064 return get_note_type (e_type
);
16067 static const char *
16068 get_netbsd_elfcore_note_type (unsigned e_type
)
16070 static char buff
[64];
16072 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16074 /* NetBSD core "procinfo" structure. */
16075 return _("NetBSD procinfo structure");
16078 /* As of Jan 2002 there are no other machine-independent notes
16079 defined for NetBSD core files. If the note type is less
16080 than the start of the machine-dependent note types, we don't
16083 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16085 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16089 switch (elf_header
.e_machine
)
16091 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16092 and PT_GETFPREGS == mach+2. */
16097 case EM_SPARC32PLUS
:
16101 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16102 return _("PT_GETREGS (reg structure)");
16103 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16104 return _("PT_GETFPREGS (fpreg structure)");
16110 /* On all other arch's, PT_GETREGS == mach+1 and
16111 PT_GETFPREGS == mach+3. */
16115 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16116 return _("PT_GETREGS (reg structure)");
16117 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16118 return _("PT_GETFPREGS (fpreg structure)");
16124 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16125 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16129 static const char *
16130 get_stapsdt_note_type (unsigned e_type
)
16132 static char buff
[64];
16137 return _("NT_STAPSDT (SystemTap probe descriptors)");
16143 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16148 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16150 int addr_size
= is_32bit_elf
? 4 : 8;
16151 char *data
= pnote
->descdata
;
16152 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16153 bfd_vma pc
, base_addr
, semaphore
;
16154 char *provider
, *probe
, *arg_fmt
;
16156 pc
= byte_get ((unsigned char *) data
, addr_size
);
16158 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16160 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16164 data
+= strlen (data
) + 1;
16166 data
+= strlen (data
) + 1;
16168 data
+= strlen (data
) + 1;
16170 printf (_(" Provider: %s\n"), provider
);
16171 printf (_(" Name: %s\n"), probe
);
16172 printf (_(" Location: "));
16173 print_vma (pc
, FULL_HEX
);
16174 printf (_(", Base: "));
16175 print_vma (base_addr
, FULL_HEX
);
16176 printf (_(", Semaphore: "));
16177 print_vma (semaphore
, FULL_HEX
);
16179 printf (_(" Arguments: %s\n"), arg_fmt
);
16181 return data
== data_end
;
16184 static const char *
16185 get_ia64_vms_note_type (unsigned e_type
)
16187 static char buff
[64];
16192 return _("NT_VMS_MHD (module header)");
16194 return _("NT_VMS_LNM (language name)");
16196 return _("NT_VMS_SRC (source files)");
16198 return "NT_VMS_TITLE";
16200 return _("NT_VMS_EIDC (consistency check)");
16201 case NT_VMS_FPMODE
:
16202 return _("NT_VMS_FPMODE (FP mode)");
16203 case NT_VMS_LINKTIME
:
16204 return "NT_VMS_LINKTIME";
16205 case NT_VMS_IMGNAM
:
16206 return _("NT_VMS_IMGNAM (image name)");
16208 return _("NT_VMS_IMGID (image id)");
16209 case NT_VMS_LINKID
:
16210 return _("NT_VMS_LINKID (link id)");
16211 case NT_VMS_IMGBID
:
16212 return _("NT_VMS_IMGBID (build id)");
16213 case NT_VMS_GSTNAM
:
16214 return _("NT_VMS_GSTNAM (sym table name)");
16215 case NT_VMS_ORIG_DYN
:
16216 return "NT_VMS_ORIG_DYN";
16217 case NT_VMS_PATCHTIME
:
16218 return "NT_VMS_PATCHTIME";
16220 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16226 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16228 switch (pnote
->type
)
16231 if (pnote
->descsz
> 36)
16233 size_t l
= strlen (pnote
->descdata
+ 34);
16234 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16235 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16236 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16237 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16240 printf (_(" Invalid size\n"));
16243 printf (_(" Language: %s\n"), pnote
->descdata
);
16246 case NT_VMS_FPMODE
:
16247 printf (_(" Floating Point mode: "));
16248 printf ("0x%016" BFD_VMA_FMT
"x\n",
16249 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16251 case NT_VMS_LINKTIME
:
16252 printf (_(" Link time: "));
16254 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16257 case NT_VMS_PATCHTIME
:
16258 printf (_(" Patch time: "));
16260 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16263 case NT_VMS_ORIG_DYN
:
16264 printf (_(" Major id: %u, minor id: %u\n"),
16265 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16266 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16267 printf (_(" Last modified : "));
16269 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16270 printf (_("\n Link flags : "));
16271 printf ("0x%016" BFD_VMA_FMT
"x\n",
16272 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16273 printf (_(" Header flags: 0x%08x\n"),
16274 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16275 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16278 case NT_VMS_IMGNAM
:
16279 printf (_(" Image name: %s\n"), pnote
->descdata
);
16281 case NT_VMS_GSTNAM
:
16282 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16285 printf (_(" Image id: %s\n"), pnote
->descdata
);
16287 case NT_VMS_LINKID
:
16288 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16296 /* Note that by the ELF standard, the name field is already null byte
16297 terminated, and namesz includes the terminating null byte.
16298 I.E. the value of namesz for the name "FSF" is 4.
16300 If the value of namesz is zero, there is no name present. */
16302 process_note (Elf_Internal_Note
* pnote
,
16303 FILE * file ATTRIBUTE_UNUSED
,
16304 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16306 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16309 if (pnote
->namesz
== 0)
16310 /* If there is no note name, then use the default set of
16311 note type strings. */
16312 nt
= get_note_type (pnote
->type
);
16314 else if (const_strneq (pnote
->namedata
, "GNU"))
16315 /* GNU-specific object file notes. */
16316 nt
= get_gnu_elf_note_type (pnote
->type
);
16318 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16319 /* FreeBSD-specific core file notes. */
16320 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16322 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16323 /* NetBSD-specific core file notes. */
16324 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16326 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16327 /* NetBSD-specific core file notes. */
16328 return process_netbsd_elf_note (pnote
);
16330 else if (strneq (pnote
->namedata
, "SPU/", 4))
16332 /* SPU-specific core file notes. */
16333 nt
= pnote
->namedata
+ 4;
16337 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16338 /* VMS/ia64-specific file notes. */
16339 nt
= get_ia64_vms_note_type (pnote
->type
);
16341 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16342 nt
= get_stapsdt_note_type (pnote
->type
);
16345 /* Don't recognize this note name; just use the default set of
16346 note type strings. */
16347 nt
= get_note_type (pnote
->type
);
16350 print_symbol (-20, name
);
16351 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16353 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16354 return print_ia64_vms_note (pnote
);
16355 else if (const_strneq (pnote
->namedata
, "GNU"))
16356 return print_gnu_note (pnote
);
16357 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16358 return print_stapsdt_note (pnote
);
16359 else if (const_strneq (pnote
->namedata
, "CORE"))
16360 return print_core_note (pnote
);
16362 else if (pnote
->descsz
)
16366 printf (_(" description data: "));
16367 for (i
= 0; i
< pnote
->descsz
; i
++)
16368 printf ("%02x ", pnote
->descdata
[i
]);
16376 process_notes_at (FILE * file
,
16377 Elf_Internal_Shdr
* section
,
16381 Elf_External_Note
* pnotes
;
16382 Elf_External_Note
* external
;
16391 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16393 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16396 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16398 if (pnotes
== NULL
)
16404 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16406 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16407 (unsigned long) offset
, (unsigned long) length
);
16409 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16411 end
= (char *) pnotes
+ length
;
16412 while ((char *) external
< end
)
16414 Elf_Internal_Note inote
;
16417 char * temp
= NULL
;
16418 size_t data_remaining
= end
- (char *) external
;
16420 if (!is_ia64_vms ())
16422 /* PR binutils/15191
16423 Make sure that there is enough data to read. */
16424 min_notesz
= offsetof (Elf_External_Note
, name
);
16425 if (data_remaining
< min_notesz
)
16427 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16428 (int) data_remaining
);
16431 inote
.type
= BYTE_GET (external
->type
);
16432 inote
.namesz
= BYTE_GET (external
->namesz
);
16433 inote
.namedata
= external
->name
;
16434 inote
.descsz
= BYTE_GET (external
->descsz
);
16435 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16436 /* PR 17531: file: 3443835e. */
16437 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16439 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16440 inote
.descdata
= inote
.namedata
;
16444 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16445 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16449 Elf64_External_VMS_Note
*vms_external
;
16451 /* PR binutils/15191
16452 Make sure that there is enough data to read. */
16453 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16454 if (data_remaining
< min_notesz
)
16456 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16457 (int) data_remaining
);
16461 vms_external
= (Elf64_External_VMS_Note
*) external
;
16462 inote
.type
= BYTE_GET (vms_external
->type
);
16463 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16464 inote
.namedata
= vms_external
->name
;
16465 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16466 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16467 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16468 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16471 if (inote
.descdata
< (char *) external
+ min_notesz
16472 || next
< (char *) external
+ min_notesz
16473 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16474 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16475 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16476 || data_remaining
< (size_t)(next
- (char *) external
))
16478 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16479 (unsigned long) ((char *) external
- (char *) pnotes
));
16480 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16481 inote
.type
, inote
.namesz
, inote
.descsz
);
16485 external
= (Elf_External_Note
*) next
;
16487 /* Verify that name is null terminated. It appears that at least
16488 one version of Linux (RedHat 6.0) generates corefiles that don't
16489 comply with the ELF spec by failing to include the null byte in
16491 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16493 temp
= (char *) malloc (inote
.namesz
+ 1);
16496 error (_("Out of memory allocating space for inote name\n"));
16501 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16502 temp
[inote
.namesz
] = 0;
16504 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16505 inote
.namedata
= temp
;
16508 res
&= process_note (& inote
, file
, section
);
16523 process_corefile_note_segments (FILE * file
)
16525 Elf_Internal_Phdr
* segment
;
16529 if (! get_program_headers (file
))
16532 for (i
= 0, segment
= program_headers
;
16533 i
< elf_header
.e_phnum
;
16536 if (segment
->p_type
== PT_NOTE
)
16537 res
&= process_notes_at (file
, NULL
,
16538 (bfd_vma
) segment
->p_offset
,
16539 (bfd_vma
) segment
->p_filesz
);
16546 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16548 Elf_External_Note
* pnotes
;
16549 Elf_External_Note
* external
;
16556 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16558 if (pnotes
== NULL
)
16562 end
= (char*) pnotes
+ length
;
16564 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16565 (unsigned long) offset
, (unsigned long) length
);
16567 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16569 Elf_External_Note
* next
;
16570 Elf_Internal_Note inote
;
16572 inote
.type
= BYTE_GET (external
->type
);
16573 inote
.namesz
= BYTE_GET (external
->namesz
);
16574 inote
.namedata
= external
->name
;
16575 inote
.descsz
= BYTE_GET (external
->descsz
);
16576 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16577 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16579 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16581 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16582 inote
.descdata
= inote
.namedata
;
16586 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16588 if ( ((char *) next
> end
)
16589 || ((char *) next
< (char *) pnotes
))
16591 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16592 (unsigned long) ((char *) external
- (char *) pnotes
));
16593 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16594 inote
.type
, inote
.namesz
, inote
.descsz
);
16600 /* Prevent out-of-bounds indexing. */
16601 if ( inote
.namedata
+ inote
.namesz
> end
16602 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16604 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16605 (unsigned long) ((char *) external
- (char *) pnotes
));
16606 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16607 inote
.type
, inote
.namesz
, inote
.descsz
);
16611 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16613 if (! print_v850_note (& inote
))
16616 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16617 inote
.namesz
, inote
.descsz
);
16627 process_note_sections (FILE * file
)
16629 Elf_Internal_Shdr
* section
;
16634 for (i
= 0, section
= section_headers
;
16635 i
< elf_header
.e_shnum
&& section
!= NULL
;
16638 if (section
->sh_type
== SHT_NOTE
)
16640 res
&= process_notes_at (file
, section
,
16641 (bfd_vma
) section
->sh_offset
,
16642 (bfd_vma
) section
->sh_size
);
16646 if (( elf_header
.e_machine
== EM_V800
16647 || elf_header
.e_machine
== EM_V850
16648 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16649 && section
->sh_type
== SHT_RENESAS_INFO
)
16651 res
&= process_v850_notes (file
,
16652 (bfd_vma
) section
->sh_offset
,
16653 (bfd_vma
) section
->sh_size
);
16659 /* Try processing NOTE segments instead. */
16660 return process_corefile_note_segments (file
);
16666 process_notes (FILE * file
)
16668 /* If we have not been asked to display the notes then do nothing. */
16672 if (elf_header
.e_type
!= ET_CORE
)
16673 return process_note_sections (file
);
16675 /* No program headers means no NOTE segment. */
16676 if (elf_header
.e_phnum
> 0)
16677 return process_corefile_note_segments (file
);
16679 printf (_("No note segments present in the core file.\n"));
16683 static unsigned char *
16684 display_public_gnu_attributes (unsigned char * start
,
16685 const unsigned char * const end
)
16687 printf (_(" Unknown GNU attribute: %s\n"), start
);
16689 start
+= strnlen ((char *) start
, end
- start
);
16690 display_raw_attribute (start
, end
);
16692 return (unsigned char *) end
;
16695 static unsigned char *
16696 display_generic_attribute (unsigned char * start
,
16698 const unsigned char * const end
)
16701 return (unsigned char *) end
;
16703 return display_tag_value (tag
, start
, end
);
16707 process_arch_specific (FILE * file
)
16712 switch (elf_header
.e_machine
)
16715 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
16716 display_arm_attribute
,
16717 display_generic_attribute
);
16720 case EM_MIPS_RS3_LE
:
16721 return process_mips_specific (file
);
16724 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
16725 display_msp430x_attribute
,
16726 display_generic_attribute
);
16729 return process_nds32_specific (file
);
16733 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16734 display_power_gnu_attribute
);
16738 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16739 display_s390_gnu_attribute
);
16742 case EM_SPARC32PLUS
:
16744 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16745 display_sparc_gnu_attribute
);
16748 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
16749 display_tic6x_attribute
,
16750 display_generic_attribute
);
16753 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
16754 display_public_gnu_attributes
,
16755 display_generic_attribute
);
16760 get_file_header (FILE * file
)
16762 /* Read in the identity array. */
16763 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16766 /* Determine how to read the rest of the header. */
16767 switch (elf_header
.e_ident
[EI_DATA
])
16772 byte_get
= byte_get_little_endian
;
16773 byte_put
= byte_put_little_endian
;
16776 byte_get
= byte_get_big_endian
;
16777 byte_put
= byte_put_big_endian
;
16781 /* For now we only support 32 bit and 64 bit ELF files. */
16782 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16784 /* Read in the rest of the header. */
16787 Elf32_External_Ehdr ehdr32
;
16789 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16792 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16793 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16794 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16795 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16796 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16797 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16798 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16799 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16800 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16801 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16802 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16803 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16804 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16808 Elf64_External_Ehdr ehdr64
;
16810 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16811 we will not be able to cope with the 64bit data found in
16812 64 ELF files. Detect this now and abort before we start
16813 overwriting things. */
16814 if (sizeof (bfd_vma
) < 8)
16816 error (_("This instance of readelf has been built without support for a\n\
16817 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16821 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16824 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16825 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16826 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16827 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16828 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16829 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16830 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16831 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16832 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16833 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16834 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16835 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16836 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16839 if (elf_header
.e_shoff
)
16841 /* There may be some extensions in the first section header. Don't
16842 bomb if we can't read it. */
16844 get_32bit_section_headers (file
, TRUE
);
16846 get_64bit_section_headers (file
, TRUE
);
16852 /* Process one ELF object file according to the command line options.
16853 This file may actually be stored in an archive. The file is
16854 positioned at the start of the ELF object. */
16857 process_object (char * file_name
, FILE * file
)
16861 if (! get_file_header (file
))
16863 error (_("%s: Failed to read file header\n"), file_name
);
16867 /* Initialise per file variables. */
16868 for (i
= ARRAY_SIZE (version_info
); i
--;)
16869 version_info
[i
] = 0;
16871 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16872 dynamic_info
[i
] = 0;
16873 dynamic_info_DT_GNU_HASH
= 0;
16875 /* Process the file. */
16877 printf (_("\nFile: %s\n"), file_name
);
16879 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16880 Note we do this even if cmdline_dump_sects is empty because we
16881 must make sure that the dump_sets array is zeroed out before each
16882 object file is processed. */
16883 if (num_dump_sects
> num_cmdline_dump_sects
)
16884 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16886 if (num_cmdline_dump_sects
> 0)
16888 if (num_dump_sects
== 0)
16889 /* A sneaky way of allocating the dump_sects array. */
16890 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16892 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16893 memcpy (dump_sects
, cmdline_dump_sects
,
16894 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16897 if (! process_file_header ())
16900 if (! process_section_headers (file
))
16902 /* Without loaded section headers we cannot process lots of
16904 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16906 if (! do_using_dynamic
)
16907 do_syms
= do_dyn_syms
= do_reloc
= 0;
16910 if (! process_section_groups (file
))
16912 /* Without loaded section groups we cannot process unwind. */
16916 if (process_program_headers (file
))
16917 process_dynamic_section (file
);
16919 process_relocs (file
);
16921 process_unwind (file
);
16923 process_symbol_table (file
);
16925 process_syminfo (file
);
16927 process_version_sections (file
);
16929 process_section_contents (file
);
16931 process_notes (file
);
16933 process_gnu_liblist (file
);
16935 process_arch_specific (file
);
16937 if (program_headers
)
16939 free (program_headers
);
16940 program_headers
= NULL
;
16943 if (section_headers
)
16945 free (section_headers
);
16946 section_headers
= NULL
;
16951 free (string_table
);
16952 string_table
= NULL
;
16953 string_table_length
= 0;
16956 if (dynamic_strings
)
16958 free (dynamic_strings
);
16959 dynamic_strings
= NULL
;
16960 dynamic_strings_length
= 0;
16963 if (dynamic_symbols
)
16965 free (dynamic_symbols
);
16966 dynamic_symbols
= NULL
;
16967 num_dynamic_syms
= 0;
16970 if (dynamic_syminfo
)
16972 free (dynamic_syminfo
);
16973 dynamic_syminfo
= NULL
;
16976 if (dynamic_section
)
16978 free (dynamic_section
);
16979 dynamic_section
= NULL
;
16982 if (section_headers_groups
)
16984 free (section_headers_groups
);
16985 section_headers_groups
= NULL
;
16988 if (section_groups
)
16990 struct group_list
* g
;
16991 struct group_list
* next
;
16993 for (i
= 0; i
< group_count
; i
++)
16995 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17002 free (section_groups
);
17003 section_groups
= NULL
;
17006 free_debug_memory ();
17011 /* Process an ELF archive.
17012 On entry the file is positioned just after the ARMAG string. */
17015 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17017 struct archive_info arch
;
17018 struct archive_info nested_arch
;
17024 /* The ARCH structure is used to hold information about this archive. */
17025 arch
.file_name
= NULL
;
17027 arch
.index_array
= NULL
;
17028 arch
.sym_table
= NULL
;
17029 arch
.longnames
= NULL
;
17031 /* The NESTED_ARCH structure is used as a single-item cache of information
17032 about a nested archive (when members of a thin archive reside within
17033 another regular archive file). */
17034 nested_arch
.file_name
= NULL
;
17035 nested_arch
.file
= NULL
;
17036 nested_arch
.index_array
= NULL
;
17037 nested_arch
.sym_table
= NULL
;
17038 nested_arch
.longnames
= NULL
;
17040 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17046 if (do_archive_index
)
17048 if (arch
.sym_table
== NULL
)
17049 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17052 unsigned long i
, l
;
17053 unsigned long current_pos
;
17055 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17056 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17057 current_pos
= ftell (file
);
17059 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17061 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17063 char * member_name
;
17065 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17067 if (member_name
!= NULL
)
17069 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17071 if (qualified_name
!= NULL
)
17073 printf (_("Contents of binary %s at offset "), qualified_name
);
17074 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17076 free (qualified_name
);
17081 if (l
>= arch
.sym_size
)
17083 error (_("%s: end of the symbol table reached before the end of the index\n"),
17087 /* PR 17531: file: 0b6630b2. */
17088 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17089 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17092 if (arch
.uses_64bit_indicies
)
17097 if (l
< arch
.sym_size
)
17098 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17099 file_name
, arch
.sym_size
- l
);
17101 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17103 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17109 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17110 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17111 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17112 && !do_section_groups
&& !do_dyn_syms
)
17114 ret
= 0; /* Archive index only. */
17125 char * qualified_name
;
17127 /* Read the next archive header. */
17128 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17130 error (_("%s: failed to seek to next archive header\n"), file_name
);
17133 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17134 if (got
!= sizeof arch
.arhdr
)
17138 error (_("%s: failed to read archive header\n"), file_name
);
17142 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17144 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17149 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17151 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17152 if (archive_file_size
& 01)
17153 ++archive_file_size
;
17155 name
= get_archive_member_name (&arch
, &nested_arch
);
17158 error (_("%s: bad archive file name\n"), file_name
);
17162 namelen
= strlen (name
);
17164 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17165 if (qualified_name
== NULL
)
17167 error (_("%s: bad archive file name\n"), file_name
);
17172 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17174 /* This is a proxy for an external member of a thin archive. */
17175 FILE * member_file
;
17176 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17177 if (member_file_name
== NULL
)
17183 member_file
= fopen (member_file_name
, "rb");
17184 if (member_file
== NULL
)
17186 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17187 free (member_file_name
);
17192 archive_file_offset
= arch
.nested_member_origin
;
17194 ret
|= process_object (qualified_name
, member_file
);
17196 fclose (member_file
);
17197 free (member_file_name
);
17199 else if (is_thin_archive
)
17201 /* PR 15140: Allow for corrupt thin archives. */
17202 if (nested_arch
.file
== NULL
)
17204 error (_("%s: contains corrupt thin archive: %s\n"),
17210 /* This is a proxy for a member of a nested archive. */
17211 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17213 /* The nested archive file will have been opened and setup by
17214 get_archive_member_name. */
17215 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17217 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17222 ret
|= process_object (qualified_name
, nested_arch
.file
);
17226 archive_file_offset
= arch
.next_arhdr_offset
;
17227 arch
.next_arhdr_offset
+= archive_file_size
;
17229 ret
|= process_object (qualified_name
, file
);
17232 if (dump_sects
!= NULL
)
17236 num_dump_sects
= 0;
17239 free (qualified_name
);
17243 if (nested_arch
.file
!= NULL
)
17244 fclose (nested_arch
.file
);
17245 release_archive (&nested_arch
);
17246 release_archive (&arch
);
17252 process_file (char * file_name
)
17255 struct stat statbuf
;
17256 char armag
[SARMAG
];
17259 if (stat (file_name
, &statbuf
) < 0)
17261 if (errno
== ENOENT
)
17262 error (_("'%s': No such file\n"), file_name
);
17264 error (_("Could not locate '%s'. System error message: %s\n"),
17265 file_name
, strerror (errno
));
17269 if (! S_ISREG (statbuf
.st_mode
))
17271 error (_("'%s' is not an ordinary file\n"), file_name
);
17275 file
= fopen (file_name
, "rb");
17278 error (_("Input file '%s' is not readable.\n"), file_name
);
17282 if (fread (armag
, SARMAG
, 1, file
) != 1)
17284 error (_("%s: Failed to read file's magic number\n"), file_name
);
17289 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17291 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17292 ret
= process_archive (file_name
, file
, FALSE
);
17293 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17294 ret
= process_archive (file_name
, file
, TRUE
);
17297 if (do_archive_index
)
17298 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17302 archive_file_size
= archive_file_offset
= 0;
17303 ret
= process_object (file_name
, file
);
17308 current_file_size
= 0;
17312 #ifdef SUPPORT_DISASSEMBLY
17313 /* Needed by the i386 disassembler. For extra credit, someone could
17314 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17318 print_address (unsigned int addr
, FILE * outfile
)
17320 fprintf (outfile
,"0x%8.8x", addr
);
17323 /* Needed by the i386 disassembler. */
17325 db_task_printsym (unsigned int addr
)
17327 print_address (addr
, stderr
);
17332 main (int argc
, char ** argv
)
17336 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17337 setlocale (LC_MESSAGES
, "");
17339 #if defined (HAVE_SETLOCALE)
17340 setlocale (LC_CTYPE
, "");
17342 bindtextdomain (PACKAGE
, LOCALEDIR
);
17343 textdomain (PACKAGE
);
17345 expandargv (&argc
, &argv
);
17347 parse_args (argc
, argv
);
17349 if (num_dump_sects
> 0)
17351 /* Make a copy of the dump_sects array. */
17352 cmdline_dump_sects
= (dump_type
*)
17353 malloc (num_dump_sects
* sizeof (* dump_sects
));
17354 if (cmdline_dump_sects
== NULL
)
17355 error (_("Out of memory allocating dump request table.\n"));
17358 memcpy (cmdline_dump_sects
, dump_sects
,
17359 num_dump_sects
* sizeof (* dump_sects
));
17360 num_cmdline_dump_sects
= num_dump_sects
;
17364 if (optind
< (argc
- 1))
17366 else if (optind
>= argc
)
17368 warn (_("Nothing to do.\n"));
17373 while (optind
< argc
)
17374 err
|= process_file (argv
[optind
++]);
17376 if (dump_sects
!= NULL
)
17378 if (cmdline_dump_sects
!= NULL
)
17379 free (cmdline_dump_sects
);