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
))
9970 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9971 strcat (buff
, " | ");
9973 strcat (buff
, _("<unknown>"));
9979 /* Display the contents of the version sections. */
9982 process_version_sections (FILE * file
)
9984 Elf_Internal_Shdr
* section
;
9991 for (i
= 0, section
= section_headers
;
9992 i
< elf_header
.e_shnum
;
9995 switch (section
->sh_type
)
9997 case SHT_GNU_verdef
:
9999 Elf_External_Verdef
* edefs
;
10007 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10008 printable_section_name (section
),
10011 printf (_(" Addr: 0x"));
10012 printf_vma (section
->sh_addr
);
10013 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10014 (unsigned long) section
->sh_offset
, section
->sh_link
,
10015 printable_section_name_from_index (section
->sh_link
));
10017 edefs
= (Elf_External_Verdef
*)
10018 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10019 _("version definition section"));
10022 endbuf
= (char *) edefs
+ section
->sh_size
;
10024 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10025 end
= (section
->sh_info
< section
->sh_size
10026 ? section
->sh_info
: section
->sh_size
);
10027 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10030 Elf_External_Verdef
* edef
;
10031 Elf_Internal_Verdef ent
;
10032 Elf_External_Verdaux
* eaux
;
10033 Elf_Internal_Verdaux aux
;
10037 /* Check for very large indices. */
10038 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10041 vstart
= ((char *) edefs
) + idx
;
10042 if (vstart
+ sizeof (*edef
) > endbuf
)
10045 edef
= (Elf_External_Verdef
*) vstart
;
10047 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10048 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10049 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10050 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10051 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10052 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10053 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10055 printf (_(" %#06x: Rev: %d Flags: %s"),
10056 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10058 printf (_(" Index: %d Cnt: %d "),
10059 ent
.vd_ndx
, ent
.vd_cnt
);
10061 /* Check for overflow. */
10062 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10065 vstart
+= ent
.vd_aux
;
10067 eaux
= (Elf_External_Verdaux
*) vstart
;
10069 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10070 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10072 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10073 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10075 printf (_("Name index: %ld\n"), aux
.vda_name
);
10077 isum
= idx
+ ent
.vd_aux
;
10079 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10081 /* Check for overflow. */
10082 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10085 isum
+= aux
.vda_next
;
10086 vstart
+= aux
.vda_next
;
10088 eaux
= (Elf_External_Verdaux
*) vstart
;
10089 if (vstart
+ sizeof (*eaux
) > endbuf
)
10092 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10093 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10095 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10096 printf (_(" %#06x: Parent %d: %s\n"),
10097 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10099 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10100 isum
, j
, aux
.vda_name
);
10103 if (j
< ent
.vd_cnt
)
10104 printf (_(" Version def aux past end of section\n"));
10107 file: id:000001,src:000172+005151,op:splice,rep:2. */
10108 if (idx
+ ent
.vd_next
< idx
)
10111 idx
+= ent
.vd_next
;
10114 if (cnt
< section
->sh_info
)
10115 printf (_(" Version definition past end of section\n"));
10121 case SHT_GNU_verneed
:
10123 Elf_External_Verneed
* eneed
;
10130 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10131 printable_section_name (section
), section
->sh_info
);
10133 printf (_(" Addr: 0x"));
10134 printf_vma (section
->sh_addr
);
10135 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10136 (unsigned long) section
->sh_offset
, section
->sh_link
,
10137 printable_section_name_from_index (section
->sh_link
));
10139 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10140 section
->sh_offset
, 1,
10142 _("Version Needs section"));
10145 endbuf
= (char *) eneed
+ section
->sh_size
;
10147 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10149 Elf_External_Verneed
* entry
;
10150 Elf_Internal_Verneed ent
;
10155 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10158 vstart
= ((char *) eneed
) + idx
;
10159 if (vstart
+ sizeof (*entry
) > endbuf
)
10162 entry
= (Elf_External_Verneed
*) vstart
;
10164 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10165 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10166 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10167 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10168 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10170 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10172 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10173 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10175 printf (_(" File: %lx"), ent
.vn_file
);
10177 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10179 /* Check for overflow. */
10180 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10182 vstart
+= ent
.vn_aux
;
10184 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10186 Elf_External_Vernaux
* eaux
;
10187 Elf_Internal_Vernaux aux
;
10189 if (vstart
+ sizeof (*eaux
) > endbuf
)
10191 eaux
= (Elf_External_Vernaux
*) vstart
;
10193 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10194 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10195 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10196 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10197 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10199 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10200 printf (_(" %#06x: Name: %s"),
10201 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10203 printf (_(" %#06x: Name index: %lx"),
10204 isum
, aux
.vna_name
);
10206 printf (_(" Flags: %s Version: %d\n"),
10207 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10209 /* Check for overflow. */
10210 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10211 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10213 warn (_("Invalid vna_next field of %lx\n"),
10218 isum
+= aux
.vna_next
;
10219 vstart
+= aux
.vna_next
;
10222 if (j
< ent
.vn_cnt
)
10223 warn (_("Missing Version Needs auxillary information\n"));
10225 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10227 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10228 cnt
= section
->sh_info
;
10231 idx
+= ent
.vn_next
;
10234 if (cnt
< section
->sh_info
)
10235 warn (_("Missing Version Needs information\n"));
10241 case SHT_GNU_versym
:
10243 Elf_Internal_Shdr
* link_section
;
10246 unsigned char * edata
;
10247 unsigned short * data
;
10249 Elf_Internal_Sym
* symbols
;
10250 Elf_Internal_Shdr
* string_sec
;
10251 unsigned long num_syms
;
10254 if (section
->sh_link
>= elf_header
.e_shnum
)
10257 link_section
= section_headers
+ section
->sh_link
;
10258 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10260 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10265 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10266 if (symbols
== NULL
)
10269 string_sec
= section_headers
+ link_section
->sh_link
;
10271 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10272 string_sec
->sh_size
,
10273 _("version string table"));
10280 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10281 printable_section_name (section
), (unsigned long) total
);
10283 printf (_(" Addr: "));
10284 printf_vma (section
->sh_addr
);
10285 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10286 (unsigned long) section
->sh_offset
, section
->sh_link
,
10287 printable_section_name (link_section
));
10289 off
= offset_from_vma (file
,
10290 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10291 total
* sizeof (short));
10292 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10294 _("version symbol data"));
10302 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10304 for (cnt
= total
; cnt
--;)
10305 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10310 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10314 char *invalid
= _("*invalid*");
10316 printf (" %03x:", cnt
);
10318 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10319 switch (data
[cnt
+ j
])
10322 fputs (_(" 0 (*local*) "), stdout
);
10326 fputs (_(" 1 (*global*) "), stdout
);
10330 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10331 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10333 /* If this index value is greater than the size of the symbols
10334 array, break to avoid an out-of-bounds read. */
10335 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10337 warn (_("invalid index into symbol array\n"));
10342 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10344 Elf_Internal_Verneed ivn
;
10345 unsigned long offset
;
10347 offset
= offset_from_vma
10348 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10349 sizeof (Elf_External_Verneed
));
10353 Elf_Internal_Vernaux ivna
;
10354 Elf_External_Verneed evn
;
10355 Elf_External_Vernaux evna
;
10356 unsigned long a_off
;
10358 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10359 _("version need")) == NULL
)
10362 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10363 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10365 a_off
= offset
+ ivn
.vn_aux
;
10369 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10370 1, _("version need aux (2)")) == NULL
)
10373 ivna
.vna_other
= 0;
10377 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10378 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10381 a_off
+= ivna
.vna_next
;
10383 while (ivna
.vna_other
!= data
[cnt
+ j
]
10384 && ivna
.vna_next
!= 0);
10386 if (ivna
.vna_other
== data
[cnt
+ j
])
10388 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10390 if (ivna
.vna_name
>= string_sec
->sh_size
)
10393 name
= strtab
+ ivna
.vna_name
;
10397 offset
+= ivn
.vn_next
;
10399 while (ivn
.vn_next
);
10402 if (data
[cnt
+ j
] != 0x8001
10403 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10405 Elf_Internal_Verdef ivd
;
10406 Elf_External_Verdef evd
;
10407 unsigned long offset
;
10409 offset
= offset_from_vma
10410 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10415 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10416 _("version def")) == NULL
)
10419 /* PR 17531: file: 046-1082287-0.004. */
10420 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10425 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10426 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10429 offset
+= ivd
.vd_next
;
10431 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10432 && ivd
.vd_next
!= 0);
10434 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10436 Elf_External_Verdaux evda
;
10437 Elf_Internal_Verdaux ivda
;
10439 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10441 if (get_data (&evda
, file
,
10442 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10444 _("version def aux")) == NULL
)
10447 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10449 if (ivda
.vda_name
>= string_sec
->sh_size
)
10451 else if (name
!= NULL
&& name
!= invalid
)
10452 name
= _("*both*");
10454 name
= strtab
+ ivda
.vda_name
;
10458 nn
+= printf ("(%s%-*s",
10460 12 - (int) strlen (name
),
10464 printf ("%*c", 18 - nn
, ' ');
10482 printf (_("\nNo version information found in this file.\n"));
10487 static const char *
10488 get_symbol_binding (unsigned int binding
)
10490 static char buff
[32];
10494 case STB_LOCAL
: return "LOCAL";
10495 case STB_GLOBAL
: return "GLOBAL";
10496 case STB_WEAK
: return "WEAK";
10498 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10499 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10501 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10503 if (binding
== STB_GNU_UNIQUE
10504 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10505 /* GNU is still using the default value 0. */
10506 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10508 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10511 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10516 static const char *
10517 get_symbol_type (unsigned int type
)
10519 static char buff
[32];
10523 case STT_NOTYPE
: return "NOTYPE";
10524 case STT_OBJECT
: return "OBJECT";
10525 case STT_FUNC
: return "FUNC";
10526 case STT_SECTION
: return "SECTION";
10527 case STT_FILE
: return "FILE";
10528 case STT_COMMON
: return "COMMON";
10529 case STT_TLS
: return "TLS";
10530 case STT_RELC
: return "RELC";
10531 case STT_SRELC
: return "SRELC";
10533 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10535 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10536 return "THUMB_FUNC";
10538 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10541 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10542 return "PARISC_MILLI";
10544 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10546 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10548 if (elf_header
.e_machine
== EM_PARISC
)
10550 if (type
== STT_HP_OPAQUE
)
10551 return "HP_OPAQUE";
10552 if (type
== STT_HP_STUB
)
10556 if (type
== STT_GNU_IFUNC
10557 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10558 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10559 /* GNU is still using the default value 0. */
10560 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10563 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10566 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10571 static const char *
10572 get_symbol_visibility (unsigned int visibility
)
10574 switch (visibility
)
10576 case STV_DEFAULT
: return "DEFAULT";
10577 case STV_INTERNAL
: return "INTERNAL";
10578 case STV_HIDDEN
: return "HIDDEN";
10579 case STV_PROTECTED
: return "PROTECTED";
10581 error (_("Unrecognized visibility value: %u"), visibility
);
10582 return _("<unknown>");
10586 static const char *
10587 get_solaris_symbol_visibility (unsigned int visibility
)
10589 switch (visibility
)
10591 case 4: return "EXPORTED";
10592 case 5: return "SINGLETON";
10593 case 6: return "ELIMINATE";
10594 default: return get_symbol_visibility (visibility
);
10598 static const char *
10599 get_mips_symbol_other (unsigned int other
)
10609 case STO_MICROMIPS
:
10610 return "MICROMIPS";
10611 case STO_MICROMIPS
| STO_MIPS_PIC
:
10612 return "MICROMIPS, MIPS PIC";
10620 static const char *
10621 get_ia64_symbol_other (unsigned int other
)
10623 if (is_ia64_vms ())
10625 static char res
[32];
10629 /* Function types is for images and .STB files only. */
10630 switch (elf_header
.e_type
)
10634 switch (VMS_ST_FUNC_TYPE (other
))
10636 case VMS_SFT_CODE_ADDR
:
10637 strcat (res
, " CA");
10639 case VMS_SFT_SYMV_IDX
:
10640 strcat (res
, " VEC");
10643 strcat (res
, " FD");
10645 case VMS_SFT_RESERVE
:
10646 strcat (res
, " RSV");
10649 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10650 VMS_ST_FUNC_TYPE (other
));
10651 strcat (res
, " <unknown>");
10658 switch (VMS_ST_LINKAGE (other
))
10660 case VMS_STL_IGNORE
:
10661 strcat (res
, " IGN");
10663 case VMS_STL_RESERVE
:
10664 strcat (res
, " RSV");
10667 strcat (res
, " STD");
10670 strcat (res
, " LNK");
10673 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10674 VMS_ST_LINKAGE (other
));
10675 strcat (res
, " <unknown>");
10687 static const char *
10688 get_ppc64_symbol_other (unsigned int other
)
10690 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10692 static char buf
[32];
10693 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10694 PPC64_LOCAL_ENTRY_OFFSET (other
));
10700 static const char *
10701 get_symbol_other (unsigned int other
)
10703 const char * result
= NULL
;
10704 static char buff
[32];
10709 switch (elf_header
.e_machine
)
10712 result
= get_mips_symbol_other (other
);
10715 result
= get_ia64_symbol_other (other
);
10718 result
= get_ppc64_symbol_other (other
);
10728 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10732 static const char *
10733 get_symbol_index_type (unsigned int type
)
10735 static char buff
[32];
10739 case SHN_UNDEF
: return "UND";
10740 case SHN_ABS
: return "ABS";
10741 case SHN_COMMON
: return "COM";
10743 if (type
== SHN_IA_64_ANSI_COMMON
10744 && elf_header
.e_machine
== EM_IA_64
10745 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10747 else if ((elf_header
.e_machine
== EM_X86_64
10748 || elf_header
.e_machine
== EM_L1OM
10749 || elf_header
.e_machine
== EM_K1OM
)
10750 && type
== SHN_X86_64_LCOMMON
)
10751 return "LARGE_COM";
10752 else if ((type
== SHN_MIPS_SCOMMON
10753 && elf_header
.e_machine
== EM_MIPS
)
10754 || (type
== SHN_TIC6X_SCOMMON
10755 && elf_header
.e_machine
== EM_TI_C6000
))
10757 else if (type
== SHN_MIPS_SUNDEFINED
10758 && elf_header
.e_machine
== EM_MIPS
)
10760 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10761 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10762 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10763 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10764 else if (type
>= SHN_LORESERVE
)
10765 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10766 else if (type
>= elf_header
.e_shnum
)
10767 sprintf (buff
, _("bad section index[%3d]"), type
);
10769 sprintf (buff
, "%3d", type
);
10777 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10779 unsigned char * e_data
;
10782 /* If the size_t type is smaller than the bfd_size_type, eg because
10783 you are building a 32-bit tool on a 64-bit host, then make sure
10784 that when (number) is cast to (size_t) no information is lost. */
10785 if (sizeof (size_t) < sizeof (bfd_size_type
)
10786 && (bfd_size_type
) ((size_t) number
) != number
)
10788 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10789 " elements of size %u\n"),
10794 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10795 attempting to allocate memory when the read is bound to fail. */
10796 if (ent_size
* number
> current_file_size
)
10798 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10803 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10804 if (e_data
== NULL
)
10806 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10811 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10813 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10814 number
* ent_size
);
10819 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10820 if (i_data
== NULL
)
10822 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10823 " dynamic entries\n"),
10830 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10838 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10840 Elf_Internal_Sym
* psym
;
10843 n
= print_vma (si
, DEC_5
);
10845 fputs (&" "[n
], stdout
);
10846 printf (" %3lu: ", hn
);
10848 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10850 printf (_("<No info available for dynamic symbol number %lu>\n"),
10851 (unsigned long) si
);
10855 psym
= dynamic_symbols
+ si
;
10856 print_vma (psym
->st_value
, LONG_HEX
);
10858 print_vma (psym
->st_size
, DEC_5
);
10860 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10861 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10863 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10864 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10867 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10869 printf (" %-7s", get_symbol_visibility (vis
));
10870 /* Check to see if any other bits in the st_other field are set.
10871 Note - displaying this information disrupts the layout of the
10872 table being generated, but for the moment this case is very
10874 if (psym
->st_other
^ vis
)
10875 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10878 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10879 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10880 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10882 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10886 static const char *
10887 get_symbol_version_string (FILE * file
,
10888 bfd_boolean is_dynsym
,
10889 const char * strtab
,
10890 unsigned long int strtab_size
,
10892 Elf_Internal_Sym
* psym
,
10893 enum versioned_symbol_info
* sym_info
,
10894 unsigned short * vna_other
)
10896 unsigned char data
[2];
10897 unsigned short vers_data
;
10898 unsigned long offset
;
10901 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10904 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10905 sizeof data
+ si
* sizeof (vers_data
));
10907 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10908 sizeof (data
), 1, _("version data")) == NULL
)
10911 vers_data
= byte_get (data
, 2);
10913 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10916 /* Usually we'd only see verdef for defined symbols, and verneed for
10917 undefined symbols. However, symbols defined by the linker in
10918 .dynbss for variables copied from a shared library in order to
10919 avoid text relocations are defined yet have verneed. We could
10920 use a heuristic to detect the special case, for example, check
10921 for verneed first on symbols defined in SHT_NOBITS sections, but
10922 it is simpler and more reliable to just look for both verdef and
10923 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10925 if (psym
->st_shndx
!= SHN_UNDEF
10926 && vers_data
!= 0x8001
10927 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10929 Elf_Internal_Verdef ivd
;
10930 Elf_Internal_Verdaux ivda
;
10931 Elf_External_Verdaux evda
;
10934 off
= offset_from_vma (file
,
10935 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10936 sizeof (Elf_External_Verdef
));
10940 Elf_External_Verdef evd
;
10942 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10943 _("version def")) == NULL
)
10951 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10952 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10953 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10956 off
+= ivd
.vd_next
;
10958 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10960 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10962 off
-= ivd
.vd_next
;
10965 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10966 _("version def aux")) != NULL
)
10968 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10970 if (psym
->st_name
!= ivda
.vda_name
)
10972 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10973 ? symbol_hidden
: symbol_public
);
10974 return (ivda
.vda_name
< strtab_size
10975 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10981 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10983 Elf_External_Verneed evn
;
10984 Elf_Internal_Verneed ivn
;
10985 Elf_Internal_Vernaux ivna
;
10987 offset
= offset_from_vma (file
,
10988 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10992 unsigned long vna_off
;
10994 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10995 _("version need")) == NULL
)
10998 ivna
.vna_other
= 0;
11003 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11004 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11006 vna_off
= offset
+ ivn
.vn_aux
;
11010 Elf_External_Vernaux evna
;
11012 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11013 _("version need aux (3)")) == NULL
)
11016 ivna
.vna_other
= 0;
11021 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11022 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11023 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11026 vna_off
+= ivna
.vna_next
;
11028 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11030 if (ivna
.vna_other
== vers_data
)
11033 offset
+= ivn
.vn_next
;
11035 while (ivn
.vn_next
!= 0);
11037 if (ivna
.vna_other
== vers_data
)
11039 *sym_info
= symbol_undefined
;
11040 *vna_other
= ivna
.vna_other
;
11041 return (ivna
.vna_name
< strtab_size
11042 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11048 /* Dump the symbol table. */
11050 process_symbol_table (FILE * file
)
11052 Elf_Internal_Shdr
* section
;
11053 bfd_size_type nbuckets
= 0;
11054 bfd_size_type nchains
= 0;
11055 bfd_vma
* buckets
= NULL
;
11056 bfd_vma
* chains
= NULL
;
11057 bfd_vma ngnubuckets
= 0;
11058 bfd_vma
* gnubuckets
= NULL
;
11059 bfd_vma
* gnuchains
= NULL
;
11060 bfd_vma gnusymidx
= 0;
11061 bfd_size_type ngnuchains
= 0;
11063 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11066 if (dynamic_info
[DT_HASH
]
11068 || (do_using_dynamic
11070 && dynamic_strings
!= NULL
)))
11072 unsigned char nb
[8];
11073 unsigned char nc
[8];
11074 unsigned int hash_ent_size
= 4;
11076 if ((elf_header
.e_machine
== EM_ALPHA
11077 || elf_header
.e_machine
== EM_S390
11078 || elf_header
.e_machine
== EM_S390_OLD
)
11079 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11083 (archive_file_offset
11084 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11085 sizeof nb
+ sizeof nc
)),
11088 error (_("Unable to seek to start of dynamic information\n"));
11092 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11094 error (_("Failed to read in number of buckets\n"));
11098 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11100 error (_("Failed to read in number of chains\n"));
11104 nbuckets
= byte_get (nb
, hash_ent_size
);
11105 nchains
= byte_get (nc
, hash_ent_size
);
11107 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11108 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11111 if (buckets
== NULL
|| chains
== NULL
)
11113 if (do_using_dynamic
)
11124 if (dynamic_info_DT_GNU_HASH
11126 || (do_using_dynamic
11128 && dynamic_strings
!= NULL
)))
11130 unsigned char nb
[16];
11131 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11132 bfd_vma buckets_vma
;
11135 (archive_file_offset
11136 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11140 error (_("Unable to seek to start of dynamic information\n"));
11144 if (fread (nb
, 16, 1, file
) != 1)
11146 error (_("Failed to read in number of buckets\n"));
11150 ngnubuckets
= byte_get (nb
, 4);
11151 gnusymidx
= byte_get (nb
+ 4, 4);
11152 bitmaskwords
= byte_get (nb
+ 8, 4);
11153 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11155 buckets_vma
+= bitmaskwords
* 4;
11157 buckets_vma
+= bitmaskwords
* 8;
11160 (archive_file_offset
11161 + offset_from_vma (file
, buckets_vma
, 4)),
11164 error (_("Unable to seek to start of dynamic information\n"));
11168 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11170 if (gnubuckets
== NULL
)
11173 for (i
= 0; i
< ngnubuckets
; i
++)
11174 if (gnubuckets
[i
] != 0)
11176 if (gnubuckets
[i
] < gnusymidx
)
11179 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11180 maxchain
= gnubuckets
[i
];
11183 if (maxchain
== 0xffffffff)
11186 maxchain
-= gnusymidx
;
11189 (archive_file_offset
11190 + offset_from_vma (file
, buckets_vma
11191 + 4 * (ngnubuckets
+ maxchain
), 4)),
11194 error (_("Unable to seek to start of dynamic information\n"));
11200 if (fread (nb
, 4, 1, file
) != 1)
11202 error (_("Failed to determine last chain length\n"));
11206 if (maxchain
+ 1 == 0)
11211 while ((byte_get (nb
, 4) & 1) == 0);
11214 (archive_file_offset
11215 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11218 error (_("Unable to seek to start of dynamic information\n"));
11222 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11223 ngnuchains
= maxchain
;
11226 if (gnuchains
== NULL
)
11231 if (do_using_dynamic
)
11236 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11238 && do_using_dynamic
11239 && dynamic_strings
!= NULL
11240 && dynamic_symbols
!= NULL
)
11244 if (dynamic_info
[DT_HASH
])
11248 printf (_("\nSymbol table for image:\n"));
11250 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11252 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11254 for (hn
= 0; hn
< nbuckets
; hn
++)
11259 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11260 print_dynamic_symbol (si
, hn
);
11264 if (dynamic_info_DT_GNU_HASH
)
11266 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11268 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11270 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11272 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11273 if (gnubuckets
[hn
] != 0)
11275 bfd_vma si
= gnubuckets
[hn
];
11276 bfd_vma off
= si
- gnusymidx
;
11280 print_dynamic_symbol (si
, hn
);
11283 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11287 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11288 && section_headers
!= NULL
)
11292 for (i
= 0, section
= section_headers
;
11293 i
< elf_header
.e_shnum
;
11297 char * strtab
= NULL
;
11298 unsigned long int strtab_size
= 0;
11299 Elf_Internal_Sym
* symtab
;
11300 Elf_Internal_Sym
* psym
;
11301 unsigned long num_syms
;
11303 if ((section
->sh_type
!= SHT_SYMTAB
11304 && section
->sh_type
!= SHT_DYNSYM
)
11306 && section
->sh_type
== SHT_SYMTAB
))
11309 if (section
->sh_entsize
== 0)
11311 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11312 printable_section_name (section
));
11316 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11317 printable_section_name (section
),
11318 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11321 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11323 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11325 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11326 if (symtab
== NULL
)
11329 if (section
->sh_link
== elf_header
.e_shstrndx
)
11331 strtab
= string_table
;
11332 strtab_size
= string_table_length
;
11334 else if (section
->sh_link
< elf_header
.e_shnum
)
11336 Elf_Internal_Shdr
* string_sec
;
11338 string_sec
= section_headers
+ section
->sh_link
;
11340 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11341 1, string_sec
->sh_size
,
11342 _("string table"));
11343 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11346 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11348 const char *version_string
;
11349 enum versioned_symbol_info sym_info
;
11350 unsigned short vna_other
;
11352 printf ("%6d: ", si
);
11353 print_vma (psym
->st_value
, LONG_HEX
);
11355 print_vma (psym
->st_size
, DEC_5
);
11356 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11357 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11358 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11359 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11362 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11364 printf (" %-7s", get_symbol_visibility (vis
));
11365 /* Check to see if any other bits in the st_other field are set.
11366 Note - displaying this information disrupts the layout of the
11367 table being generated, but for the moment this case is very rare. */
11368 if (psym
->st_other
^ vis
)
11369 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11371 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11372 print_symbol (25, psym
->st_name
< strtab_size
11373 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11376 = get_symbol_version_string (file
,
11377 section
->sh_type
== SHT_DYNSYM
,
11378 strtab
, strtab_size
, si
,
11379 psym
, &sym_info
, &vna_other
);
11380 if (version_string
)
11382 if (sym_info
== symbol_undefined
)
11383 printf ("@%s (%d)", version_string
, vna_other
);
11385 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11391 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11392 && si
>= section
->sh_info
11393 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11394 && elf_header
.e_machine
!= EM_MIPS
11395 /* Solaris binaries have been found to violate this requirement as
11396 well. Not sure if this is a bug or an ABI requirement. */
11397 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11398 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11399 si
, printable_section_name (section
), section
->sh_info
);
11403 if (strtab
!= string_table
)
11409 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11411 if (do_histogram
&& buckets
!= NULL
)
11413 unsigned long * lengths
;
11414 unsigned long * counts
;
11417 unsigned long maxlength
= 0;
11418 unsigned long nzero_counts
= 0;
11419 unsigned long nsyms
= 0;
11420 unsigned long chained
;
11422 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11423 (unsigned long) nbuckets
);
11425 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11426 if (lengths
== NULL
)
11428 error (_("Out of memory allocating space for histogram buckets\n"));
11432 printf (_(" Length Number %% of total Coverage\n"));
11433 for (hn
= 0; hn
< nbuckets
; ++hn
)
11435 for (si
= buckets
[hn
], chained
= 0;
11436 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11437 si
= chains
[si
], ++chained
)
11440 if (maxlength
< ++lengths
[hn
])
11444 /* PR binutils/17531: A corrupt binary could contain broken
11445 histogram data. Do not go into an infinite loop trying
11447 if (chained
> nchains
)
11449 error (_("histogram chain is corrupt\n"));
11454 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11455 if (counts
== NULL
)
11458 error (_("Out of memory allocating space for histogram counts\n"));
11462 for (hn
= 0; hn
< nbuckets
; ++hn
)
11463 ++counts
[lengths
[hn
]];
11468 printf (" 0 %-10lu (%5.1f%%)\n",
11469 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11470 for (i
= 1; i
<= maxlength
; ++i
)
11472 nzero_counts
+= counts
[i
] * i
;
11473 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11474 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11475 (nzero_counts
* 100.0) / nsyms
);
11483 if (buckets
!= NULL
)
11489 if (do_histogram
&& gnubuckets
!= NULL
)
11491 unsigned long * lengths
;
11492 unsigned long * counts
;
11494 unsigned long maxlength
= 0;
11495 unsigned long nzero_counts
= 0;
11496 unsigned long nsyms
= 0;
11498 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11499 (unsigned long) ngnubuckets
);
11501 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11502 if (lengths
== NULL
)
11504 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11508 printf (_(" Length Number %% of total Coverage\n"));
11510 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11511 if (gnubuckets
[hn
] != 0)
11513 bfd_vma off
, length
= 1;
11515 for (off
= gnubuckets
[hn
] - gnusymidx
;
11516 /* PR 17531 file: 010-77222-0.004. */
11517 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11520 lengths
[hn
] = length
;
11521 if (length
> maxlength
)
11522 maxlength
= length
;
11526 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11527 if (counts
== NULL
)
11530 error (_("Out of memory allocating space for gnu histogram counts\n"));
11534 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11535 ++counts
[lengths
[hn
]];
11537 if (ngnubuckets
> 0)
11540 printf (" 0 %-10lu (%5.1f%%)\n",
11541 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11542 for (j
= 1; j
<= maxlength
; ++j
)
11544 nzero_counts
+= counts
[j
] * j
;
11545 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11546 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11547 (nzero_counts
* 100.0) / nsyms
);
11561 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11565 if (dynamic_syminfo
== NULL
11567 /* No syminfo, this is ok. */
11570 /* There better should be a dynamic symbol section. */
11571 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11575 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11576 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11578 printf (_(" Num: Name BoundTo Flags\n"));
11579 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11581 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11583 printf ("%4d: ", i
);
11584 if (i
>= num_dynamic_syms
)
11585 printf (_("<corrupt index>"));
11586 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11587 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11589 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11592 switch (dynamic_syminfo
[i
].si_boundto
)
11594 case SYMINFO_BT_SELF
:
11595 fputs ("SELF ", stdout
);
11597 case SYMINFO_BT_PARENT
:
11598 fputs ("PARENT ", stdout
);
11601 if (dynamic_syminfo
[i
].si_boundto
> 0
11602 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11603 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11605 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11609 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11613 if (flags
& SYMINFO_FLG_DIRECT
)
11614 printf (" DIRECT");
11615 if (flags
& SYMINFO_FLG_PASSTHRU
)
11616 printf (" PASSTHRU");
11617 if (flags
& SYMINFO_FLG_COPY
)
11619 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11620 printf (" LAZYLOAD");
11628 #define IN_RANGE(START,END,ADDR,OFF) \
11629 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11631 /* Check to see if the given reloc needs to be handled in a target specific
11632 manner. If so then process the reloc and return TRUE otherwise return
11635 If called with reloc == NULL, then this is a signal that reloc processing
11636 for the current section has finished, and any saved state should be
11640 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11641 unsigned char * start
,
11642 unsigned char * end
,
11643 Elf_Internal_Sym
* symtab
,
11644 unsigned long num_syms
)
11646 unsigned int reloc_type
= 0;
11647 unsigned long sym_index
= 0;
11651 reloc_type
= get_reloc_type (reloc
->r_info
);
11652 sym_index
= get_reloc_symindex (reloc
->r_info
);
11655 switch (elf_header
.e_machine
)
11658 case EM_MSP430_OLD
:
11660 static Elf_Internal_Sym
* saved_sym
= NULL
;
11668 switch (reloc_type
)
11670 case 10: /* R_MSP430_SYM_DIFF */
11671 if (uses_msp430x_relocs ())
11673 /* Fall through. */
11674 case 21: /* R_MSP430X_SYM_DIFF */
11676 if (sym_index
>= num_syms
)
11677 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11680 saved_sym
= symtab
+ sym_index
;
11683 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11684 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11685 goto handle_sym_diff
;
11687 case 5: /* R_MSP430_16_BYTE */
11688 case 9: /* R_MSP430_8 */
11689 if (uses_msp430x_relocs ())
11691 goto handle_sym_diff
;
11693 case 2: /* R_MSP430_ABS16 */
11694 case 15: /* R_MSP430X_ABS16 */
11695 if (! uses_msp430x_relocs ())
11697 goto handle_sym_diff
;
11700 if (saved_sym
!= NULL
)
11702 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11705 if (sym_index
>= num_syms
)
11706 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11710 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11711 - saved_sym
->st_value
);
11713 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11714 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11717 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11718 (long) reloc
->r_offset
);
11727 if (saved_sym
!= NULL
)
11728 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11735 case EM_CYGNUS_MN10300
:
11737 static Elf_Internal_Sym
* saved_sym
= NULL
;
11745 switch (reloc_type
)
11747 case 34: /* R_MN10300_ALIGN */
11749 case 33: /* R_MN10300_SYM_DIFF */
11750 if (sym_index
>= num_syms
)
11751 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11754 saved_sym
= symtab
+ sym_index
;
11757 case 1: /* R_MN10300_32 */
11758 case 2: /* R_MN10300_16 */
11759 if (saved_sym
!= NULL
)
11761 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11764 if (sym_index
>= num_syms
)
11765 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11769 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11770 - saved_sym
->st_value
);
11772 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11773 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11775 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11776 (long) reloc
->r_offset
);
11784 if (saved_sym
!= NULL
)
11785 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11793 static bfd_vma saved_sym1
= 0;
11794 static bfd_vma saved_sym2
= 0;
11795 static bfd_vma value
;
11799 saved_sym1
= saved_sym2
= 0;
11803 switch (reloc_type
)
11805 case 0x80: /* R_RL78_SYM. */
11806 saved_sym1
= saved_sym2
;
11807 if (sym_index
>= num_syms
)
11808 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11812 saved_sym2
= symtab
[sym_index
].st_value
;
11813 saved_sym2
+= reloc
->r_addend
;
11817 case 0x83: /* R_RL78_OPsub. */
11818 value
= saved_sym1
- saved_sym2
;
11819 saved_sym2
= saved_sym1
= 0;
11823 case 0x41: /* R_RL78_ABS32. */
11824 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11825 byte_put (start
+ reloc
->r_offset
, value
, 4);
11827 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11828 (long) reloc
->r_offset
);
11832 case 0x43: /* R_RL78_ABS16. */
11833 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11834 byte_put (start
+ reloc
->r_offset
, value
, 2);
11836 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11837 (long) reloc
->r_offset
);
11851 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11852 DWARF debug sections. This is a target specific test. Note - we do not
11853 go through the whole including-target-headers-multiple-times route, (as
11854 we have already done with <elf/h8.h>) because this would become very
11855 messy and even then this function would have to contain target specific
11856 information (the names of the relocs instead of their numeric values).
11857 FIXME: This is not the correct way to solve this problem. The proper way
11858 is to have target specific reloc sizing and typing functions created by
11859 the reloc-macros.h header, in the same way that it already creates the
11860 reloc naming functions. */
11863 is_32bit_abs_reloc (unsigned int reloc_type
)
11865 /* Please keep this table alpha-sorted for ease of visual lookup. */
11866 switch (elf_header
.e_machine
)
11870 return reloc_type
== 1; /* R_386_32. */
11872 return reloc_type
== 1; /* R_68K_32. */
11874 return reloc_type
== 1; /* R_860_32. */
11876 return reloc_type
== 2; /* R_960_32. */
11878 return (reloc_type
== 258
11879 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11880 case EM_ADAPTEVA_EPIPHANY
:
11881 return reloc_type
== 3;
11883 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11885 return reloc_type
== 1; /* R_ARC_32. */
11886 case EM_ARC_COMPACT
:
11887 case EM_ARC_COMPACT2
:
11888 return reloc_type
== 4; /* R_ARC_32. */
11890 return reloc_type
== 2; /* R_ARM_ABS32 */
11893 return reloc_type
== 1;
11895 return reloc_type
== 0x12; /* R_byte4_data. */
11897 return reloc_type
== 3; /* R_CRIS_32. */
11899 return reloc_type
== 3; /* R_CR16_NUM32. */
11901 return reloc_type
== 15; /* R_CRX_NUM32. */
11902 case EM_CYGNUS_FRV
:
11903 return reloc_type
== 1;
11904 case EM_CYGNUS_D10V
:
11906 return reloc_type
== 6; /* R_D10V_32. */
11907 case EM_CYGNUS_D30V
:
11909 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11911 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11912 case EM_CYGNUS_FR30
:
11914 return reloc_type
== 3; /* R_FR30_32. */
11916 return reloc_type
== 1; /* R_FT32_32. */
11920 return reloc_type
== 1; /* R_H8_DIR32. */
11922 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11923 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11926 return reloc_type
== 2; /* R_IP2K_32. */
11928 return reloc_type
== 2; /* R_IQ2000_32. */
11929 case EM_LATTICEMICO32
:
11930 return reloc_type
== 3; /* R_LM32_32. */
11933 return reloc_type
== 3; /* R_M32C_32. */
11935 return reloc_type
== 34; /* R_M32R_32_RELA. */
11938 return reloc_type
== 6; /* R_M68HC11_32. */
11940 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11941 case EM_CYGNUS_MEP
:
11942 return reloc_type
== 4; /* R_MEP_32. */
11944 return reloc_type
== 2; /* R_METAG_ADDR32. */
11945 case EM_MICROBLAZE
:
11946 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11948 return reloc_type
== 2; /* R_MIPS_32. */
11950 return reloc_type
== 4; /* R_MMIX_32. */
11951 case EM_CYGNUS_MN10200
:
11953 return reloc_type
== 1; /* R_MN10200_32. */
11954 case EM_CYGNUS_MN10300
:
11956 return reloc_type
== 1; /* R_MN10300_32. */
11958 return reloc_type
== 1; /* R_MOXIE_32. */
11959 case EM_MSP430_OLD
:
11961 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11963 return reloc_type
== 2; /* R_MT_32. */
11965 return reloc_type
== 20; /* R_NDS32_RELA. */
11966 case EM_ALTERA_NIOS2
:
11967 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11969 return reloc_type
== 1; /* R_NIOS_32. */
11971 return reloc_type
== 1; /* R_OR1K_32. */
11973 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11974 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11977 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11979 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11981 return reloc_type
== 1; /* R_PPC_ADDR32. */
11983 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
11985 return reloc_type
== 1; /* R_RISCV_32. */
11987 return reloc_type
== 1; /* R_RL78_DIR32. */
11989 return reloc_type
== 1; /* R_RX_DIR32. */
11991 return reloc_type
== 1; /* R_I370_ADDR31. */
11994 return reloc_type
== 4; /* R_S390_32. */
11996 return reloc_type
== 8; /* R_SCORE_ABS32. */
11998 return reloc_type
== 1; /* R_SH_DIR32. */
11999 case EM_SPARC32PLUS
:
12002 return reloc_type
== 3 /* R_SPARC_32. */
12003 || reloc_type
== 23; /* R_SPARC_UA32. */
12005 return reloc_type
== 6; /* R_SPU_ADDR32 */
12007 return reloc_type
== 1; /* R_C6000_ABS32. */
12009 return reloc_type
== 2; /* R_TILEGX_32. */
12011 return reloc_type
== 1; /* R_TILEPRO_32. */
12012 case EM_CYGNUS_V850
:
12014 return reloc_type
== 6; /* R_V850_ABS32. */
12016 return reloc_type
== 0x33; /* R_V810_WORD. */
12018 return reloc_type
== 1; /* R_VAX_32. */
12020 return reloc_type
== 3; /* R_VISIUM_32. */
12024 return reloc_type
== 10; /* R_X86_64_32. */
12027 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12029 return reloc_type
== 4; /* R_XGATE_32. */
12031 return reloc_type
== 1; /* R_XSTROMY16_32. */
12032 case EM_XTENSA_OLD
:
12034 return reloc_type
== 1; /* R_XTENSA_32. */
12037 static unsigned int prev_warn
= 0;
12039 /* Avoid repeating the same warning multiple times. */
12040 if (prev_warn
!= elf_header
.e_machine
)
12041 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12042 elf_header
.e_machine
);
12043 prev_warn
= elf_header
.e_machine
;
12049 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12050 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12053 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12055 switch (elf_header
.e_machine
)
12056 /* Please keep this table alpha-sorted for ease of visual lookup. */
12060 return reloc_type
== 2; /* R_386_PC32. */
12062 return reloc_type
== 4; /* R_68K_PC32. */
12064 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12065 case EM_ADAPTEVA_EPIPHANY
:
12066 return reloc_type
== 6;
12068 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12069 case EM_ARC_COMPACT
:
12070 case EM_ARC_COMPACT2
:
12071 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12073 return reloc_type
== 3; /* R_ARM_REL32 */
12076 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12077 case EM_MICROBLAZE
:
12078 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12080 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12082 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12084 return reloc_type
== 26; /* R_PPC_REL32. */
12086 return reloc_type
== 26; /* R_PPC64_REL32. */
12089 return reloc_type
== 5; /* R_390_PC32. */
12091 return reloc_type
== 2; /* R_SH_REL32. */
12092 case EM_SPARC32PLUS
:
12095 return reloc_type
== 6; /* R_SPARC_DISP32. */
12097 return reloc_type
== 13; /* R_SPU_REL32. */
12099 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12101 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12103 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12107 return reloc_type
== 2; /* R_X86_64_PC32. */
12108 case EM_XTENSA_OLD
:
12110 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12112 /* Do not abort or issue an error message here. Not all targets use
12113 pc-relative 32-bit relocs in their DWARF debug information and we
12114 have already tested for target coverage in is_32bit_abs_reloc. A
12115 more helpful warning message will be generated by apply_relocations
12116 anyway, so just return. */
12121 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12122 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12125 is_64bit_abs_reloc (unsigned int reloc_type
)
12127 switch (elf_header
.e_machine
)
12130 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12132 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12134 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12136 return reloc_type
== 80; /* R_PARISC_DIR64. */
12138 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12140 return reloc_type
== 2; /* R_RISCV_64. */
12141 case EM_SPARC32PLUS
:
12144 return reloc_type
== 54; /* R_SPARC_UA64. */
12148 return reloc_type
== 1; /* R_X86_64_64. */
12151 return reloc_type
== 22; /* R_S390_64. */
12153 return reloc_type
== 1; /* R_TILEGX_64. */
12155 return reloc_type
== 18; /* R_MIPS_64. */
12161 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12162 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12165 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12167 switch (elf_header
.e_machine
)
12170 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12172 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12174 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12176 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12178 return reloc_type
== 44; /* R_PPC64_REL64. */
12179 case EM_SPARC32PLUS
:
12182 return reloc_type
== 46; /* R_SPARC_DISP64. */
12186 return reloc_type
== 24; /* R_X86_64_PC64. */
12189 return reloc_type
== 23; /* R_S390_PC64. */
12191 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12197 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12198 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12201 is_24bit_abs_reloc (unsigned int reloc_type
)
12203 switch (elf_header
.e_machine
)
12205 case EM_CYGNUS_MN10200
:
12207 return reloc_type
== 4; /* R_MN10200_24. */
12209 return reloc_type
== 5; /* R_FT32_20. */
12215 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12216 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12219 is_16bit_abs_reloc (unsigned int reloc_type
)
12221 /* Please keep this table alpha-sorted for ease of visual lookup. */
12222 switch (elf_header
.e_machine
)
12225 case EM_ARC_COMPACT
:
12226 case EM_ARC_COMPACT2
:
12227 return reloc_type
== 2; /* R_ARC_16. */
12228 case EM_ADAPTEVA_EPIPHANY
:
12229 return reloc_type
== 5;
12232 return reloc_type
== 4; /* R_AVR_16. */
12233 case EM_CYGNUS_D10V
:
12235 return reloc_type
== 3; /* R_D10V_16. */
12239 return reloc_type
== R_H8_DIR16
;
12242 return reloc_type
== 1; /* R_IP2K_16. */
12245 return reloc_type
== 1; /* R_M32C_16 */
12246 case EM_CYGNUS_MN10200
:
12248 return reloc_type
== 2; /* R_MN10200_16. */
12249 case EM_CYGNUS_MN10300
:
12251 return reloc_type
== 2; /* R_MN10300_16. */
12253 if (uses_msp430x_relocs ())
12254 return reloc_type
== 2; /* R_MSP430_ABS16. */
12255 /* Fall through. */
12256 case EM_MSP430_OLD
:
12257 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12259 return reloc_type
== 19; /* R_NDS32_RELA. */
12260 case EM_ALTERA_NIOS2
:
12261 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12263 return reloc_type
== 9; /* R_NIOS_16. */
12265 return reloc_type
== 2; /* R_OR1K_16. */
12267 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12269 return reloc_type
== 2; /* R_C6000_ABS16. */
12271 return reloc_type
== 2; /* R_VISIUM_16. */
12274 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12276 return reloc_type
== 3; /* R_XGATE_16. */
12282 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12283 relocation entries (possibly formerly used for SHT_GROUP sections). */
12286 is_none_reloc (unsigned int reloc_type
)
12288 switch (elf_header
.e_machine
)
12290 case EM_386
: /* R_386_NONE. */
12291 case EM_68K
: /* R_68K_NONE. */
12292 case EM_ADAPTEVA_EPIPHANY
:
12293 case EM_ALPHA
: /* R_ALPHA_NONE. */
12294 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12295 case EM_ARC
: /* R_ARC_NONE. */
12296 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12297 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12298 case EM_ARM
: /* R_ARM_NONE. */
12299 case EM_C166
: /* R_XC16X_NONE. */
12300 case EM_CRIS
: /* R_CRIS_NONE. */
12301 case EM_FT32
: /* R_FT32_NONE. */
12302 case EM_IA_64
: /* R_IA64_NONE. */
12303 case EM_K1OM
: /* R_X86_64_NONE. */
12304 case EM_L1OM
: /* R_X86_64_NONE. */
12305 case EM_M32R
: /* R_M32R_NONE. */
12306 case EM_MIPS
: /* R_MIPS_NONE. */
12307 case EM_MN10300
: /* R_MN10300_NONE. */
12308 case EM_MOXIE
: /* R_MOXIE_NONE. */
12309 case EM_NIOS32
: /* R_NIOS_NONE. */
12310 case EM_OR1K
: /* R_OR1K_NONE. */
12311 case EM_PARISC
: /* R_PARISC_NONE. */
12312 case EM_PPC64
: /* R_PPC64_NONE. */
12313 case EM_PPC
: /* R_PPC_NONE. */
12314 case EM_RISCV
: /* R_RISCV_NONE. */
12315 case EM_S390
: /* R_390_NONE. */
12317 case EM_SH
: /* R_SH_NONE. */
12318 case EM_SPARC32PLUS
:
12319 case EM_SPARC
: /* R_SPARC_NONE. */
12321 case EM_TILEGX
: /* R_TILEGX_NONE. */
12322 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12323 case EM_TI_C6000
:/* R_C6000_NONE. */
12324 case EM_X86_64
: /* R_X86_64_NONE. */
12326 return reloc_type
== 0;
12329 return reloc_type
== 0 || reloc_type
== 256;
12332 return (reloc_type
== 0 /* R_AVR_NONE. */
12333 || reloc_type
== 30 /* R_AVR_DIFF8. */
12334 || reloc_type
== 31 /* R_AVR_DIFF16. */
12335 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12337 return reloc_type
== 3; /* R_METAG_NONE. */
12339 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12340 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12341 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12342 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12343 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12345 return (reloc_type
== 0 /* R_PRU_NONE. */
12346 || reloc_type
== 65 /* R_PRU_DIFF8. */
12347 || reloc_type
== 66 /* R_PRU_DIFF16. */
12348 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12349 case EM_XTENSA_OLD
:
12351 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12352 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12353 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12354 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12359 /* Returns TRUE if there is a relocation against
12360 section NAME at OFFSET bytes. */
12363 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12365 Elf_Internal_Rela
* relocs
;
12366 Elf_Internal_Rela
* rp
;
12368 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12371 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12373 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12374 if (rp
->r_offset
== offset
)
12380 /* Apply relocations to a section.
12381 Note: So far support has been added only for those relocations
12382 which can be found in debug sections.
12383 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12384 loaded relocs. It is then the caller's responsibility to free them.
12385 FIXME: Add support for more relocations ? */
12388 apply_relocations (void * file
,
12389 const Elf_Internal_Shdr
* section
,
12390 unsigned char * start
,
12391 bfd_size_type size
,
12392 void ** relocs_return
,
12393 unsigned long * num_relocs_return
)
12395 Elf_Internal_Shdr
* relsec
;
12396 unsigned char * end
= start
+ size
;
12398 if (relocs_return
!= NULL
)
12400 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12401 * num_relocs_return
= 0;
12404 if (elf_header
.e_type
!= ET_REL
)
12407 /* Find the reloc section associated with the section. */
12408 for (relsec
= section_headers
;
12409 relsec
< section_headers
+ elf_header
.e_shnum
;
12412 bfd_boolean is_rela
;
12413 unsigned long num_relocs
;
12414 Elf_Internal_Rela
* relocs
;
12415 Elf_Internal_Rela
* rp
;
12416 Elf_Internal_Shdr
* symsec
;
12417 Elf_Internal_Sym
* symtab
;
12418 unsigned long num_syms
;
12419 Elf_Internal_Sym
* sym
;
12421 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12422 || relsec
->sh_info
>= elf_header
.e_shnum
12423 || section_headers
+ relsec
->sh_info
!= section
12424 || relsec
->sh_size
== 0
12425 || relsec
->sh_link
>= elf_header
.e_shnum
)
12428 is_rela
= relsec
->sh_type
== SHT_RELA
;
12432 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12433 relsec
->sh_size
, & relocs
, & num_relocs
))
12438 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12439 relsec
->sh_size
, & relocs
, & num_relocs
))
12443 /* SH uses RELA but uses in place value instead of the addend field. */
12444 if (elf_header
.e_machine
== EM_SH
)
12447 symsec
= section_headers
+ relsec
->sh_link
;
12448 if (symsec
->sh_type
!= SHT_SYMTAB
12449 && symsec
->sh_type
!= SHT_DYNSYM
)
12451 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12453 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12456 unsigned int reloc_type
;
12457 unsigned int reloc_size
;
12458 unsigned char * rloc
;
12459 unsigned long sym_index
;
12461 reloc_type
= get_reloc_type (rp
->r_info
);
12463 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12465 else if (is_none_reloc (reloc_type
))
12467 else if (is_32bit_abs_reloc (reloc_type
)
12468 || is_32bit_pcrel_reloc (reloc_type
))
12470 else if (is_64bit_abs_reloc (reloc_type
)
12471 || is_64bit_pcrel_reloc (reloc_type
))
12473 else if (is_24bit_abs_reloc (reloc_type
))
12475 else if (is_16bit_abs_reloc (reloc_type
))
12479 static unsigned int prev_reloc
= 0;
12480 if (reloc_type
!= prev_reloc
)
12481 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12482 reloc_type
, printable_section_name (section
));
12483 prev_reloc
= reloc_type
;
12487 rloc
= start
+ rp
->r_offset
;
12488 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12490 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12491 (unsigned long) rp
->r_offset
,
12492 printable_section_name (section
));
12496 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12497 if (sym_index
>= num_syms
)
12499 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12500 sym_index
, printable_section_name (section
));
12503 sym
= symtab
+ sym_index
;
12505 /* If the reloc has a symbol associated with it,
12506 make sure that it is of an appropriate type.
12508 Relocations against symbols without type can happen.
12509 Gcc -feliminate-dwarf2-dups may generate symbols
12510 without type for debug info.
12512 Icc generates relocations against function symbols
12513 instead of local labels.
12515 Relocations against object symbols can happen, eg when
12516 referencing a global array. For an example of this see
12517 the _clz.o binary in libgcc.a. */
12519 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12520 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12522 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12523 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12524 (long int)(rp
- relocs
),
12525 printable_section_name (relsec
));
12531 addend
+= rp
->r_addend
;
12532 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12533 partial_inplace. */
12535 || (elf_header
.e_machine
== EM_XTENSA
12536 && reloc_type
== 1)
12537 || ((elf_header
.e_machine
== EM_PJ
12538 || elf_header
.e_machine
== EM_PJ_OLD
)
12539 && reloc_type
== 1)
12540 || ((elf_header
.e_machine
== EM_D30V
12541 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12542 && reloc_type
== 12))
12543 addend
+= byte_get (rloc
, reloc_size
);
12545 if (is_32bit_pcrel_reloc (reloc_type
)
12546 || is_64bit_pcrel_reloc (reloc_type
))
12548 /* On HPPA, all pc-relative relocations are biased by 8. */
12549 if (elf_header
.e_machine
== EM_PARISC
)
12551 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12555 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12559 /* Let the target specific reloc processing code know that
12560 we have finished with these relocs. */
12561 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12565 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12566 * num_relocs_return
= num_relocs
;
12575 #ifdef SUPPORT_DISASSEMBLY
12577 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12579 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12581 /* FIXME: XXX -- to be done --- XXX */
12587 /* Reads in the contents of SECTION from FILE, returning a pointer
12588 to a malloc'ed buffer or NULL if something went wrong. */
12591 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12593 bfd_size_type num_bytes
;
12595 num_bytes
= section
->sh_size
;
12597 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12599 printf (_("\nSection '%s' has no data to dump.\n"),
12600 printable_section_name (section
));
12604 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12605 _("section contents"));
12608 /* Uncompresses a section that was compressed using zlib, in place. */
12611 uncompress_section_contents (unsigned char **buffer
,
12612 dwarf_size_type uncompressed_size
,
12613 dwarf_size_type
*size
)
12615 dwarf_size_type compressed_size
= *size
;
12616 unsigned char * compressed_buffer
= *buffer
;
12617 unsigned char * uncompressed_buffer
;
12621 /* It is possible the section consists of several compressed
12622 buffers concatenated together, so we uncompress in a loop. */
12623 /* PR 18313: The state field in the z_stream structure is supposed
12624 to be invisible to the user (ie us), but some compilers will
12625 still complain about it being used without initialisation. So
12626 we first zero the entire z_stream structure and then set the fields
12628 memset (& strm
, 0, sizeof strm
);
12629 strm
.avail_in
= compressed_size
;
12630 strm
.next_in
= (Bytef
*) compressed_buffer
;
12631 strm
.avail_out
= uncompressed_size
;
12632 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12634 rc
= inflateInit (& strm
);
12635 while (strm
.avail_in
> 0)
12639 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12640 + (uncompressed_size
- strm
.avail_out
));
12641 rc
= inflate (&strm
, Z_FINISH
);
12642 if (rc
!= Z_STREAM_END
)
12644 rc
= inflateReset (& strm
);
12646 rc
= inflateEnd (& strm
);
12648 || strm
.avail_out
!= 0)
12651 *buffer
= uncompressed_buffer
;
12652 *size
= uncompressed_size
;
12656 free (uncompressed_buffer
);
12657 /* Indicate decompression failure. */
12663 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12665 Elf_Internal_Shdr
* relsec
;
12666 bfd_size_type num_bytes
;
12667 unsigned char * data
;
12668 unsigned char * end
;
12669 unsigned char * real_start
;
12670 unsigned char * start
;
12671 bfd_boolean some_strings_shown
;
12673 real_start
= start
= (unsigned char *) get_section_contents (section
,
12677 num_bytes
= section
->sh_size
;
12679 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12681 if (decompress_dumps
)
12683 dwarf_size_type new_size
= num_bytes
;
12684 dwarf_size_type uncompressed_size
= 0;
12686 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12688 Elf_Internal_Chdr chdr
;
12689 unsigned int compression_header_size
12690 = get_compression_header (& chdr
, (unsigned char *) start
,
12693 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12695 warn (_("section '%s' has unsupported compress type: %d\n"),
12696 printable_section_name (section
), chdr
.ch_type
);
12699 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12701 warn (_("compressed section '%s' is corrupted\n"),
12702 printable_section_name (section
));
12705 uncompressed_size
= chdr
.ch_size
;
12706 start
+= compression_header_size
;
12707 new_size
-= compression_header_size
;
12709 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12711 /* Read the zlib header. In this case, it should be "ZLIB"
12712 followed by the uncompressed section size, 8 bytes in
12713 big-endian order. */
12714 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12715 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12716 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12717 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12718 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12719 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12720 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12721 uncompressed_size
+= start
[11];
12726 if (uncompressed_size
)
12728 if (uncompress_section_contents (& start
,
12729 uncompressed_size
, & new_size
))
12730 num_bytes
= new_size
;
12733 error (_("Unable to decompress section %s\n"),
12734 printable_section_name (section
));
12739 start
= real_start
;
12742 /* If the section being dumped has relocations against it the user might
12743 be expecting these relocations to have been applied. Check for this
12744 case and issue a warning message in order to avoid confusion.
12745 FIXME: Maybe we ought to have an option that dumps a section with
12746 relocs applied ? */
12747 for (relsec
= section_headers
;
12748 relsec
< section_headers
+ elf_header
.e_shnum
;
12751 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12752 || relsec
->sh_info
>= elf_header
.e_shnum
12753 || section_headers
+ relsec
->sh_info
!= section
12754 || relsec
->sh_size
== 0
12755 || relsec
->sh_link
>= elf_header
.e_shnum
)
12758 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12763 end
= start
+ num_bytes
;
12764 some_strings_shown
= FALSE
;
12768 while (!ISPRINT (* data
))
12769 if (++ data
>= end
)
12774 size_t maxlen
= end
- data
;
12777 /* PR 11128: Use two separate invocations in order to work
12778 around bugs in the Solaris 8 implementation of printf. */
12779 printf (" [%6tx] ", data
- start
);
12781 printf (" [%6Ix] ", (size_t) (data
- start
));
12785 print_symbol ((int) maxlen
, (const char *) data
);
12787 data
+= strnlen ((const char *) data
, maxlen
);
12791 printf (_("<corrupt>\n"));
12794 some_strings_shown
= TRUE
;
12798 if (! some_strings_shown
)
12799 printf (_(" No strings found in this section."));
12807 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12809 bfd_boolean relocate
)
12811 Elf_Internal_Shdr
* relsec
;
12812 bfd_size_type bytes
;
12813 bfd_size_type section_size
;
12815 unsigned char * data
;
12816 unsigned char * real_start
;
12817 unsigned char * start
;
12819 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12822 section_size
= section
->sh_size
;
12824 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12826 if (decompress_dumps
)
12828 dwarf_size_type new_size
= section_size
;
12829 dwarf_size_type uncompressed_size
= 0;
12831 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12833 Elf_Internal_Chdr chdr
;
12834 unsigned int compression_header_size
12835 = get_compression_header (& chdr
, start
, section_size
);
12837 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12839 warn (_("section '%s' has unsupported compress type: %d\n"),
12840 printable_section_name (section
), chdr
.ch_type
);
12843 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12845 warn (_("compressed section '%s' is corrupted\n"),
12846 printable_section_name (section
));
12849 uncompressed_size
= chdr
.ch_size
;
12850 start
+= compression_header_size
;
12851 new_size
-= compression_header_size
;
12853 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12855 /* Read the zlib header. In this case, it should be "ZLIB"
12856 followed by the uncompressed section size, 8 bytes in
12857 big-endian order. */
12858 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12859 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12860 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12861 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12862 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12863 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12864 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12865 uncompressed_size
+= start
[11];
12870 if (uncompressed_size
)
12872 if (uncompress_section_contents (& start
, uncompressed_size
,
12875 section_size
= new_size
;
12879 error (_("Unable to decompress section %s\n"),
12880 printable_section_name (section
));
12881 /* FIXME: Print the section anyway ? */
12886 start
= real_start
;
12891 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12895 /* If the section being dumped has relocations against it the user might
12896 be expecting these relocations to have been applied. Check for this
12897 case and issue a warning message in order to avoid confusion.
12898 FIXME: Maybe we ought to have an option that dumps a section with
12899 relocs applied ? */
12900 for (relsec
= section_headers
;
12901 relsec
< section_headers
+ elf_header
.e_shnum
;
12904 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12905 || relsec
->sh_info
>= elf_header
.e_shnum
12906 || section_headers
+ relsec
->sh_info
!= section
12907 || relsec
->sh_size
== 0
12908 || relsec
->sh_link
>= elf_header
.e_shnum
)
12911 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12916 addr
= section
->sh_addr
;
12917 bytes
= section_size
;
12926 lbytes
= (bytes
> 16 ? 16 : bytes
);
12928 printf (" 0x%8.8lx ", (unsigned long) addr
);
12930 for (j
= 0; j
< 16; j
++)
12933 printf ("%2.2x", data
[j
]);
12941 for (j
= 0; j
< lbytes
; j
++)
12944 if (k
>= ' ' && k
< 0x7f)
12963 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12964 const Elf_Internal_Shdr
* sec
, void * file
)
12966 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12969 /* If it is already loaded, do nothing. */
12970 if (section
->start
!= NULL
)
12973 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12974 section
->address
= sec
->sh_addr
;
12975 section
->user_data
= NULL
;
12976 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12978 sec
->sh_size
, buf
);
12979 if (section
->start
== NULL
)
12983 unsigned char *start
= section
->start
;
12984 dwarf_size_type size
= sec
->sh_size
;
12985 dwarf_size_type uncompressed_size
= 0;
12987 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12989 Elf_Internal_Chdr chdr
;
12990 unsigned int compression_header_size
;
12992 if (size
< (is_32bit_elf
12993 ? sizeof (Elf32_External_Chdr
)
12994 : sizeof (Elf64_External_Chdr
)))
12996 warn (_("compressed section %s is too small to contain a compression header"),
13001 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13003 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13005 warn (_("section '%s' has unsupported compress type: %d\n"),
13006 section
->name
, chdr
.ch_type
);
13009 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13011 warn (_("compressed section '%s' is corrupted\n"),
13015 uncompressed_size
= chdr
.ch_size
;
13016 start
+= compression_header_size
;
13017 size
-= compression_header_size
;
13019 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13021 /* Read the zlib header. In this case, it should be "ZLIB"
13022 followed by the uncompressed section size, 8 bytes in
13023 big-endian order. */
13024 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13025 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13026 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13027 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13028 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13029 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13030 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13031 uncompressed_size
+= start
[11];
13036 if (uncompressed_size
)
13038 if (uncompress_section_contents (&start
, uncompressed_size
,
13041 /* Free the compressed buffer, update the section buffer
13042 and the section size if uncompress is successful. */
13043 free (section
->start
);
13044 section
->start
= start
;
13048 error (_("Unable to decompress section %s\n"),
13049 printable_section_name (sec
));
13054 section
->size
= size
;
13057 if (section
->start
== NULL
)
13060 if (debug_displays
[debug
].relocate
)
13061 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13062 & section
->reloc_info
, & section
->num_relocs
);
13065 section
->reloc_info
= NULL
;
13066 section
->num_relocs
= 0;
13072 /* If this is not NULL, load_debug_section will only look for sections
13073 within the list of sections given here. */
13074 unsigned int *section_subset
= NULL
;
13077 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13079 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13080 Elf_Internal_Shdr
* sec
;
13082 /* Locate the debug section. */
13083 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13085 section
->name
= section
->uncompressed_name
;
13088 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13090 section
->name
= section
->compressed_name
;
13095 /* If we're loading from a subset of sections, and we've loaded
13096 a section matching this name before, it's likely that it's a
13098 if (section_subset
!= NULL
)
13099 free_debug_section (debug
);
13101 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13105 free_debug_section (enum dwarf_section_display_enum debug
)
13107 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13109 if (section
->start
== NULL
)
13112 free ((char *) section
->start
);
13113 section
->start
= NULL
;
13114 section
->address
= 0;
13119 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13121 char * name
= SECTION_NAME (section
);
13122 const char * print_name
= printable_section_name (section
);
13123 bfd_size_type length
;
13127 length
= section
->sh_size
;
13130 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13133 if (section
->sh_type
== SHT_NOBITS
)
13135 /* There is no point in dumping the contents of a debugging section
13136 which has the NOBITS type - the bits in the file will be random.
13137 This can happen when a file containing a .eh_frame section is
13138 stripped with the --only-keep-debug command line option. */
13139 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13144 if (const_strneq (name
, ".gnu.linkonce.wi."))
13145 name
= ".debug_info";
13147 /* See if we know how to display the contents of this section. */
13148 for (i
= 0; i
< max
; i
++)
13149 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13150 || (i
== line
&& const_strneq (name
, ".debug_line."))
13151 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13153 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13154 int secondary
= (section
!= find_section (name
));
13157 free_debug_section ((enum dwarf_section_display_enum
) i
);
13159 if (i
== line
&& const_strneq (name
, ".debug_line."))
13161 else if (streq (sec
->uncompressed_name
, name
))
13162 sec
->name
= sec
->uncompressed_name
;
13164 sec
->name
= sec
->compressed_name
;
13165 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13168 /* If this debug section is part of a CU/TU set in a .dwp file,
13169 restrict load_debug_section to the sections in that set. */
13170 section_subset
= find_cu_tu_set (file
, shndx
);
13172 result
&= debug_displays
[i
].display (sec
, file
);
13174 section_subset
= NULL
;
13176 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13177 free_debug_section ((enum dwarf_section_display_enum
) i
);
13185 printf (_("Unrecognized debug section: %s\n"), print_name
);
13192 /* Set DUMP_SECTS for all sections where dumps were requested
13193 based on section name. */
13196 initialise_dumps_byname (void)
13198 struct dump_list_entry
* cur
;
13200 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13205 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13206 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13208 request_dump_bynumber (i
, cur
->type
);
13213 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13219 process_section_contents (FILE * file
)
13221 Elf_Internal_Shdr
* section
;
13227 initialise_dumps_byname ();
13229 for (i
= 0, section
= section_headers
;
13230 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13233 #ifdef SUPPORT_DISASSEMBLY
13234 if (dump_sects
[i
] & DISASS_DUMP
)
13235 disassemble_section (section
, file
);
13237 if (dump_sects
[i
] & HEX_DUMP
)
13238 dump_section_as_bytes (section
, file
, FALSE
);
13240 if (dump_sects
[i
] & RELOC_DUMP
)
13241 dump_section_as_bytes (section
, file
, TRUE
);
13243 if (dump_sects
[i
] & STRING_DUMP
)
13244 dump_section_as_strings (section
, file
);
13246 if (dump_sects
[i
] & DEBUG_DUMP
)
13247 display_debug_section (i
, section
, file
);
13250 /* Check to see if the user requested a
13251 dump of a section that does not exist. */
13252 while (i
< num_dump_sects
)
13255 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13261 process_mips_fpe_exception (int mask
)
13266 if (mask
& OEX_FPU_INEX
)
13267 fputs ("INEX", stdout
), first
= 0;
13268 if (mask
& OEX_FPU_UFLO
)
13269 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13270 if (mask
& OEX_FPU_OFLO
)
13271 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13272 if (mask
& OEX_FPU_DIV0
)
13273 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13274 if (mask
& OEX_FPU_INVAL
)
13275 printf ("%sINVAL", first
? "" : "|");
13278 fputs ("0", stdout
);
13281 /* Display's the value of TAG at location P. If TAG is
13282 greater than 0 it is assumed to be an unknown tag, and
13283 a message is printed to this effect. Otherwise it is
13284 assumed that a message has already been printed.
13286 If the bottom bit of TAG is set it assumed to have a
13287 string value, otherwise it is assumed to have an integer
13290 Returns an updated P pointing to the first unread byte
13291 beyond the end of TAG's value.
13293 Reads at or beyond END will not be made. */
13295 static unsigned char *
13296 display_tag_value (signed int tag
,
13298 const unsigned char * const end
)
13303 printf (" Tag_unknown_%d: ", tag
);
13307 warn (_("<corrupt tag>\n"));
13311 /* PR 17531 file: 027-19978-0.004. */
13312 size_t maxlen
= (end
- p
) - 1;
13317 print_symbol ((int) maxlen
, (const char *) p
);
13318 p
+= strnlen ((char *) p
, maxlen
) + 1;
13322 printf (_("<corrupt string tag>"));
13323 p
= (unsigned char *) end
;
13331 val
= read_uleb128 (p
, &len
, end
);
13333 printf ("%ld (0x%lx)\n", val
, val
);
13340 /* ARM EABI attributes section. */
13345 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13347 const char ** table
;
13348 } arm_attr_public_tag
;
13350 static const char * arm_attr_tag_CPU_arch
[] =
13351 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13352 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13354 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13355 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13356 {"No", "Thumb-1", "Thumb-2", "Yes"};
13357 static const char * arm_attr_tag_FP_arch
[] =
13358 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13359 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13360 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13361 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13362 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13363 "NEON for ARMv8.1"};
13364 static const char * arm_attr_tag_PCS_config
[] =
13365 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13366 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13367 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13368 {"V6", "SB", "TLS", "Unused"};
13369 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13370 {"Absolute", "PC-relative", "SB-relative", "None"};
13371 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13372 {"Absolute", "PC-relative", "None"};
13373 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13374 {"None", "direct", "GOT-indirect"};
13375 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13376 {"None", "??? 1", "2", "??? 3", "4"};
13377 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13378 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13379 {"Unused", "Needed", "Sign only"};
13380 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13381 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13382 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13383 {"Unused", "Finite", "RTABI", "IEEE 754"};
13384 static const char * arm_attr_tag_ABI_enum_size
[] =
13385 {"Unused", "small", "int", "forced to int"};
13386 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13387 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13388 static const char * arm_attr_tag_ABI_VFP_args
[] =
13389 {"AAPCS", "VFP registers", "custom", "compatible"};
13390 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13391 {"AAPCS", "WMMX registers", "custom"};
13392 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13393 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13394 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13395 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13396 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13397 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13398 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13399 static const char * arm_attr_tag_FP_HP_extension
[] =
13400 {"Not Allowed", "Allowed"};
13401 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13402 {"None", "IEEE 754", "Alternative Format"};
13403 static const char * arm_attr_tag_DSP_extension
[] =
13404 {"Follow architecture", "Allowed"};
13405 static const char * arm_attr_tag_MPextension_use
[] =
13406 {"Not Allowed", "Allowed"};
13407 static const char * arm_attr_tag_DIV_use
[] =
13408 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13409 "Allowed in v7-A with integer division extension"};
13410 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13411 static const char * arm_attr_tag_Virtualization_use
[] =
13412 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13413 "TrustZone and Virtualization Extensions"};
13414 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13415 {"Not Allowed", "Allowed"};
13417 #define LOOKUP(id, name) \
13418 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13419 static arm_attr_public_tag arm_attr_public_tags
[] =
13421 {4, "CPU_raw_name", 1, NULL
},
13422 {5, "CPU_name", 1, NULL
},
13423 LOOKUP(6, CPU_arch
),
13424 {7, "CPU_arch_profile", 0, NULL
},
13425 LOOKUP(8, ARM_ISA_use
),
13426 LOOKUP(9, THUMB_ISA_use
),
13427 LOOKUP(10, FP_arch
),
13428 LOOKUP(11, WMMX_arch
),
13429 LOOKUP(12, Advanced_SIMD_arch
),
13430 LOOKUP(13, PCS_config
),
13431 LOOKUP(14, ABI_PCS_R9_use
),
13432 LOOKUP(15, ABI_PCS_RW_data
),
13433 LOOKUP(16, ABI_PCS_RO_data
),
13434 LOOKUP(17, ABI_PCS_GOT_use
),
13435 LOOKUP(18, ABI_PCS_wchar_t
),
13436 LOOKUP(19, ABI_FP_rounding
),
13437 LOOKUP(20, ABI_FP_denormal
),
13438 LOOKUP(21, ABI_FP_exceptions
),
13439 LOOKUP(22, ABI_FP_user_exceptions
),
13440 LOOKUP(23, ABI_FP_number_model
),
13441 {24, "ABI_align_needed", 0, NULL
},
13442 {25, "ABI_align_preserved", 0, NULL
},
13443 LOOKUP(26, ABI_enum_size
),
13444 LOOKUP(27, ABI_HardFP_use
),
13445 LOOKUP(28, ABI_VFP_args
),
13446 LOOKUP(29, ABI_WMMX_args
),
13447 LOOKUP(30, ABI_optimization_goals
),
13448 LOOKUP(31, ABI_FP_optimization_goals
),
13449 {32, "compatibility", 0, NULL
},
13450 LOOKUP(34, CPU_unaligned_access
),
13451 LOOKUP(36, FP_HP_extension
),
13452 LOOKUP(38, ABI_FP_16bit_format
),
13453 LOOKUP(42, MPextension_use
),
13454 LOOKUP(44, DIV_use
),
13455 LOOKUP(46, DSP_extension
),
13456 {64, "nodefaults", 0, NULL
},
13457 {65, "also_compatible_with", 0, NULL
},
13458 LOOKUP(66, T2EE_use
),
13459 {67, "conformance", 1, NULL
},
13460 LOOKUP(68, Virtualization_use
),
13461 LOOKUP(70, MPextension_use_legacy
)
13465 static unsigned char *
13466 display_arm_attribute (unsigned char * p
,
13467 const unsigned char * const end
)
13472 arm_attr_public_tag
* attr
;
13476 tag
= read_uleb128 (p
, &len
, end
);
13479 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13481 if (arm_attr_public_tags
[i
].tag
== tag
)
13483 attr
= &arm_attr_public_tags
[i
];
13490 printf (" Tag_%s: ", attr
->name
);
13491 switch (attr
->type
)
13496 case 7: /* Tag_CPU_arch_profile. */
13497 val
= read_uleb128 (p
, &len
, end
);
13501 case 0: printf (_("None\n")); break;
13502 case 'A': printf (_("Application\n")); break;
13503 case 'R': printf (_("Realtime\n")); break;
13504 case 'M': printf (_("Microcontroller\n")); break;
13505 case 'S': printf (_("Application or Realtime\n")); break;
13506 default: printf ("??? (%d)\n", val
); break;
13510 case 24: /* Tag_align_needed. */
13511 val
= read_uleb128 (p
, &len
, end
);
13515 case 0: printf (_("None\n")); break;
13516 case 1: printf (_("8-byte\n")); break;
13517 case 2: printf (_("4-byte\n")); break;
13518 case 3: printf ("??? 3\n"); break;
13521 printf (_("8-byte and up to %d-byte extended\n"),
13524 printf ("??? (%d)\n", val
);
13529 case 25: /* Tag_align_preserved. */
13530 val
= read_uleb128 (p
, &len
, end
);
13534 case 0: printf (_("None\n")); break;
13535 case 1: printf (_("8-byte, except leaf SP\n")); break;
13536 case 2: printf (_("8-byte\n")); break;
13537 case 3: printf ("??? 3\n"); break;
13540 printf (_("8-byte and up to %d-byte extended\n"),
13543 printf ("??? (%d)\n", val
);
13548 case 32: /* Tag_compatibility. */
13550 val
= read_uleb128 (p
, &len
, end
);
13552 printf (_("flag = %d, vendor = "), val
);
13555 size_t maxlen
= (end
- p
) - 1;
13557 print_symbol ((int) maxlen
, (const char *) p
);
13558 p
+= strnlen ((char *) p
, maxlen
) + 1;
13562 printf (_("<corrupt>"));
13563 p
= (unsigned char *) end
;
13569 case 64: /* Tag_nodefaults. */
13570 /* PR 17531: file: 001-505008-0.01. */
13573 printf (_("True\n"));
13576 case 65: /* Tag_also_compatible_with. */
13577 val
= read_uleb128 (p
, &len
, end
);
13579 if (val
== 6 /* Tag_CPU_arch. */)
13581 val
= read_uleb128 (p
, &len
, end
);
13583 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13584 printf ("??? (%d)\n", val
);
13586 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13590 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13595 printf (_("<unknown: %d>\n"), tag
);
13601 return display_tag_value (-1, p
, end
);
13603 return display_tag_value (0, p
, end
);
13606 assert (attr
->type
& 0x80);
13607 val
= read_uleb128 (p
, &len
, end
);
13609 type
= attr
->type
& 0x7f;
13611 printf ("??? (%d)\n", val
);
13613 printf ("%s\n", attr
->table
[val
]);
13618 return display_tag_value (tag
, p
, end
);
13621 static unsigned char *
13622 display_gnu_attribute (unsigned char * p
,
13623 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13624 const unsigned char * const end
)
13630 tag
= read_uleb128 (p
, &len
, end
);
13633 /* Tag_compatibility is the only generic GNU attribute defined at
13637 val
= read_uleb128 (p
, &len
, end
);
13640 printf (_("flag = %d, vendor = "), val
);
13643 printf (_("<corrupt>\n"));
13644 warn (_("corrupt vendor attribute\n"));
13650 size_t maxlen
= (end
- p
) - 1;
13652 print_symbol ((int) maxlen
, (const char *) p
);
13653 p
+= strnlen ((char *) p
, maxlen
) + 1;
13657 printf (_("<corrupt>"));
13658 p
= (unsigned char *) end
;
13665 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13666 return display_proc_gnu_attribute (p
, tag
, end
);
13668 return display_tag_value (tag
, p
, end
);
13671 static unsigned char *
13672 display_power_gnu_attribute (unsigned char * p
,
13674 const unsigned char * const end
)
13679 if (tag
== Tag_GNU_Power_ABI_FP
)
13681 val
= read_uleb128 (p
, &len
, end
);
13683 printf (" Tag_GNU_Power_ABI_FP: ");
13686 printf (_("<corrupt>\n"));
13691 printf ("(%#x), ", val
);
13696 printf (_("unspecified hard/soft float, "));
13699 printf (_("hard float, "));
13702 printf (_("soft float, "));
13705 printf (_("single-precision hard float, "));
13712 printf (_("unspecified long double\n"));
13715 printf (_("128-bit IBM long double\n"));
13718 printf (_("64-bit long double\n"));
13721 printf (_("128-bit IEEE long double\n"));
13727 if (tag
== Tag_GNU_Power_ABI_Vector
)
13729 val
= read_uleb128 (p
, &len
, end
);
13731 printf (" Tag_GNU_Power_ABI_Vector: ");
13734 printf (_("<corrupt>\n"));
13739 printf ("(%#x), ", val
);
13744 printf (_("unspecified\n"));
13747 printf (_("generic\n"));
13750 printf ("AltiVec\n");
13759 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13761 val
= read_uleb128 (p
, &len
, end
);
13763 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13766 printf (_("<corrupt>\n"));
13771 printf ("(%#x), ", val
);
13776 printf (_("unspecified\n"));
13779 printf ("r3/r4\n");
13782 printf (_("memory\n"));
13791 return display_tag_value (tag
& 1, p
, end
);
13794 static unsigned char *
13795 display_s390_gnu_attribute (unsigned char * p
,
13797 const unsigned char * const end
)
13802 if (tag
== Tag_GNU_S390_ABI_Vector
)
13804 val
= read_uleb128 (p
, &len
, end
);
13806 printf (" Tag_GNU_S390_ABI_Vector: ");
13811 printf (_("any\n"));
13814 printf (_("software\n"));
13817 printf (_("hardware\n"));
13820 printf ("??? (%d)\n", val
);
13826 return display_tag_value (tag
& 1, p
, end
);
13830 display_sparc_hwcaps (unsigned int mask
)
13836 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13837 fputs ("mul32", stdout
), first
= 0;
13838 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13839 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13840 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13841 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13842 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13843 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13844 if (mask
& ELF_SPARC_HWCAP_POPC
)
13845 printf ("%spopc", first
? "" : "|"), first
= 0;
13846 if (mask
& ELF_SPARC_HWCAP_VIS
)
13847 printf ("%svis", first
? "" : "|"), first
= 0;
13848 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13849 printf ("%svis2", first
? "" : "|"), first
= 0;
13850 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13851 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13852 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13853 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13854 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13855 printf ("%svis3", first
? "" : "|"), first
= 0;
13856 if (mask
& ELF_SPARC_HWCAP_HPC
)
13857 printf ("%shpc", first
? "" : "|"), first
= 0;
13858 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13859 printf ("%srandom", first
? "" : "|"), first
= 0;
13860 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13861 printf ("%strans", first
? "" : "|"), first
= 0;
13862 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13863 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13864 if (mask
& ELF_SPARC_HWCAP_IMA
)
13865 printf ("%sima", first
? "" : "|"), first
= 0;
13866 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13867 printf ("%scspare", first
? "" : "|"), first
= 0;
13870 fputc ('0', stdout
);
13871 fputc ('\n', stdout
);
13875 display_sparc_hwcaps2 (unsigned int mask
)
13881 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13882 fputs ("fjathplus", stdout
), first
= 0;
13883 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13884 printf ("%svis3b", first
? "" : "|"), first
= 0;
13885 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13886 printf ("%sadp", first
? "" : "|"), first
= 0;
13887 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13888 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13889 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13890 printf ("%smwait", first
? "" : "|"), first
= 0;
13891 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13892 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13893 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13894 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13895 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13896 printf ("%snsec", first
? "" : "|"), first
= 0;
13897 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13898 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13899 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13900 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13901 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13902 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13905 fputc ('0', stdout
);
13906 fputc ('\n', stdout
);
13909 static unsigned char *
13910 display_sparc_gnu_attribute (unsigned char * p
,
13912 const unsigned char * const end
)
13917 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13919 val
= read_uleb128 (p
, &len
, end
);
13921 printf (" Tag_GNU_Sparc_HWCAPS: ");
13922 display_sparc_hwcaps (val
);
13925 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13927 val
= read_uleb128 (p
, &len
, end
);
13929 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13930 display_sparc_hwcaps2 (val
);
13934 return display_tag_value (tag
, p
, end
);
13938 print_mips_fp_abi_value (int val
)
13942 case Val_GNU_MIPS_ABI_FP_ANY
:
13943 printf (_("Hard or soft float\n"));
13945 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13946 printf (_("Hard float (double precision)\n"));
13948 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13949 printf (_("Hard float (single precision)\n"));
13951 case Val_GNU_MIPS_ABI_FP_SOFT
:
13952 printf (_("Soft float\n"));
13954 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13955 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13957 case Val_GNU_MIPS_ABI_FP_XX
:
13958 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13960 case Val_GNU_MIPS_ABI_FP_64
:
13961 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13963 case Val_GNU_MIPS_ABI_FP_64A
:
13964 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13966 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13967 printf (_("NaN 2008 compatibility\n"));
13970 printf ("??? (%d)\n", val
);
13975 static unsigned char *
13976 display_mips_gnu_attribute (unsigned char * p
,
13978 const unsigned char * const end
)
13980 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13985 val
= read_uleb128 (p
, &len
, end
);
13987 printf (" Tag_GNU_MIPS_ABI_FP: ");
13989 print_mips_fp_abi_value (val
);
13994 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13999 val
= read_uleb128 (p
, &len
, end
);
14001 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14005 case Val_GNU_MIPS_ABI_MSA_ANY
:
14006 printf (_("Any MSA or not\n"));
14008 case Val_GNU_MIPS_ABI_MSA_128
:
14009 printf (_("128-bit MSA\n"));
14012 printf ("??? (%d)\n", val
);
14018 return display_tag_value (tag
& 1, p
, end
);
14021 static unsigned char *
14022 display_tic6x_attribute (unsigned char * p
,
14023 const unsigned char * const end
)
14029 tag
= read_uleb128 (p
, &len
, end
);
14035 val
= read_uleb128 (p
, &len
, end
);
14037 printf (" Tag_ISA: ");
14041 case C6XABI_Tag_ISA_none
:
14042 printf (_("None\n"));
14044 case C6XABI_Tag_ISA_C62X
:
14047 case C6XABI_Tag_ISA_C67X
:
14050 case C6XABI_Tag_ISA_C67XP
:
14051 printf ("C67x+\n");
14053 case C6XABI_Tag_ISA_C64X
:
14056 case C6XABI_Tag_ISA_C64XP
:
14057 printf ("C64x+\n");
14059 case C6XABI_Tag_ISA_C674X
:
14060 printf ("C674x\n");
14063 printf ("??? (%d)\n", val
);
14068 case Tag_ABI_wchar_t
:
14069 val
= read_uleb128 (p
, &len
, end
);
14071 printf (" Tag_ABI_wchar_t: ");
14075 printf (_("Not used\n"));
14078 printf (_("2 bytes\n"));
14081 printf (_("4 bytes\n"));
14084 printf ("??? (%d)\n", val
);
14089 case Tag_ABI_stack_align_needed
:
14090 val
= read_uleb128 (p
, &len
, end
);
14092 printf (" Tag_ABI_stack_align_needed: ");
14096 printf (_("8-byte\n"));
14099 printf (_("16-byte\n"));
14102 printf ("??? (%d)\n", val
);
14107 case Tag_ABI_stack_align_preserved
:
14108 val
= read_uleb128 (p
, &len
, end
);
14110 printf (" Tag_ABI_stack_align_preserved: ");
14114 printf (_("8-byte\n"));
14117 printf (_("16-byte\n"));
14120 printf ("??? (%d)\n", val
);
14126 val
= read_uleb128 (p
, &len
, end
);
14128 printf (" Tag_ABI_DSBT: ");
14132 printf (_("DSBT addressing not used\n"));
14135 printf (_("DSBT addressing used\n"));
14138 printf ("??? (%d)\n", val
);
14144 val
= read_uleb128 (p
, &len
, end
);
14146 printf (" Tag_ABI_PID: ");
14150 printf (_("Data addressing position-dependent\n"));
14153 printf (_("Data addressing position-independent, GOT near DP\n"));
14156 printf (_("Data addressing position-independent, GOT far from DP\n"));
14159 printf ("??? (%d)\n", val
);
14165 val
= read_uleb128 (p
, &len
, end
);
14167 printf (" Tag_ABI_PIC: ");
14171 printf (_("Code addressing position-dependent\n"));
14174 printf (_("Code addressing position-independent\n"));
14177 printf ("??? (%d)\n", val
);
14182 case Tag_ABI_array_object_alignment
:
14183 val
= read_uleb128 (p
, &len
, end
);
14185 printf (" Tag_ABI_array_object_alignment: ");
14189 printf (_("8-byte\n"));
14192 printf (_("4-byte\n"));
14195 printf (_("16-byte\n"));
14198 printf ("??? (%d)\n", val
);
14203 case Tag_ABI_array_object_align_expected
:
14204 val
= read_uleb128 (p
, &len
, end
);
14206 printf (" Tag_ABI_array_object_align_expected: ");
14210 printf (_("8-byte\n"));
14213 printf (_("4-byte\n"));
14216 printf (_("16-byte\n"));
14219 printf ("??? (%d)\n", val
);
14224 case Tag_ABI_compatibility
:
14226 val
= read_uleb128 (p
, &len
, end
);
14228 printf (" Tag_ABI_compatibility: ");
14229 printf (_("flag = %d, vendor = "), val
);
14232 size_t maxlen
= (end
- p
) - 1;
14234 print_symbol ((int) maxlen
, (const char *) p
);
14235 p
+= strnlen ((char *) p
, maxlen
) + 1;
14239 printf (_("<corrupt>"));
14240 p
= (unsigned char *) end
;
14246 case Tag_ABI_conformance
:
14248 printf (" Tag_ABI_conformance: \"");
14251 size_t maxlen
= (end
- p
) - 1;
14253 print_symbol ((int) maxlen
, (const char *) p
);
14254 p
+= strnlen ((char *) p
, maxlen
) + 1;
14258 printf (_("<corrupt>"));
14259 p
= (unsigned char *) end
;
14266 return display_tag_value (tag
, p
, end
);
14270 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14272 unsigned long addr
= 0;
14273 size_t bytes
= end
- p
;
14280 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14282 printf (" 0x%8.8lx ", addr
);
14284 for (j
= 0; j
< 16; j
++)
14287 printf ("%2.2x", p
[j
]);
14295 for (j
= 0; j
< lbytes
; j
++)
14298 if (k
>= ' ' && k
< 0x7f)
14314 static unsigned char *
14315 display_msp430x_attribute (unsigned char * p
,
14316 const unsigned char * const end
)
14322 tag
= read_uleb128 (p
, & len
, end
);
14327 case OFBA_MSPABI_Tag_ISA
:
14328 val
= read_uleb128 (p
, &len
, end
);
14330 printf (" Tag_ISA: ");
14333 case 0: printf (_("None\n")); break;
14334 case 1: printf (_("MSP430\n")); break;
14335 case 2: printf (_("MSP430X\n")); break;
14336 default: printf ("??? (%d)\n", val
); break;
14340 case OFBA_MSPABI_Tag_Code_Model
:
14341 val
= read_uleb128 (p
, &len
, end
);
14343 printf (" Tag_Code_Model: ");
14346 case 0: printf (_("None\n")); break;
14347 case 1: printf (_("Small\n")); break;
14348 case 2: printf (_("Large\n")); break;
14349 default: printf ("??? (%d)\n", val
); break;
14353 case OFBA_MSPABI_Tag_Data_Model
:
14354 val
= read_uleb128 (p
, &len
, end
);
14356 printf (" Tag_Data_Model: ");
14359 case 0: printf (_("None\n")); break;
14360 case 1: printf (_("Small\n")); break;
14361 case 2: printf (_("Large\n")); break;
14362 case 3: printf (_("Restricted Large\n")); break;
14363 default: printf ("??? (%d)\n", val
); break;
14368 printf (_(" <unknown tag %d>: "), tag
);
14375 size_t maxlen
= (end
- p
) - 1;
14377 print_symbol ((int) maxlen
, (const char *) p
);
14378 p
+= strnlen ((char *) p
, maxlen
) + 1;
14382 printf (_("<corrupt>"));
14383 p
= (unsigned char *) end
;
14389 val
= read_uleb128 (p
, &len
, end
);
14391 printf ("%d (0x%x)\n", val
, val
);
14401 process_attributes (FILE * file
,
14402 const char * public_name
,
14403 unsigned int proc_type
,
14404 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14405 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14407 Elf_Internal_Shdr
* sect
;
14410 /* Find the section header so that we get the size. */
14411 for (i
= 0, sect
= section_headers
;
14412 i
< elf_header
.e_shnum
;
14415 unsigned char * contents
;
14418 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14421 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14422 sect
->sh_size
, _("attributes"));
14423 if (contents
== NULL
)
14427 /* The first character is the version of the attributes.
14428 Currently only version 1, (aka 'A') is recognised here. */
14430 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14433 bfd_vma section_len
;
14435 section_len
= sect
->sh_size
- 1;
14438 while (section_len
> 0)
14441 unsigned int namelen
;
14442 bfd_boolean public_section
;
14443 bfd_boolean gnu_section
;
14445 if (section_len
<= 4)
14447 error (_("Tag section ends prematurely\n"));
14450 attr_len
= byte_get (p
, 4);
14453 if (attr_len
> section_len
)
14455 error (_("Bad attribute length (%u > %u)\n"),
14456 (unsigned) attr_len
, (unsigned) section_len
);
14457 attr_len
= section_len
;
14459 /* PR 17531: file: 001-101425-0.004 */
14460 else if (attr_len
< 5)
14462 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14466 section_len
-= attr_len
;
14469 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14470 if (namelen
== 0 || namelen
>= attr_len
)
14472 error (_("Corrupt attribute section name\n"));
14476 printf (_("Attribute Section: "));
14477 print_symbol (INT_MAX
, (const char *) p
);
14480 if (public_name
&& streq ((char *) p
, public_name
))
14481 public_section
= TRUE
;
14483 public_section
= FALSE
;
14485 if (streq ((char *) p
, "gnu"))
14486 gnu_section
= TRUE
;
14488 gnu_section
= FALSE
;
14491 attr_len
-= namelen
;
14493 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14498 unsigned char * end
;
14500 /* PR binutils/17531: Safe handling of corrupt files. */
14503 error (_("Unused bytes at end of section\n"));
14509 size
= byte_get (p
, 4);
14510 if (size
> attr_len
)
14512 error (_("Bad subsection length (%u > %u)\n"),
14513 (unsigned) size
, (unsigned) attr_len
);
14516 /* PR binutils/17531: Safe handling of corrupt files. */
14519 error (_("Bad subsection length (%u < 6)\n"),
14526 end
= p
+ size
- 1;
14527 assert (end
<= contents
+ sect
->sh_size
);
14533 printf (_("File Attributes\n"));
14536 printf (_("Section Attributes:"));
14539 printf (_("Symbol Attributes:"));
14540 /* Fall through. */
14546 val
= read_uleb128 (p
, &j
, end
);
14550 printf (" %d", val
);
14555 printf (_("Unknown tag: %d\n"), tag
);
14556 public_section
= FALSE
;
14560 if (public_section
&& display_pub_attribute
!= NULL
)
14563 p
= display_pub_attribute (p
, end
);
14566 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14569 p
= display_gnu_attribute (p
,
14570 display_proc_gnu_attribute
,
14576 printf (_(" Unknown attribute:\n"));
14577 display_raw_attribute (p
, end
);
14591 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14592 Print the Address, Access and Initial fields of an entry at VMA ADDR
14593 and return the VMA of the next entry, or -1 if there was a problem.
14594 Does not read from DATA_END or beyond. */
14597 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14598 unsigned char * data_end
)
14601 print_vma (addr
, LONG_HEX
);
14603 if (addr
< pltgot
+ 0xfff0)
14604 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14606 printf ("%10s", "");
14609 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14613 unsigned char * from
= data
+ addr
- pltgot
;
14615 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14617 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14618 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14619 return (bfd_vma
) -1;
14623 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14624 print_vma (entry
, LONG_HEX
);
14627 return addr
+ (is_32bit_elf
? 4 : 8);
14630 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14631 PLTGOT. Print the Address and Initial fields of an entry at VMA
14632 ADDR and return the VMA of the next entry. */
14635 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14638 print_vma (addr
, LONG_HEX
);
14641 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14646 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14647 print_vma (entry
, LONG_HEX
);
14649 return addr
+ (is_32bit_elf
? 4 : 8);
14653 print_mips_ases (unsigned int mask
)
14655 if (mask
& AFL_ASE_DSP
)
14656 fputs ("\n\tDSP ASE", stdout
);
14657 if (mask
& AFL_ASE_DSPR2
)
14658 fputs ("\n\tDSP R2 ASE", stdout
);
14659 if (mask
& AFL_ASE_DSPR3
)
14660 fputs ("\n\tDSP R3 ASE", stdout
);
14661 if (mask
& AFL_ASE_EVA
)
14662 fputs ("\n\tEnhanced VA Scheme", stdout
);
14663 if (mask
& AFL_ASE_MCU
)
14664 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14665 if (mask
& AFL_ASE_MDMX
)
14666 fputs ("\n\tMDMX ASE", stdout
);
14667 if (mask
& AFL_ASE_MIPS3D
)
14668 fputs ("\n\tMIPS-3D ASE", stdout
);
14669 if (mask
& AFL_ASE_MT
)
14670 fputs ("\n\tMT ASE", stdout
);
14671 if (mask
& AFL_ASE_SMARTMIPS
)
14672 fputs ("\n\tSmartMIPS ASE", stdout
);
14673 if (mask
& AFL_ASE_VIRT
)
14674 fputs ("\n\tVZ ASE", stdout
);
14675 if (mask
& AFL_ASE_MSA
)
14676 fputs ("\n\tMSA ASE", stdout
);
14677 if (mask
& AFL_ASE_MIPS16
)
14678 fputs ("\n\tMIPS16 ASE", stdout
);
14679 if (mask
& AFL_ASE_MICROMIPS
)
14680 fputs ("\n\tMICROMIPS ASE", stdout
);
14681 if (mask
& AFL_ASE_XPA
)
14682 fputs ("\n\tXPA ASE", stdout
);
14684 fprintf (stdout
, "\n\t%s", _("None"));
14685 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14686 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14690 print_mips_isa_ext (unsigned int isa_ext
)
14695 fputs (_("None"), stdout
);
14698 fputs ("RMI XLR", stdout
);
14700 case AFL_EXT_OCTEON3
:
14701 fputs ("Cavium Networks Octeon3", stdout
);
14703 case AFL_EXT_OCTEON2
:
14704 fputs ("Cavium Networks Octeon2", stdout
);
14706 case AFL_EXT_OCTEONP
:
14707 fputs ("Cavium Networks OcteonP", stdout
);
14709 case AFL_EXT_LOONGSON_3A
:
14710 fputs ("Loongson 3A", stdout
);
14712 case AFL_EXT_OCTEON
:
14713 fputs ("Cavium Networks Octeon", stdout
);
14716 fputs ("Toshiba R5900", stdout
);
14719 fputs ("MIPS R4650", stdout
);
14722 fputs ("LSI R4010", stdout
);
14725 fputs ("NEC VR4100", stdout
);
14728 fputs ("Toshiba R3900", stdout
);
14730 case AFL_EXT_10000
:
14731 fputs ("MIPS R10000", stdout
);
14734 fputs ("Broadcom SB-1", stdout
);
14737 fputs ("NEC VR4111/VR4181", stdout
);
14740 fputs ("NEC VR4120", stdout
);
14743 fputs ("NEC VR5400", stdout
);
14746 fputs ("NEC VR5500", stdout
);
14748 case AFL_EXT_LOONGSON_2E
:
14749 fputs ("ST Microelectronics Loongson 2E", stdout
);
14751 case AFL_EXT_LOONGSON_2F
:
14752 fputs ("ST Microelectronics Loongson 2F", stdout
);
14755 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14760 get_mips_reg_size (int reg_size
)
14762 return (reg_size
== AFL_REG_NONE
) ? 0
14763 : (reg_size
== AFL_REG_32
) ? 32
14764 : (reg_size
== AFL_REG_64
) ? 64
14765 : (reg_size
== AFL_REG_128
) ? 128
14770 process_mips_specific (FILE * file
)
14772 Elf_Internal_Dyn
* entry
;
14773 Elf_Internal_Shdr
*sect
= NULL
;
14774 size_t liblist_offset
= 0;
14775 size_t liblistno
= 0;
14776 size_t conflictsno
= 0;
14777 size_t options_offset
= 0;
14778 size_t conflicts_offset
= 0;
14779 size_t pltrelsz
= 0;
14781 bfd_vma pltgot
= 0;
14782 bfd_vma mips_pltgot
= 0;
14783 bfd_vma jmprel
= 0;
14784 bfd_vma local_gotno
= 0;
14785 bfd_vma gotsym
= 0;
14786 bfd_vma symtabno
= 0;
14788 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14789 display_mips_gnu_attribute
);
14791 sect
= find_section (".MIPS.abiflags");
14795 Elf_External_ABIFlags_v0
*abiflags_ext
;
14796 Elf_Internal_ABIFlags_v0 abiflags_in
;
14798 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14799 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14802 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14803 sect
->sh_size
, _("MIPS ABI Flags section"));
14806 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14807 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14808 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14809 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14810 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14811 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14812 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14813 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14814 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14815 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14816 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14818 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14819 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14820 if (abiflags_in
.isa_rev
> 1)
14821 printf ("r%d", abiflags_in
.isa_rev
);
14822 printf ("\nGPR size: %d",
14823 get_mips_reg_size (abiflags_in
.gpr_size
));
14824 printf ("\nCPR1 size: %d",
14825 get_mips_reg_size (abiflags_in
.cpr1_size
));
14826 printf ("\nCPR2 size: %d",
14827 get_mips_reg_size (abiflags_in
.cpr2_size
));
14828 fputs ("\nFP ABI: ", stdout
);
14829 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14830 fputs ("ISA Extension: ", stdout
);
14831 print_mips_isa_ext (abiflags_in
.isa_ext
);
14832 fputs ("\nASEs:", stdout
);
14833 print_mips_ases (abiflags_in
.ases
);
14834 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14835 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14836 fputc ('\n', stdout
);
14837 free (abiflags_ext
);
14842 /* We have a lot of special sections. Thanks SGI! */
14843 if (dynamic_section
== NULL
)
14844 /* No information available. */
14847 for (entry
= dynamic_section
;
14848 /* PR 17531 file: 012-50589-0.004. */
14849 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14851 switch (entry
->d_tag
)
14853 case DT_MIPS_LIBLIST
:
14855 = offset_from_vma (file
, entry
->d_un
.d_val
,
14856 liblistno
* sizeof (Elf32_External_Lib
));
14858 case DT_MIPS_LIBLISTNO
:
14859 liblistno
= entry
->d_un
.d_val
;
14861 case DT_MIPS_OPTIONS
:
14862 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14864 case DT_MIPS_CONFLICT
:
14866 = offset_from_vma (file
, entry
->d_un
.d_val
,
14867 conflictsno
* sizeof (Elf32_External_Conflict
));
14869 case DT_MIPS_CONFLICTNO
:
14870 conflictsno
= entry
->d_un
.d_val
;
14873 pltgot
= entry
->d_un
.d_ptr
;
14875 case DT_MIPS_LOCAL_GOTNO
:
14876 local_gotno
= entry
->d_un
.d_val
;
14878 case DT_MIPS_GOTSYM
:
14879 gotsym
= entry
->d_un
.d_val
;
14881 case DT_MIPS_SYMTABNO
:
14882 symtabno
= entry
->d_un
.d_val
;
14884 case DT_MIPS_PLTGOT
:
14885 mips_pltgot
= entry
->d_un
.d_ptr
;
14888 pltrel
= entry
->d_un
.d_val
;
14891 pltrelsz
= entry
->d_un
.d_val
;
14894 jmprel
= entry
->d_un
.d_ptr
;
14900 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14902 Elf32_External_Lib
* elib
;
14905 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14907 sizeof (Elf32_External_Lib
),
14908 _("liblist section data"));
14911 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14912 (unsigned long) liblistno
);
14913 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14916 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14923 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14924 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14925 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14926 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14927 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14929 tmp
= gmtime (&atime
);
14930 snprintf (timebuf
, sizeof (timebuf
),
14931 "%04u-%02u-%02uT%02u:%02u:%02u",
14932 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14933 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14935 printf ("%3lu: ", (unsigned long) cnt
);
14936 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14937 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14939 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14940 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14941 liblist
.l_version
);
14943 if (liblist
.l_flags
== 0)
14947 static const struct
14954 { " EXACT_MATCH", LL_EXACT_MATCH
},
14955 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14956 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14957 { " EXPORTS", LL_EXPORTS
},
14958 { " DELAY_LOAD", LL_DELAY_LOAD
},
14959 { " DELTA", LL_DELTA
}
14961 int flags
= liblist
.l_flags
;
14964 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14965 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14967 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14968 flags
^= l_flags_vals
[fcnt
].bit
;
14971 printf (" %#x", (unsigned int) flags
);
14981 if (options_offset
!= 0)
14983 Elf_External_Options
* eopt
;
14984 Elf_Internal_Options
* iopt
;
14985 Elf_Internal_Options
* option
;
14988 sect
= section_headers
;
14990 /* Find the section header so that we get the size. */
14991 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14992 /* PR 17533 file: 012-277276-0.004. */
14995 error (_("No MIPS_OPTIONS header found\n"));
14999 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15000 sect
->sh_size
, _("options"));
15003 iopt
= (Elf_Internal_Options
*)
15004 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15007 error (_("Out of memory allocating space for MIPS options\n"));
15014 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15016 Elf_External_Options
* eoption
;
15018 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15020 option
->kind
= BYTE_GET (eoption
->kind
);
15021 option
->size
= BYTE_GET (eoption
->size
);
15022 option
->section
= BYTE_GET (eoption
->section
);
15023 option
->info
= BYTE_GET (eoption
->info
);
15025 /* PR 17531: file: ffa0fa3b. */
15026 if (option
->size
< sizeof (* eopt
)
15027 || offset
+ option
->size
> sect
->sh_size
)
15029 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15032 offset
+= option
->size
;
15038 printf (_("\nSection '%s' contains %d entries:\n"),
15039 printable_section_name (sect
), cnt
);
15048 switch (option
->kind
)
15051 /* This shouldn't happen. */
15052 printf (" NULL %d %lx", option
->section
, option
->info
);
15055 printf (" REGINFO ");
15056 if (elf_header
.e_machine
== EM_MIPS
)
15059 Elf32_External_RegInfo
* ereg
;
15060 Elf32_RegInfo reginfo
;
15062 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15063 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15064 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15065 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15066 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15067 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15068 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15070 printf ("GPR %08lx GP 0x%lx\n",
15071 reginfo
.ri_gprmask
,
15072 (unsigned long) reginfo
.ri_gp_value
);
15073 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15074 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15075 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15080 Elf64_External_RegInfo
* ereg
;
15081 Elf64_Internal_RegInfo reginfo
;
15083 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15084 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15085 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15086 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15087 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15088 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15089 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15091 printf ("GPR %08lx GP 0x",
15092 reginfo
.ri_gprmask
);
15093 printf_vma (reginfo
.ri_gp_value
);
15096 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15097 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15098 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15102 case ODK_EXCEPTIONS
:
15103 fputs (" EXCEPTIONS fpe_min(", stdout
);
15104 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15105 fputs (") fpe_max(", stdout
);
15106 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15107 fputs (")", stdout
);
15109 if (option
->info
& OEX_PAGE0
)
15110 fputs (" PAGE0", stdout
);
15111 if (option
->info
& OEX_SMM
)
15112 fputs (" SMM", stdout
);
15113 if (option
->info
& OEX_FPDBUG
)
15114 fputs (" FPDBUG", stdout
);
15115 if (option
->info
& OEX_DISMISS
)
15116 fputs (" DISMISS", stdout
);
15119 fputs (" PAD ", stdout
);
15120 if (option
->info
& OPAD_PREFIX
)
15121 fputs (" PREFIX", stdout
);
15122 if (option
->info
& OPAD_POSTFIX
)
15123 fputs (" POSTFIX", stdout
);
15124 if (option
->info
& OPAD_SYMBOL
)
15125 fputs (" SYMBOL", stdout
);
15128 fputs (" HWPATCH ", stdout
);
15129 if (option
->info
& OHW_R4KEOP
)
15130 fputs (" R4KEOP", stdout
);
15131 if (option
->info
& OHW_R8KPFETCH
)
15132 fputs (" R8KPFETCH", stdout
);
15133 if (option
->info
& OHW_R5KEOP
)
15134 fputs (" R5KEOP", stdout
);
15135 if (option
->info
& OHW_R5KCVTL
)
15136 fputs (" R5KCVTL", stdout
);
15139 fputs (" FILL ", stdout
);
15140 /* XXX Print content of info word? */
15143 fputs (" TAGS ", stdout
);
15144 /* XXX Print content of info word? */
15147 fputs (" HWAND ", stdout
);
15148 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15149 fputs (" R4KEOP_CHECKED", stdout
);
15150 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15151 fputs (" R4KEOP_CLEAN", stdout
);
15154 fputs (" HWOR ", stdout
);
15155 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15156 fputs (" R4KEOP_CHECKED", stdout
);
15157 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15158 fputs (" R4KEOP_CLEAN", stdout
);
15161 printf (" GP_GROUP %#06lx self-contained %#06lx",
15162 option
->info
& OGP_GROUP
,
15163 (option
->info
& OGP_SELF
) >> 16);
15166 printf (" IDENT %#06lx self-contained %#06lx",
15167 option
->info
& OGP_GROUP
,
15168 (option
->info
& OGP_SELF
) >> 16);
15171 /* This shouldn't happen. */
15172 printf (" %3d ??? %d %lx",
15173 option
->kind
, option
->section
, option
->info
);
15177 len
= sizeof (* eopt
);
15178 while (len
< option
->size
)
15180 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15182 if (ISPRINT (datum
))
15183 printf ("%c", datum
);
15185 printf ("\\%03o", datum
);
15188 fputs ("\n", stdout
);
15190 offset
+= option
->size
;
15198 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15200 Elf32_Conflict
* iconf
;
15203 if (dynamic_symbols
== NULL
)
15205 error (_("conflict list found without a dynamic symbol table\n"));
15209 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15212 error (_("Out of memory allocating space for dynamic conflicts\n"));
15218 Elf32_External_Conflict
* econf32
;
15220 econf32
= (Elf32_External_Conflict
*)
15221 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15222 sizeof (* econf32
), _("conflict"));
15226 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15227 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15233 Elf64_External_Conflict
* econf64
;
15235 econf64
= (Elf64_External_Conflict
*)
15236 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15237 sizeof (* econf64
), _("conflict"));
15241 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15242 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15247 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15248 (unsigned long) conflictsno
);
15249 puts (_(" Num: Index Value Name"));
15251 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15253 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15255 if (iconf
[cnt
] >= num_dynamic_syms
)
15256 printf (_("<corrupt symbol index>"));
15259 Elf_Internal_Sym
* psym
;
15261 psym
= & dynamic_symbols
[iconf
[cnt
]];
15262 print_vma (psym
->st_value
, FULL_HEX
);
15264 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15265 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15267 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15275 if (pltgot
!= 0 && local_gotno
!= 0)
15277 bfd_vma ent
, local_end
, global_end
;
15279 unsigned char * data
;
15280 unsigned char * data_end
;
15284 addr_size
= (is_32bit_elf
? 4 : 8);
15285 local_end
= pltgot
+ local_gotno
* addr_size
;
15287 /* PR binutils/17533 file: 012-111227-0.004 */
15288 if (symtabno
< gotsym
)
15290 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15291 (unsigned long) gotsym
, (unsigned long) symtabno
);
15295 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15296 /* PR 17531: file: 54c91a34. */
15297 if (global_end
< local_end
)
15299 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15303 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15304 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15305 global_end
- pltgot
, 1,
15306 _("Global Offset Table data"));
15309 data_end
= data
+ (global_end
- pltgot
);
15311 printf (_("\nPrimary GOT:\n"));
15312 printf (_(" Canonical gp value: "));
15313 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15316 printf (_(" Reserved entries:\n"));
15317 printf (_(" %*s %10s %*s Purpose\n"),
15318 addr_size
* 2, _("Address"), _("Access"),
15319 addr_size
* 2, _("Initial"));
15320 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15321 printf (_(" Lazy resolver\n"));
15322 if (ent
== (bfd_vma
) -1)
15323 goto got_print_fail
;
15325 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15326 >> (addr_size
* 8 - 1)) != 0)
15328 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15329 printf (_(" Module pointer (GNU extension)\n"));
15330 if (ent
== (bfd_vma
) -1)
15331 goto got_print_fail
;
15335 if (ent
< local_end
)
15337 printf (_(" Local entries:\n"));
15338 printf (" %*s %10s %*s\n",
15339 addr_size
* 2, _("Address"), _("Access"),
15340 addr_size
* 2, _("Initial"));
15341 while (ent
< local_end
)
15343 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15345 if (ent
== (bfd_vma
) -1)
15346 goto got_print_fail
;
15351 if (gotsym
< symtabno
)
15355 printf (_(" Global entries:\n"));
15356 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15357 addr_size
* 2, _("Address"),
15359 addr_size
* 2, _("Initial"),
15360 addr_size
* 2, _("Sym.Val."),
15362 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15363 _("Ndx"), _("Name"));
15365 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15367 for (i
= gotsym
; i
< symtabno
; i
++)
15369 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15372 if (dynamic_symbols
== NULL
)
15373 printf (_("<no dynamic symbols>"));
15374 else if (i
< num_dynamic_syms
)
15376 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15378 print_vma (psym
->st_value
, LONG_HEX
);
15379 printf (" %-7s %3s ",
15380 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15381 get_symbol_index_type (psym
->st_shndx
));
15383 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15384 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15386 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15389 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15390 (unsigned long) i
);
15393 if (ent
== (bfd_vma
) -1)
15404 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15407 size_t offset
, rel_offset
;
15408 unsigned long count
, i
;
15409 unsigned char * data
;
15410 int addr_size
, sym_width
;
15411 Elf_Internal_Rela
* rels
;
15413 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15414 if (pltrel
== DT_RELA
)
15416 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15421 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15426 addr_size
= (is_32bit_elf
? 4 : 8);
15427 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15429 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15430 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15431 1, _("Procedure Linkage Table data"));
15435 printf ("\nPLT GOT:\n\n");
15436 printf (_(" Reserved entries:\n"));
15437 printf (_(" %*s %*s Purpose\n"),
15438 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15439 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15440 printf (_(" PLT lazy resolver\n"));
15441 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15442 printf (_(" Module pointer\n"));
15445 printf (_(" Entries:\n"));
15446 printf (" %*s %*s %*s %-7s %3s %s\n",
15447 addr_size
* 2, _("Address"),
15448 addr_size
* 2, _("Initial"),
15449 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15450 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15451 for (i
= 0; i
< count
; i
++)
15453 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15455 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15458 if (idx
>= num_dynamic_syms
)
15459 printf (_("<corrupt symbol index: %lu>"), idx
);
15462 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15464 print_vma (psym
->st_value
, LONG_HEX
);
15465 printf (" %-7s %3s ",
15466 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15467 get_symbol_index_type (psym
->st_shndx
));
15468 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15469 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15471 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15486 process_nds32_specific (FILE * file
)
15488 Elf_Internal_Shdr
*sect
= NULL
;
15490 sect
= find_section (".nds32_e_flags");
15493 unsigned int *flag
;
15495 printf ("\nNDS32 elf flags section:\n");
15496 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15497 sect
->sh_size
, _("NDS32 elf flags section"));
15499 switch ((*flag
) & 0x3)
15502 printf ("(VEC_SIZE):\tNo entry.\n");
15505 printf ("(VEC_SIZE):\t4 bytes\n");
15508 printf ("(VEC_SIZE):\t16 bytes\n");
15511 printf ("(VEC_SIZE):\treserved\n");
15520 process_gnu_liblist (FILE * file
)
15522 Elf_Internal_Shdr
* section
;
15523 Elf_Internal_Shdr
* string_sec
;
15524 Elf32_External_Lib
* elib
;
15526 size_t strtab_size
;
15533 for (i
= 0, section
= section_headers
;
15534 i
< elf_header
.e_shnum
;
15537 switch (section
->sh_type
)
15539 case SHT_GNU_LIBLIST
:
15540 if (section
->sh_link
>= elf_header
.e_shnum
)
15543 elib
= (Elf32_External_Lib
*)
15544 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15545 _("liblist section data"));
15549 string_sec
= section_headers
+ section
->sh_link
;
15551 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15552 string_sec
->sh_size
,
15553 _("liblist string table"));
15555 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15561 strtab_size
= string_sec
->sh_size
;
15563 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15564 printable_section_name (section
),
15565 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15567 puts (_(" Library Time Stamp Checksum Version Flags"));
15569 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15577 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15578 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15579 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15580 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15581 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15583 tmp
= gmtime (&atime
);
15584 snprintf (timebuf
, sizeof (timebuf
),
15585 "%04u-%02u-%02uT%02u:%02u:%02u",
15586 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15587 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15589 printf ("%3lu: ", (unsigned long) cnt
);
15591 printf ("%-20s", liblist
.l_name
< strtab_size
15592 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15594 printf ("%-20.20s", liblist
.l_name
< strtab_size
15595 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15596 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15597 liblist
.l_version
, liblist
.l_flags
);
15608 static const char *
15609 get_note_type (unsigned e_type
)
15611 static char buff
[64];
15613 if (elf_header
.e_type
== ET_CORE
)
15617 return _("NT_AUXV (auxiliary vector)");
15619 return _("NT_PRSTATUS (prstatus structure)");
15621 return _("NT_FPREGSET (floating point registers)");
15623 return _("NT_PRPSINFO (prpsinfo structure)");
15624 case NT_TASKSTRUCT
:
15625 return _("NT_TASKSTRUCT (task structure)");
15627 return _("NT_PRXFPREG (user_xfpregs structure)");
15629 return _("NT_PPC_VMX (ppc Altivec registers)");
15631 return _("NT_PPC_VSX (ppc VSX registers)");
15633 return _("NT_386_TLS (x86 TLS information)");
15634 case NT_386_IOPERM
:
15635 return _("NT_386_IOPERM (x86 I/O permissions)");
15636 case NT_X86_XSTATE
:
15637 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15638 case NT_S390_HIGH_GPRS
:
15639 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15640 case NT_S390_TIMER
:
15641 return _("NT_S390_TIMER (s390 timer register)");
15642 case NT_S390_TODCMP
:
15643 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15644 case NT_S390_TODPREG
:
15645 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15647 return _("NT_S390_CTRS (s390 control registers)");
15648 case NT_S390_PREFIX
:
15649 return _("NT_S390_PREFIX (s390 prefix register)");
15650 case NT_S390_LAST_BREAK
:
15651 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15652 case NT_S390_SYSTEM_CALL
:
15653 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15655 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15656 case NT_S390_VXRS_LOW
:
15657 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15658 case NT_S390_VXRS_HIGH
:
15659 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15661 return _("NT_ARM_VFP (arm VFP registers)");
15663 return _("NT_ARM_TLS (AArch TLS registers)");
15664 case NT_ARM_HW_BREAK
:
15665 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15666 case NT_ARM_HW_WATCH
:
15667 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15669 return _("NT_PSTATUS (pstatus structure)");
15671 return _("NT_FPREGS (floating point registers)");
15673 return _("NT_PSINFO (psinfo structure)");
15675 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15677 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15678 case NT_WIN32PSTATUS
:
15679 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15681 return _("NT_SIGINFO (siginfo_t data)");
15683 return _("NT_FILE (mapped files)");
15691 return _("NT_VERSION (version)");
15693 return _("NT_ARCH (architecture)");
15698 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15703 print_core_note (Elf_Internal_Note
*pnote
)
15705 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15706 bfd_vma count
, page_size
;
15707 unsigned char *descdata
, *filenames
, *descend
;
15709 if (pnote
->type
!= NT_FILE
)
15715 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15716 /* Still "successful". */
15721 if (pnote
->descsz
< 2 * addr_size
)
15723 printf (_(" Malformed note - too short for header\n"));
15727 descdata
= (unsigned char *) pnote
->descdata
;
15728 descend
= descdata
+ pnote
->descsz
;
15730 if (descdata
[pnote
->descsz
- 1] != '\0')
15732 printf (_(" Malformed note - does not end with \\0\n"));
15736 count
= byte_get (descdata
, addr_size
);
15737 descdata
+= addr_size
;
15739 page_size
= byte_get (descdata
, addr_size
);
15740 descdata
+= addr_size
;
15742 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15744 printf (_(" Malformed note - too short for supplied file count\n"));
15748 printf (_(" Page size: "));
15749 print_vma (page_size
, DEC
);
15752 printf (_(" %*s%*s%*s\n"),
15753 (int) (2 + 2 * addr_size
), _("Start"),
15754 (int) (4 + 2 * addr_size
), _("End"),
15755 (int) (4 + 2 * addr_size
), _("Page Offset"));
15756 filenames
= descdata
+ count
* 3 * addr_size
;
15757 while (count
-- > 0)
15759 bfd_vma start
, end
, file_ofs
;
15761 if (filenames
== descend
)
15763 printf (_(" Malformed note - filenames end too early\n"));
15767 start
= byte_get (descdata
, addr_size
);
15768 descdata
+= addr_size
;
15769 end
= byte_get (descdata
, addr_size
);
15770 descdata
+= addr_size
;
15771 file_ofs
= byte_get (descdata
, addr_size
);
15772 descdata
+= addr_size
;
15775 print_vma (start
, FULL_HEX
);
15777 print_vma (end
, FULL_HEX
);
15779 print_vma (file_ofs
, FULL_HEX
);
15780 printf ("\n %s\n", filenames
);
15782 filenames
+= 1 + strlen ((char *) filenames
);
15788 static const char *
15789 get_gnu_elf_note_type (unsigned e_type
)
15791 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15794 case NT_GNU_ABI_TAG
:
15795 return _("NT_GNU_ABI_TAG (ABI version tag)");
15797 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15798 case NT_GNU_BUILD_ID
:
15799 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15800 case NT_GNU_GOLD_VERSION
:
15801 return _("NT_GNU_GOLD_VERSION (gold version)");
15804 static char buff
[64];
15806 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15813 print_gnu_note (Elf_Internal_Note
*pnote
)
15815 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15816 switch (pnote
->type
)
15818 case NT_GNU_BUILD_ID
:
15822 printf (_(" Build ID: "));
15823 for (i
= 0; i
< pnote
->descsz
; ++i
)
15824 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15829 case NT_GNU_ABI_TAG
:
15831 unsigned long os
, major
, minor
, subminor
;
15832 const char *osname
;
15834 /* PR 17531: file: 030-599401-0.004. */
15835 if (pnote
->descsz
< 16)
15837 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15841 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15842 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15843 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15844 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15848 case GNU_ABI_TAG_LINUX
:
15851 case GNU_ABI_TAG_HURD
:
15854 case GNU_ABI_TAG_SOLARIS
:
15855 osname
= "Solaris";
15857 case GNU_ABI_TAG_FREEBSD
:
15858 osname
= "FreeBSD";
15860 case GNU_ABI_TAG_NETBSD
:
15863 case GNU_ABI_TAG_SYLLABLE
:
15864 osname
= "Syllable";
15866 case GNU_ABI_TAG_NACL
:
15870 osname
= "Unknown";
15874 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15875 major
, minor
, subminor
);
15879 case NT_GNU_GOLD_VERSION
:
15883 printf (_(" Version: "));
15884 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15885 printf ("%c", pnote
->descdata
[i
]);
15892 unsigned long num_entries
, mask
;
15894 /* Hardware capabilities information. Word 0 is the number of entries.
15895 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15896 is a series of entries, where each entry is a single byte followed
15897 by a nul terminated string. The byte gives the bit number to test
15898 if enabled in the bitmask. */
15899 printf (_(" Hardware Capabilities: "));
15900 if (pnote
->descsz
< 8)
15902 printf (_("<corrupt GNU_HWCAP>\n"));
15905 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15906 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15907 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15908 /* FIXME: Add code to display the entries... */
15913 /* Handle unrecognised types. An error message should have already been
15914 created by get_gnu_elf_note_type(), so all that we need to do is to
15915 display the data. */
15919 printf (_(" Description data: "));
15920 for (i
= 0; i
< pnote
->descsz
; ++i
)
15921 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15930 static const char *
15931 get_v850_elf_note_type (enum v850_notes n_type
)
15933 static char buff
[64];
15937 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15938 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15939 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15940 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15941 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15942 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15944 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15950 print_v850_note (Elf_Internal_Note
* pnote
)
15954 if (pnote
->descsz
!= 4)
15956 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15960 printf (_("not set\n"));
15964 switch (pnote
->type
)
15966 case V850_NOTE_ALIGNMENT
:
15969 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15970 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15974 case V850_NOTE_DATA_SIZE
:
15977 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15978 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15982 case V850_NOTE_FPU_INFO
:
15985 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15986 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15990 case V850_NOTE_MMU_INFO
:
15991 case V850_NOTE_CACHE_INFO
:
15992 case V850_NOTE_SIMD_INFO
:
15993 if (val
== EF_RH850_SIMD
)
15995 printf (_("yes\n"));
16001 /* An 'unknown note type' message will already have been displayed. */
16005 printf (_("unknown value: %x\n"), val
);
16010 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16012 unsigned int version
;
16014 switch (pnote
->type
)
16016 case NT_NETBSD_IDENT
:
16017 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16018 if ((version
/ 10000) % 100)
16019 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16020 version
, version
/ 100000000, (version
/ 1000000) % 100,
16021 (version
/ 10000) % 100 > 26 ? "Z" : "",
16022 'A' + (version
/ 10000) % 26);
16024 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16025 version
, version
/ 100000000, (version
/ 1000000) % 100,
16026 (version
/ 100) % 100);
16029 case NT_NETBSD_MARCH
:
16030 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16038 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16043 static const char *
16044 get_freebsd_elfcore_note_type (unsigned e_type
)
16048 case NT_FREEBSD_THRMISC
:
16049 return _("NT_THRMISC (thrmisc structure)");
16050 case NT_FREEBSD_PROCSTAT_PROC
:
16051 return _("NT_PROCSTAT_PROC (proc data)");
16052 case NT_FREEBSD_PROCSTAT_FILES
:
16053 return _("NT_PROCSTAT_FILES (files data)");
16054 case NT_FREEBSD_PROCSTAT_VMMAP
:
16055 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16056 case NT_FREEBSD_PROCSTAT_GROUPS
:
16057 return _("NT_PROCSTAT_GROUPS (groups data)");
16058 case NT_FREEBSD_PROCSTAT_UMASK
:
16059 return _("NT_PROCSTAT_UMASK (umask data)");
16060 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16061 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16062 case NT_FREEBSD_PROCSTAT_OSREL
:
16063 return _("NT_PROCSTAT_OSREL (osreldate data)");
16064 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16065 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16066 case NT_FREEBSD_PROCSTAT_AUXV
:
16067 return _("NT_PROCSTAT_AUXV (auxv data)");
16069 return get_note_type (e_type
);
16072 static const char *
16073 get_netbsd_elfcore_note_type (unsigned e_type
)
16075 static char buff
[64];
16077 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16079 /* NetBSD core "procinfo" structure. */
16080 return _("NetBSD procinfo structure");
16083 /* As of Jan 2002 there are no other machine-independent notes
16084 defined for NetBSD core files. If the note type is less
16085 than the start of the machine-dependent note types, we don't
16088 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16090 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16094 switch (elf_header
.e_machine
)
16096 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16097 and PT_GETFPREGS == mach+2. */
16102 case EM_SPARC32PLUS
:
16106 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16107 return _("PT_GETREGS (reg structure)");
16108 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16109 return _("PT_GETFPREGS (fpreg structure)");
16115 /* On all other arch's, PT_GETREGS == mach+1 and
16116 PT_GETFPREGS == mach+3. */
16120 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16121 return _("PT_GETREGS (reg structure)");
16122 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16123 return _("PT_GETFPREGS (fpreg structure)");
16129 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16130 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16134 static const char *
16135 get_stapsdt_note_type (unsigned e_type
)
16137 static char buff
[64];
16142 return _("NT_STAPSDT (SystemTap probe descriptors)");
16148 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16153 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16155 int addr_size
= is_32bit_elf
? 4 : 8;
16156 char *data
= pnote
->descdata
;
16157 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16158 bfd_vma pc
, base_addr
, semaphore
;
16159 char *provider
, *probe
, *arg_fmt
;
16161 pc
= byte_get ((unsigned char *) data
, addr_size
);
16163 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16165 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16169 data
+= strlen (data
) + 1;
16171 data
+= strlen (data
) + 1;
16173 data
+= strlen (data
) + 1;
16175 printf (_(" Provider: %s\n"), provider
);
16176 printf (_(" Name: %s\n"), probe
);
16177 printf (_(" Location: "));
16178 print_vma (pc
, FULL_HEX
);
16179 printf (_(", Base: "));
16180 print_vma (base_addr
, FULL_HEX
);
16181 printf (_(", Semaphore: "));
16182 print_vma (semaphore
, FULL_HEX
);
16184 printf (_(" Arguments: %s\n"), arg_fmt
);
16186 return data
== data_end
;
16189 static const char *
16190 get_ia64_vms_note_type (unsigned e_type
)
16192 static char buff
[64];
16197 return _("NT_VMS_MHD (module header)");
16199 return _("NT_VMS_LNM (language name)");
16201 return _("NT_VMS_SRC (source files)");
16203 return "NT_VMS_TITLE";
16205 return _("NT_VMS_EIDC (consistency check)");
16206 case NT_VMS_FPMODE
:
16207 return _("NT_VMS_FPMODE (FP mode)");
16208 case NT_VMS_LINKTIME
:
16209 return "NT_VMS_LINKTIME";
16210 case NT_VMS_IMGNAM
:
16211 return _("NT_VMS_IMGNAM (image name)");
16213 return _("NT_VMS_IMGID (image id)");
16214 case NT_VMS_LINKID
:
16215 return _("NT_VMS_LINKID (link id)");
16216 case NT_VMS_IMGBID
:
16217 return _("NT_VMS_IMGBID (build id)");
16218 case NT_VMS_GSTNAM
:
16219 return _("NT_VMS_GSTNAM (sym table name)");
16220 case NT_VMS_ORIG_DYN
:
16221 return "NT_VMS_ORIG_DYN";
16222 case NT_VMS_PATCHTIME
:
16223 return "NT_VMS_PATCHTIME";
16225 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16231 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16233 switch (pnote
->type
)
16236 if (pnote
->descsz
> 36)
16238 size_t l
= strlen (pnote
->descdata
+ 34);
16239 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16240 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16241 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16242 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16245 printf (_(" Invalid size\n"));
16248 printf (_(" Language: %s\n"), pnote
->descdata
);
16251 case NT_VMS_FPMODE
:
16252 printf (_(" Floating Point mode: "));
16253 printf ("0x%016" BFD_VMA_FMT
"x\n",
16254 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16256 case NT_VMS_LINKTIME
:
16257 printf (_(" Link time: "));
16259 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16262 case NT_VMS_PATCHTIME
:
16263 printf (_(" Patch time: "));
16265 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16268 case NT_VMS_ORIG_DYN
:
16269 printf (_(" Major id: %u, minor id: %u\n"),
16270 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16271 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16272 printf (_(" Last modified : "));
16274 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16275 printf (_("\n Link flags : "));
16276 printf ("0x%016" BFD_VMA_FMT
"x\n",
16277 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16278 printf (_(" Header flags: 0x%08x\n"),
16279 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16280 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16283 case NT_VMS_IMGNAM
:
16284 printf (_(" Image name: %s\n"), pnote
->descdata
);
16286 case NT_VMS_GSTNAM
:
16287 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16290 printf (_(" Image id: %s\n"), pnote
->descdata
);
16292 case NT_VMS_LINKID
:
16293 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16301 /* Note that by the ELF standard, the name field is already null byte
16302 terminated, and namesz includes the terminating null byte.
16303 I.E. the value of namesz for the name "FSF" is 4.
16305 If the value of namesz is zero, there is no name present. */
16307 process_note (Elf_Internal_Note
* pnote
,
16308 FILE * file ATTRIBUTE_UNUSED
,
16309 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16311 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16314 if (pnote
->namesz
== 0)
16315 /* If there is no note name, then use the default set of
16316 note type strings. */
16317 nt
= get_note_type (pnote
->type
);
16319 else if (const_strneq (pnote
->namedata
, "GNU"))
16320 /* GNU-specific object file notes. */
16321 nt
= get_gnu_elf_note_type (pnote
->type
);
16323 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16324 /* FreeBSD-specific core file notes. */
16325 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16327 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16328 /* NetBSD-specific core file notes. */
16329 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16331 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16332 /* NetBSD-specific core file notes. */
16333 return process_netbsd_elf_note (pnote
);
16335 else if (strneq (pnote
->namedata
, "SPU/", 4))
16337 /* SPU-specific core file notes. */
16338 nt
= pnote
->namedata
+ 4;
16342 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16343 /* VMS/ia64-specific file notes. */
16344 nt
= get_ia64_vms_note_type (pnote
->type
);
16346 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16347 nt
= get_stapsdt_note_type (pnote
->type
);
16350 /* Don't recognize this note name; just use the default set of
16351 note type strings. */
16352 nt
= get_note_type (pnote
->type
);
16355 print_symbol (-20, name
);
16356 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16358 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16359 return print_ia64_vms_note (pnote
);
16360 else if (const_strneq (pnote
->namedata
, "GNU"))
16361 return print_gnu_note (pnote
);
16362 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16363 return print_stapsdt_note (pnote
);
16364 else if (const_strneq (pnote
->namedata
, "CORE"))
16365 return print_core_note (pnote
);
16367 else if (pnote
->descsz
)
16371 printf (_(" description data: "));
16372 for (i
= 0; i
< pnote
->descsz
; i
++)
16373 printf ("%02x ", pnote
->descdata
[i
]);
16381 process_notes_at (FILE * file
,
16382 Elf_Internal_Shdr
* section
,
16386 Elf_External_Note
* pnotes
;
16387 Elf_External_Note
* external
;
16396 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16398 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16401 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16403 if (pnotes
== NULL
)
16409 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16411 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16412 (unsigned long) offset
, (unsigned long) length
);
16414 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16416 end
= (char *) pnotes
+ length
;
16417 while ((char *) external
< end
)
16419 Elf_Internal_Note inote
;
16422 char * temp
= NULL
;
16423 size_t data_remaining
= end
- (char *) external
;
16425 if (!is_ia64_vms ())
16427 /* PR binutils/15191
16428 Make sure that there is enough data to read. */
16429 min_notesz
= offsetof (Elf_External_Note
, name
);
16430 if (data_remaining
< min_notesz
)
16432 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16433 (int) data_remaining
);
16436 inote
.type
= BYTE_GET (external
->type
);
16437 inote
.namesz
= BYTE_GET (external
->namesz
);
16438 inote
.namedata
= external
->name
;
16439 inote
.descsz
= BYTE_GET (external
->descsz
);
16440 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16441 /* PR 17531: file: 3443835e. */
16442 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16444 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16445 inote
.descdata
= inote
.namedata
;
16449 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16450 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16454 Elf64_External_VMS_Note
*vms_external
;
16456 /* PR binutils/15191
16457 Make sure that there is enough data to read. */
16458 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16459 if (data_remaining
< min_notesz
)
16461 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16462 (int) data_remaining
);
16466 vms_external
= (Elf64_External_VMS_Note
*) external
;
16467 inote
.type
= BYTE_GET (vms_external
->type
);
16468 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16469 inote
.namedata
= vms_external
->name
;
16470 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16471 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16472 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16473 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16476 if (inote
.descdata
< (char *) external
+ min_notesz
16477 || next
< (char *) external
+ min_notesz
16478 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16479 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16480 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16481 || data_remaining
< (size_t)(next
- (char *) external
))
16483 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16484 (unsigned long) ((char *) external
- (char *) pnotes
));
16485 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16486 inote
.type
, inote
.namesz
, inote
.descsz
);
16490 external
= (Elf_External_Note
*) next
;
16492 /* Verify that name is null terminated. It appears that at least
16493 one version of Linux (RedHat 6.0) generates corefiles that don't
16494 comply with the ELF spec by failing to include the null byte in
16496 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16498 temp
= (char *) malloc (inote
.namesz
+ 1);
16501 error (_("Out of memory allocating space for inote name\n"));
16506 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16507 temp
[inote
.namesz
] = 0;
16509 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16510 inote
.namedata
= temp
;
16513 res
&= process_note (& inote
, file
, section
);
16528 process_corefile_note_segments (FILE * file
)
16530 Elf_Internal_Phdr
* segment
;
16534 if (! get_program_headers (file
))
16537 for (i
= 0, segment
= program_headers
;
16538 i
< elf_header
.e_phnum
;
16541 if (segment
->p_type
== PT_NOTE
)
16542 res
&= process_notes_at (file
, NULL
,
16543 (bfd_vma
) segment
->p_offset
,
16544 (bfd_vma
) segment
->p_filesz
);
16551 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16553 Elf_External_Note
* pnotes
;
16554 Elf_External_Note
* external
;
16561 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16563 if (pnotes
== NULL
)
16567 end
= (char*) pnotes
+ length
;
16569 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16570 (unsigned long) offset
, (unsigned long) length
);
16572 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16574 Elf_External_Note
* next
;
16575 Elf_Internal_Note inote
;
16577 inote
.type
= BYTE_GET (external
->type
);
16578 inote
.namesz
= BYTE_GET (external
->namesz
);
16579 inote
.namedata
= external
->name
;
16580 inote
.descsz
= BYTE_GET (external
->descsz
);
16581 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16582 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16584 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16586 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16587 inote
.descdata
= inote
.namedata
;
16591 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16593 if ( ((char *) next
> end
)
16594 || ((char *) next
< (char *) pnotes
))
16596 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16597 (unsigned long) ((char *) external
- (char *) pnotes
));
16598 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16599 inote
.type
, inote
.namesz
, inote
.descsz
);
16605 /* Prevent out-of-bounds indexing. */
16606 if ( inote
.namedata
+ inote
.namesz
> end
16607 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16609 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16610 (unsigned long) ((char *) external
- (char *) pnotes
));
16611 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16612 inote
.type
, inote
.namesz
, inote
.descsz
);
16616 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16618 if (! print_v850_note (& inote
))
16621 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16622 inote
.namesz
, inote
.descsz
);
16632 process_note_sections (FILE * file
)
16634 Elf_Internal_Shdr
* section
;
16639 for (i
= 0, section
= section_headers
;
16640 i
< elf_header
.e_shnum
&& section
!= NULL
;
16643 if (section
->sh_type
== SHT_NOTE
)
16645 res
&= process_notes_at (file
, section
,
16646 (bfd_vma
) section
->sh_offset
,
16647 (bfd_vma
) section
->sh_size
);
16651 if (( elf_header
.e_machine
== EM_V800
16652 || elf_header
.e_machine
== EM_V850
16653 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16654 && section
->sh_type
== SHT_RENESAS_INFO
)
16656 res
&= process_v850_notes (file
,
16657 (bfd_vma
) section
->sh_offset
,
16658 (bfd_vma
) section
->sh_size
);
16664 /* Try processing NOTE segments instead. */
16665 return process_corefile_note_segments (file
);
16671 process_notes (FILE * file
)
16673 /* If we have not been asked to display the notes then do nothing. */
16677 if (elf_header
.e_type
!= ET_CORE
)
16678 return process_note_sections (file
);
16680 /* No program headers means no NOTE segment. */
16681 if (elf_header
.e_phnum
> 0)
16682 return process_corefile_note_segments (file
);
16684 printf (_("No note segments present in the core file.\n"));
16688 static unsigned char *
16689 display_public_gnu_attributes (unsigned char * start
,
16690 const unsigned char * const end
)
16692 printf (_(" Unknown GNU attribute: %s\n"), start
);
16694 start
+= strnlen ((char *) start
, end
- start
);
16695 display_raw_attribute (start
, end
);
16697 return (unsigned char *) end
;
16700 static unsigned char *
16701 display_generic_attribute (unsigned char * start
,
16703 const unsigned char * const end
)
16706 return (unsigned char *) end
;
16708 return display_tag_value (tag
, start
, end
);
16712 process_arch_specific (FILE * file
)
16717 switch (elf_header
.e_machine
)
16720 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
16721 display_arm_attribute
,
16722 display_generic_attribute
);
16725 case EM_MIPS_RS3_LE
:
16726 return process_mips_specific (file
);
16729 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
16730 display_msp430x_attribute
,
16731 display_generic_attribute
);
16734 return process_nds32_specific (file
);
16738 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16739 display_power_gnu_attribute
);
16743 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16744 display_s390_gnu_attribute
);
16747 case EM_SPARC32PLUS
:
16749 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16750 display_sparc_gnu_attribute
);
16753 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
16754 display_tic6x_attribute
,
16755 display_generic_attribute
);
16758 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
16759 display_public_gnu_attributes
,
16760 display_generic_attribute
);
16765 get_file_header (FILE * file
)
16767 /* Read in the identity array. */
16768 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16771 /* Determine how to read the rest of the header. */
16772 switch (elf_header
.e_ident
[EI_DATA
])
16777 byte_get
= byte_get_little_endian
;
16778 byte_put
= byte_put_little_endian
;
16781 byte_get
= byte_get_big_endian
;
16782 byte_put
= byte_put_big_endian
;
16786 /* For now we only support 32 bit and 64 bit ELF files. */
16787 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16789 /* Read in the rest of the header. */
16792 Elf32_External_Ehdr ehdr32
;
16794 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16797 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16798 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16799 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16800 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16801 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16802 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16803 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16804 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16805 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16806 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16807 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16808 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16809 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16813 Elf64_External_Ehdr ehdr64
;
16815 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16816 we will not be able to cope with the 64bit data found in
16817 64 ELF files. Detect this now and abort before we start
16818 overwriting things. */
16819 if (sizeof (bfd_vma
) < 8)
16821 error (_("This instance of readelf has been built without support for a\n\
16822 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16826 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16829 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16830 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16831 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16832 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16833 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16834 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16835 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16836 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16837 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16838 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16839 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16840 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16841 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16844 if (elf_header
.e_shoff
)
16846 /* There may be some extensions in the first section header. Don't
16847 bomb if we can't read it. */
16849 get_32bit_section_headers (file
, TRUE
);
16851 get_64bit_section_headers (file
, TRUE
);
16857 /* Process one ELF object file according to the command line options.
16858 This file may actually be stored in an archive. The file is
16859 positioned at the start of the ELF object. */
16862 process_object (char * file_name
, FILE * file
)
16866 if (! get_file_header (file
))
16868 error (_("%s: Failed to read file header\n"), file_name
);
16872 /* Initialise per file variables. */
16873 for (i
= ARRAY_SIZE (version_info
); i
--;)
16874 version_info
[i
] = 0;
16876 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16877 dynamic_info
[i
] = 0;
16878 dynamic_info_DT_GNU_HASH
= 0;
16880 /* Process the file. */
16882 printf (_("\nFile: %s\n"), file_name
);
16884 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16885 Note we do this even if cmdline_dump_sects is empty because we
16886 must make sure that the dump_sets array is zeroed out before each
16887 object file is processed. */
16888 if (num_dump_sects
> num_cmdline_dump_sects
)
16889 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16891 if (num_cmdline_dump_sects
> 0)
16893 if (num_dump_sects
== 0)
16894 /* A sneaky way of allocating the dump_sects array. */
16895 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16897 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16898 memcpy (dump_sects
, cmdline_dump_sects
,
16899 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16902 if (! process_file_header ())
16905 if (! process_section_headers (file
))
16907 /* Without loaded section headers we cannot process lots of
16909 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16911 if (! do_using_dynamic
)
16912 do_syms
= do_dyn_syms
= do_reloc
= 0;
16915 if (! process_section_groups (file
))
16917 /* Without loaded section groups we cannot process unwind. */
16921 if (process_program_headers (file
))
16922 process_dynamic_section (file
);
16924 process_relocs (file
);
16926 process_unwind (file
);
16928 process_symbol_table (file
);
16930 process_syminfo (file
);
16932 process_version_sections (file
);
16934 process_section_contents (file
);
16936 process_notes (file
);
16938 process_gnu_liblist (file
);
16940 process_arch_specific (file
);
16942 if (program_headers
)
16944 free (program_headers
);
16945 program_headers
= NULL
;
16948 if (section_headers
)
16950 free (section_headers
);
16951 section_headers
= NULL
;
16956 free (string_table
);
16957 string_table
= NULL
;
16958 string_table_length
= 0;
16961 if (dynamic_strings
)
16963 free (dynamic_strings
);
16964 dynamic_strings
= NULL
;
16965 dynamic_strings_length
= 0;
16968 if (dynamic_symbols
)
16970 free (dynamic_symbols
);
16971 dynamic_symbols
= NULL
;
16972 num_dynamic_syms
= 0;
16975 if (dynamic_syminfo
)
16977 free (dynamic_syminfo
);
16978 dynamic_syminfo
= NULL
;
16981 if (dynamic_section
)
16983 free (dynamic_section
);
16984 dynamic_section
= NULL
;
16987 if (section_headers_groups
)
16989 free (section_headers_groups
);
16990 section_headers_groups
= NULL
;
16993 if (section_groups
)
16995 struct group_list
* g
;
16996 struct group_list
* next
;
16998 for (i
= 0; i
< group_count
; i
++)
17000 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17007 free (section_groups
);
17008 section_groups
= NULL
;
17011 free_debug_memory ();
17016 /* Process an ELF archive.
17017 On entry the file is positioned just after the ARMAG string. */
17020 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17022 struct archive_info arch
;
17023 struct archive_info nested_arch
;
17029 /* The ARCH structure is used to hold information about this archive. */
17030 arch
.file_name
= NULL
;
17032 arch
.index_array
= NULL
;
17033 arch
.sym_table
= NULL
;
17034 arch
.longnames
= NULL
;
17036 /* The NESTED_ARCH structure is used as a single-item cache of information
17037 about a nested archive (when members of a thin archive reside within
17038 another regular archive file). */
17039 nested_arch
.file_name
= NULL
;
17040 nested_arch
.file
= NULL
;
17041 nested_arch
.index_array
= NULL
;
17042 nested_arch
.sym_table
= NULL
;
17043 nested_arch
.longnames
= NULL
;
17045 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17051 if (do_archive_index
)
17053 if (arch
.sym_table
== NULL
)
17054 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17057 unsigned long i
, l
;
17058 unsigned long current_pos
;
17060 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17061 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17062 current_pos
= ftell (file
);
17064 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17066 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17068 char * member_name
;
17070 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17072 if (member_name
!= NULL
)
17074 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17076 if (qualified_name
!= NULL
)
17078 printf (_("Contents of binary %s at offset "), qualified_name
);
17079 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17081 free (qualified_name
);
17086 if (l
>= arch
.sym_size
)
17088 error (_("%s: end of the symbol table reached before the end of the index\n"),
17092 /* PR 17531: file: 0b6630b2. */
17093 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17094 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17097 if (arch
.uses_64bit_indicies
)
17102 if (l
< arch
.sym_size
)
17103 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17104 file_name
, arch
.sym_size
- l
);
17106 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17108 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17114 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17115 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17116 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17117 && !do_section_groups
&& !do_dyn_syms
)
17119 ret
= 0; /* Archive index only. */
17130 char * qualified_name
;
17132 /* Read the next archive header. */
17133 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17135 error (_("%s: failed to seek to next archive header\n"), file_name
);
17138 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17139 if (got
!= sizeof arch
.arhdr
)
17143 error (_("%s: failed to read archive header\n"), file_name
);
17147 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17149 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17154 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17156 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17157 if (archive_file_size
& 01)
17158 ++archive_file_size
;
17160 name
= get_archive_member_name (&arch
, &nested_arch
);
17163 error (_("%s: bad archive file name\n"), file_name
);
17167 namelen
= strlen (name
);
17169 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17170 if (qualified_name
== NULL
)
17172 error (_("%s: bad archive file name\n"), file_name
);
17177 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17179 /* This is a proxy for an external member of a thin archive. */
17180 FILE * member_file
;
17181 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17182 if (member_file_name
== NULL
)
17188 member_file
= fopen (member_file_name
, "rb");
17189 if (member_file
== NULL
)
17191 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17192 free (member_file_name
);
17197 archive_file_offset
= arch
.nested_member_origin
;
17199 ret
|= process_object (qualified_name
, member_file
);
17201 fclose (member_file
);
17202 free (member_file_name
);
17204 else if (is_thin_archive
)
17206 /* PR 15140: Allow for corrupt thin archives. */
17207 if (nested_arch
.file
== NULL
)
17209 error (_("%s: contains corrupt thin archive: %s\n"),
17215 /* This is a proxy for a member of a nested archive. */
17216 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17218 /* The nested archive file will have been opened and setup by
17219 get_archive_member_name. */
17220 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17222 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17227 ret
|= process_object (qualified_name
, nested_arch
.file
);
17231 archive_file_offset
= arch
.next_arhdr_offset
;
17232 arch
.next_arhdr_offset
+= archive_file_size
;
17234 ret
|= process_object (qualified_name
, file
);
17237 if (dump_sects
!= NULL
)
17241 num_dump_sects
= 0;
17244 free (qualified_name
);
17248 if (nested_arch
.file
!= NULL
)
17249 fclose (nested_arch
.file
);
17250 release_archive (&nested_arch
);
17251 release_archive (&arch
);
17257 process_file (char * file_name
)
17260 struct stat statbuf
;
17261 char armag
[SARMAG
];
17264 if (stat (file_name
, &statbuf
) < 0)
17266 if (errno
== ENOENT
)
17267 error (_("'%s': No such file\n"), file_name
);
17269 error (_("Could not locate '%s'. System error message: %s\n"),
17270 file_name
, strerror (errno
));
17274 if (! S_ISREG (statbuf
.st_mode
))
17276 error (_("'%s' is not an ordinary file\n"), file_name
);
17280 file
= fopen (file_name
, "rb");
17283 error (_("Input file '%s' is not readable.\n"), file_name
);
17287 if (fread (armag
, SARMAG
, 1, file
) != 1)
17289 error (_("%s: Failed to read file's magic number\n"), file_name
);
17294 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17296 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17297 ret
= process_archive (file_name
, file
, FALSE
);
17298 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17299 ret
= process_archive (file_name
, file
, TRUE
);
17302 if (do_archive_index
)
17303 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17307 archive_file_size
= archive_file_offset
= 0;
17308 ret
= process_object (file_name
, file
);
17313 current_file_size
= 0;
17317 #ifdef SUPPORT_DISASSEMBLY
17318 /* Needed by the i386 disassembler. For extra credit, someone could
17319 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17323 print_address (unsigned int addr
, FILE * outfile
)
17325 fprintf (outfile
,"0x%8.8x", addr
);
17328 /* Needed by the i386 disassembler. */
17330 db_task_printsym (unsigned int addr
)
17332 print_address (addr
, stderr
);
17337 main (int argc
, char ** argv
)
17341 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17342 setlocale (LC_MESSAGES
, "");
17344 #if defined (HAVE_SETLOCALE)
17345 setlocale (LC_CTYPE
, "");
17347 bindtextdomain (PACKAGE
, LOCALEDIR
);
17348 textdomain (PACKAGE
);
17350 expandargv (&argc
, &argv
);
17352 parse_args (argc
, argv
);
17354 if (num_dump_sects
> 0)
17356 /* Make a copy of the dump_sects array. */
17357 cmdline_dump_sects
= (dump_type
*)
17358 malloc (num_dump_sects
* sizeof (* dump_sects
));
17359 if (cmdline_dump_sects
== NULL
)
17360 error (_("Out of memory allocating dump request table.\n"));
17363 memcpy (cmdline_dump_sects
, dump_sects
,
17364 num_dump_sects
* sizeof (* dump_sects
));
17365 num_cmdline_dump_sects
= num_dump_sects
;
17369 if (optind
< (argc
- 1))
17371 else if (optind
>= argc
)
17373 warn (_("Nothing to do.\n"));
17378 while (optind
< argc
)
17379 err
|= process_file (argv
[optind
++]);
17381 if (dump_sects
!= NULL
)
17383 if (cmdline_dump_sects
!= NULL
)
17384 free (cmdline_dump_sects
);