1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 typedef struct elf_section_list
171 Elf_Internal_Shdr
* hdr
;
172 struct elf_section_list
* next
;
175 char * program_name
= "readelf";
176 static unsigned long archive_file_offset
;
177 static unsigned long archive_file_size
;
178 static bfd_size_type current_file_size
;
179 static unsigned long dynamic_addr
;
180 static bfd_size_type dynamic_size
;
181 static size_t dynamic_nent
;
182 static char * dynamic_strings
;
183 static unsigned long dynamic_strings_length
;
184 static char * string_table
;
185 static unsigned long string_table_length
;
186 static unsigned long num_dynamic_syms
;
187 static Elf_Internal_Sym
* dynamic_symbols
;
188 static Elf_Internal_Syminfo
* dynamic_syminfo
;
189 static unsigned long dynamic_syminfo_offset
;
190 static unsigned int dynamic_syminfo_nent
;
191 static char program_interpreter
[PATH_MAX
];
192 static bfd_vma dynamic_info
[DT_ENCODING
];
193 static bfd_vma dynamic_info_DT_GNU_HASH
;
194 static bfd_vma version_info
[16];
195 static Elf_Internal_Ehdr elf_header
;
196 static Elf_Internal_Shdr
* section_headers
;
197 static Elf_Internal_Phdr
* program_headers
;
198 static Elf_Internal_Dyn
* dynamic_section
;
199 static elf_section_list
* symtab_shndx_list
;
200 static int show_name
;
201 static int do_dynamic
;
203 static int do_dyn_syms
;
205 static int do_sections
;
206 static int do_section_groups
;
207 static int do_section_details
;
208 static int do_segments
;
209 static int do_unwind
;
210 static int do_using_dynamic
;
211 static int do_header
;
213 static int do_version
;
214 static int do_histogram
;
215 static int do_debugging
;
218 static int do_archive_index
;
219 static int is_32bit_elf
;
220 static int decompress_dumps
;
224 struct group_list
* next
;
225 unsigned int section_index
;
230 struct group_list
* root
;
231 unsigned int group_index
;
234 static size_t group_count
;
235 static struct group
* section_groups
;
236 static struct group
** section_headers_groups
;
239 /* Flag bits indicating particular types of dump. */
240 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
241 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
244 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
246 typedef unsigned char dump_type
;
248 /* A linked list of the section names for which dumps were requested. */
249 struct dump_list_entry
253 struct dump_list_entry
* next
;
255 static struct dump_list_entry
* dump_sects_byname
;
257 /* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259 static dump_type
* cmdline_dump_sects
= NULL
;
260 static unsigned int num_cmdline_dump_sects
= 0;
262 /* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
267 static dump_type
* dump_sects
= NULL
;
268 static unsigned int num_dump_sects
= 0;
271 /* How to print a vma value. */
272 typedef enum print_mode
284 /* Versioned symbol info. */
285 enum versioned_symbol_info
292 static const char *get_symbol_version_string
293 (FILE *file
, int is_dynsym
, const char *strtab
,
294 unsigned long int strtab_size
, unsigned int si
,
295 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
296 unsigned short *vna_other
);
300 #define SECTION_NAME(X) \
301 ((X) == NULL ? _("<none>") \
302 : string_table == NULL ? _("<no-name>") \
303 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
304 : string_table + (X)->sh_name))
306 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
308 #define GET_ELF_SYMBOLS(file, section, sym_count) \
309 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
310 : get_64bit_elf_symbols (file, section, sym_count))
312 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
313 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
314 already been called and verified that the string exists. */
315 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
317 #define REMOVE_ARCH_BITS(ADDR) \
320 if (elf_header.e_machine == EM_ARM) \
325 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
326 the offset of the current archive member, if we are examining an archive.
327 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
328 using malloc and fill that. In either case return the pointer to the start of
329 the retrieved data or NULL if something went wrong. If something does go wrong
330 and REASON is not NULL then emit an error message using REASON as part of the
334 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
335 bfd_size_type nmemb
, const char * reason
)
338 bfd_size_type amt
= size
* nmemb
;
340 if (size
== 0 || nmemb
== 0)
343 /* If the size_t type is smaller than the bfd_size_type, eg because
344 you are building a 32-bit tool on a 64-bit host, then make sure
345 that when the sizes are cast to (size_t) no information is lost. */
346 if (sizeof (size_t) < sizeof (bfd_size_type
)
347 && ( (bfd_size_type
) ((size_t) size
) != size
348 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
351 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
352 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
353 nmemb
, size
, reason
);
357 /* Check for size overflow. */
361 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
362 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
363 nmemb
, size
, reason
);
367 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
368 attempting to allocate memory when the read is bound to fail. */
369 if (amt
> current_file_size
370 || offset
+ archive_file_offset
+ amt
> current_file_size
)
373 error (_("Reading 0x%" BFD_VMA_FMT
"x"
374 " bytes extends past end of file for %s\n"),
379 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
382 error (_("Unable to seek to 0x%lx for %s\n"),
383 archive_file_offset
+ offset
, reason
);
390 /* Check for overflow. */
391 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
392 /* + 1 so that we can '\0' terminate invalid string table sections. */
393 mvar
= malloc ((size_t) amt
+ 1);
398 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
404 ((char *) mvar
)[amt
] = '\0';
407 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
410 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
420 /* Print a VMA value. */
423 print_vma (bfd_vma vma
, print_mode mode
)
436 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
443 return printf ("%5" BFD_VMA_FMT
"d", vma
);
451 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
454 return printf ("%" BFD_VMA_FMT
"d", vma
);
457 return printf ("%" BFD_VMA_FMT
"u", vma
);
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
477 #ifdef HAVE_MBSTATE_T
484 /* Keep the width positive. This also helps. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
695 static inline unsigned long
696 read_uleb128 (unsigned char *data
,
697 unsigned int *length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
833 warn (_("Don't know about relocations on this machine architecture\n"));
839 slurp_rela_relocs (FILE * file
,
840 unsigned long rel_offset
,
841 unsigned long rel_size
,
842 Elf_Internal_Rela
** relasp
,
843 unsigned long * nrelasp
)
845 Elf_Internal_Rela
* relas
;
851 Elf32_External_Rela
* erelas
;
853 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
854 rel_size
, _("32-bit relocation data"));
858 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
860 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
861 sizeof (Elf_Internal_Rela
));
866 error (_("out of memory parsing relocs\n"));
870 for (i
= 0; i
< nrelas
; i
++)
872 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
873 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
874 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
881 Elf64_External_Rela
* erelas
;
883 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
884 rel_size
, _("64-bit relocation data"));
888 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
890 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
891 sizeof (Elf_Internal_Rela
));
896 error (_("out of memory parsing relocs\n"));
900 for (i
= 0; i
< nrelas
; i
++)
902 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
903 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
904 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
906 /* The #ifdef BFD64 below is to prevent a compile time
907 warning. We know that if we do not have a 64 bit data
908 type that we will never execute this code anyway. */
910 if (elf_header
.e_machine
== EM_MIPS
911 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
913 /* In little-endian objects, r_info isn't really a
914 64-bit little-endian value: it has a 32-bit
915 little-endian symbol index followed by four
916 individual byte fields. Reorder INFO
918 bfd_vma inf
= relas
[i
].r_info
;
919 inf
= (((inf
& 0xffffffff) << 32)
920 | ((inf
>> 56) & 0xff)
921 | ((inf
>> 40) & 0xff00)
922 | ((inf
>> 24) & 0xff0000)
923 | ((inf
>> 8) & 0xff000000));
924 relas
[i
].r_info
= inf
;
937 slurp_rel_relocs (FILE * file
,
938 unsigned long rel_offset
,
939 unsigned long rel_size
,
940 Elf_Internal_Rela
** relsp
,
941 unsigned long * nrelsp
)
943 Elf_Internal_Rela
* rels
;
949 Elf32_External_Rel
* erels
;
951 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
952 rel_size
, _("32-bit relocation data"));
956 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
958 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
963 error (_("out of memory parsing relocs\n"));
967 for (i
= 0; i
< nrels
; i
++)
969 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
970 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
971 rels
[i
].r_addend
= 0;
978 Elf64_External_Rel
* erels
;
980 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
981 rel_size
, _("64-bit relocation data"));
985 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
987 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
992 error (_("out of memory parsing relocs\n"));
996 for (i
= 0; i
< nrels
; i
++)
998 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
999 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1000 rels
[i
].r_addend
= 0;
1002 /* The #ifdef BFD64 below is to prevent a compile time
1003 warning. We know that if we do not have a 64 bit data
1004 type that we will never execute this code anyway. */
1006 if (elf_header
.e_machine
== EM_MIPS
1007 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1009 /* In little-endian objects, r_info isn't really a
1010 64-bit little-endian value: it has a 32-bit
1011 little-endian symbol index followed by four
1012 individual byte fields. Reorder INFO
1014 bfd_vma inf
= rels
[i
].r_info
;
1015 inf
= (((inf
& 0xffffffff) << 32)
1016 | ((inf
>> 56) & 0xff)
1017 | ((inf
>> 40) & 0xff00)
1018 | ((inf
>> 24) & 0xff0000)
1019 | ((inf
>> 8) & 0xff000000));
1020 rels
[i
].r_info
= inf
;
1032 /* Returns the reloc type extracted from the reloc info field. */
1035 get_reloc_type (bfd_vma reloc_info
)
1038 return ELF32_R_TYPE (reloc_info
);
1040 switch (elf_header
.e_machine
)
1043 /* Note: We assume that reloc_info has already been adjusted for us. */
1044 return ELF64_MIPS_R_TYPE (reloc_info
);
1047 return ELF64_R_TYPE_ID (reloc_info
);
1050 return ELF64_R_TYPE (reloc_info
);
1054 /* Return the symbol index extracted from the reloc info field. */
1057 get_reloc_symindex (bfd_vma reloc_info
)
1059 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1062 static inline bfd_boolean
1063 uses_msp430x_relocs (void)
1066 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1067 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1068 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1069 /* TI compiler uses ELFOSABI_NONE. */
1070 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1073 /* Display the contents of the relocation data found at the specified
1077 dump_relocations (FILE * file
,
1078 unsigned long rel_offset
,
1079 unsigned long rel_size
,
1080 Elf_Internal_Sym
* symtab
,
1081 unsigned long nsyms
,
1083 unsigned long strtablen
,
1088 Elf_Internal_Rela
* rels
;
1090 if (is_rela
== UNKNOWN
)
1091 is_rela
= guess_is_rela (elf_header
.e_machine
);
1095 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1100 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1109 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1111 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1116 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1118 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1126 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1128 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1133 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1135 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1139 for (i
= 0; i
< rel_size
; i
++)
1144 bfd_vma symtab_index
;
1147 offset
= rels
[i
].r_offset
;
1148 inf
= rels
[i
].r_info
;
1150 type
= get_reloc_type (inf
);
1151 symtab_index
= get_reloc_symindex (inf
);
1155 printf ("%8.8lx %8.8lx ",
1156 (unsigned long) offset
& 0xffffffff,
1157 (unsigned long) inf
& 0xffffffff);
1161 #if BFD_HOST_64BIT_LONG
1163 ? "%16.16lx %16.16lx "
1164 : "%12.12lx %12.12lx ",
1166 #elif BFD_HOST_64BIT_LONG_LONG
1169 ? "%16.16llx %16.16llx "
1170 : "%12.12llx %12.12llx ",
1174 ? "%16.16I64x %16.16I64x "
1175 : "%12.12I64x %12.12I64x ",
1180 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1181 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1182 _bfd_int64_high (offset
),
1183 _bfd_int64_low (offset
),
1184 _bfd_int64_high (inf
),
1185 _bfd_int64_low (inf
));
1189 switch (elf_header
.e_machine
)
1196 rtype
= elf_aarch64_reloc_type (type
);
1200 case EM_CYGNUS_M32R
:
1201 rtype
= elf_m32r_reloc_type (type
);
1206 rtype
= elf_i386_reloc_type (type
);
1211 rtype
= elf_m68hc11_reloc_type (type
);
1215 rtype
= elf_m68k_reloc_type (type
);
1219 rtype
= elf_i960_reloc_type (type
);
1224 rtype
= elf_avr_reloc_type (type
);
1227 case EM_OLD_SPARCV9
:
1228 case EM_SPARC32PLUS
:
1231 rtype
= elf_sparc_reloc_type (type
);
1235 rtype
= elf_spu_reloc_type (type
);
1239 rtype
= v800_reloc_type (type
);
1242 case EM_CYGNUS_V850
:
1243 rtype
= v850_reloc_type (type
);
1247 case EM_CYGNUS_D10V
:
1248 rtype
= elf_d10v_reloc_type (type
);
1252 case EM_CYGNUS_D30V
:
1253 rtype
= elf_d30v_reloc_type (type
);
1257 rtype
= elf_dlx_reloc_type (type
);
1261 rtype
= elf_sh_reloc_type (type
);
1265 case EM_CYGNUS_MN10300
:
1266 rtype
= elf_mn10300_reloc_type (type
);
1270 case EM_CYGNUS_MN10200
:
1271 rtype
= elf_mn10200_reloc_type (type
);
1275 case EM_CYGNUS_FR30
:
1276 rtype
= elf_fr30_reloc_type (type
);
1280 rtype
= elf_frv_reloc_type (type
);
1284 rtype
= elf_ft32_reloc_type (type
);
1288 rtype
= elf_mcore_reloc_type (type
);
1292 rtype
= elf_mmix_reloc_type (type
);
1296 rtype
= elf_moxie_reloc_type (type
);
1300 if (uses_msp430x_relocs ())
1302 rtype
= elf_msp430x_reloc_type (type
);
1307 rtype
= elf_msp430_reloc_type (type
);
1311 rtype
= elf_nds32_reloc_type (type
);
1315 rtype
= elf_ppc_reloc_type (type
);
1319 rtype
= elf_ppc64_reloc_type (type
);
1323 case EM_MIPS_RS3_LE
:
1324 rtype
= elf_mips_reloc_type (type
);
1328 rtype
= elf_riscv_reloc_type (type
);
1332 rtype
= elf_alpha_reloc_type (type
);
1336 rtype
= elf_arm_reloc_type (type
);
1340 case EM_ARC_COMPACT
:
1341 case EM_ARC_COMPACT2
:
1342 rtype
= elf_arc_reloc_type (type
);
1346 rtype
= elf_hppa_reloc_type (type
);
1352 rtype
= elf_h8_reloc_type (type
);
1356 rtype
= elf_or1k_reloc_type (type
);
1361 rtype
= elf_pj_reloc_type (type
);
1364 rtype
= elf_ia64_reloc_type (type
);
1368 rtype
= elf_cris_reloc_type (type
);
1372 rtype
= elf_i860_reloc_type (type
);
1378 rtype
= elf_x86_64_reloc_type (type
);
1382 rtype
= i370_reloc_type (type
);
1387 rtype
= elf_s390_reloc_type (type
);
1391 rtype
= elf_score_reloc_type (type
);
1395 rtype
= elf_xstormy16_reloc_type (type
);
1399 rtype
= elf_crx_reloc_type (type
);
1403 rtype
= elf_vax_reloc_type (type
);
1407 rtype
= elf_visium_reloc_type (type
);
1410 case EM_ADAPTEVA_EPIPHANY
:
1411 rtype
= elf_epiphany_reloc_type (type
);
1416 rtype
= elf_ip2k_reloc_type (type
);
1420 rtype
= elf_iq2000_reloc_type (type
);
1425 rtype
= elf_xtensa_reloc_type (type
);
1428 case EM_LATTICEMICO32
:
1429 rtype
= elf_lm32_reloc_type (type
);
1434 rtype
= elf_m32c_reloc_type (type
);
1438 rtype
= elf_mt_reloc_type (type
);
1442 rtype
= elf_bfin_reloc_type (type
);
1446 rtype
= elf_mep_reloc_type (type
);
1450 rtype
= elf_cr16_reloc_type (type
);
1454 case EM_MICROBLAZE_OLD
:
1455 rtype
= elf_microblaze_reloc_type (type
);
1459 rtype
= elf_rl78_reloc_type (type
);
1463 rtype
= elf_rx_reloc_type (type
);
1467 rtype
= elf_metag_reloc_type (type
);
1472 rtype
= elf_xc16x_reloc_type (type
);
1476 rtype
= elf_tic6x_reloc_type (type
);
1480 rtype
= elf_tilegx_reloc_type (type
);
1484 rtype
= elf_tilepro_reloc_type (type
);
1488 rtype
= elf_xgate_reloc_type (type
);
1491 case EM_ALTERA_NIOS2
:
1492 rtype
= elf_nios2_reloc_type (type
);
1496 rtype
= elf_pru_reloc_type (type
);
1501 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1503 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1505 if (elf_header
.e_machine
== EM_ALPHA
1507 && streq (rtype
, "R_ALPHA_LITUSE")
1510 switch (rels
[i
].r_addend
)
1512 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1513 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1514 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1515 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1516 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1517 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1518 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1519 default: rtype
= NULL
;
1522 printf (" (%s)", rtype
);
1526 printf (_("<unknown addend: %lx>"),
1527 (unsigned long) rels
[i
].r_addend
);
1530 else if (symtab_index
)
1532 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1533 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1536 Elf_Internal_Sym
* psym
;
1537 const char * version_string
;
1538 enum versioned_symbol_info sym_info
;
1539 unsigned short vna_other
;
1541 psym
= symtab
+ symtab_index
;
1544 = get_symbol_version_string (file
, is_dynsym
,
1553 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1557 unsigned int width
= is_32bit_elf
? 8 : 14;
1559 /* Relocations against GNU_IFUNC symbols do not use the value
1560 of the symbol as the address to relocate against. Instead
1561 they invoke the function named by the symbol and use its
1562 result as the address for relocation.
1564 To indicate this to the user, do not display the value of
1565 the symbol in the "Symbols's Value" field. Instead show
1566 its name followed by () as a hint that the symbol is
1570 || psym
->st_name
== 0
1571 || psym
->st_name
>= strtablen
)
1574 name
= strtab
+ psym
->st_name
;
1576 len
= print_symbol (width
, name
);
1578 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1580 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1584 print_vma (psym
->st_value
, LONG_HEX
);
1586 printf (is_32bit_elf
? " " : " ");
1589 if (psym
->st_name
== 0)
1591 const char * sec_name
= "<null>";
1594 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1596 if (psym
->st_shndx
< elf_header
.e_shnum
)
1597 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1598 else if (psym
->st_shndx
== SHN_ABS
)
1600 else if (psym
->st_shndx
== SHN_COMMON
)
1601 sec_name
= "COMMON";
1602 else if ((elf_header
.e_machine
== EM_MIPS
1603 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1604 || (elf_header
.e_machine
== EM_TI_C6000
1605 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1606 sec_name
= "SCOMMON";
1607 else if (elf_header
.e_machine
== EM_MIPS
1608 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1609 sec_name
= "SUNDEF";
1610 else if ((elf_header
.e_machine
== EM_X86_64
1611 || elf_header
.e_machine
== EM_L1OM
1612 || elf_header
.e_machine
== EM_K1OM
)
1613 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1614 sec_name
= "LARGE_COMMON";
1615 else if (elf_header
.e_machine
== EM_IA_64
1616 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1617 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1618 sec_name
= "ANSI_COM";
1619 else if (is_ia64_vms ()
1620 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1621 sec_name
= "VMS_SYMVEC";
1624 sprintf (name_buf
, "<section 0x%x>",
1625 (unsigned int) psym
->st_shndx
);
1626 sec_name
= name_buf
;
1629 print_symbol (22, sec_name
);
1631 else if (strtab
== NULL
)
1632 printf (_("<string table index: %3ld>"), psym
->st_name
);
1633 else if (psym
->st_name
>= strtablen
)
1634 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1637 print_symbol (22, strtab
+ psym
->st_name
);
1639 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1645 bfd_vma off
= rels
[i
].r_addend
;
1647 if ((bfd_signed_vma
) off
< 0)
1648 printf (" - %" BFD_VMA_FMT
"x", - off
);
1650 printf (" + %" BFD_VMA_FMT
"x", off
);
1656 bfd_vma off
= rels
[i
].r_addend
;
1658 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1659 if ((bfd_signed_vma
) off
< 0)
1660 printf ("-%" BFD_VMA_FMT
"x", - off
);
1662 printf ("%" BFD_VMA_FMT
"x", off
);
1665 if (elf_header
.e_machine
== EM_SPARCV9
1667 && streq (rtype
, "R_SPARC_OLO10"))
1668 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1673 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1675 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1676 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1677 const char * rtype2
= elf_mips_reloc_type (type2
);
1678 const char * rtype3
= elf_mips_reloc_type (type3
);
1680 printf (" Type2: ");
1683 printf (_("unrecognized: %-7lx"),
1684 (unsigned long) type2
& 0xffffffff);
1686 printf ("%-17.17s", rtype2
);
1688 printf ("\n Type3: ");
1691 printf (_("unrecognized: %-7lx"),
1692 (unsigned long) type3
& 0xffffffff);
1694 printf ("%-17.17s", rtype3
);
1705 get_mips_dynamic_type (unsigned long type
)
1709 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1710 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1711 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1712 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1713 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1714 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1715 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1716 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1717 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1718 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1719 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1720 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1721 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1722 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1723 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1724 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1725 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1726 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1727 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1728 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1729 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1730 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1731 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1732 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1733 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1734 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1735 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1736 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1737 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1738 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1739 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1740 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1741 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1742 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1743 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1744 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1745 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1746 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1747 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1748 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1749 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1750 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1751 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1752 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1753 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1754 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1761 get_sparc64_dynamic_type (unsigned long type
)
1765 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1772 get_ppc_dynamic_type (unsigned long type
)
1776 case DT_PPC_GOT
: return "PPC_GOT";
1777 case DT_PPC_OPT
: return "PPC_OPT";
1784 get_ppc64_dynamic_type (unsigned long type
)
1788 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1789 case DT_PPC64_OPD
: return "PPC64_OPD";
1790 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1791 case DT_PPC64_OPT
: return "PPC64_OPT";
1798 get_parisc_dynamic_type (unsigned long type
)
1802 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1803 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1804 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1805 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1806 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1807 case DT_HP_PREINIT
: return "HP_PREINIT";
1808 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1809 case DT_HP_NEEDED
: return "HP_NEEDED";
1810 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1811 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1812 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1813 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1814 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1815 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1816 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1817 case DT_HP_FILTERED
: return "HP_FILTERED";
1818 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1819 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1820 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1821 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1822 case DT_PLT
: return "PLT";
1823 case DT_PLT_SIZE
: return "PLT_SIZE";
1824 case DT_DLT
: return "DLT";
1825 case DT_DLT_SIZE
: return "DLT_SIZE";
1832 get_ia64_dynamic_type (unsigned long type
)
1836 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1837 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1838 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1839 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1840 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1841 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1842 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1843 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1844 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1845 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1846 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1847 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1848 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1849 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1850 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1851 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1852 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1853 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1854 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1855 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1856 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1857 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1858 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1859 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1860 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1861 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1862 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1863 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1864 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1865 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1866 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1873 get_solaris_section_type (unsigned long type
)
1877 case 0x6fffffee: return "SUNW_ancillary";
1878 case 0x6fffffef: return "SUNW_capchain";
1879 case 0x6ffffff0: return "SUNW_capinfo";
1880 case 0x6ffffff1: return "SUNW_symsort";
1881 case 0x6ffffff2: return "SUNW_tlssort";
1882 case 0x6ffffff3: return "SUNW_LDYNSYM";
1883 case 0x6ffffff4: return "SUNW_dof";
1884 case 0x6ffffff5: return "SUNW_cap";
1885 case 0x6ffffff6: return "SUNW_SIGNATURE";
1886 case 0x6ffffff7: return "SUNW_ANNOTATE";
1887 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1888 case 0x6ffffff9: return "SUNW_DEBUG";
1889 case 0x6ffffffa: return "SUNW_move";
1890 case 0x6ffffffb: return "SUNW_COMDAT";
1891 case 0x6ffffffc: return "SUNW_syminfo";
1892 case 0x6ffffffd: return "SUNW_verdef";
1893 case 0x6ffffffe: return "SUNW_verneed";
1894 case 0x6fffffff: return "SUNW_versym";
1895 case 0x70000000: return "SPARC_GOTDATA";
1896 default: return NULL
;
1901 get_alpha_dynamic_type (unsigned long type
)
1905 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1912 get_score_dynamic_type (unsigned long type
)
1916 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1917 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1918 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1919 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1920 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1921 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1928 get_tic6x_dynamic_type (unsigned long type
)
1932 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1933 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1934 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1935 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1936 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1937 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1944 get_nios2_dynamic_type (unsigned long type
)
1948 case DT_NIOS2_GP
: return "NIOS2_GP";
1955 get_solaris_dynamic_type (unsigned long type
)
1959 case 0x6000000d: return "SUNW_AUXILIARY";
1960 case 0x6000000e: return "SUNW_RTLDINF";
1961 case 0x6000000f: return "SUNW_FILTER";
1962 case 0x60000010: return "SUNW_CAP";
1963 case 0x60000011: return "SUNW_SYMTAB";
1964 case 0x60000012: return "SUNW_SYMSZ";
1965 case 0x60000013: return "SUNW_SORTENT";
1966 case 0x60000014: return "SUNW_SYMSORT";
1967 case 0x60000015: return "SUNW_SYMSORTSZ";
1968 case 0x60000016: return "SUNW_TLSSORT";
1969 case 0x60000017: return "SUNW_TLSSORTSZ";
1970 case 0x60000018: return "SUNW_CAPINFO";
1971 case 0x60000019: return "SUNW_STRPAD";
1972 case 0x6000001a: return "SUNW_CAPCHAIN";
1973 case 0x6000001b: return "SUNW_LDMACH";
1974 case 0x6000001d: return "SUNW_CAPCHAINENT";
1975 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1976 case 0x60000021: return "SUNW_PARENT";
1977 case 0x60000023: return "SUNW_ASLR";
1978 case 0x60000025: return "SUNW_RELAX";
1979 case 0x60000029: return "SUNW_NXHEAP";
1980 case 0x6000002b: return "SUNW_NXSTACK";
1982 case 0x70000001: return "SPARC_REGISTER";
1983 case 0x7ffffffd: return "AUXILIARY";
1984 case 0x7ffffffe: return "USED";
1985 case 0x7fffffff: return "FILTER";
1987 default: return NULL
;
1992 get_dynamic_type (unsigned long type
)
1994 static char buff
[64];
1998 case DT_NULL
: return "NULL";
1999 case DT_NEEDED
: return "NEEDED";
2000 case DT_PLTRELSZ
: return "PLTRELSZ";
2001 case DT_PLTGOT
: return "PLTGOT";
2002 case DT_HASH
: return "HASH";
2003 case DT_STRTAB
: return "STRTAB";
2004 case DT_SYMTAB
: return "SYMTAB";
2005 case DT_RELA
: return "RELA";
2006 case DT_RELASZ
: return "RELASZ";
2007 case DT_RELAENT
: return "RELAENT";
2008 case DT_STRSZ
: return "STRSZ";
2009 case DT_SYMENT
: return "SYMENT";
2010 case DT_INIT
: return "INIT";
2011 case DT_FINI
: return "FINI";
2012 case DT_SONAME
: return "SONAME";
2013 case DT_RPATH
: return "RPATH";
2014 case DT_SYMBOLIC
: return "SYMBOLIC";
2015 case DT_REL
: return "REL";
2016 case DT_RELSZ
: return "RELSZ";
2017 case DT_RELENT
: return "RELENT";
2018 case DT_PLTREL
: return "PLTREL";
2019 case DT_DEBUG
: return "DEBUG";
2020 case DT_TEXTREL
: return "TEXTREL";
2021 case DT_JMPREL
: return "JMPREL";
2022 case DT_BIND_NOW
: return "BIND_NOW";
2023 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2024 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2025 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2026 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2027 case DT_RUNPATH
: return "RUNPATH";
2028 case DT_FLAGS
: return "FLAGS";
2030 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2031 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2032 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2034 case DT_CHECKSUM
: return "CHECKSUM";
2035 case DT_PLTPADSZ
: return "PLTPADSZ";
2036 case DT_MOVEENT
: return "MOVEENT";
2037 case DT_MOVESZ
: return "MOVESZ";
2038 case DT_FEATURE
: return "FEATURE";
2039 case DT_POSFLAG_1
: return "POSFLAG_1";
2040 case DT_SYMINSZ
: return "SYMINSZ";
2041 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2043 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2044 case DT_CONFIG
: return "CONFIG";
2045 case DT_DEPAUDIT
: return "DEPAUDIT";
2046 case DT_AUDIT
: return "AUDIT";
2047 case DT_PLTPAD
: return "PLTPAD";
2048 case DT_MOVETAB
: return "MOVETAB";
2049 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2051 case DT_VERSYM
: return "VERSYM";
2053 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2054 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2055 case DT_RELACOUNT
: return "RELACOUNT";
2056 case DT_RELCOUNT
: return "RELCOUNT";
2057 case DT_FLAGS_1
: return "FLAGS_1";
2058 case DT_VERDEF
: return "VERDEF";
2059 case DT_VERDEFNUM
: return "VERDEFNUM";
2060 case DT_VERNEED
: return "VERNEED";
2061 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2063 case DT_AUXILIARY
: return "AUXILIARY";
2064 case DT_USED
: return "USED";
2065 case DT_FILTER
: return "FILTER";
2067 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2068 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2069 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2070 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2071 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2072 case DT_GNU_HASH
: return "GNU_HASH";
2075 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2077 const char * result
;
2079 switch (elf_header
.e_machine
)
2082 case EM_MIPS_RS3_LE
:
2083 result
= get_mips_dynamic_type (type
);
2086 result
= get_sparc64_dynamic_type (type
);
2089 result
= get_ppc_dynamic_type (type
);
2092 result
= get_ppc64_dynamic_type (type
);
2095 result
= get_ia64_dynamic_type (type
);
2098 result
= get_alpha_dynamic_type (type
);
2101 result
= get_score_dynamic_type (type
);
2104 result
= get_tic6x_dynamic_type (type
);
2106 case EM_ALTERA_NIOS2
:
2107 result
= get_nios2_dynamic_type (type
);
2110 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2111 result
= get_solaris_dynamic_type (type
);
2120 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2122 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2123 || (elf_header
.e_machine
== EM_PARISC
2124 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2126 const char * result
;
2128 switch (elf_header
.e_machine
)
2131 result
= get_parisc_dynamic_type (type
);
2134 result
= get_ia64_dynamic_type (type
);
2137 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2138 result
= get_solaris_dynamic_type (type
);
2147 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2151 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2158 get_file_type (unsigned e_type
)
2160 static char buff
[32];
2164 case ET_NONE
: return _("NONE (None)");
2165 case ET_REL
: return _("REL (Relocatable file)");
2166 case ET_EXEC
: return _("EXEC (Executable file)");
2167 case ET_DYN
: return _("DYN (Shared object file)");
2168 case ET_CORE
: return _("CORE (Core file)");
2171 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2172 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2173 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2174 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2176 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2182 get_machine_name (unsigned e_machine
)
2184 static char buff
[64]; /* XXX */
2188 case EM_NONE
: return _("None");
2189 case EM_AARCH64
: return "AArch64";
2190 case EM_M32
: return "WE32100";
2191 case EM_SPARC
: return "Sparc";
2192 case EM_SPU
: return "SPU";
2193 case EM_386
: return "Intel 80386";
2194 case EM_68K
: return "MC68000";
2195 case EM_88K
: return "MC88000";
2196 case EM_IAMCU
: return "Intel MCU";
2197 case EM_860
: return "Intel 80860";
2198 case EM_MIPS
: return "MIPS R3000";
2199 case EM_S370
: return "IBM System/370";
2200 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2201 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2202 case EM_PARISC
: return "HPPA";
2203 case EM_PPC_OLD
: return "Power PC (old)";
2204 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2205 case EM_960
: return "Intel 90860";
2206 case EM_PPC
: return "PowerPC";
2207 case EM_PPC64
: return "PowerPC64";
2208 case EM_FR20
: return "Fujitsu FR20";
2209 case EM_FT32
: return "FTDI FT32";
2210 case EM_RH32
: return "TRW RH32";
2211 case EM_MCORE
: return "MCORE";
2212 case EM_ARM
: return "ARM";
2213 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2214 case EM_SH
: return "Renesas / SuperH SH";
2215 case EM_SPARCV9
: return "Sparc v9";
2216 case EM_TRICORE
: return "Siemens Tricore";
2217 case EM_ARC
: return "ARC";
2218 case EM_ARC_COMPACT
: return "ARCompact";
2219 case EM_ARC_COMPACT2
: return "ARCv2";
2220 case EM_H8_300
: return "Renesas H8/300";
2221 case EM_H8_300H
: return "Renesas H8/300H";
2222 case EM_H8S
: return "Renesas H8S";
2223 case EM_H8_500
: return "Renesas H8/500";
2224 case EM_IA_64
: return "Intel IA-64";
2225 case EM_MIPS_X
: return "Stanford MIPS-X";
2226 case EM_COLDFIRE
: return "Motorola Coldfire";
2227 case EM_ALPHA
: return "Alpha";
2228 case EM_CYGNUS_D10V
:
2229 case EM_D10V
: return "d10v";
2230 case EM_CYGNUS_D30V
:
2231 case EM_D30V
: return "d30v";
2232 case EM_CYGNUS_M32R
:
2233 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2234 case EM_CYGNUS_V850
:
2235 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2236 case EM_V850
: return "Renesas V850";
2237 case EM_CYGNUS_MN10300
:
2238 case EM_MN10300
: return "mn10300";
2239 case EM_CYGNUS_MN10200
:
2240 case EM_MN10200
: return "mn10200";
2241 case EM_MOXIE
: return "Moxie";
2242 case EM_CYGNUS_FR30
:
2243 case EM_FR30
: return "Fujitsu FR30";
2244 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2246 case EM_PJ
: return "picoJava";
2247 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2248 case EM_PCP
: return "Siemens PCP";
2249 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2250 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2251 case EM_STARCORE
: return "Motorola Star*Core processor";
2252 case EM_ME16
: return "Toyota ME16 processor";
2253 case EM_ST100
: return "STMicroelectronics ST100 processor";
2254 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2255 case EM_PDSP
: return "Sony DSP processor";
2256 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2257 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2258 case EM_FX66
: return "Siemens FX66 microcontroller";
2259 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2260 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2261 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2262 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2263 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2264 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2265 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2266 case EM_SVX
: return "Silicon Graphics SVx";
2267 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2268 case EM_VAX
: return "Digital VAX";
2269 case EM_VISIUM
: return "CDS VISIUMcore processor";
2271 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2272 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2273 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2274 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2275 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2276 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2277 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2278 case EM_PRISM
: return "Vitesse Prism";
2279 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2280 case EM_L1OM
: return "Intel L1OM";
2281 case EM_K1OM
: return "Intel K1OM";
2283 case EM_S390
: return "IBM S/390";
2284 case EM_SCORE
: return "SUNPLUS S+Core";
2285 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2286 case EM_OR1K
: return "OpenRISC 1000";
2287 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2288 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2289 case EM_DLX
: return "OpenDLX";
2291 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2292 case EM_IQ2000
: return "Vitesse IQ2000";
2294 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2295 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2296 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2297 case EM_NS32K
: return "National Semiconductor 32000 series";
2298 case EM_TPC
: return "Tenor Network TPC processor";
2299 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2300 case EM_MAX
: return "MAX Processor";
2301 case EM_CR
: return "National Semiconductor CompactRISC";
2302 case EM_F2MC16
: return "Fujitsu F2MC16";
2303 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2304 case EM_LATTICEMICO32
: return "Lattice Mico32";
2306 case EM_M32C
: return "Renesas M32c";
2307 case EM_MT
: return "Morpho Techologies MT processor";
2308 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2309 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2310 case EM_SEP
: return "Sharp embedded microprocessor";
2311 case EM_ARCA
: return "Arca RISC microprocessor";
2312 case EM_UNICORE
: return "Unicore";
2313 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2314 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2315 case EM_NIOS32
: return "Altera Nios";
2316 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2318 case EM_XC16X
: return "Infineon Technologies xc16x";
2319 case EM_M16C
: return "Renesas M16C series microprocessors";
2320 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2321 case EM_CE
: return "Freescale Communication Engine RISC core";
2322 case EM_TSK3000
: return "Altium TSK3000 core";
2323 case EM_RS08
: return "Freescale RS08 embedded processor";
2324 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2325 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2326 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2327 case EM_SE_C17
: return "Seiko Epson C17 family";
2328 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2329 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2330 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2331 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2332 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2333 case EM_R32C
: return "Renesas R32C series microprocessors";
2334 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2335 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2336 case EM_8051
: return "Intel 8051 and variants";
2337 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2338 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2339 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2340 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2341 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2342 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2343 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2344 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2347 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2348 case EM_RISCV
: return "RISC-V";
2349 case EM_RL78
: return "Renesas RL78";
2350 case EM_RX
: return "Renesas RX";
2351 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2352 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2353 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2354 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2355 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2356 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2357 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2358 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2359 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2360 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2361 case EM_CUDA
: return "NVIDIA CUDA architecture";
2362 case EM_XGATE
: return "Motorola XGATE embedded processor";
2363 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2364 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2365 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2366 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2367 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2368 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2369 case EM_BA1
: return "Beyond BA1 CPU architecture";
2370 case EM_BA2
: return "Beyond BA2 CPU architecture";
2371 case EM_XCORE
: return "XMOS xCORE processor family";
2372 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2373 case EM_KM32
: return "KM211 KM32 32-bit processor";
2374 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2375 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2376 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2377 case EM_KVARC
: return "KM211 KVARC processor";
2378 case EM_CDP
: return "Paneve CDP architecture family";
2379 case EM_COGE
: return "Cognitive Smart Memory Processor";
2380 case EM_COOL
: return "Bluechip Systems CoolEngine";
2381 case EM_NORC
: return "Nanoradio Optimized RISC";
2382 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2383 case EM_Z80
: return "Zilog Z80";
2384 case EM_AMDGPU
: return "AMD GPU architecture";
2385 case EM_TI_PRU
: return "TI PRU I/O processor";
2387 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2393 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2395 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2396 other compilers don't a specific architecture type in the e_flags, and
2397 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2398 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2401 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2402 but also sets a specific architecture type in the e_flags field.
2404 However, when decoding the flags we don't worry if we see an
2405 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2406 ARCEM architecture type. */
2408 switch (e_flags
& EF_ARC_MACH_MSK
)
2410 /* We only expect these to occur for EM_ARC_COMPACT2. */
2411 case EF_ARC_CPU_ARCV2EM
:
2412 strcat (buf
, ", ARC EM");
2414 case EF_ARC_CPU_ARCV2HS
:
2415 strcat (buf
, ", ARC HS");
2418 /* We only expect these to occur for EM_ARC_COMPACT. */
2419 case E_ARC_MACH_ARC600
:
2420 strcat (buf
, ", ARC600");
2422 case E_ARC_MACH_ARC601
:
2423 strcat (buf
, ", ARC601");
2425 case E_ARC_MACH_ARC700
:
2426 strcat (buf
, ", ARC700");
2429 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2430 new ELF with new architecture being read by an old version of
2431 readelf, or (c) An ELF built with non-GNU compiler that does not
2432 set the architecture in the e_flags. */
2434 if (e_machine
== EM_ARC_COMPACT
)
2435 strcat (buf
, ", Unknown ARCompact");
2437 strcat (buf
, ", Unknown ARC");
2441 switch (e_flags
& EF_ARC_OSABI_MSK
)
2443 case E_ARC_OSABI_ORIG
:
2444 strcat (buf
, ", (ABI:legacy)");
2446 case E_ARC_OSABI_V2
:
2447 strcat (buf
, ", (ABI:v2)");
2449 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2450 case E_ARC_OSABI_V3
:
2451 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2454 strcat (buf
, ", unrecognised ARC OSABI flag");
2460 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2465 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2466 e_flags
&= ~ EF_ARM_EABIMASK
;
2468 /* Handle "generic" ARM flags. */
2469 if (e_flags
& EF_ARM_RELEXEC
)
2471 strcat (buf
, ", relocatable executable");
2472 e_flags
&= ~ EF_ARM_RELEXEC
;
2475 /* Now handle EABI specific flags. */
2479 strcat (buf
, ", <unrecognized EABI>");
2484 case EF_ARM_EABI_VER1
:
2485 strcat (buf
, ", Version1 EABI");
2490 /* Process flags one bit at a time. */
2491 flag
= e_flags
& - e_flags
;
2496 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2497 strcat (buf
, ", sorted symbol tables");
2507 case EF_ARM_EABI_VER2
:
2508 strcat (buf
, ", Version2 EABI");
2513 /* Process flags one bit at a time. */
2514 flag
= e_flags
& - e_flags
;
2519 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2520 strcat (buf
, ", sorted symbol tables");
2523 case EF_ARM_DYNSYMSUSESEGIDX
:
2524 strcat (buf
, ", dynamic symbols use segment index");
2527 case EF_ARM_MAPSYMSFIRST
:
2528 strcat (buf
, ", mapping symbols precede others");
2538 case EF_ARM_EABI_VER3
:
2539 strcat (buf
, ", Version3 EABI");
2542 case EF_ARM_EABI_VER4
:
2543 strcat (buf
, ", Version4 EABI");
2548 /* Process flags one bit at a time. */
2549 flag
= e_flags
& - e_flags
;
2555 strcat (buf
, ", BE8");
2559 strcat (buf
, ", LE8");
2570 case EF_ARM_EABI_VER5
:
2571 strcat (buf
, ", Version5 EABI");
2576 /* Process flags one bit at a time. */
2577 flag
= e_flags
& - e_flags
;
2583 strcat (buf
, ", BE8");
2587 strcat (buf
, ", LE8");
2590 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2591 strcat (buf
, ", soft-float ABI");
2594 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2595 strcat (buf
, ", hard-float ABI");
2605 case EF_ARM_EABI_UNKNOWN
:
2606 strcat (buf
, ", GNU EABI");
2611 /* Process flags one bit at a time. */
2612 flag
= e_flags
& - e_flags
;
2617 case EF_ARM_INTERWORK
:
2618 strcat (buf
, ", interworking enabled");
2621 case EF_ARM_APCS_26
:
2622 strcat (buf
, ", uses APCS/26");
2625 case EF_ARM_APCS_FLOAT
:
2626 strcat (buf
, ", uses APCS/float");
2630 strcat (buf
, ", position independent");
2634 strcat (buf
, ", 8 bit structure alignment");
2637 case EF_ARM_NEW_ABI
:
2638 strcat (buf
, ", uses new ABI");
2641 case EF_ARM_OLD_ABI
:
2642 strcat (buf
, ", uses old ABI");
2645 case EF_ARM_SOFT_FLOAT
:
2646 strcat (buf
, ", software FP");
2649 case EF_ARM_VFP_FLOAT
:
2650 strcat (buf
, ", VFP");
2653 case EF_ARM_MAVERICK_FLOAT
:
2654 strcat (buf
, ", Maverick FP");
2665 strcat (buf
,_(", <unknown>"));
2669 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2671 --size
; /* Leave space for null terminator. */
2673 switch (e_flags
& EF_AVR_MACH
)
2675 case E_AVR_MACH_AVR1
:
2676 strncat (buf
, ", avr:1", size
);
2678 case E_AVR_MACH_AVR2
:
2679 strncat (buf
, ", avr:2", size
);
2681 case E_AVR_MACH_AVR25
:
2682 strncat (buf
, ", avr:25", size
);
2684 case E_AVR_MACH_AVR3
:
2685 strncat (buf
, ", avr:3", size
);
2687 case E_AVR_MACH_AVR31
:
2688 strncat (buf
, ", avr:31", size
);
2690 case E_AVR_MACH_AVR35
:
2691 strncat (buf
, ", avr:35", size
);
2693 case E_AVR_MACH_AVR4
:
2694 strncat (buf
, ", avr:4", size
);
2696 case E_AVR_MACH_AVR5
:
2697 strncat (buf
, ", avr:5", size
);
2699 case E_AVR_MACH_AVR51
:
2700 strncat (buf
, ", avr:51", size
);
2702 case E_AVR_MACH_AVR6
:
2703 strncat (buf
, ", avr:6", size
);
2705 case E_AVR_MACH_AVRTINY
:
2706 strncat (buf
, ", avr:100", size
);
2708 case E_AVR_MACH_XMEGA1
:
2709 strncat (buf
, ", avr:101", size
);
2711 case E_AVR_MACH_XMEGA2
:
2712 strncat (buf
, ", avr:102", size
);
2714 case E_AVR_MACH_XMEGA3
:
2715 strncat (buf
, ", avr:103", size
);
2717 case E_AVR_MACH_XMEGA4
:
2718 strncat (buf
, ", avr:104", size
);
2720 case E_AVR_MACH_XMEGA5
:
2721 strncat (buf
, ", avr:105", size
);
2723 case E_AVR_MACH_XMEGA6
:
2724 strncat (buf
, ", avr:106", size
);
2726 case E_AVR_MACH_XMEGA7
:
2727 strncat (buf
, ", avr:107", size
);
2730 strncat (buf
, ", avr:<unknown>", size
);
2734 size
-= strlen (buf
);
2735 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2736 strncat (buf
, ", link-relax", size
);
2740 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2749 static const char *ABI_STRINGS
[] =
2751 "ABI v0", /* use r5 as return register; only used in N1213HC */
2752 "ABI v1", /* use r0 as return register */
2753 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2754 "ABI v2fp", /* for FPU */
2758 static const char *VER_STRINGS
[] =
2760 "Andes ELF V1.3 or older",
2764 static const char *ARCH_STRINGS
[] =
2773 abi
= EF_NDS_ABI
& e_flags
;
2774 arch
= EF_NDS_ARCH
& e_flags
;
2775 config
= EF_NDS_INST
& e_flags
;
2776 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2778 memset (buf
, 0, size
);
2785 case E_NDS_ABI_V2FP
:
2786 case E_NDS_ABI_AABI
:
2787 case E_NDS_ABI_V2FP_PLUS
:
2788 /* In case there are holes in the array. */
2789 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2793 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2799 case E_NDS32_ELF_VER_1_2
:
2800 case E_NDS32_ELF_VER_1_3
:
2801 case E_NDS32_ELF_VER_1_4
:
2802 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2806 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2810 if (E_NDS_ABI_V0
== abi
)
2812 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2813 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2814 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2815 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2821 case E_NDS_ARCH_STAR_V1_0
:
2822 case E_NDS_ARCH_STAR_V2_0
:
2823 case E_NDS_ARCH_STAR_V3_0
:
2824 case E_NDS_ARCH_STAR_V3_M
:
2825 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2829 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2830 /* ARCH version determines how the e_flags are interpreted.
2831 If it is unknown, we cannot proceed. */
2835 /* Newer ABI; Now handle architecture specific flags. */
2836 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2838 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2839 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2841 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2842 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2844 if (config
& E_NDS32_HAS_DIV_INST
)
2845 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2847 if (config
& E_NDS32_HAS_16BIT_INST
)
2848 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2852 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2854 if (version
<= E_NDS32_ELF_VER_1_3
)
2855 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2857 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2860 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2861 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2863 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2864 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2866 if (config
& E_NDS32_HAS_16BIT_INST
)
2868 if (version
<= E_NDS32_ELF_VER_1_3
)
2869 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2871 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2875 if (config
& E_NDS32_HAS_EXT_INST
)
2876 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2878 if (config
& E_NDS32_HAS_EXT2_INST
)
2879 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2881 if (config
& E_NDS32_HAS_FPU_INST
)
2884 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2887 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2890 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2893 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2901 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2903 case E_NDS32_FPU_REG_8SP_4DP
:
2904 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2906 case E_NDS32_FPU_REG_16SP_8DP
:
2907 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2909 case E_NDS32_FPU_REG_32SP_16DP
:
2910 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2912 case E_NDS32_FPU_REG_32SP_32DP
:
2913 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2918 if (config
& E_NDS32_HAS_AUDIO_INST
)
2919 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2921 if (config
& E_NDS32_HAS_STRING_INST
)
2922 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2924 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2925 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2927 if (config
& E_NDS32_HAS_VIDEO_INST
)
2929 if (version
<= E_NDS32_ELF_VER_1_3
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2932 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2935 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2938 if (config
& E_NDS32_HAS_L2C_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2943 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2945 static char buf
[1024];
2956 case EM_ARC_COMPACT2
:
2957 case EM_ARC_COMPACT
:
2958 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2962 decode_ARM_machine_flags (e_flags
, buf
);
2966 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2970 if (e_flags
& EF_BFIN_PIC
)
2971 strcat (buf
, ", PIC");
2973 if (e_flags
& EF_BFIN_FDPIC
)
2974 strcat (buf
, ", FDPIC");
2976 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2977 strcat (buf
, ", code in L1");
2979 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2980 strcat (buf
, ", data in L1");
2985 switch (e_flags
& EF_FRV_CPU_MASK
)
2987 case EF_FRV_CPU_GENERIC
:
2991 strcat (buf
, ", fr???");
2994 case EF_FRV_CPU_FR300
:
2995 strcat (buf
, ", fr300");
2998 case EF_FRV_CPU_FR400
:
2999 strcat (buf
, ", fr400");
3001 case EF_FRV_CPU_FR405
:
3002 strcat (buf
, ", fr405");
3005 case EF_FRV_CPU_FR450
:
3006 strcat (buf
, ", fr450");
3009 case EF_FRV_CPU_FR500
:
3010 strcat (buf
, ", fr500");
3012 case EF_FRV_CPU_FR550
:
3013 strcat (buf
, ", fr550");
3016 case EF_FRV_CPU_SIMPLE
:
3017 strcat (buf
, ", simple");
3019 case EF_FRV_CPU_TOMCAT
:
3020 strcat (buf
, ", tomcat");
3026 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3027 strcat (buf
, ", m68000");
3028 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3029 strcat (buf
, ", cpu32");
3030 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3031 strcat (buf
, ", fido_a");
3034 char const * isa
= _("unknown");
3035 char const * mac
= _("unknown mac");
3036 char const * additional
= NULL
;
3038 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3040 case EF_M68K_CF_ISA_A_NODIV
:
3042 additional
= ", nodiv";
3044 case EF_M68K_CF_ISA_A
:
3047 case EF_M68K_CF_ISA_A_PLUS
:
3050 case EF_M68K_CF_ISA_B_NOUSP
:
3052 additional
= ", nousp";
3054 case EF_M68K_CF_ISA_B
:
3057 case EF_M68K_CF_ISA_C
:
3060 case EF_M68K_CF_ISA_C_NODIV
:
3062 additional
= ", nodiv";
3065 strcat (buf
, ", cf, isa ");
3068 strcat (buf
, additional
);
3069 if (e_flags
& EF_M68K_CF_FLOAT
)
3070 strcat (buf
, ", float");
3071 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3076 case EF_M68K_CF_MAC
:
3079 case EF_M68K_CF_EMAC
:
3082 case EF_M68K_CF_EMAC_B
:
3095 switch (e_flags
& EF_MEP_CPU_MASK
)
3097 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3098 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3099 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3100 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3101 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3102 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3103 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3106 switch (e_flags
& EF_MEP_COP_MASK
)
3108 case EF_MEP_COP_NONE
: break;
3109 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3110 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3111 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3112 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3113 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3116 if (e_flags
& EF_MEP_LIBRARY
)
3117 strcat (buf
, ", Built for Library");
3119 if (e_flags
& EF_MEP_INDEX_MASK
)
3120 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3121 e_flags
& EF_MEP_INDEX_MASK
);
3123 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3124 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3125 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3129 if (e_flags
& EF_PPC_EMB
)
3130 strcat (buf
, ", emb");
3132 if (e_flags
& EF_PPC_RELOCATABLE
)
3133 strcat (buf
, _(", relocatable"));
3135 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3136 strcat (buf
, _(", relocatable-lib"));
3140 if (e_flags
& EF_PPC64_ABI
)
3142 char abi
[] = ", abiv0";
3144 abi
[6] += e_flags
& EF_PPC64_ABI
;
3150 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3151 strcat (buf
, ", RH850 ABI");
3153 if (e_flags
& EF_V800_850E3
)
3154 strcat (buf
, ", V3 architecture");
3156 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3157 strcat (buf
, ", FPU not used");
3159 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3160 strcat (buf
, ", regmode: COMMON");
3162 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3163 strcat (buf
, ", r4 not used");
3165 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3166 strcat (buf
, ", r30 not used");
3168 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3169 strcat (buf
, ", r5 not used");
3171 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3172 strcat (buf
, ", r2 not used");
3174 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3176 switch (e_flags
& - e_flags
)
3178 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3179 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3180 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3181 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3182 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3183 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3184 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3185 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3186 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3187 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3188 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3189 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3196 case EM_CYGNUS_V850
:
3197 switch (e_flags
& EF_V850_ARCH
)
3199 case E_V850E3V5_ARCH
:
3200 strcat (buf
, ", v850e3v5");
3202 case E_V850E2V3_ARCH
:
3203 strcat (buf
, ", v850e2v3");
3206 strcat (buf
, ", v850e2");
3209 strcat (buf
, ", v850e1");
3212 strcat (buf
, ", v850e");
3215 strcat (buf
, ", v850");
3218 strcat (buf
, _(", unknown v850 architecture variant"));
3224 case EM_CYGNUS_M32R
:
3225 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3226 strcat (buf
, ", m32r");
3230 case EM_MIPS_RS3_LE
:
3231 if (e_flags
& EF_MIPS_NOREORDER
)
3232 strcat (buf
, ", noreorder");
3234 if (e_flags
& EF_MIPS_PIC
)
3235 strcat (buf
, ", pic");
3237 if (e_flags
& EF_MIPS_CPIC
)
3238 strcat (buf
, ", cpic");
3240 if (e_flags
& EF_MIPS_UCODE
)
3241 strcat (buf
, ", ugen_reserved");
3243 if (e_flags
& EF_MIPS_ABI2
)
3244 strcat (buf
, ", abi2");
3246 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3247 strcat (buf
, ", odk first");
3249 if (e_flags
& EF_MIPS_32BITMODE
)
3250 strcat (buf
, ", 32bitmode");
3252 if (e_flags
& EF_MIPS_NAN2008
)
3253 strcat (buf
, ", nan2008");
3255 if (e_flags
& EF_MIPS_FP64
)
3256 strcat (buf
, ", fp64");
3258 switch ((e_flags
& EF_MIPS_MACH
))
3260 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3261 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3262 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3263 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3264 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3265 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3266 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3267 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3268 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3269 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3270 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3271 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3272 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3273 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3274 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3275 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3276 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3278 /* We simply ignore the field in this case to avoid confusion:
3279 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3282 default: strcat (buf
, _(", unknown CPU")); break;
3285 switch ((e_flags
& EF_MIPS_ABI
))
3287 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3288 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3289 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3290 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3292 /* We simply ignore the field in this case to avoid confusion:
3293 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3294 This means it is likely to be an o32 file, but not for
3297 default: strcat (buf
, _(", unknown ABI")); break;
3300 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3301 strcat (buf
, ", mdmx");
3303 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3304 strcat (buf
, ", mips16");
3306 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3307 strcat (buf
, ", micromips");
3309 switch ((e_flags
& EF_MIPS_ARCH
))
3311 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3312 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3313 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3314 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3315 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3316 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3317 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3318 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3319 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3320 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3321 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3322 default: strcat (buf
, _(", unknown ISA")); break;
3327 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3331 if (e_flags
& EF_RISCV_RVC
)
3332 strcat (buf
, ", RVC");
3334 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3336 case EF_RISCV_FLOAT_ABI_SOFT
:
3337 strcat (buf
, ", soft-float ABI");
3340 case EF_RISCV_FLOAT_ABI_SINGLE
:
3341 strcat (buf
, ", single-float ABI");
3344 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3345 strcat (buf
, ", double-float ABI");
3348 case EF_RISCV_FLOAT_ABI_QUAD
:
3349 strcat (buf
, ", quad-float ABI");
3355 switch ((e_flags
& EF_SH_MACH_MASK
))
3357 case EF_SH1
: strcat (buf
, ", sh1"); break;
3358 case EF_SH2
: strcat (buf
, ", sh2"); break;
3359 case EF_SH3
: strcat (buf
, ", sh3"); break;
3360 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3361 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3362 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3363 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3364 case EF_SH4
: strcat (buf
, ", sh4"); break;
3365 case EF_SH5
: strcat (buf
, ", sh5"); break;
3366 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3367 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3368 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3369 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3370 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3371 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3372 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3373 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3374 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3375 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3376 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3377 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3378 default: strcat (buf
, _(", unknown ISA")); break;
3381 if (e_flags
& EF_SH_PIC
)
3382 strcat (buf
, ", pic");
3384 if (e_flags
& EF_SH_FDPIC
)
3385 strcat (buf
, ", fdpic");
3389 if (e_flags
& EF_OR1K_NODELAY
)
3390 strcat (buf
, ", no delay");
3394 if (e_flags
& EF_SPARC_32PLUS
)
3395 strcat (buf
, ", v8+");
3397 if (e_flags
& EF_SPARC_SUN_US1
)
3398 strcat (buf
, ", ultrasparcI");
3400 if (e_flags
& EF_SPARC_SUN_US3
)
3401 strcat (buf
, ", ultrasparcIII");
3403 if (e_flags
& EF_SPARC_HAL_R1
)
3404 strcat (buf
, ", halr1");
3406 if (e_flags
& EF_SPARC_LEDATA
)
3407 strcat (buf
, ", ledata");
3409 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3410 strcat (buf
, ", tso");
3412 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3413 strcat (buf
, ", pso");
3415 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3416 strcat (buf
, ", rmo");
3420 switch (e_flags
& EF_PARISC_ARCH
)
3422 case EFA_PARISC_1_0
:
3423 strcpy (buf
, ", PA-RISC 1.0");
3425 case EFA_PARISC_1_1
:
3426 strcpy (buf
, ", PA-RISC 1.1");
3428 case EFA_PARISC_2_0
:
3429 strcpy (buf
, ", PA-RISC 2.0");
3434 if (e_flags
& EF_PARISC_TRAPNIL
)
3435 strcat (buf
, ", trapnil");
3436 if (e_flags
& EF_PARISC_EXT
)
3437 strcat (buf
, ", ext");
3438 if (e_flags
& EF_PARISC_LSB
)
3439 strcat (buf
, ", lsb");
3440 if (e_flags
& EF_PARISC_WIDE
)
3441 strcat (buf
, ", wide");
3442 if (e_flags
& EF_PARISC_NO_KABP
)
3443 strcat (buf
, ", no kabp");
3444 if (e_flags
& EF_PARISC_LAZYSWAP
)
3445 strcat (buf
, ", lazyswap");
3450 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3451 strcat (buf
, ", new calling convention");
3453 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3454 strcat (buf
, ", gnu calling convention");
3458 if ((e_flags
& EF_IA_64_ABI64
))
3459 strcat (buf
, ", 64-bit");
3461 strcat (buf
, ", 32-bit");
3462 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3463 strcat (buf
, ", reduced fp model");
3464 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3465 strcat (buf
, ", no function descriptors, constant gp");
3466 else if ((e_flags
& EF_IA_64_CONS_GP
))
3467 strcat (buf
, ", constant gp");
3468 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3469 strcat (buf
, ", absolute");
3470 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3472 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3473 strcat (buf
, ", vms_linkages");
3474 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3476 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3478 case EF_IA_64_VMS_COMCOD_WARNING
:
3479 strcat (buf
, ", warning");
3481 case EF_IA_64_VMS_COMCOD_ERROR
:
3482 strcat (buf
, ", error");
3484 case EF_IA_64_VMS_COMCOD_ABORT
:
3485 strcat (buf
, ", abort");
3488 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3489 e_flags
& EF_IA_64_VMS_COMCOD
);
3490 strcat (buf
, ", <unknown>");
3496 if ((e_flags
& EF_VAX_NONPIC
))
3497 strcat (buf
, ", non-PIC");
3498 if ((e_flags
& EF_VAX_DFLOAT
))
3499 strcat (buf
, ", D-Float");
3500 if ((e_flags
& EF_VAX_GFLOAT
))
3501 strcat (buf
, ", G-Float");
3505 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3506 strcat (buf
, ", mcm");
3507 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3508 strcat (buf
, ", mcm24");
3509 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3510 strcat (buf
, ", gr6");
3514 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3516 case E_FLAG_RL78_ANY_CPU
: break;
3517 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3518 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3519 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3521 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3522 strcat (buf
, ", 64-bit doubles");
3526 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3527 strcat (buf
, ", 64-bit doubles");
3528 if (e_flags
& E_FLAG_RX_DSP
)
3529 strcat (buf
, ", dsp");
3530 if (e_flags
& E_FLAG_RX_PID
)
3531 strcat (buf
, ", pid");
3532 if (e_flags
& E_FLAG_RX_ABI
)
3533 strcat (buf
, ", RX ABI");
3534 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3535 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3536 ? ", uses String instructions" : ", bans String instructions");
3537 if (e_flags
& E_FLAG_RX_V2
)
3538 strcat (buf
, ", V2");
3542 if (e_flags
& EF_S390_HIGH_GPRS
)
3543 strcat (buf
, ", highgprs");
3547 if ((e_flags
& EF_C6000_REL
))
3548 strcat (buf
, ", relocatable module");
3552 strcat (buf
, _(": architecture variant: "));
3553 switch (e_flags
& EF_MSP430_MACH
)
3555 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3556 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3557 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3558 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3559 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3560 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3561 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3562 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3563 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3564 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3565 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3566 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3567 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3568 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3569 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3571 strcat (buf
, _(": unknown")); break;
3574 if (e_flags
& ~ EF_MSP430_MACH
)
3575 strcat (buf
, _(": unknown extra flag bits also present"));
3583 get_osabi_name (unsigned int osabi
)
3585 static char buff
[32];
3589 case ELFOSABI_NONE
: return "UNIX - System V";
3590 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3591 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3592 case ELFOSABI_GNU
: return "UNIX - GNU";
3593 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3594 case ELFOSABI_AIX
: return "UNIX - AIX";
3595 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3596 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3597 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3598 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3599 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3600 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3601 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3602 case ELFOSABI_AROS
: return "AROS";
3603 case ELFOSABI_FENIXOS
: return "FenixOS";
3604 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3605 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3608 switch (elf_header
.e_machine
)
3613 case ELFOSABI_ARM
: return "ARM";
3624 case ELFOSABI_STANDALONE
: return _("Standalone App");
3633 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3634 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3643 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3649 get_aarch64_segment_type (unsigned long type
)
3653 case PT_AARCH64_ARCHEXT
:
3654 return "AARCH64_ARCHEXT";
3663 get_arm_segment_type (unsigned long type
)
3677 get_mips_segment_type (unsigned long type
)
3681 case PT_MIPS_REGINFO
:
3683 case PT_MIPS_RTPROC
:
3685 case PT_MIPS_OPTIONS
:
3687 case PT_MIPS_ABIFLAGS
:
3697 get_parisc_segment_type (unsigned long type
)
3701 case PT_HP_TLS
: return "HP_TLS";
3702 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3703 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3704 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3705 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3706 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3707 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3708 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3709 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3710 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3711 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3712 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3713 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3714 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3715 case PT_HP_STACK
: return "HP_STACK";
3716 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3717 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3718 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3719 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3728 get_ia64_segment_type (unsigned long type
)
3732 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3733 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3734 case PT_HP_TLS
: return "HP_TLS";
3735 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3736 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3737 case PT_IA_64_HP_STACK
: return "HP_STACK";
3746 get_tic6x_segment_type (unsigned long type
)
3750 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3759 get_solaris_segment_type (unsigned long type
)
3763 case 0x6464e550: return "PT_SUNW_UNWIND";
3764 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3765 case 0x6ffffff7: return "PT_LOSUNW";
3766 case 0x6ffffffa: return "PT_SUNWBSS";
3767 case 0x6ffffffb: return "PT_SUNWSTACK";
3768 case 0x6ffffffc: return "PT_SUNWDTRACE";
3769 case 0x6ffffffd: return "PT_SUNWCAP";
3770 case 0x6fffffff: return "PT_HISUNW";
3771 default: return NULL
;
3776 get_segment_type (unsigned long p_type
)
3778 static char buff
[32];
3782 case PT_NULL
: return "NULL";
3783 case PT_LOAD
: return "LOAD";
3784 case PT_DYNAMIC
: return "DYNAMIC";
3785 case PT_INTERP
: return "INTERP";
3786 case PT_NOTE
: return "NOTE";
3787 case PT_SHLIB
: return "SHLIB";
3788 case PT_PHDR
: return "PHDR";
3789 case PT_TLS
: return "TLS";
3791 case PT_GNU_EH_FRAME
:
3792 return "GNU_EH_FRAME";
3793 case PT_GNU_STACK
: return "GNU_STACK";
3794 case PT_GNU_RELRO
: return "GNU_RELRO";
3797 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3799 const char * result
;
3801 switch (elf_header
.e_machine
)
3804 result
= get_aarch64_segment_type (p_type
);
3807 result
= get_arm_segment_type (p_type
);
3810 case EM_MIPS_RS3_LE
:
3811 result
= get_mips_segment_type (p_type
);
3814 result
= get_parisc_segment_type (p_type
);
3817 result
= get_ia64_segment_type (p_type
);
3820 result
= get_tic6x_segment_type (p_type
);
3830 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3832 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3834 const char * result
;
3836 switch (elf_header
.e_machine
)
3839 result
= get_parisc_segment_type (p_type
);
3842 result
= get_ia64_segment_type (p_type
);
3845 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3846 result
= get_solaris_segment_type (p_type
);
3855 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3858 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3865 get_mips_section_type_name (unsigned int sh_type
)
3869 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3870 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3871 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3872 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3873 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3874 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3875 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3876 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3877 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3878 case SHT_MIPS_RELD
: return "MIPS_RELD";
3879 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3880 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3881 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3882 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3883 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3884 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3885 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3886 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3887 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3888 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3889 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3890 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3891 case SHT_MIPS_LINE
: return "MIPS_LINE";
3892 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3893 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3894 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3895 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3896 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3897 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3898 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3899 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3900 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3901 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3902 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3903 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3904 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3905 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3906 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3907 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3908 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3916 get_parisc_section_type_name (unsigned int sh_type
)
3920 case SHT_PARISC_EXT
: return "PARISC_EXT";
3921 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3922 case SHT_PARISC_DOC
: return "PARISC_DOC";
3923 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3924 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3925 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3926 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3934 get_ia64_section_type_name (unsigned int sh_type
)
3936 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3937 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3938 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3942 case SHT_IA_64_EXT
: return "IA_64_EXT";
3943 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3944 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3945 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3946 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3947 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3948 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3949 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3950 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3951 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3959 get_x86_64_section_type_name (unsigned int sh_type
)
3963 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3971 get_aarch64_section_type_name (unsigned int sh_type
)
3975 case SHT_AARCH64_ATTRIBUTES
:
3976 return "AARCH64_ATTRIBUTES";
3984 get_arm_section_type_name (unsigned int sh_type
)
3988 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3989 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3990 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3991 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3992 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4000 get_tic6x_section_type_name (unsigned int sh_type
)
4004 case SHT_C6000_UNWIND
:
4005 return "C6000_UNWIND";
4006 case SHT_C6000_PREEMPTMAP
:
4007 return "C6000_PREEMPTMAP";
4008 case SHT_C6000_ATTRIBUTES
:
4009 return "C6000_ATTRIBUTES";
4014 case SHT_TI_HANDLER
:
4015 return "TI_HANDLER";
4016 case SHT_TI_INITINFO
:
4017 return "TI_INITINFO";
4018 case SHT_TI_PHATTRS
:
4019 return "TI_PHATTRS";
4027 get_msp430x_section_type_name (unsigned int sh_type
)
4031 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4032 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4033 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4034 default: return NULL
;
4039 get_v850_section_type_name (unsigned int sh_type
)
4043 case SHT_V850_SCOMMON
: return "V850 Small Common";
4044 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4045 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4046 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4047 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4048 default: return NULL
;
4053 get_section_type_name (unsigned int sh_type
)
4055 static char buff
[32];
4056 const char * result
;
4060 case SHT_NULL
: return "NULL";
4061 case SHT_PROGBITS
: return "PROGBITS";
4062 case SHT_SYMTAB
: return "SYMTAB";
4063 case SHT_STRTAB
: return "STRTAB";
4064 case SHT_RELA
: return "RELA";
4065 case SHT_HASH
: return "HASH";
4066 case SHT_DYNAMIC
: return "DYNAMIC";
4067 case SHT_NOTE
: return "NOTE";
4068 case SHT_NOBITS
: return "NOBITS";
4069 case SHT_REL
: return "REL";
4070 case SHT_SHLIB
: return "SHLIB";
4071 case SHT_DYNSYM
: return "DYNSYM";
4072 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4073 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4074 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4075 case SHT_GNU_HASH
: return "GNU_HASH";
4076 case SHT_GROUP
: return "GROUP";
4077 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4078 case SHT_GNU_verdef
: return "VERDEF";
4079 case SHT_GNU_verneed
: return "VERNEED";
4080 case SHT_GNU_versym
: return "VERSYM";
4081 case 0x6ffffff0: return "VERSYM";
4082 case 0x6ffffffc: return "VERDEF";
4083 case 0x7ffffffd: return "AUXILIARY";
4084 case 0x7fffffff: return "FILTER";
4085 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4088 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4090 switch (elf_header
.e_machine
)
4093 case EM_MIPS_RS3_LE
:
4094 result
= get_mips_section_type_name (sh_type
);
4097 result
= get_parisc_section_type_name (sh_type
);
4100 result
= get_ia64_section_type_name (sh_type
);
4105 result
= get_x86_64_section_type_name (sh_type
);
4108 result
= get_aarch64_section_type_name (sh_type
);
4111 result
= get_arm_section_type_name (sh_type
);
4114 result
= get_tic6x_section_type_name (sh_type
);
4117 result
= get_msp430x_section_type_name (sh_type
);
4121 case EM_CYGNUS_V850
:
4122 result
= get_v850_section_type_name (sh_type
);
4132 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4134 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4136 switch (elf_header
.e_machine
)
4139 result
= get_ia64_section_type_name (sh_type
);
4142 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4143 result
= get_solaris_section_type (sh_type
);
4148 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4149 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4150 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4151 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4163 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4165 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4167 switch (elf_header
.e_machine
)
4171 case EM_CYGNUS_V850
:
4172 result
= get_v850_section_type_name (sh_type
);
4182 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4185 /* This message is probably going to be displayed in a 15
4186 character wide field, so put the hex value first. */
4187 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4193 #define OPTION_DEBUG_DUMP 512
4194 #define OPTION_DYN_SYMS 513
4195 #define OPTION_DWARF_DEPTH 514
4196 #define OPTION_DWARF_START 515
4197 #define OPTION_DWARF_CHECK 516
4199 static struct option options
[] =
4201 {"all", no_argument
, 0, 'a'},
4202 {"file-header", no_argument
, 0, 'h'},
4203 {"program-headers", no_argument
, 0, 'l'},
4204 {"headers", no_argument
, 0, 'e'},
4205 {"histogram", no_argument
, 0, 'I'},
4206 {"segments", no_argument
, 0, 'l'},
4207 {"sections", no_argument
, 0, 'S'},
4208 {"section-headers", no_argument
, 0, 'S'},
4209 {"section-groups", no_argument
, 0, 'g'},
4210 {"section-details", no_argument
, 0, 't'},
4211 {"full-section-name",no_argument
, 0, 'N'},
4212 {"symbols", no_argument
, 0, 's'},
4213 {"syms", no_argument
, 0, 's'},
4214 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4215 {"relocs", no_argument
, 0, 'r'},
4216 {"notes", no_argument
, 0, 'n'},
4217 {"dynamic", no_argument
, 0, 'd'},
4218 {"arch-specific", no_argument
, 0, 'A'},
4219 {"version-info", no_argument
, 0, 'V'},
4220 {"use-dynamic", no_argument
, 0, 'D'},
4221 {"unwind", no_argument
, 0, 'u'},
4222 {"archive-index", no_argument
, 0, 'c'},
4223 {"hex-dump", required_argument
, 0, 'x'},
4224 {"relocated-dump", required_argument
, 0, 'R'},
4225 {"string-dump", required_argument
, 0, 'p'},
4226 {"decompress", no_argument
, 0, 'z'},
4227 #ifdef SUPPORT_DISASSEMBLY
4228 {"instruction-dump", required_argument
, 0, 'i'},
4230 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4232 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4233 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4234 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4236 {"version", no_argument
, 0, 'v'},
4237 {"wide", no_argument
, 0, 'W'},
4238 {"help", no_argument
, 0, 'H'},
4239 {0, no_argument
, 0, 0}
4243 usage (FILE * stream
)
4245 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4246 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4247 fprintf (stream
, _(" Options are:\n\
4248 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4249 -h --file-header Display the ELF file header\n\
4250 -l --program-headers Display the program headers\n\
4251 --segments An alias for --program-headers\n\
4252 -S --section-headers Display the sections' header\n\
4253 --sections An alias for --section-headers\n\
4254 -g --section-groups Display the section groups\n\
4255 -t --section-details Display the section details\n\
4256 -e --headers Equivalent to: -h -l -S\n\
4257 -s --syms Display the symbol table\n\
4258 --symbols An alias for --syms\n\
4259 --dyn-syms Display the dynamic symbol table\n\
4260 -n --notes Display the core notes (if present)\n\
4261 -r --relocs Display the relocations (if present)\n\
4262 -u --unwind Display the unwind info (if present)\n\
4263 -d --dynamic Display the dynamic section (if present)\n\
4264 -V --version-info Display the version sections (if present)\n\
4265 -A --arch-specific Display architecture specific information (if any)\n\
4266 -c --archive-index Display the symbol/file index in an archive\n\
4267 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4268 -x --hex-dump=<number|name>\n\
4269 Dump the contents of section <number|name> as bytes\n\
4270 -p --string-dump=<number|name>\n\
4271 Dump the contents of section <number|name> as strings\n\
4272 -R --relocated-dump=<number|name>\n\
4273 Dump the contents of section <number|name> as relocated bytes\n\
4274 -z --decompress Decompress section before dumping it\n\
4275 -w[lLiaprmfFsoRt] or\n\
4276 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4277 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4278 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4280 Display the contents of DWARF2 debug sections\n"));
4281 fprintf (stream
, _("\
4282 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4283 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4285 #ifdef SUPPORT_DISASSEMBLY
4286 fprintf (stream
, _("\
4287 -i --instruction-dump=<number|name>\n\
4288 Disassemble the contents of section <number|name>\n"));
4290 fprintf (stream
, _("\
4291 -I --histogram Display histogram of bucket list lengths\n\
4292 -W --wide Allow output width to exceed 80 characters\n\
4293 @<file> Read options from <file>\n\
4294 -H --help Display this information\n\
4295 -v --version Display the version number of readelf\n"));
4297 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4298 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4300 exit (stream
== stdout
? 0 : 1);
4303 /* Record the fact that the user wants the contents of section number
4304 SECTION to be displayed using the method(s) encoded as flags bits
4305 in TYPE. Note, TYPE can be zero if we are creating the array for
4309 request_dump_bynumber (unsigned int section
, dump_type type
)
4311 if (section
>= num_dump_sects
)
4313 dump_type
* new_dump_sects
;
4315 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4316 sizeof (* dump_sects
));
4318 if (new_dump_sects
== NULL
)
4319 error (_("Out of memory allocating dump request table.\n"));
4324 /* Copy current flag settings. */
4325 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4330 dump_sects
= new_dump_sects
;
4331 num_dump_sects
= section
+ 1;
4336 dump_sects
[section
] |= type
;
4341 /* Request a dump by section name. */
4344 request_dump_byname (const char * section
, dump_type type
)
4346 struct dump_list_entry
* new_request
;
4348 new_request
= (struct dump_list_entry
*)
4349 malloc (sizeof (struct dump_list_entry
));
4351 error (_("Out of memory allocating dump request table.\n"));
4353 new_request
->name
= strdup (section
);
4354 if (!new_request
->name
)
4355 error (_("Out of memory allocating dump request table.\n"));
4357 new_request
->type
= type
;
4359 new_request
->next
= dump_sects_byname
;
4360 dump_sects_byname
= new_request
;
4364 request_dump (dump_type type
)
4370 section
= strtoul (optarg
, & cp
, 0);
4372 if (! *cp
&& section
>= 0)
4373 request_dump_bynumber (section
, type
);
4375 request_dump_byname (optarg
, type
);
4380 parse_args (int argc
, char ** argv
)
4387 while ((c
= getopt_long
4388 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4406 do_section_groups
++;
4414 do_section_groups
++;
4419 do_section_details
++;
4463 request_dump (HEX_DUMP
);
4466 request_dump (STRING_DUMP
);
4469 request_dump (RELOC_DUMP
);
4479 dwarf_select_sections_all ();
4484 dwarf_select_sections_by_letters (optarg
);
4487 case OPTION_DEBUG_DUMP
:
4494 dwarf_select_sections_by_names (optarg
);
4497 case OPTION_DWARF_DEPTH
:
4501 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4504 case OPTION_DWARF_START
:
4508 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4511 case OPTION_DWARF_CHECK
:
4514 case OPTION_DYN_SYMS
:
4517 #ifdef SUPPORT_DISASSEMBLY
4519 request_dump (DISASS_DUMP
);
4523 print_version (program_name
);
4532 /* xgettext:c-format */
4533 error (_("Invalid option '-%c'\n"), c
);
4540 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4541 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4542 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4543 && !do_section_groups
&& !do_archive_index
4549 get_elf_class (unsigned int elf_class
)
4551 static char buff
[32];
4555 case ELFCLASSNONE
: return _("none");
4556 case ELFCLASS32
: return "ELF32";
4557 case ELFCLASS64
: return "ELF64";
4559 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4565 get_data_encoding (unsigned int encoding
)
4567 static char buff
[32];
4571 case ELFDATANONE
: return _("none");
4572 case ELFDATA2LSB
: return _("2's complement, little endian");
4573 case ELFDATA2MSB
: return _("2's complement, big endian");
4575 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4580 /* Decode the data held in 'elf_header'. */
4583 process_file_header (void)
4585 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4586 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4587 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4588 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4591 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4595 init_dwarf_regnames (elf_header
.e_machine
);
4601 printf (_("ELF Header:\n"));
4602 printf (_(" Magic: "));
4603 for (i
= 0; i
< EI_NIDENT
; i
++)
4604 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4606 printf (_(" Class: %s\n"),
4607 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4608 printf (_(" Data: %s\n"),
4609 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4610 printf (_(" Version: %d %s\n"),
4611 elf_header
.e_ident
[EI_VERSION
],
4612 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4614 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4615 ? _("<unknown: %lx>")
4617 printf (_(" OS/ABI: %s\n"),
4618 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4619 printf (_(" ABI Version: %d\n"),
4620 elf_header
.e_ident
[EI_ABIVERSION
]);
4621 printf (_(" Type: %s\n"),
4622 get_file_type (elf_header
.e_type
));
4623 printf (_(" Machine: %s\n"),
4624 get_machine_name (elf_header
.e_machine
));
4625 printf (_(" Version: 0x%lx\n"),
4626 (unsigned long) elf_header
.e_version
);
4628 printf (_(" Entry point address: "));
4629 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4630 printf (_("\n Start of program headers: "));
4631 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4632 printf (_(" (bytes into file)\n Start of section headers: "));
4633 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4634 printf (_(" (bytes into file)\n"));
4636 printf (_(" Flags: 0x%lx%s\n"),
4637 (unsigned long) elf_header
.e_flags
,
4638 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4639 printf (_(" Size of this header: %ld (bytes)\n"),
4640 (long) elf_header
.e_ehsize
);
4641 printf (_(" Size of program headers: %ld (bytes)\n"),
4642 (long) elf_header
.e_phentsize
);
4643 printf (_(" Number of program headers: %ld"),
4644 (long) elf_header
.e_phnum
);
4645 if (section_headers
!= NULL
4646 && elf_header
.e_phnum
== PN_XNUM
4647 && section_headers
[0].sh_info
!= 0)
4648 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4649 putc ('\n', stdout
);
4650 printf (_(" Size of section headers: %ld (bytes)\n"),
4651 (long) elf_header
.e_shentsize
);
4652 printf (_(" Number of section headers: %ld"),
4653 (long) elf_header
.e_shnum
);
4654 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4655 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4656 putc ('\n', stdout
);
4657 printf (_(" Section header string table index: %ld"),
4658 (long) elf_header
.e_shstrndx
);
4659 if (section_headers
!= NULL
4660 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4661 printf (" (%u)", section_headers
[0].sh_link
);
4662 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4663 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4664 printf (_(" <corrupt: out of range>"));
4665 putc ('\n', stdout
);
4668 if (section_headers
!= NULL
)
4670 if (elf_header
.e_phnum
== PN_XNUM
4671 && section_headers
[0].sh_info
!= 0)
4672 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4673 if (elf_header
.e_shnum
== SHN_UNDEF
)
4674 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4675 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4676 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4677 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4678 elf_header
.e_shstrndx
= SHN_UNDEF
;
4679 free (section_headers
);
4680 section_headers
= NULL
;
4687 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4689 Elf32_External_Phdr
* phdrs
;
4690 Elf32_External_Phdr
* external
;
4691 Elf_Internal_Phdr
* internal
;
4693 unsigned int size
= elf_header
.e_phentsize
;
4694 unsigned int num
= elf_header
.e_phnum
;
4696 /* PR binutils/17531: Cope with unexpected section header sizes. */
4697 if (size
== 0 || num
== 0)
4699 if (size
< sizeof * phdrs
)
4701 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4704 if (size
> sizeof * phdrs
)
4705 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4707 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4708 size
, num
, _("program headers"));
4712 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4713 i
< elf_header
.e_phnum
;
4714 i
++, internal
++, external
++)
4716 internal
->p_type
= BYTE_GET (external
->p_type
);
4717 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4718 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4719 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4720 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4721 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4722 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4723 internal
->p_align
= BYTE_GET (external
->p_align
);
4731 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4733 Elf64_External_Phdr
* phdrs
;
4734 Elf64_External_Phdr
* external
;
4735 Elf_Internal_Phdr
* internal
;
4737 unsigned int size
= elf_header
.e_phentsize
;
4738 unsigned int num
= elf_header
.e_phnum
;
4740 /* PR binutils/17531: Cope with unexpected section header sizes. */
4741 if (size
== 0 || num
== 0)
4743 if (size
< sizeof * phdrs
)
4745 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4748 if (size
> sizeof * phdrs
)
4749 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4751 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4752 size
, num
, _("program headers"));
4756 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4757 i
< elf_header
.e_phnum
;
4758 i
++, internal
++, external
++)
4760 internal
->p_type
= BYTE_GET (external
->p_type
);
4761 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4762 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4763 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4764 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4765 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4766 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4767 internal
->p_align
= BYTE_GET (external
->p_align
);
4774 /* Returns 1 if the program headers were read into `program_headers'. */
4777 get_program_headers (FILE * file
)
4779 Elf_Internal_Phdr
* phdrs
;
4781 /* Check cache of prior read. */
4782 if (program_headers
!= NULL
)
4785 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4786 sizeof (Elf_Internal_Phdr
));
4790 error (_("Out of memory reading %u program headers\n"),
4791 elf_header
.e_phnum
);
4796 ? get_32bit_program_headers (file
, phdrs
)
4797 : get_64bit_program_headers (file
, phdrs
))
4799 program_headers
= phdrs
;
4807 /* Returns 1 if the program headers were loaded. */
4810 process_program_headers (FILE * file
)
4812 Elf_Internal_Phdr
* segment
;
4814 Elf_Internal_Phdr
* previous_load
= NULL
;
4816 if (elf_header
.e_phnum
== 0)
4818 /* PR binutils/12467. */
4819 if (elf_header
.e_phoff
!= 0)
4820 warn (_("possibly corrupt ELF header - it has a non-zero program"
4821 " header offset, but no program headers\n"));
4822 else if (do_segments
)
4823 printf (_("\nThere are no program headers in this file.\n"));
4827 if (do_segments
&& !do_header
)
4829 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4830 printf (_("Entry point "));
4831 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4832 printf (_("\nThere are %d program headers, starting at offset "),
4833 elf_header
.e_phnum
);
4834 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4838 if (! get_program_headers (file
))
4843 if (elf_header
.e_phnum
> 1)
4844 printf (_("\nProgram Headers:\n"));
4846 printf (_("\nProgram Headers:\n"));
4850 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4853 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4857 (_(" Type Offset VirtAddr PhysAddr\n"));
4859 (_(" FileSiz MemSiz Flags Align\n"));
4866 for (i
= 0, segment
= program_headers
;
4867 i
< elf_header
.e_phnum
;
4872 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4876 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4877 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4878 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4879 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4880 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4882 (segment
->p_flags
& PF_R
? 'R' : ' '),
4883 (segment
->p_flags
& PF_W
? 'W' : ' '),
4884 (segment
->p_flags
& PF_X
? 'E' : ' '));
4885 printf ("%#lx", (unsigned long) segment
->p_align
);
4889 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4890 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4893 print_vma (segment
->p_offset
, FULL_HEX
);
4897 print_vma (segment
->p_vaddr
, FULL_HEX
);
4899 print_vma (segment
->p_paddr
, FULL_HEX
);
4902 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4903 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4906 print_vma (segment
->p_filesz
, FULL_HEX
);
4910 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4911 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4914 print_vma (segment
->p_memsz
, FULL_HEX
);
4918 (segment
->p_flags
& PF_R
? 'R' : ' '),
4919 (segment
->p_flags
& PF_W
? 'W' : ' '),
4920 (segment
->p_flags
& PF_X
? 'E' : ' '));
4922 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4923 printf ("%#lx", (unsigned long) segment
->p_align
);
4926 print_vma (segment
->p_align
, PREFIX_HEX
);
4931 print_vma (segment
->p_offset
, FULL_HEX
);
4933 print_vma (segment
->p_vaddr
, FULL_HEX
);
4935 print_vma (segment
->p_paddr
, FULL_HEX
);
4937 print_vma (segment
->p_filesz
, FULL_HEX
);
4939 print_vma (segment
->p_memsz
, FULL_HEX
);
4941 (segment
->p_flags
& PF_R
? 'R' : ' '),
4942 (segment
->p_flags
& PF_W
? 'W' : ' '),
4943 (segment
->p_flags
& PF_X
? 'E' : ' '));
4944 print_vma (segment
->p_align
, PREFIX_HEX
);
4947 putc ('\n', stdout
);
4950 switch (segment
->p_type
)
4953 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4954 required by the ELF standard, several programs, including the Linux
4955 kernel, make use of non-ordered segments. */
4957 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4958 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4960 if (segment
->p_memsz
< segment
->p_filesz
)
4961 error (_("the segment's file size is larger than its memory size\n"));
4962 previous_load
= segment
;
4966 /* PR 20815 - Verify that the program header is loaded into memory. */
4967 if (i
> 0 && previous_load
!= NULL
)
4968 error (_("the PHDR segment must occur before any LOAD segment\n"));
4969 if (elf_header
.e_machine
!= EM_PARISC
)
4973 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4974 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4975 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4976 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4978 if (j
== elf_header
.e_phnum
)
4979 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4985 error (_("more than one dynamic segment\n"));
4987 /* By default, assume that the .dynamic section is the first
4988 section in the DYNAMIC segment. */
4989 dynamic_addr
= segment
->p_offset
;
4990 dynamic_size
= segment
->p_filesz
;
4991 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4992 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4994 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4995 dynamic_addr
= dynamic_size
= 0;
4998 /* Try to locate the .dynamic section. If there is
4999 a section header table, we can easily locate it. */
5000 if (section_headers
!= NULL
)
5002 Elf_Internal_Shdr
* sec
;
5004 sec
= find_section (".dynamic");
5005 if (sec
== NULL
|| sec
->sh_size
== 0)
5007 /* A corresponding .dynamic section is expected, but on
5008 IA-64/OpenVMS it is OK for it to be missing. */
5009 if (!is_ia64_vms ())
5010 error (_("no .dynamic section in the dynamic segment\n"));
5014 if (sec
->sh_type
== SHT_NOBITS
)
5020 dynamic_addr
= sec
->sh_offset
;
5021 dynamic_size
= sec
->sh_size
;
5023 if (dynamic_addr
< segment
->p_offset
5024 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5025 warn (_("the .dynamic section is not contained"
5026 " within the dynamic segment\n"));
5027 else if (dynamic_addr
> segment
->p_offset
)
5028 warn (_("the .dynamic section is not the first section"
5029 " in the dynamic segment.\n"));
5034 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5036 error (_("Unable to find program interpreter name\n"));
5040 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5042 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5043 error (_("Internal error: failed to create format string to display program interpreter\n"));
5045 program_interpreter
[0] = 0;
5046 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5047 error (_("Unable to read program interpreter name\n"));
5050 printf (_(" [Requesting program interpreter: %s]\n"),
5051 program_interpreter
);
5057 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5059 printf (_("\n Section to Segment mapping:\n"));
5060 printf (_(" Segment Sections...\n"));
5062 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5065 Elf_Internal_Shdr
* section
;
5067 segment
= program_headers
+ i
;
5068 section
= section_headers
+ 1;
5070 printf (" %2.2d ", i
);
5072 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5074 if (!ELF_TBSS_SPECIAL (section
, segment
)
5075 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5076 printf ("%s ", printable_section_name (section
));
5087 /* Find the file offset corresponding to VMA by using the program headers. */
5090 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5092 Elf_Internal_Phdr
* seg
;
5094 if (! get_program_headers (file
))
5096 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5100 for (seg
= program_headers
;
5101 seg
< program_headers
+ elf_header
.e_phnum
;
5104 if (seg
->p_type
!= PT_LOAD
)
5107 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5108 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5109 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5112 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5113 (unsigned long) vma
);
5118 /* Allocate memory and load the sections headers into the global pointer
5119 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5120 generate any error messages if the load fails. */
5123 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5125 Elf32_External_Shdr
* shdrs
;
5126 Elf_Internal_Shdr
* internal
;
5128 unsigned int size
= elf_header
.e_shentsize
;
5129 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5131 /* PR binutils/17531: Cope with unexpected section header sizes. */
5132 if (size
== 0 || num
== 0)
5134 if (size
< sizeof * shdrs
)
5137 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5140 if (!probe
&& size
> sizeof * shdrs
)
5141 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5143 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5145 probe
? NULL
: _("section headers"));
5149 if (section_headers
!= NULL
)
5150 free (section_headers
);
5151 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5152 sizeof (Elf_Internal_Shdr
));
5153 if (section_headers
== NULL
)
5156 error (_("Out of memory reading %u section headers\n"), num
);
5160 for (i
= 0, internal
= section_headers
;
5164 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5165 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5166 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5167 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5168 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5169 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5170 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5171 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5172 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5173 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5174 if (!probe
&& internal
->sh_link
> num
)
5175 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5176 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5177 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5185 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5187 Elf64_External_Shdr
* shdrs
;
5188 Elf_Internal_Shdr
* internal
;
5190 unsigned int size
= elf_header
.e_shentsize
;
5191 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5193 /* PR binutils/17531: Cope with unexpected section header sizes. */
5194 if (size
== 0 || num
== 0)
5196 if (size
< sizeof * shdrs
)
5199 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5202 if (! probe
&& size
> sizeof * shdrs
)
5203 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5205 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5207 probe
? NULL
: _("section headers"));
5211 if (section_headers
!= NULL
)
5212 free (section_headers
);
5213 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5214 sizeof (Elf_Internal_Shdr
));
5215 if (section_headers
== NULL
)
5218 error (_("Out of memory reading %u section headers\n"), num
);
5222 for (i
= 0, internal
= section_headers
;
5226 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5227 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5228 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5229 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5230 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5231 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5232 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5233 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5234 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5235 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5236 if (!probe
&& internal
->sh_link
> num
)
5237 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5238 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5239 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5246 static Elf_Internal_Sym
*
5247 get_32bit_elf_symbols (FILE * file
,
5248 Elf_Internal_Shdr
* section
,
5249 unsigned long * num_syms_return
)
5251 unsigned long number
= 0;
5252 Elf32_External_Sym
* esyms
= NULL
;
5253 Elf_External_Sym_Shndx
* shndx
= NULL
;
5254 Elf_Internal_Sym
* isyms
= NULL
;
5255 Elf_Internal_Sym
* psym
;
5258 if (section
->sh_size
== 0)
5260 if (num_syms_return
!= NULL
)
5261 * num_syms_return
= 0;
5265 /* Run some sanity checks first. */
5266 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5268 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5269 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5273 if (section
->sh_size
> current_file_size
)
5275 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5276 printable_section_name (section
), (unsigned long) section
->sh_size
);
5280 number
= section
->sh_size
/ section
->sh_entsize
;
5282 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5284 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5285 (unsigned long) section
->sh_size
,
5286 printable_section_name (section
),
5287 (unsigned long) section
->sh_entsize
);
5291 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5292 section
->sh_size
, _("symbols"));
5297 elf_section_list
* entry
;
5300 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5301 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5303 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5304 entry
->hdr
->sh_offset
,
5305 1, entry
->hdr
->sh_size
,
5306 _("symbol table section indicies"));
5309 /* PR17531: file: heap-buffer-overflow */
5310 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5312 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5313 printable_section_name (entry
->hdr
),
5314 (unsigned long) entry
->hdr
->sh_size
,
5315 (unsigned long) section
->sh_size
);
5321 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5325 error (_("Out of memory reading %lu symbols\n"),
5326 (unsigned long) number
);
5330 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5332 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5333 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5334 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5335 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5336 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5338 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5339 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5340 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5341 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5342 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5351 if (num_syms_return
!= NULL
)
5352 * num_syms_return
= isyms
== NULL
? 0 : number
;
5357 static Elf_Internal_Sym
*
5358 get_64bit_elf_symbols (FILE * file
,
5359 Elf_Internal_Shdr
* section
,
5360 unsigned long * num_syms_return
)
5362 unsigned long number
= 0;
5363 Elf64_External_Sym
* esyms
= NULL
;
5364 Elf_External_Sym_Shndx
* shndx
= NULL
;
5365 Elf_Internal_Sym
* isyms
= NULL
;
5366 Elf_Internal_Sym
* psym
;
5369 if (section
->sh_size
== 0)
5371 if (num_syms_return
!= NULL
)
5372 * num_syms_return
= 0;
5376 /* Run some sanity checks first. */
5377 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5379 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5380 printable_section_name (section
),
5381 (unsigned long) section
->sh_entsize
);
5385 if (section
->sh_size
> current_file_size
)
5387 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5388 printable_section_name (section
),
5389 (unsigned long) section
->sh_size
);
5393 number
= section
->sh_size
/ section
->sh_entsize
;
5395 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5397 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5398 (unsigned long) section
->sh_size
,
5399 printable_section_name (section
),
5400 (unsigned long) section
->sh_entsize
);
5404 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5405 section
->sh_size
, _("symbols"));
5410 elf_section_list
* entry
;
5413 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5414 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5416 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5417 entry
->hdr
->sh_offset
,
5418 1, entry
->hdr
->sh_size
,
5419 _("symbol table section indicies"));
5422 /* PR17531: file: heap-buffer-overflow */
5423 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5425 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5426 printable_section_name (entry
->hdr
),
5427 (unsigned long) entry
->hdr
->sh_size
,
5428 (unsigned long) section
->sh_size
);
5434 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5438 error (_("Out of memory reading %lu symbols\n"),
5439 (unsigned long) number
);
5443 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5445 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5446 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5447 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5448 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5450 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5452 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5453 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5454 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5456 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5457 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5466 if (num_syms_return
!= NULL
)
5467 * num_syms_return
= isyms
== NULL
? 0 : number
;
5473 get_elf_section_flags (bfd_vma sh_flags
)
5475 static char buff
[1024];
5477 int field_size
= is_32bit_elf
? 8 : 16;
5479 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5480 bfd_vma os_flags
= 0;
5481 bfd_vma proc_flags
= 0;
5482 bfd_vma unknown_flags
= 0;
5490 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5491 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5492 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5493 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5494 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5495 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5496 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5497 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5498 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5499 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5500 /* IA-64 specific. */
5501 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5502 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5503 /* IA-64 OpenVMS specific. */
5504 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5505 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5506 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5507 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5508 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5509 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5511 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5512 /* SPARC specific. */
5513 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5514 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5516 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5517 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5518 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5521 if (do_section_details
)
5523 sprintf (buff
, "[%*.*lx]: ",
5524 field_size
, field_size
, (unsigned long) sh_flags
);
5525 p
+= field_size
+ 4;
5532 flag
= sh_flags
& - sh_flags
;
5535 if (do_section_details
)
5539 case SHF_WRITE
: sindex
= 0; break;
5540 case SHF_ALLOC
: sindex
= 1; break;
5541 case SHF_EXECINSTR
: sindex
= 2; break;
5542 case SHF_MERGE
: sindex
= 3; break;
5543 case SHF_STRINGS
: sindex
= 4; break;
5544 case SHF_INFO_LINK
: sindex
= 5; break;
5545 case SHF_LINK_ORDER
: sindex
= 6; break;
5546 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5547 case SHF_GROUP
: sindex
= 8; break;
5548 case SHF_TLS
: sindex
= 9; break;
5549 case SHF_EXCLUDE
: sindex
= 18; break;
5550 case SHF_COMPRESSED
: sindex
= 20; break;
5554 switch (elf_header
.e_machine
)
5557 if (flag
== SHF_IA_64_SHORT
)
5559 else if (flag
== SHF_IA_64_NORECOV
)
5562 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5565 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5566 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5567 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5568 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5569 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5570 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5581 case EM_OLD_SPARCV9
:
5582 case EM_SPARC32PLUS
:
5585 if (flag
== SHF_ORDERED
)
5592 case SHF_ENTRYSECT
: sindex
= 21; break;
5593 case SHF_ARM_PURECODE
: sindex
= 22; break;
5594 case SHF_COMDEF
: sindex
= 23; break;
5606 if (p
!= buff
+ field_size
+ 4)
5608 if (size
< (10 + 2))
5610 warn (_("Internal error: not enough buffer room for section flag info"));
5611 return _("<unknown>");
5618 size
-= flags
[sindex
].len
;
5619 p
= stpcpy (p
, flags
[sindex
].str
);
5621 else if (flag
& SHF_MASKOS
)
5623 else if (flag
& SHF_MASKPROC
)
5626 unknown_flags
|= flag
;
5632 case SHF_WRITE
: *p
= 'W'; break;
5633 case SHF_ALLOC
: *p
= 'A'; break;
5634 case SHF_EXECINSTR
: *p
= 'X'; break;
5635 case SHF_MERGE
: *p
= 'M'; break;
5636 case SHF_STRINGS
: *p
= 'S'; break;
5637 case SHF_INFO_LINK
: *p
= 'I'; break;
5638 case SHF_LINK_ORDER
: *p
= 'L'; break;
5639 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5640 case SHF_GROUP
: *p
= 'G'; break;
5641 case SHF_TLS
: *p
= 'T'; break;
5642 case SHF_EXCLUDE
: *p
= 'E'; break;
5643 case SHF_COMPRESSED
: *p
= 'C'; break;
5646 if ((elf_header
.e_machine
== EM_X86_64
5647 || elf_header
.e_machine
== EM_L1OM
5648 || elf_header
.e_machine
== EM_K1OM
)
5649 && flag
== SHF_X86_64_LARGE
)
5651 else if (elf_header
.e_machine
== EM_ARM
5652 && flag
== SHF_ARM_PURECODE
)
5654 else if (flag
& SHF_MASKOS
)
5657 sh_flags
&= ~ SHF_MASKOS
;
5659 else if (flag
& SHF_MASKPROC
)
5662 sh_flags
&= ~ SHF_MASKPROC
;
5672 if (do_section_details
)
5676 size
-= 5 + field_size
;
5677 if (p
!= buff
+ field_size
+ 4)
5681 warn (_("Internal error: not enough buffer room for section flag info"));
5682 return _("<unknown>");
5688 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5689 (unsigned long) os_flags
);
5690 p
+= 5 + field_size
;
5694 size
-= 7 + field_size
;
5695 if (p
!= buff
+ field_size
+ 4)
5699 warn (_("Internal error: not enough buffer room for section flag info"));
5700 return _("<unknown>");
5706 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5707 (unsigned long) proc_flags
);
5708 p
+= 7 + field_size
;
5712 size
-= 10 + field_size
;
5713 if (p
!= buff
+ field_size
+ 4)
5717 warn (_("Internal error: not enough buffer room for section flag info"));
5718 return _("<unknown>");
5724 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5725 (unsigned long) unknown_flags
);
5726 p
+= 10 + field_size
;
5735 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5739 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5741 if (size
< sizeof (* echdr
))
5743 error (_("Compressed section is too small even for a compression header\n"));
5747 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5748 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5749 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5750 return sizeof (*echdr
);
5754 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5756 if (size
< sizeof (* echdr
))
5758 error (_("Compressed section is too small even for a compression header\n"));
5762 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5763 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5764 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5765 return sizeof (*echdr
);
5770 process_section_headers (FILE * file
)
5772 Elf_Internal_Shdr
* section
;
5775 section_headers
= NULL
;
5777 if (elf_header
.e_shnum
== 0)
5779 /* PR binutils/12467. */
5780 if (elf_header
.e_shoff
!= 0)
5781 warn (_("possibly corrupt ELF file header - it has a non-zero"
5782 " section header offset, but no section headers\n"));
5783 else if (do_sections
)
5784 printf (_("\nThere are no sections in this file.\n"));
5789 if (do_sections
&& !do_header
)
5790 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5791 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5795 if (! get_32bit_section_headers (file
, FALSE
))
5798 else if (! get_64bit_section_headers (file
, FALSE
))
5801 /* Read in the string table, so that we have names to display. */
5802 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5803 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5805 section
= section_headers
+ elf_header
.e_shstrndx
;
5807 if (section
->sh_size
!= 0)
5809 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5810 1, section
->sh_size
,
5813 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5817 /* Scan the sections for the dynamic symbol table
5818 and dynamic string table and debug sections. */
5819 dynamic_symbols
= NULL
;
5820 dynamic_strings
= NULL
;
5821 dynamic_syminfo
= NULL
;
5822 symtab_shndx_list
= NULL
;
5824 eh_addr_size
= is_32bit_elf
? 4 : 8;
5825 switch (elf_header
.e_machine
)
5828 case EM_MIPS_RS3_LE
:
5829 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5830 FDE addresses. However, the ABI also has a semi-official ILP32
5831 variant for which the normal FDE address size rules apply.
5833 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5834 section, where XX is the size of longs in bits. Unfortunately,
5835 earlier compilers provided no way of distinguishing ILP32 objects
5836 from LP64 objects, so if there's any doubt, we should assume that
5837 the official LP64 form is being used. */
5838 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5839 && find_section (".gcc_compiled_long32") == NULL
)
5845 switch (elf_header
.e_flags
& EF_H8_MACH
)
5847 case E_H8_MACH_H8300
:
5848 case E_H8_MACH_H8300HN
:
5849 case E_H8_MACH_H8300SN
:
5850 case E_H8_MACH_H8300SXN
:
5853 case E_H8_MACH_H8300H
:
5854 case E_H8_MACH_H8300S
:
5855 case E_H8_MACH_H8300SX
:
5863 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5865 case EF_M32C_CPU_M16C
:
5872 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5875 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5876 if (section->sh_entsize != expected_entsize) \
5879 sprintf_vma (buf, section->sh_entsize); \
5880 /* Note: coded this way so that there is a single string for \
5882 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5883 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5884 (unsigned) expected_entsize); \
5885 section->sh_entsize = expected_entsize; \
5890 #define CHECK_ENTSIZE(section, i, type) \
5891 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5892 sizeof (Elf64_External_##type))
5894 for (i
= 0, section
= section_headers
;
5895 i
< elf_header
.e_shnum
;
5898 char * name
= SECTION_NAME (section
);
5900 if (section
->sh_type
== SHT_DYNSYM
)
5902 if (dynamic_symbols
!= NULL
)
5904 error (_("File contains multiple dynamic symbol tables\n"));
5908 CHECK_ENTSIZE (section
, i
, Sym
);
5909 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5911 else if (section
->sh_type
== SHT_STRTAB
5912 && streq (name
, ".dynstr"))
5914 if (dynamic_strings
!= NULL
)
5916 error (_("File contains multiple dynamic string tables\n"));
5920 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5921 1, section
->sh_size
,
5922 _("dynamic strings"));
5923 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5925 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5927 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5928 entry
->hdr
= section
;
5929 entry
->next
= symtab_shndx_list
;
5930 symtab_shndx_list
= entry
;
5932 else if (section
->sh_type
== SHT_SYMTAB
)
5933 CHECK_ENTSIZE (section
, i
, Sym
);
5934 else if (section
->sh_type
== SHT_GROUP
)
5935 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5936 else if (section
->sh_type
== SHT_REL
)
5937 CHECK_ENTSIZE (section
, i
, Rel
);
5938 else if (section
->sh_type
== SHT_RELA
)
5939 CHECK_ENTSIZE (section
, i
, Rela
);
5940 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5941 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5942 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5943 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5944 || do_debug_addr
|| do_debug_cu_index
)
5945 && (const_strneq (name
, ".debug_")
5946 || const_strneq (name
, ".zdebug_")))
5949 name
+= sizeof (".zdebug_") - 1;
5951 name
+= sizeof (".debug_") - 1;
5954 || (do_debug_info
&& const_strneq (name
, "info"))
5955 || (do_debug_info
&& const_strneq (name
, "types"))
5956 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5957 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5958 || (do_debug_lines
&& const_strneq (name
, "line."))
5959 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5960 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5961 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5962 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5963 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5964 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5965 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
5966 || (do_debug_frames
&& const_strneq (name
, "frame"))
5967 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5968 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5969 || (do_debug_str
&& const_strneq (name
, "str"))
5970 || (do_debug_loc
&& const_strneq (name
, "loc"))
5971 || (do_debug_loc
&& const_strneq (name
, "loclists"))
5972 || (do_debug_addr
&& const_strneq (name
, "addr"))
5973 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5974 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5976 request_dump_bynumber (i
, DEBUG_DUMP
);
5978 /* Linkonce section to be combined with .debug_info at link time. */
5979 else if ((do_debugging
|| do_debug_info
)
5980 && const_strneq (name
, ".gnu.linkonce.wi."))
5981 request_dump_bynumber (i
, DEBUG_DUMP
);
5982 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5983 request_dump_bynumber (i
, DEBUG_DUMP
);
5984 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5985 request_dump_bynumber (i
, DEBUG_DUMP
);
5986 /* Trace sections for Itanium VMS. */
5987 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5988 || do_trace_aranges
)
5989 && const_strneq (name
, ".trace_"))
5991 name
+= sizeof (".trace_") - 1;
5994 || (do_trace_info
&& streq (name
, "info"))
5995 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5996 || (do_trace_aranges
&& streq (name
, "aranges"))
5998 request_dump_bynumber (i
, DEBUG_DUMP
);
6005 if (elf_header
.e_shnum
> 1)
6006 printf (_("\nSection Headers:\n"));
6008 printf (_("\nSection Header:\n"));
6012 if (do_section_details
)
6014 printf (_(" [Nr] Name\n"));
6015 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6019 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6023 if (do_section_details
)
6025 printf (_(" [Nr] Name\n"));
6026 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6030 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6034 if (do_section_details
)
6036 printf (_(" [Nr] Name\n"));
6037 printf (_(" Type Address Offset Link\n"));
6038 printf (_(" Size EntSize Info Align\n"));
6042 printf (_(" [Nr] Name Type Address Offset\n"));
6043 printf (_(" Size EntSize Flags Link Info Align\n"));
6047 if (do_section_details
)
6048 printf (_(" Flags\n"));
6050 for (i
= 0, section
= section_headers
;
6051 i
< elf_header
.e_shnum
;
6054 /* Run some sanity checks on the section header. */
6056 /* Check the sh_link field. */
6057 switch (section
->sh_type
)
6059 case SHT_SYMTAB_SHNDX
:
6063 case SHT_GNU_versym
:
6066 if (section
->sh_link
< 1
6067 || section
->sh_link
>= elf_header
.e_shnum
6068 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6069 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6070 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6071 i
, section
->sh_link
);
6077 case SHT_GNU_verneed
:
6078 case SHT_GNU_verdef
:
6079 case SHT_GNU_LIBLIST
:
6080 if (section
->sh_link
< 1
6081 || section
->sh_link
>= elf_header
.e_shnum
6082 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6083 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6084 i
, section
->sh_link
);
6087 case SHT_INIT_ARRAY
:
6088 case SHT_FINI_ARRAY
:
6089 case SHT_PREINIT_ARRAY
:
6090 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6091 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6092 i
, section
->sh_link
);
6096 /* FIXME: Add support for target specific section types. */
6097 #if 0 /* Currently we do not check other section types as there are too
6098 many special cases. Stab sections for example have a type
6099 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6101 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6102 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6103 i
, section
->sh_link
);
6108 /* Check the sh_info field. */
6109 switch (section
->sh_type
)
6113 if (section
->sh_info
< 1
6114 || section
->sh_info
>= elf_header
.e_shnum
6115 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6116 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6117 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6118 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6119 /* FIXME: Are other section types valid ? */
6120 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6122 if (section
->sh_info
== 0
6123 && (streq (SECTION_NAME (section
), ".rel.dyn")
6124 || streq (SECTION_NAME (section
), ".rela.dyn")))
6125 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6126 of zero. The relocations in these sections may apply
6127 to many different sections. */
6130 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6131 i
, section
->sh_info
);
6137 case SHT_SYMTAB_SHNDX
:
6138 case SHT_INIT_ARRAY
:
6139 case SHT_FINI_ARRAY
:
6140 case SHT_PREINIT_ARRAY
:
6141 if (section
->sh_info
!= 0)
6142 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6143 i
, section
->sh_info
);
6149 /* A symbol index - we assume that it is valid. */
6153 /* FIXME: Add support for target specific section types. */
6154 if (section
->sh_type
== SHT_NOBITS
)
6155 /* NOBITS section headers with non-zero sh_info fields can be
6156 created when a binary is stripped of everything but its debug
6157 information. The stripped sections have their headers
6158 preserved but their types set to SHT_NOBITS. So do not check
6159 this type of section. */
6161 else if (section
->sh_flags
& SHF_INFO_LINK
)
6163 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6164 warn (_("[%2u]: Expected link to another section in info field"), i
);
6166 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6167 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6168 i
, section
->sh_info
);
6172 printf (" [%2u] ", i
);
6173 if (do_section_details
)
6174 printf ("%s\n ", printable_section_name (section
));
6176 print_symbol (-17, SECTION_NAME (section
));
6178 printf (do_wide
? " %-15s " : " %-15.15s ",
6179 get_section_type_name (section
->sh_type
));
6183 const char * link_too_big
= NULL
;
6185 print_vma (section
->sh_addr
, LONG_HEX
);
6187 printf ( " %6.6lx %6.6lx %2.2lx",
6188 (unsigned long) section
->sh_offset
,
6189 (unsigned long) section
->sh_size
,
6190 (unsigned long) section
->sh_entsize
);
6192 if (do_section_details
)
6193 fputs (" ", stdout
);
6195 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6197 if (section
->sh_link
>= elf_header
.e_shnum
)
6200 /* The sh_link value is out of range. Normally this indicates
6201 an error but it can have special values in Solaris binaries. */
6202 switch (elf_header
.e_machine
)
6209 case EM_OLD_SPARCV9
:
6210 case EM_SPARC32PLUS
:
6213 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6214 link_too_big
= "BEFORE";
6215 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6216 link_too_big
= "AFTER";
6223 if (do_section_details
)
6225 if (link_too_big
!= NULL
&& * link_too_big
)
6226 printf ("<%s> ", link_too_big
);
6228 printf ("%2u ", section
->sh_link
);
6229 printf ("%3u %2lu\n", section
->sh_info
,
6230 (unsigned long) section
->sh_addralign
);
6233 printf ("%2u %3u %2lu\n",
6236 (unsigned long) section
->sh_addralign
);
6238 if (link_too_big
&& ! * link_too_big
)
6239 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6240 i
, section
->sh_link
);
6244 print_vma (section
->sh_addr
, LONG_HEX
);
6246 if ((long) section
->sh_offset
== section
->sh_offset
)
6247 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6251 print_vma (section
->sh_offset
, LONG_HEX
);
6254 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6255 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6259 print_vma (section
->sh_size
, LONG_HEX
);
6262 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6263 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6267 print_vma (section
->sh_entsize
, LONG_HEX
);
6270 if (do_section_details
)
6271 fputs (" ", stdout
);
6273 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6275 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6277 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6278 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6281 print_vma (section
->sh_addralign
, DEC
);
6285 else if (do_section_details
)
6287 printf (" %-15.15s ",
6288 get_section_type_name (section
->sh_type
));
6289 print_vma (section
->sh_addr
, LONG_HEX
);
6290 if ((long) section
->sh_offset
== section
->sh_offset
)
6291 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6295 print_vma (section
->sh_offset
, LONG_HEX
);
6297 printf (" %u\n ", section
->sh_link
);
6298 print_vma (section
->sh_size
, LONG_HEX
);
6300 print_vma (section
->sh_entsize
, LONG_HEX
);
6302 printf (" %-16u %lu\n",
6304 (unsigned long) section
->sh_addralign
);
6309 print_vma (section
->sh_addr
, LONG_HEX
);
6310 if ((long) section
->sh_offset
== section
->sh_offset
)
6311 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6315 print_vma (section
->sh_offset
, LONG_HEX
);
6318 print_vma (section
->sh_size
, LONG_HEX
);
6320 print_vma (section
->sh_entsize
, LONG_HEX
);
6322 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6324 printf (" %2u %3u %lu\n",
6327 (unsigned long) section
->sh_addralign
);
6330 if (do_section_details
)
6332 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6333 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6335 /* Minimum section size is 12 bytes for 32-bit compression
6336 header + 12 bytes for compressed data header. */
6337 unsigned char buf
[24];
6339 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6340 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6341 sizeof (buf
), _("compression header")))
6343 Elf_Internal_Chdr chdr
;
6345 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6347 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6350 printf (_(" [<unknown>: 0x%x], "),
6352 print_vma (chdr
.ch_size
, LONG_HEX
);
6353 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6359 if (!do_section_details
)
6361 /* The ordering of the letters shown here matches the ordering of the
6362 corresponding SHF_xxx values, and hence the order in which these
6363 letters will be displayed to the user. */
6364 printf (_("Key to Flags:\n\
6365 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6366 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6367 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6368 if (elf_header
.e_machine
== EM_X86_64
6369 || elf_header
.e_machine
== EM_L1OM
6370 || elf_header
.e_machine
== EM_K1OM
)
6371 printf (_("l (large), "));
6372 else if (elf_header
.e_machine
== EM_ARM
)
6373 printf (_("y (purecode), "));
6374 printf ("p (processor specific)\n");
6381 get_group_flags (unsigned int flags
)
6383 static char buff
[128];
6387 else if (flags
== GRP_COMDAT
)
6390 snprintf (buff
, 14, _("[0x%x: "), flags
);
6392 flags
&= ~ GRP_COMDAT
;
6393 if (flags
& GRP_MASKOS
)
6395 strcat (buff
, "<OS specific>");
6396 flags
&= ~ GRP_MASKOS
;
6399 if (flags
& GRP_MASKPROC
)
6401 strcat (buff
, "<PROC specific>");
6402 flags
&= ~ GRP_MASKPROC
;
6406 strcat (buff
, "<unknown>");
6413 process_section_groups (FILE * file
)
6415 Elf_Internal_Shdr
* section
;
6417 struct group
* group
;
6418 Elf_Internal_Shdr
* symtab_sec
;
6419 Elf_Internal_Shdr
* strtab_sec
;
6420 Elf_Internal_Sym
* symtab
;
6421 unsigned long num_syms
;
6425 /* Don't process section groups unless needed. */
6426 if (!do_unwind
&& !do_section_groups
)
6429 if (elf_header
.e_shnum
== 0)
6431 if (do_section_groups
)
6432 printf (_("\nThere are no sections to group in this file.\n"));
6437 if (section_headers
== NULL
)
6439 error (_("Section headers are not available!\n"));
6440 /* PR 13622: This can happen with a corrupt ELF header. */
6444 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6445 sizeof (struct group
*));
6447 if (section_headers_groups
== NULL
)
6449 error (_("Out of memory reading %u section group headers\n"),
6450 elf_header
.e_shnum
);
6454 /* Scan the sections for the group section. */
6456 for (i
= 0, section
= section_headers
;
6457 i
< elf_header
.e_shnum
;
6459 if (section
->sh_type
== SHT_GROUP
)
6462 if (group_count
== 0)
6464 if (do_section_groups
)
6465 printf (_("\nThere are no section groups in this file.\n"));
6470 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6472 if (section_groups
== NULL
)
6474 error (_("Out of memory reading %lu groups\n"),
6475 (unsigned long) group_count
);
6485 for (i
= 0, section
= section_headers
, group
= section_groups
;
6486 i
< elf_header
.e_shnum
;
6489 if (section
->sh_type
== SHT_GROUP
)
6491 const char * name
= printable_section_name (section
);
6492 const char * group_name
;
6493 unsigned char * start
;
6494 unsigned char * indices
;
6495 unsigned int entry
, j
, size
;
6496 Elf_Internal_Shdr
* sec
;
6497 Elf_Internal_Sym
* sym
;
6499 /* Get the symbol table. */
6500 if (section
->sh_link
>= elf_header
.e_shnum
6501 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6504 error (_("Bad sh_link in group section `%s'\n"), name
);
6508 if (symtab_sec
!= sec
)
6513 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6518 error (_("Corrupt header in group section `%s'\n"), name
);
6522 if (section
->sh_info
>= num_syms
)
6524 error (_("Bad sh_info in group section `%s'\n"), name
);
6528 sym
= symtab
+ section
->sh_info
;
6530 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6532 if (sym
->st_shndx
== 0
6533 || sym
->st_shndx
>= elf_header
.e_shnum
)
6535 error (_("Bad sh_info in group section `%s'\n"), name
);
6539 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6548 /* Get the string table. */
6549 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6558 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6564 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6565 1, strtab_sec
->sh_size
,
6567 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6569 group_name
= sym
->st_name
< strtab_size
6570 ? strtab
+ sym
->st_name
: _("<corrupt>");
6573 /* PR 17531: file: loop. */
6574 if (section
->sh_entsize
> section
->sh_size
)
6576 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6577 printable_section_name (section
),
6578 (unsigned long) section
->sh_entsize
,
6579 (unsigned long) section
->sh_size
);
6583 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6584 1, section
->sh_size
,
6590 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6591 entry
= byte_get (indices
, 4);
6594 if (do_section_groups
)
6596 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6597 get_group_flags (entry
), i
, name
, group_name
, size
);
6599 printf (_(" [Index] Name\n"));
6602 group
->group_index
= i
;
6604 for (j
= 0; j
< size
; j
++)
6606 struct group_list
* g
;
6608 entry
= byte_get (indices
, 4);
6611 if (entry
>= elf_header
.e_shnum
)
6613 static unsigned num_group_errors
= 0;
6615 if (num_group_errors
++ < 10)
6617 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6618 entry
, i
, elf_header
.e_shnum
- 1);
6619 if (num_group_errors
== 10)
6620 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6625 if (section_headers_groups
[entry
] != NULL
)
6629 static unsigned num_errs
= 0;
6631 if (num_errs
++ < 10)
6633 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6635 section_headers_groups
[entry
]->group_index
);
6637 warn (_("Further error messages about already contained group sections suppressed\n"));
6643 /* Intel C/C++ compiler may put section 0 in a
6644 section group. We just warn it the first time
6645 and ignore it afterwards. */
6646 static int warned
= 0;
6649 error (_("section 0 in group section [%5u]\n"),
6650 section_headers_groups
[entry
]->group_index
);
6656 section_headers_groups
[entry
] = group
;
6658 if (do_section_groups
)
6660 sec
= section_headers
+ entry
;
6661 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6664 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6665 g
->section_index
= entry
;
6666 g
->next
= group
->root
;
6684 /* Data used to display dynamic fixups. */
6686 struct ia64_vms_dynfixup
6688 bfd_vma needed_ident
; /* Library ident number. */
6689 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6690 bfd_vma fixup_needed
; /* Index of the library. */
6691 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6692 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6695 /* Data used to display dynamic relocations. */
6697 struct ia64_vms_dynimgrela
6699 bfd_vma img_rela_cnt
; /* Number of relocations. */
6700 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6703 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6707 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6708 const char *strtab
, unsigned int strtab_sz
)
6710 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6712 const char *lib_name
;
6714 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6715 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6716 _("dynamic section image fixups"));
6720 if (fixup
->needed
< strtab_sz
)
6721 lib_name
= strtab
+ fixup
->needed
;
6724 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6725 (unsigned long) fixup
->needed
);
6728 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6729 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6731 (_("Seg Offset Type SymVec DataType\n"));
6733 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6738 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6739 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6740 type
= BYTE_GET (imfs
[i
].type
);
6741 rtype
= elf_ia64_reloc_type (type
);
6743 printf (" 0x%08x ", type
);
6745 printf (" %-32s ", rtype
);
6746 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6747 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6753 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6756 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6758 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6761 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6762 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6763 _("dynamic section image relocations"));
6767 printf (_("\nImage relocs\n"));
6769 (_("Seg Offset Type Addend Seg Sym Off\n"));
6771 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6776 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6777 printf ("%08" BFD_VMA_FMT
"x ",
6778 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6779 type
= BYTE_GET (imrs
[i
].type
);
6780 rtype
= elf_ia64_reloc_type (type
);
6782 printf ("0x%08x ", type
);
6784 printf ("%-31s ", rtype
);
6785 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6786 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6787 printf ("%08" BFD_VMA_FMT
"x\n",
6788 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6794 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6797 process_ia64_vms_dynamic_relocs (FILE *file
)
6799 struct ia64_vms_dynfixup fixup
;
6800 struct ia64_vms_dynimgrela imgrela
;
6801 Elf_Internal_Dyn
*entry
;
6803 bfd_vma strtab_off
= 0;
6804 bfd_vma strtab_sz
= 0;
6805 char *strtab
= NULL
;
6807 memset (&fixup
, 0, sizeof (fixup
));
6808 memset (&imgrela
, 0, sizeof (imgrela
));
6810 /* Note: the order of the entries is specified by the OpenVMS specs. */
6811 for (entry
= dynamic_section
;
6812 entry
< dynamic_section
+ dynamic_nent
;
6815 switch (entry
->d_tag
)
6817 case DT_IA_64_VMS_STRTAB_OFFSET
:
6818 strtab_off
= entry
->d_un
.d_val
;
6821 strtab_sz
= entry
->d_un
.d_val
;
6823 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6824 1, strtab_sz
, _("dynamic string section"));
6827 case DT_IA_64_VMS_NEEDED_IDENT
:
6828 fixup
.needed_ident
= entry
->d_un
.d_val
;
6831 fixup
.needed
= entry
->d_un
.d_val
;
6833 case DT_IA_64_VMS_FIXUP_NEEDED
:
6834 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6836 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6837 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6839 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6840 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6842 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6845 case DT_IA_64_VMS_IMG_RELA_CNT
:
6846 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6848 case DT_IA_64_VMS_IMG_RELA_OFF
:
6849 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6851 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6871 } dynamic_relocations
[] =
6873 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6874 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6875 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6878 /* Process the reloc section. */
6881 process_relocs (FILE * file
)
6883 unsigned long rel_size
;
6884 unsigned long rel_offset
;
6890 if (do_using_dynamic
)
6894 int has_dynamic_reloc
;
6897 has_dynamic_reloc
= 0;
6899 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6901 is_rela
= dynamic_relocations
[i
].rela
;
6902 name
= dynamic_relocations
[i
].name
;
6903 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6904 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6906 has_dynamic_reloc
|= rel_size
;
6908 if (is_rela
== UNKNOWN
)
6910 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6911 switch (dynamic_info
[DT_PLTREL
])
6925 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6926 name
, rel_offset
, rel_size
);
6928 dump_relocations (file
,
6929 offset_from_vma (file
, rel_offset
, rel_size
),
6931 dynamic_symbols
, num_dynamic_syms
,
6932 dynamic_strings
, dynamic_strings_length
,
6938 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6940 if (! has_dynamic_reloc
)
6941 printf (_("\nThere are no dynamic relocations in this file.\n"));
6945 Elf_Internal_Shdr
* section
;
6949 for (i
= 0, section
= section_headers
;
6950 i
< elf_header
.e_shnum
;
6953 if ( section
->sh_type
!= SHT_RELA
6954 && section
->sh_type
!= SHT_REL
)
6957 rel_offset
= section
->sh_offset
;
6958 rel_size
= section
->sh_size
;
6962 Elf_Internal_Shdr
* strsec
;
6965 printf (_("\nRelocation section "));
6967 if (string_table
== NULL
)
6968 printf ("%d", section
->sh_name
);
6970 printf ("'%s'", printable_section_name (section
));
6972 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6973 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6975 is_rela
= section
->sh_type
== SHT_RELA
;
6977 if (section
->sh_link
!= 0
6978 && section
->sh_link
< elf_header
.e_shnum
)
6980 Elf_Internal_Shdr
* symsec
;
6981 Elf_Internal_Sym
* symtab
;
6982 unsigned long nsyms
;
6983 unsigned long strtablen
= 0;
6984 char * strtab
= NULL
;
6986 symsec
= section_headers
+ section
->sh_link
;
6987 if (symsec
->sh_type
!= SHT_SYMTAB
6988 && symsec
->sh_type
!= SHT_DYNSYM
)
6991 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6996 if (symsec
->sh_link
!= 0
6997 && symsec
->sh_link
< elf_header
.e_shnum
)
6999 strsec
= section_headers
+ symsec
->sh_link
;
7001 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7004 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7007 dump_relocations (file
, rel_offset
, rel_size
,
7008 symtab
, nsyms
, strtab
, strtablen
,
7010 symsec
->sh_type
== SHT_DYNSYM
);
7016 dump_relocations (file
, rel_offset
, rel_size
,
7017 NULL
, 0, NULL
, 0, is_rela
, 0);
7024 printf (_("\nThere are no relocations in this file.\n"));
7030 /* An absolute address consists of a section and an offset. If the
7031 section is NULL, the offset itself is the address, otherwise, the
7032 address equals to LOAD_ADDRESS(section) + offset. */
7036 unsigned short section
;
7040 #define ABSADDR(a) \
7042 ? section_headers [(a).section].sh_addr + (a).offset \
7045 /* Find the nearest symbol at or below ADDR. Returns the symbol
7046 name, if found, and the offset from the symbol to ADDR. */
7049 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7050 unsigned long nsyms
,
7051 const char * strtab
,
7052 unsigned long strtab_size
,
7053 struct absaddr addr
,
7054 const char ** symname
,
7057 bfd_vma dist
= 0x100000;
7058 Elf_Internal_Sym
* sym
;
7059 Elf_Internal_Sym
* beg
;
7060 Elf_Internal_Sym
* end
;
7061 Elf_Internal_Sym
* best
= NULL
;
7063 REMOVE_ARCH_BITS (addr
.offset
);
7065 end
= symtab
+ nsyms
;
7071 sym
= beg
+ (end
- beg
) / 2;
7073 value
= sym
->st_value
;
7074 REMOVE_ARCH_BITS (value
);
7076 if (sym
->st_name
!= 0
7077 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7078 && addr
.offset
>= value
7079 && addr
.offset
- value
< dist
)
7082 dist
= addr
.offset
- value
;
7087 if (addr
.offset
< value
)
7095 *symname
= (best
->st_name
>= strtab_size
7096 ? _("<corrupt>") : strtab
+ best
->st_name
);
7102 *offset
= addr
.offset
;
7106 symcmp (const void *p
, const void *q
)
7108 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7109 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7111 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7114 /* Process the unwind section. */
7116 #include "unwind-ia64.h"
7118 struct ia64_unw_table_entry
7120 struct absaddr start
;
7122 struct absaddr info
;
7125 struct ia64_unw_aux_info
7127 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7128 unsigned long table_len
; /* Length of unwind table. */
7129 unsigned char * info
; /* Unwind info. */
7130 unsigned long info_size
; /* Size of unwind info. */
7131 bfd_vma info_addr
; /* Starting address of unwind info. */
7132 bfd_vma seg_base
; /* Starting address of segment. */
7133 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7134 unsigned long nsyms
; /* Number of symbols. */
7135 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7136 unsigned long nfuns
; /* Number of entries in funtab. */
7137 char * strtab
; /* The string table. */
7138 unsigned long strtab_size
; /* Size of string table. */
7142 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7144 struct ia64_unw_table_entry
* tp
;
7145 unsigned long j
, nfuns
;
7148 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7149 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7150 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7151 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7153 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7155 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7159 const unsigned char * dp
;
7160 const unsigned char * head
;
7161 const unsigned char * end
;
7162 const char * procname
;
7164 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7165 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7167 fputs ("\n<", stdout
);
7171 fputs (procname
, stdout
);
7174 printf ("+%lx", (unsigned long) offset
);
7177 fputs (">: [", stdout
);
7178 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7179 fputc ('-', stdout
);
7180 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7181 printf ("], info at +0x%lx\n",
7182 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7184 /* PR 17531: file: 86232b32. */
7185 if (aux
->info
== NULL
)
7188 /* PR 17531: file: 0997b4d1. */
7189 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7191 warn (_("Invalid offset %lx in table entry %ld\n"),
7192 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7196 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7197 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7199 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7200 (unsigned) UNW_VER (stamp
),
7201 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7202 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7203 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7204 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7206 if (UNW_VER (stamp
) != 1)
7208 printf (_("\tUnknown version.\n"));
7213 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7214 /* PR 17531: file: 16ceda89. */
7215 if (end
> aux
->info
+ aux
->info_size
)
7216 end
= aux
->info
+ aux
->info_size
;
7217 for (dp
= head
+ 8; dp
< end
;)
7218 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7225 slurp_ia64_unwind_table (FILE * file
,
7226 struct ia64_unw_aux_info
* aux
,
7227 Elf_Internal_Shdr
* sec
)
7229 unsigned long size
, nrelas
, i
;
7230 Elf_Internal_Phdr
* seg
;
7231 struct ia64_unw_table_entry
* tep
;
7232 Elf_Internal_Shdr
* relsec
;
7233 Elf_Internal_Rela
* rela
;
7234 Elf_Internal_Rela
* rp
;
7235 unsigned char * table
;
7237 Elf_Internal_Sym
* sym
;
7238 const char * relname
;
7242 /* First, find the starting address of the segment that includes
7245 if (elf_header
.e_phnum
)
7247 if (! get_program_headers (file
))
7250 for (seg
= program_headers
;
7251 seg
< program_headers
+ elf_header
.e_phnum
;
7254 if (seg
->p_type
!= PT_LOAD
)
7257 if (sec
->sh_addr
>= seg
->p_vaddr
7258 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7260 aux
->seg_base
= seg
->p_vaddr
;
7266 /* Second, build the unwind table from the contents of the unwind section: */
7267 size
= sec
->sh_size
;
7268 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7273 aux
->table_len
= size
/ (3 * eh_addr_size
);
7274 aux
->table
= (struct ia64_unw_table_entry
*)
7275 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7278 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7280 tep
->start
.section
= SHN_UNDEF
;
7281 tep
->end
.section
= SHN_UNDEF
;
7282 tep
->info
.section
= SHN_UNDEF
;
7283 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7284 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7285 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7286 tep
->start
.offset
+= aux
->seg_base
;
7287 tep
->end
.offset
+= aux
->seg_base
;
7288 tep
->info
.offset
+= aux
->seg_base
;
7292 /* Third, apply any relocations to the unwind table: */
7293 for (relsec
= section_headers
;
7294 relsec
< section_headers
+ elf_header
.e_shnum
;
7297 if (relsec
->sh_type
!= SHT_RELA
7298 || relsec
->sh_info
>= elf_header
.e_shnum
7299 || section_headers
+ relsec
->sh_info
!= sec
)
7302 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7311 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7313 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7314 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7316 /* PR 17531: file: 9fa67536. */
7317 if (relname
== NULL
)
7319 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7323 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7325 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7329 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7331 /* PR 17531: file: 5bc8d9bf. */
7332 if (i
>= aux
->table_len
)
7334 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7338 switch (rp
->r_offset
/ eh_addr_size
% 3)
7341 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7342 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7345 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7346 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7349 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7350 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7364 ia64_process_unwind (FILE * file
)
7366 Elf_Internal_Shdr
* sec
;
7367 Elf_Internal_Shdr
* unwsec
= NULL
;
7368 Elf_Internal_Shdr
* strsec
;
7369 unsigned long i
, unwcount
= 0, unwstart
= 0;
7370 struct ia64_unw_aux_info aux
;
7372 memset (& aux
, 0, sizeof (aux
));
7374 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7376 if (sec
->sh_type
== SHT_SYMTAB
7377 && sec
->sh_link
< elf_header
.e_shnum
)
7379 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7381 strsec
= section_headers
+ sec
->sh_link
;
7382 if (aux
.strtab
!= NULL
)
7384 error (_("Multiple auxillary string tables encountered\n"));
7387 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7390 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7392 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7397 printf (_("\nThere are no unwind sections in this file.\n"));
7399 while (unwcount
-- > 0)
7404 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7405 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7406 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7411 /* We have already counted the number of SHT_IA64_UNWIND
7412 sections so the loop above should never fail. */
7413 assert (unwsec
!= NULL
);
7416 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7418 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7420 /* We need to find which section group it is in. */
7421 struct group_list
* g
;
7423 if (section_headers_groups
== NULL
7424 || section_headers_groups
[i
] == NULL
)
7425 i
= elf_header
.e_shnum
;
7428 g
= section_headers_groups
[i
]->root
;
7430 for (; g
!= NULL
; g
= g
->next
)
7432 sec
= section_headers
+ g
->section_index
;
7434 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7439 i
= elf_header
.e_shnum
;
7442 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7444 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7445 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7446 suffix
= SECTION_NAME (unwsec
) + len
;
7447 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7449 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7450 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7455 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7456 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7457 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7458 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7460 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7461 suffix
= SECTION_NAME (unwsec
) + len
;
7462 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7464 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7465 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7469 if (i
== elf_header
.e_shnum
)
7471 printf (_("\nCould not find unwind info section for "));
7473 if (string_table
== NULL
)
7474 printf ("%d", unwsec
->sh_name
);
7476 printf ("'%s'", printable_section_name (unwsec
));
7480 aux
.info_addr
= sec
->sh_addr
;
7481 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7484 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7486 printf (_("\nUnwind section "));
7488 if (string_table
== NULL
)
7489 printf ("%d", unwsec
->sh_name
);
7491 printf ("'%s'", printable_section_name (unwsec
));
7493 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7494 (unsigned long) unwsec
->sh_offset
,
7495 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7497 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7498 && aux
.table_len
> 0)
7499 dump_ia64_unwind (& aux
);
7502 free ((char *) aux
.table
);
7504 free ((char *) aux
.info
);
7513 free ((char *) aux
.strtab
);
7516 struct hppa_unw_table_entry
7518 struct absaddr start
;
7520 unsigned int Cannot_unwind
:1; /* 0 */
7521 unsigned int Millicode
:1; /* 1 */
7522 unsigned int Millicode_save_sr0
:1; /* 2 */
7523 unsigned int Region_description
:2; /* 3..4 */
7524 unsigned int reserved1
:1; /* 5 */
7525 unsigned int Entry_SR
:1; /* 6 */
7526 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7527 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7528 unsigned int Args_stored
:1; /* 16 */
7529 unsigned int Variable_Frame
:1; /* 17 */
7530 unsigned int Separate_Package_Body
:1; /* 18 */
7531 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7532 unsigned int Stack_Overflow_Check
:1; /* 20 */
7533 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7534 unsigned int Ada_Region
:1; /* 22 */
7535 unsigned int cxx_info
:1; /* 23 */
7536 unsigned int cxx_try_catch
:1; /* 24 */
7537 unsigned int sched_entry_seq
:1; /* 25 */
7538 unsigned int reserved2
:1; /* 26 */
7539 unsigned int Save_SP
:1; /* 27 */
7540 unsigned int Save_RP
:1; /* 28 */
7541 unsigned int Save_MRP_in_frame
:1; /* 29 */
7542 unsigned int extn_ptr_defined
:1; /* 30 */
7543 unsigned int Cleanup_defined
:1; /* 31 */
7545 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7546 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7547 unsigned int Large_frame
:1; /* 2 */
7548 unsigned int Pseudo_SP_Set
:1; /* 3 */
7549 unsigned int reserved4
:1; /* 4 */
7550 unsigned int Total_frame_size
:27; /* 5..31 */
7553 struct hppa_unw_aux_info
7555 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7556 unsigned long table_len
; /* Length of unwind table. */
7557 bfd_vma seg_base
; /* Starting address of segment. */
7558 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7559 unsigned long nsyms
; /* Number of symbols. */
7560 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7561 unsigned long nfuns
; /* Number of entries in funtab. */
7562 char * strtab
; /* The string table. */
7563 unsigned long strtab_size
; /* Size of string table. */
7567 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7569 struct hppa_unw_table_entry
* tp
;
7570 unsigned long j
, nfuns
;
7572 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7573 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7574 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7575 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7577 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7579 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7582 const char * procname
;
7584 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7585 aux
->strtab_size
, tp
->start
, &procname
,
7588 fputs ("\n<", stdout
);
7592 fputs (procname
, stdout
);
7595 printf ("+%lx", (unsigned long) offset
);
7598 fputs (">: [", stdout
);
7599 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7600 fputc ('-', stdout
);
7601 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7604 #define PF(_m) if (tp->_m) printf (#_m " ");
7605 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7608 PF(Millicode_save_sr0
);
7609 /* PV(Region_description); */
7615 PF(Separate_Package_Body
);
7616 PF(Frame_Extension_Millicode
);
7617 PF(Stack_Overflow_Check
);
7618 PF(Two_Instruction_SP_Increment
);
7622 PF(sched_entry_seq
);
7625 PF(Save_MRP_in_frame
);
7626 PF(extn_ptr_defined
);
7627 PF(Cleanup_defined
);
7628 PF(MPE_XL_interrupt_marker
);
7629 PF(HP_UX_interrupt_marker
);
7632 PV(Total_frame_size
);
7643 slurp_hppa_unwind_table (FILE * file
,
7644 struct hppa_unw_aux_info
* aux
,
7645 Elf_Internal_Shdr
* sec
)
7647 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7648 Elf_Internal_Phdr
* seg
;
7649 struct hppa_unw_table_entry
* tep
;
7650 Elf_Internal_Shdr
* relsec
;
7651 Elf_Internal_Rela
* rela
;
7652 Elf_Internal_Rela
* rp
;
7653 unsigned char * table
;
7655 Elf_Internal_Sym
* sym
;
7656 const char * relname
;
7658 /* First, find the starting address of the segment that includes
7661 if (elf_header
.e_phnum
)
7663 if (! get_program_headers (file
))
7666 for (seg
= program_headers
;
7667 seg
< program_headers
+ elf_header
.e_phnum
;
7670 if (seg
->p_type
!= PT_LOAD
)
7673 if (sec
->sh_addr
>= seg
->p_vaddr
7674 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7676 aux
->seg_base
= seg
->p_vaddr
;
7682 /* Second, build the unwind table from the contents of the unwind
7684 size
= sec
->sh_size
;
7685 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7691 nentries
= size
/ unw_ent_size
;
7692 size
= unw_ent_size
* nentries
;
7694 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7695 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7697 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7699 unsigned int tmp1
, tmp2
;
7701 tep
->start
.section
= SHN_UNDEF
;
7702 tep
->end
.section
= SHN_UNDEF
;
7704 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7705 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7706 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7707 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7709 tep
->start
.offset
+= aux
->seg_base
;
7710 tep
->end
.offset
+= aux
->seg_base
;
7712 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7713 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7714 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7715 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7716 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7717 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7718 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7719 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7720 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7721 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7722 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7723 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7724 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7725 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7726 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7727 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7728 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7729 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7730 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7731 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7732 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7733 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7734 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7735 tep
->Cleanup_defined
= tmp1
& 0x1;
7737 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7738 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7739 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7740 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7741 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7742 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7746 /* Third, apply any relocations to the unwind table. */
7747 for (relsec
= section_headers
;
7748 relsec
< section_headers
+ elf_header
.e_shnum
;
7751 if (relsec
->sh_type
!= SHT_RELA
7752 || relsec
->sh_info
>= elf_header
.e_shnum
7753 || section_headers
+ relsec
->sh_info
!= sec
)
7756 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7760 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7762 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7763 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7765 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7766 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7768 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7772 i
= rp
->r_offset
/ unw_ent_size
;
7774 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7777 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7778 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7781 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7782 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7792 aux
->table_len
= nentries
;
7798 hppa_process_unwind (FILE * file
)
7800 struct hppa_unw_aux_info aux
;
7801 Elf_Internal_Shdr
* unwsec
= NULL
;
7802 Elf_Internal_Shdr
* strsec
;
7803 Elf_Internal_Shdr
* sec
;
7806 if (string_table
== NULL
)
7809 memset (& aux
, 0, sizeof (aux
));
7811 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7813 if (sec
->sh_type
== SHT_SYMTAB
7814 && sec
->sh_link
< elf_header
.e_shnum
)
7816 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7818 strsec
= section_headers
+ sec
->sh_link
;
7819 if (aux
.strtab
!= NULL
)
7821 error (_("Multiple auxillary string tables encountered\n"));
7824 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7827 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7829 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7834 printf (_("\nThere are no unwind sections in this file.\n"));
7836 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7838 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7840 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7841 printable_section_name (sec
),
7842 (unsigned long) sec
->sh_offset
,
7843 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7845 slurp_hppa_unwind_table (file
, &aux
, sec
);
7846 if (aux
.table_len
> 0)
7847 dump_hppa_unwind (&aux
);
7850 free ((char *) aux
.table
);
7858 free ((char *) aux
.strtab
);
7863 unsigned char * data
; /* The unwind data. */
7864 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7865 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7866 unsigned long nrelas
; /* The number of relocations. */
7867 unsigned int rel_type
; /* REL or RELA ? */
7868 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7871 struct arm_unw_aux_info
7873 FILE * file
; /* The file containing the unwind sections. */
7874 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7875 unsigned long nsyms
; /* Number of symbols. */
7876 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7877 unsigned long nfuns
; /* Number of these symbols. */
7878 char * strtab
; /* The file's string table. */
7879 unsigned long strtab_size
; /* Size of string table. */
7883 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7884 bfd_vma fn
, struct absaddr addr
)
7886 const char *procname
;
7889 if (addr
.section
== SHN_UNDEF
)
7892 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7893 aux
->strtab_size
, addr
, &procname
,
7896 print_vma (fn
, PREFIX_HEX
);
7900 fputs (" <", stdout
);
7901 fputs (procname
, stdout
);
7904 printf ("+0x%lx", (unsigned long) sym_offset
);
7905 fputc ('>', stdout
);
7912 arm_free_section (struct arm_section
*arm_sec
)
7914 if (arm_sec
->data
!= NULL
)
7915 free (arm_sec
->data
);
7917 if (arm_sec
->rela
!= NULL
)
7918 free (arm_sec
->rela
);
7921 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7922 cached section and install SEC instead.
7923 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7924 and return its valued in * WORDP, relocating if necessary.
7925 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7926 relocation's offset in ADDR.
7927 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7928 into the string table of the symbol associated with the reloc. If no
7929 reloc was applied store -1 there.
7930 5) Return TRUE upon success, FALSE otherwise. */
7933 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7934 struct arm_section
* arm_sec
,
7935 Elf_Internal_Shdr
* sec
,
7936 bfd_vma word_offset
,
7937 unsigned int * wordp
,
7938 struct absaddr
* addr
,
7941 Elf_Internal_Rela
*rp
;
7942 Elf_Internal_Sym
*sym
;
7943 const char * relname
;
7945 bfd_boolean wrapped
;
7947 if (sec
== NULL
|| arm_sec
== NULL
)
7950 addr
->section
= SHN_UNDEF
;
7953 if (sym_name
!= NULL
)
7954 *sym_name
= (bfd_vma
) -1;
7956 /* If necessary, update the section cache. */
7957 if (sec
!= arm_sec
->sec
)
7959 Elf_Internal_Shdr
*relsec
;
7961 arm_free_section (arm_sec
);
7964 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7965 sec
->sh_size
, _("unwind data"));
7966 arm_sec
->rela
= NULL
;
7967 arm_sec
->nrelas
= 0;
7969 for (relsec
= section_headers
;
7970 relsec
< section_headers
+ elf_header
.e_shnum
;
7973 if (relsec
->sh_info
>= elf_header
.e_shnum
7974 || section_headers
+ relsec
->sh_info
!= sec
7975 /* PR 15745: Check the section type as well. */
7976 || (relsec
->sh_type
!= SHT_REL
7977 && relsec
->sh_type
!= SHT_RELA
))
7980 arm_sec
->rel_type
= relsec
->sh_type
;
7981 if (relsec
->sh_type
== SHT_REL
)
7983 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7985 & arm_sec
->rela
, & arm_sec
->nrelas
))
7988 else /* relsec->sh_type == SHT_RELA */
7990 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7992 & arm_sec
->rela
, & arm_sec
->nrelas
))
7998 arm_sec
->next_rela
= arm_sec
->rela
;
8001 /* If there is no unwind data we can do nothing. */
8002 if (arm_sec
->data
== NULL
)
8005 /* If the offset is invalid then fail. */
8006 if (word_offset
> (sec
->sh_size
- 4)
8008 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
8009 || ((bfd_signed_vma
) word_offset
) < 0)
8012 /* Get the word at the required offset. */
8013 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8015 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8016 if (arm_sec
->rela
== NULL
)
8022 /* Look through the relocs to find the one that applies to the provided offset. */
8024 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8026 bfd_vma prelval
, offset
;
8028 if (rp
->r_offset
> word_offset
&& !wrapped
)
8033 if (rp
->r_offset
> word_offset
)
8036 if (rp
->r_offset
& 3)
8038 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8039 (unsigned long) rp
->r_offset
);
8043 if (rp
->r_offset
< word_offset
)
8046 /* PR 17531: file: 027-161405-0.004 */
8047 if (aux
->symtab
== NULL
)
8050 if (arm_sec
->rel_type
== SHT_REL
)
8052 offset
= word
& 0x7fffffff;
8053 if (offset
& 0x40000000)
8054 offset
|= ~ (bfd_vma
) 0x7fffffff;
8056 else if (arm_sec
->rel_type
== SHT_RELA
)
8057 offset
= rp
->r_addend
;
8060 error (_("Unknown section relocation type %d encountered\n"),
8065 /* PR 17531 file: 027-1241568-0.004. */
8066 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8068 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8069 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8073 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8074 offset
+= sym
->st_value
;
8075 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8077 /* Check that we are processing the expected reloc type. */
8078 if (elf_header
.e_machine
== EM_ARM
)
8080 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8081 if (relname
== NULL
)
8083 warn (_("Skipping unknown ARM relocation type: %d\n"),
8084 (int) ELF32_R_TYPE (rp
->r_info
));
8088 if (streq (relname
, "R_ARM_NONE"))
8091 if (! streq (relname
, "R_ARM_PREL31"))
8093 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8097 else if (elf_header
.e_machine
== EM_TI_C6000
)
8099 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8100 if (relname
== NULL
)
8102 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8103 (int) ELF32_R_TYPE (rp
->r_info
));
8107 if (streq (relname
, "R_C6000_NONE"))
8110 if (! streq (relname
, "R_C6000_PREL31"))
8112 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8120 /* This function currently only supports ARM and TI unwinders. */
8121 warn (_("Only TI and ARM unwinders are currently supported\n"));
8125 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8126 addr
->section
= sym
->st_shndx
;
8127 addr
->offset
= offset
;
8130 * sym_name
= sym
->st_name
;
8135 arm_sec
->next_rela
= rp
;
8140 static const char *tic6x_unwind_regnames
[16] =
8142 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8143 "A14", "A13", "A12", "A11", "A10",
8144 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8148 decode_tic6x_unwind_regmask (unsigned int mask
)
8152 for (i
= 12; mask
; mask
>>= 1, i
--)
8156 fputs (tic6x_unwind_regnames
[i
], stdout
);
8158 fputs (", ", stdout
);
8164 if (remaining == 0 && more_words) \
8167 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8168 data_offset, & word, & addr, NULL)) \
8174 #define GET_OP(OP) \
8179 (OP) = word >> 24; \
8184 printf (_("[Truncated opcode]\n")); \
8187 printf ("0x%02x ", OP)
8190 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8192 unsigned int remaining
,
8193 unsigned int more_words
,
8194 bfd_vma data_offset
,
8195 Elf_Internal_Shdr
* data_sec
,
8196 struct arm_section
* data_arm_sec
)
8198 struct absaddr addr
;
8200 /* Decode the unwinding instructions. */
8203 unsigned int op
, op2
;
8212 printf (" 0x%02x ", op
);
8214 if ((op
& 0xc0) == 0x00)
8216 int offset
= ((op
& 0x3f) << 2) + 4;
8218 printf (" vsp = vsp + %d", offset
);
8220 else if ((op
& 0xc0) == 0x40)
8222 int offset
= ((op
& 0x3f) << 2) + 4;
8224 printf (" vsp = vsp - %d", offset
);
8226 else if ((op
& 0xf0) == 0x80)
8229 if (op
== 0x80 && op2
== 0)
8230 printf (_("Refuse to unwind"));
8233 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8238 for (i
= 0; i
< 12; i
++)
8239 if (mask
& (1 << i
))
8245 printf ("r%d", 4 + i
);
8250 else if ((op
& 0xf0) == 0x90)
8252 if (op
== 0x9d || op
== 0x9f)
8253 printf (_(" [Reserved]"));
8255 printf (" vsp = r%d", op
& 0x0f);
8257 else if ((op
& 0xf0) == 0xa0)
8259 int end
= 4 + (op
& 0x07);
8264 for (i
= 4; i
<= end
; i
++)
8280 else if (op
== 0xb0)
8281 printf (_(" finish"));
8282 else if (op
== 0xb1)
8285 if (op2
== 0 || (op2
& 0xf0) != 0)
8286 printf (_("[Spare]"));
8289 unsigned int mask
= op2
& 0x0f;
8294 for (i
= 0; i
< 12; i
++)
8295 if (mask
& (1 << i
))
8306 else if (op
== 0xb2)
8308 unsigned char buf
[9];
8309 unsigned int i
, len
;
8310 unsigned long offset
;
8312 for (i
= 0; i
< sizeof (buf
); i
++)
8315 if ((buf
[i
] & 0x80) == 0)
8318 if (i
== sizeof (buf
))
8319 printf (_("corrupt change to vsp"));
8322 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8323 assert (len
== i
+ 1);
8324 offset
= offset
* 4 + 0x204;
8325 printf ("vsp = vsp + %ld", offset
);
8328 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8330 unsigned int first
, last
;
8337 printf ("pop {D%d", first
);
8339 printf ("-D%d", first
+ last
);
8342 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8344 unsigned int count
= op
& 0x07;
8348 printf ("-D%d", 8 + count
);
8351 else if (op
>= 0xc0 && op
<= 0xc5)
8353 unsigned int count
= op
& 0x07;
8355 printf (" pop {wR10");
8357 printf ("-wR%d", 10 + count
);
8360 else if (op
== 0xc6)
8362 unsigned int first
, last
;
8367 printf ("pop {wR%d", first
);
8369 printf ("-wR%d", first
+ last
);
8372 else if (op
== 0xc7)
8375 if (op2
== 0 || (op2
& 0xf0) != 0)
8376 printf (_("[Spare]"));
8379 unsigned int mask
= op2
& 0x0f;
8384 for (i
= 0; i
< 4; i
++)
8385 if (mask
& (1 << i
))
8391 printf ("wCGR%d", i
);
8397 printf (_(" [unsupported opcode]"));
8403 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8405 unsigned int remaining
,
8406 unsigned int more_words
,
8407 bfd_vma data_offset
,
8408 Elf_Internal_Shdr
* data_sec
,
8409 struct arm_section
* data_arm_sec
)
8411 struct absaddr addr
;
8413 /* Decode the unwinding instructions. */
8416 unsigned int op
, op2
;
8425 printf (" 0x%02x ", op
);
8427 if ((op
& 0xc0) == 0x00)
8429 int offset
= ((op
& 0x3f) << 3) + 8;
8430 printf (" sp = sp + %d", offset
);
8432 else if ((op
& 0xc0) == 0x80)
8435 if (op
== 0x80 && op2
== 0)
8436 printf (_("Refuse to unwind"));
8439 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8441 printf ("pop compact {");
8445 decode_tic6x_unwind_regmask (mask
);
8449 else if ((op
& 0xf0) == 0xc0)
8457 unsigned int offset
;
8461 /* Scan entire instruction first so that GET_OP output is not
8462 interleaved with disassembly. */
8464 for (i
= 0; nregs
< (op
& 0xf); i
++)
8470 regpos
[nregs
].offset
= i
* 2;
8471 regpos
[nregs
].reg
= reg
;
8478 regpos
[nregs
].offset
= i
* 2 + 1;
8479 regpos
[nregs
].reg
= reg
;
8484 printf (_("pop frame {"));
8486 for (i
= i
* 2; i
> 0; i
--)
8488 if (regpos
[reg
].offset
== i
- 1)
8490 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8497 fputs (name
, stdout
);
8504 else if (op
== 0xd0)
8505 printf (" MOV FP, SP");
8506 else if (op
== 0xd1)
8507 printf (" __c6xabi_pop_rts");
8508 else if (op
== 0xd2)
8510 unsigned char buf
[9];
8511 unsigned int i
, len
;
8512 unsigned long offset
;
8514 for (i
= 0; i
< sizeof (buf
); i
++)
8517 if ((buf
[i
] & 0x80) == 0)
8520 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8521 if (i
== sizeof (buf
))
8523 printf ("<corrupt sp adjust>\n");
8524 warn (_("Corrupt stack pointer adjustment detected\n"));
8528 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8529 assert (len
== i
+ 1);
8530 offset
= offset
* 8 + 0x408;
8531 printf (_("sp = sp + %ld"), offset
);
8533 else if ((op
& 0xf0) == 0xe0)
8535 if ((op
& 0x0f) == 7)
8538 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8542 printf (_(" [unsupported opcode]"));
8549 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8553 offset
= word
& 0x7fffffff;
8554 if (offset
& 0x40000000)
8555 offset
|= ~ (bfd_vma
) 0x7fffffff;
8557 if (elf_header
.e_machine
== EM_TI_C6000
)
8560 return offset
+ where
;
8564 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8566 unsigned int remaining
,
8567 bfd_vma data_offset
,
8568 Elf_Internal_Shdr
* data_sec
,
8569 struct arm_section
* data_arm_sec
)
8572 unsigned int more_words
= 0;
8573 struct absaddr addr
;
8574 bfd_vma sym_name
= (bfd_vma
) -1;
8578 /* Fetch the first word.
8579 Note - when decoding an object file the address extracted
8580 here will always be 0. So we also pass in the sym_name
8581 parameter so that we can find the symbol associated with
8582 the personality routine. */
8583 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8584 & word
, & addr
, & sym_name
))
8590 if ((word
& 0x80000000) == 0)
8592 /* Expand prel31 for personality routine. */
8594 const char *procname
;
8596 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8597 printf (_(" Personality routine: "));
8599 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8600 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8602 procname
= aux
->strtab
+ sym_name
;
8603 print_vma (fn
, PREFIX_HEX
);
8606 fputs (" <", stdout
);
8607 fputs (procname
, stdout
);
8608 fputc ('>', stdout
);
8612 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8613 fputc ('\n', stdout
);
8615 /* The GCC personality routines use the standard compact
8616 encoding, starting with one byte giving the number of
8618 if (procname
!= NULL
8619 && (const_strneq (procname
, "__gcc_personality_v0")
8620 || const_strneq (procname
, "__gxx_personality_v0")
8621 || const_strneq (procname
, "__gcj_personality_v0")
8622 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8629 printf (_(" [Truncated data]\n"));
8632 more_words
= word
>> 24;
8642 /* ARM EHABI Section 6.3:
8644 An exception-handling table entry for the compact model looks like:
8648 1 0 index Data for personalityRoutine[index] */
8650 if (elf_header
.e_machine
== EM_ARM
8651 && (word
& 0x70000000))
8652 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8654 per_index
= (word
>> 24) & 0x7f;
8655 printf (_(" Compact model index: %d\n"), per_index
);
8662 else if (per_index
< 3)
8664 more_words
= (word
>> 16) & 0xff;
8670 switch (elf_header
.e_machine
)
8675 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8676 data_offset
, data_sec
, data_arm_sec
);
8680 warn (_("Unknown ARM compact model index encountered\n"));
8681 printf (_(" [reserved]\n"));
8688 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8689 data_offset
, data_sec
, data_arm_sec
);
8691 else if (per_index
< 5)
8693 if (((word
>> 17) & 0x7f) == 0x7f)
8694 printf (_(" Restore stack from frame pointer\n"));
8696 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8697 printf (_(" Registers restored: "));
8699 printf (" (compact) ");
8700 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8702 printf (_(" Return register: %s\n"),
8703 tic6x_unwind_regnames
[word
& 0xf]);
8706 printf (_(" [reserved (%d)]\n"), per_index
);
8710 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8711 elf_header
.e_machine
);
8714 /* Decode the descriptors. Not implemented. */
8718 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8720 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8721 unsigned int i
, exidx_len
;
8722 unsigned long j
, nfuns
;
8724 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8725 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8726 exidx_len
= exidx_sec
->sh_size
/ 8;
8728 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8729 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8730 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8731 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8733 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8735 for (i
= 0; i
< exidx_len
; i
++)
8737 unsigned int exidx_fn
, exidx_entry
;
8738 struct absaddr fn_addr
, entry_addr
;
8741 fputc ('\n', stdout
);
8743 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8744 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8745 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8746 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8749 arm_free_section (& exidx_arm_sec
);
8750 arm_free_section (& extab_arm_sec
);
8754 /* ARM EHABI, Section 5:
8755 An index table entry consists of 2 words.
8756 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8757 if (exidx_fn
& 0x80000000)
8758 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8760 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8762 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8763 fputs (": ", stdout
);
8765 if (exidx_entry
== 1)
8767 print_vma (exidx_entry
, PREFIX_HEX
);
8768 fputs (" [cantunwind]\n", stdout
);
8770 else if (exidx_entry
& 0x80000000)
8772 print_vma (exidx_entry
, PREFIX_HEX
);
8773 fputc ('\n', stdout
);
8774 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8778 bfd_vma table
, table_offset
= 0;
8779 Elf_Internal_Shdr
*table_sec
;
8781 fputs ("@", stdout
);
8782 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8783 print_vma (table
, PREFIX_HEX
);
8786 /* Locate the matching .ARM.extab. */
8787 if (entry_addr
.section
!= SHN_UNDEF
8788 && entry_addr
.section
< elf_header
.e_shnum
)
8790 table_sec
= section_headers
+ entry_addr
.section
;
8791 table_offset
= entry_addr
.offset
;
8793 if (table_offset
> table_sec
->sh_size
8794 || ((bfd_signed_vma
) table_offset
) < 0)
8796 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8797 (unsigned long) table_offset
,
8798 printable_section_name (table_sec
));
8804 table_sec
= find_section_by_address (table
);
8805 if (table_sec
!= NULL
)
8806 table_offset
= table
- table_sec
->sh_addr
;
8808 if (table_sec
== NULL
)
8810 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8811 (unsigned long) table
);
8814 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8822 arm_free_section (&exidx_arm_sec
);
8823 arm_free_section (&extab_arm_sec
);
8826 /* Used for both ARM and C6X unwinding tables. */
8829 arm_process_unwind (FILE *file
)
8831 struct arm_unw_aux_info aux
;
8832 Elf_Internal_Shdr
*unwsec
= NULL
;
8833 Elf_Internal_Shdr
*strsec
;
8834 Elf_Internal_Shdr
*sec
;
8836 unsigned int sec_type
;
8838 switch (elf_header
.e_machine
)
8841 sec_type
= SHT_ARM_EXIDX
;
8845 sec_type
= SHT_C6000_UNWIND
;
8849 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8850 elf_header
.e_machine
);
8854 if (string_table
== NULL
)
8857 memset (& aux
, 0, sizeof (aux
));
8860 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8862 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8864 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8866 strsec
= section_headers
+ sec
->sh_link
;
8868 /* PR binutils/17531 file: 011-12666-0.004. */
8869 if (aux
.strtab
!= NULL
)
8871 error (_("Multiple string tables found in file.\n"));
8874 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8875 1, strsec
->sh_size
, _("string table"));
8876 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8878 else if (sec
->sh_type
== sec_type
)
8883 printf (_("\nThere are no unwind sections in this file.\n"));
8885 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8887 if (sec
->sh_type
== sec_type
)
8889 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8890 printable_section_name (sec
),
8891 (unsigned long) sec
->sh_offset
,
8892 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8894 dump_arm_unwind (&aux
, sec
);
8901 free ((char *) aux
.strtab
);
8905 process_unwind (FILE * file
)
8907 struct unwind_handler
8910 void (* handler
)(FILE *);
8913 { EM_ARM
, arm_process_unwind
},
8914 { EM_IA_64
, ia64_process_unwind
},
8915 { EM_PARISC
, hppa_process_unwind
},
8916 { EM_TI_C6000
, arm_process_unwind
},
8924 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8925 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8927 handlers
[i
].handler (file
);
8931 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8932 get_machine_name (elf_header
.e_machine
));
8936 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8938 switch (entry
->d_tag
)
8941 if (entry
->d_un
.d_val
== 0)
8945 static const char * opts
[] =
8947 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8948 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8949 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8950 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8956 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8957 if (entry
->d_un
.d_val
& (1 << cnt
))
8959 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8965 case DT_MIPS_IVERSION
:
8966 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8967 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8971 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8972 /* Note: coded this way so that there is a single string for translation. */
8973 printf (_("<corrupt: %s>"), buf
);
8977 case DT_MIPS_TIME_STAMP
:
8981 time_t atime
= entry
->d_un
.d_val
;
8983 tmp
= gmtime (&atime
);
8984 /* PR 17531: file: 6accc532. */
8986 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8988 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8989 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8990 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8991 printf (_("Time Stamp: %s"), timebuf
);
8995 case DT_MIPS_RLD_VERSION
:
8996 case DT_MIPS_LOCAL_GOTNO
:
8997 case DT_MIPS_CONFLICTNO
:
8998 case DT_MIPS_LIBLISTNO
:
8999 case DT_MIPS_SYMTABNO
:
9000 case DT_MIPS_UNREFEXTNO
:
9001 case DT_MIPS_HIPAGENO
:
9002 case DT_MIPS_DELTA_CLASS_NO
:
9003 case DT_MIPS_DELTA_INSTANCE_NO
:
9004 case DT_MIPS_DELTA_RELOC_NO
:
9005 case DT_MIPS_DELTA_SYM_NO
:
9006 case DT_MIPS_DELTA_CLASSSYM_NO
:
9007 case DT_MIPS_COMPACT_SIZE
:
9008 print_vma (entry
->d_un
.d_val
, DEC
);
9012 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9018 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9020 switch (entry
->d_tag
)
9022 case DT_HP_DLD_FLAGS
:
9031 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9032 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9033 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9034 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9035 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9036 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9037 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9038 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9039 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9040 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9041 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9042 { DT_HP_GST
, "HP_GST" },
9043 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9044 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9045 { DT_HP_NODELETE
, "HP_NODELETE" },
9046 { DT_HP_GROUP
, "HP_GROUP" },
9047 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9051 bfd_vma val
= entry
->d_un
.d_val
;
9053 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9054 if (val
& flags
[cnt
].bit
)
9058 fputs (flags
[cnt
].str
, stdout
);
9060 val
^= flags
[cnt
].bit
;
9063 if (val
!= 0 || first
)
9067 print_vma (val
, HEX
);
9073 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9081 /* VMS vs Unix time offset and factor. */
9083 #define VMS_EPOCH_OFFSET 35067168000000000LL
9084 #define VMS_GRANULARITY_FACTOR 10000000
9086 /* Display a VMS time in a human readable format. */
9089 print_vms_time (bfd_int64_t vmstime
)
9094 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9095 tm
= gmtime (&unxtime
);
9096 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9097 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9098 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9103 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9105 switch (entry
->d_tag
)
9107 case DT_IA_64_PLT_RESERVE
:
9108 /* First 3 slots reserved. */
9109 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9111 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9114 case DT_IA_64_VMS_LINKTIME
:
9116 print_vms_time (entry
->d_un
.d_val
);
9120 case DT_IA_64_VMS_LNKFLAGS
:
9121 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9122 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9123 printf (" CALL_DEBUG");
9124 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9125 printf (" NOP0BUFS");
9126 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9127 printf (" P0IMAGE");
9128 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9129 printf (" MKTHREADS");
9130 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9131 printf (" UPCALLS");
9132 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9134 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9135 printf (" INITIALIZE");
9136 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9138 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9139 printf (" EXE_INIT");
9140 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9141 printf (" TBK_IN_IMG");
9142 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9143 printf (" DBG_IN_IMG");
9144 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9145 printf (" TBK_IN_DSF");
9146 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9147 printf (" DBG_IN_DSF");
9148 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9149 printf (" SIGNATURES");
9150 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9151 printf (" REL_SEG_OFF");
9155 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9162 get_32bit_dynamic_section (FILE * file
)
9164 Elf32_External_Dyn
* edyn
;
9165 Elf32_External_Dyn
* ext
;
9166 Elf_Internal_Dyn
* entry
;
9168 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9169 dynamic_size
, _("dynamic section"));
9173 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9174 might not have the luxury of section headers. Look for the DT_NULL
9175 terminator to determine the number of entries. */
9176 for (ext
= edyn
, dynamic_nent
= 0;
9177 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9181 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9185 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9187 if (dynamic_section
== NULL
)
9189 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9190 (unsigned long) dynamic_nent
);
9195 for (ext
= edyn
, entry
= dynamic_section
;
9196 entry
< dynamic_section
+ dynamic_nent
;
9199 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9200 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9209 get_64bit_dynamic_section (FILE * file
)
9211 Elf64_External_Dyn
* edyn
;
9212 Elf64_External_Dyn
* ext
;
9213 Elf_Internal_Dyn
* entry
;
9215 /* Read in the data. */
9216 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9217 dynamic_size
, _("dynamic section"));
9221 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9222 might not have the luxury of section headers. Look for the DT_NULL
9223 terminator to determine the number of entries. */
9224 for (ext
= edyn
, dynamic_nent
= 0;
9225 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9226 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9230 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9234 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9236 if (dynamic_section
== NULL
)
9238 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9239 (unsigned long) dynamic_nent
);
9244 /* Convert from external to internal formats. */
9245 for (ext
= edyn
, entry
= dynamic_section
;
9246 entry
< dynamic_section
+ dynamic_nent
;
9249 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9250 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9259 print_dynamic_flags (bfd_vma flags
)
9267 flag
= flags
& - flags
;
9277 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9278 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9279 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9280 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9281 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9282 default: fputs (_("unknown"), stdout
); break;
9288 /* Parse and display the contents of the dynamic section. */
9291 process_dynamic_section (FILE * file
)
9293 Elf_Internal_Dyn
* entry
;
9295 if (dynamic_size
== 0)
9298 printf (_("\nThere is no dynamic section in this file.\n"));
9305 if (! get_32bit_dynamic_section (file
))
9308 else if (! get_64bit_dynamic_section (file
))
9311 /* Find the appropriate symbol table. */
9312 if (dynamic_symbols
== NULL
)
9314 for (entry
= dynamic_section
;
9315 entry
< dynamic_section
+ dynamic_nent
;
9318 Elf_Internal_Shdr section
;
9320 if (entry
->d_tag
!= DT_SYMTAB
)
9323 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9325 /* Since we do not know how big the symbol table is,
9326 we default to reading in the entire file (!) and
9327 processing that. This is overkill, I know, but it
9329 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9331 if (archive_file_offset
!= 0)
9332 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9335 if (fseek (file
, 0, SEEK_END
))
9336 error (_("Unable to seek to end of file!\n"));
9338 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9342 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9344 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9345 section
.sh_name
= string_table_length
;
9347 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9348 if (num_dynamic_syms
< 1)
9350 error (_("Unable to determine the number of symbols to load\n"));
9356 /* Similarly find a string table. */
9357 if (dynamic_strings
== NULL
)
9359 for (entry
= dynamic_section
;
9360 entry
< dynamic_section
+ dynamic_nent
;
9363 unsigned long offset
;
9366 if (entry
->d_tag
!= DT_STRTAB
)
9369 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9371 /* Since we do not know how big the string table is,
9372 we default to reading in the entire file (!) and
9373 processing that. This is overkill, I know, but it
9376 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9378 if (archive_file_offset
!= 0)
9379 str_tab_len
= archive_file_size
- offset
;
9382 if (fseek (file
, 0, SEEK_END
))
9383 error (_("Unable to seek to end of file\n"));
9384 str_tab_len
= ftell (file
) - offset
;
9387 if (str_tab_len
< 1)
9390 (_("Unable to determine the length of the dynamic string table\n"));
9394 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9396 _("dynamic string table"));
9397 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9402 /* And find the syminfo section if available. */
9403 if (dynamic_syminfo
== NULL
)
9405 unsigned long syminsz
= 0;
9407 for (entry
= dynamic_section
;
9408 entry
< dynamic_section
+ dynamic_nent
;
9411 if (entry
->d_tag
== DT_SYMINENT
)
9413 /* Note: these braces are necessary to avoid a syntax
9414 error from the SunOS4 C compiler. */
9415 /* PR binutils/17531: A corrupt file can trigger this test.
9416 So do not use an assert, instead generate an error message. */
9417 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9418 error (_("Bad value (%d) for SYMINENT entry\n"),
9419 (int) entry
->d_un
.d_val
);
9421 else if (entry
->d_tag
== DT_SYMINSZ
)
9422 syminsz
= entry
->d_un
.d_val
;
9423 else if (entry
->d_tag
== DT_SYMINFO
)
9424 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9428 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9430 Elf_External_Syminfo
* extsyminfo
;
9431 Elf_External_Syminfo
* extsym
;
9432 Elf_Internal_Syminfo
* syminfo
;
9434 /* There is a syminfo section. Read the data. */
9435 extsyminfo
= (Elf_External_Syminfo
*)
9436 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9437 _("symbol information"));
9441 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9442 if (dynamic_syminfo
== NULL
)
9444 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9445 (unsigned long) syminsz
);
9449 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9450 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9451 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9452 ++syminfo
, ++extsym
)
9454 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9455 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9462 if (do_dynamic
&& dynamic_addr
)
9463 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9464 dynamic_addr
, (unsigned long) dynamic_nent
);
9466 printf (_(" Tag Type Name/Value\n"));
9468 for (entry
= dynamic_section
;
9469 entry
< dynamic_section
+ dynamic_nent
;
9477 print_vma (entry
->d_tag
, FULL_HEX
);
9478 dtype
= get_dynamic_type (entry
->d_tag
);
9479 printf (" (%s)%*s", dtype
,
9480 ((is_32bit_elf
? 27 : 19)
9481 - (int) strlen (dtype
)),
9485 switch (entry
->d_tag
)
9489 print_dynamic_flags (entry
->d_un
.d_val
);
9499 switch (entry
->d_tag
)
9502 printf (_("Auxiliary library"));
9506 printf (_("Filter library"));
9510 printf (_("Configuration file"));
9514 printf (_("Dependency audit library"));
9518 printf (_("Audit library"));
9522 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9523 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9527 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9536 printf (_("Flags:"));
9538 if (entry
->d_un
.d_val
== 0)
9539 printf (_(" None\n"));
9542 unsigned long int val
= entry
->d_un
.d_val
;
9544 if (val
& DTF_1_PARINIT
)
9546 printf (" PARINIT");
9547 val
^= DTF_1_PARINIT
;
9549 if (val
& DTF_1_CONFEXP
)
9551 printf (" CONFEXP");
9552 val
^= DTF_1_CONFEXP
;
9555 printf (" %lx", val
);
9564 printf (_("Flags:"));
9566 if (entry
->d_un
.d_val
== 0)
9567 printf (_(" None\n"));
9570 unsigned long int val
= entry
->d_un
.d_val
;
9572 if (val
& DF_P1_LAZYLOAD
)
9574 printf (" LAZYLOAD");
9575 val
^= DF_P1_LAZYLOAD
;
9577 if (val
& DF_P1_GROUPPERM
)
9579 printf (" GROUPPERM");
9580 val
^= DF_P1_GROUPPERM
;
9583 printf (" %lx", val
);
9592 printf (_("Flags:"));
9593 if (entry
->d_un
.d_val
== 0)
9594 printf (_(" None\n"));
9597 unsigned long int val
= entry
->d_un
.d_val
;
9604 if (val
& DF_1_GLOBAL
)
9609 if (val
& DF_1_GROUP
)
9614 if (val
& DF_1_NODELETE
)
9616 printf (" NODELETE");
9617 val
^= DF_1_NODELETE
;
9619 if (val
& DF_1_LOADFLTR
)
9621 printf (" LOADFLTR");
9622 val
^= DF_1_LOADFLTR
;
9624 if (val
& DF_1_INITFIRST
)
9626 printf (" INITFIRST");
9627 val
^= DF_1_INITFIRST
;
9629 if (val
& DF_1_NOOPEN
)
9634 if (val
& DF_1_ORIGIN
)
9639 if (val
& DF_1_DIRECT
)
9644 if (val
& DF_1_TRANS
)
9649 if (val
& DF_1_INTERPOSE
)
9651 printf (" INTERPOSE");
9652 val
^= DF_1_INTERPOSE
;
9654 if (val
& DF_1_NODEFLIB
)
9656 printf (" NODEFLIB");
9657 val
^= DF_1_NODEFLIB
;
9659 if (val
& DF_1_NODUMP
)
9664 if (val
& DF_1_CONFALT
)
9666 printf (" CONFALT");
9667 val
^= DF_1_CONFALT
;
9669 if (val
& DF_1_ENDFILTEE
)
9671 printf (" ENDFILTEE");
9672 val
^= DF_1_ENDFILTEE
;
9674 if (val
& DF_1_DISPRELDNE
)
9676 printf (" DISPRELDNE");
9677 val
^= DF_1_DISPRELDNE
;
9679 if (val
& DF_1_DISPRELPND
)
9681 printf (" DISPRELPND");
9682 val
^= DF_1_DISPRELPND
;
9684 if (val
& DF_1_NODIRECT
)
9686 printf (" NODIRECT");
9687 val
^= DF_1_NODIRECT
;
9689 if (val
& DF_1_IGNMULDEF
)
9691 printf (" IGNMULDEF");
9692 val
^= DF_1_IGNMULDEF
;
9694 if (val
& DF_1_NOKSYMS
)
9696 printf (" NOKSYMS");
9697 val
^= DF_1_NOKSYMS
;
9699 if (val
& DF_1_NOHDR
)
9704 if (val
& DF_1_EDITED
)
9709 if (val
& DF_1_NORELOC
)
9711 printf (" NORELOC");
9712 val
^= DF_1_NORELOC
;
9714 if (val
& DF_1_SYMINTPOSE
)
9716 printf (" SYMINTPOSE");
9717 val
^= DF_1_SYMINTPOSE
;
9719 if (val
& DF_1_GLOBAUDIT
)
9721 printf (" GLOBAUDIT");
9722 val
^= DF_1_GLOBAUDIT
;
9724 if (val
& DF_1_SINGLETON
)
9726 printf (" SINGLETON");
9727 val
^= DF_1_SINGLETON
;
9729 if (val
& DF_1_STUB
)
9740 printf (" %lx", val
);
9747 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9749 puts (get_dynamic_type (entry
->d_un
.d_val
));
9769 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9775 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9776 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9782 switch (entry
->d_tag
)
9785 printf (_("Shared library: [%s]"), name
);
9787 if (streq (name
, program_interpreter
))
9788 printf (_(" program interpreter"));
9792 printf (_("Library soname: [%s]"), name
);
9796 printf (_("Library rpath: [%s]"), name
);
9800 printf (_("Library runpath: [%s]"), name
);
9804 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9809 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9822 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9827 case DT_INIT_ARRAYSZ
:
9828 case DT_FINI_ARRAYSZ
:
9829 case DT_GNU_CONFLICTSZ
:
9830 case DT_GNU_LIBLISTSZ
:
9833 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9834 printf (_(" (bytes)\n"));
9844 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9857 if (entry
->d_tag
== DT_USED
9858 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9860 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9864 printf (_("Not needed object: [%s]\n"), name
);
9869 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9875 /* The value of this entry is ignored. */
9880 case DT_GNU_PRELINKED
:
9884 time_t atime
= entry
->d_un
.d_val
;
9886 tmp
= gmtime (&atime
);
9887 /* PR 17533 file: 041-1244816-0.004. */
9889 printf (_("<corrupt time val: %lx"),
9890 (unsigned long) atime
);
9892 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9893 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9894 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9900 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9903 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9909 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9910 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9915 switch (elf_header
.e_machine
)
9918 case EM_MIPS_RS3_LE
:
9919 dynamic_section_mips_val (entry
);
9922 dynamic_section_parisc_val (entry
);
9925 dynamic_section_ia64_val (entry
);
9928 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9940 get_ver_flags (unsigned int flags
)
9942 static char buff
[32];
9949 if (flags
& VER_FLG_BASE
)
9950 strcat (buff
, "BASE ");
9952 if (flags
& VER_FLG_WEAK
)
9954 if (flags
& VER_FLG_BASE
)
9955 strcat (buff
, "| ");
9957 strcat (buff
, "WEAK ");
9960 if (flags
& VER_FLG_INFO
)
9962 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9963 strcat (buff
, "| ");
9965 strcat (buff
, "INFO ");
9968 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9969 strcat (buff
, _("| <unknown>"));
9974 /* Display the contents of the version sections. */
9977 process_version_sections (FILE * file
)
9979 Elf_Internal_Shdr
* section
;
9986 for (i
= 0, section
= section_headers
;
9987 i
< elf_header
.e_shnum
;
9990 switch (section
->sh_type
)
9992 case SHT_GNU_verdef
:
9994 Elf_External_Verdef
* edefs
;
10001 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10002 printable_section_name (section
),
10005 printf (_(" Addr: 0x"));
10006 printf_vma (section
->sh_addr
);
10007 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10008 (unsigned long) section
->sh_offset
, section
->sh_link
,
10009 printable_section_name_from_index (section
->sh_link
));
10011 edefs
= (Elf_External_Verdef
*)
10012 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10013 _("version definition section"));
10016 endbuf
= (char *) edefs
+ section
->sh_size
;
10018 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10021 Elf_External_Verdef
* edef
;
10022 Elf_Internal_Verdef ent
;
10023 Elf_External_Verdaux
* eaux
;
10024 Elf_Internal_Verdaux aux
;
10028 /* Check for very large indices. */
10029 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10032 vstart
= ((char *) edefs
) + idx
;
10033 if (vstart
+ sizeof (*edef
) > endbuf
)
10036 edef
= (Elf_External_Verdef
*) vstart
;
10038 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10039 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10040 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10041 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10042 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10043 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10044 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10046 printf (_(" %#06x: Rev: %d Flags: %s"),
10047 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10049 printf (_(" Index: %d Cnt: %d "),
10050 ent
.vd_ndx
, ent
.vd_cnt
);
10052 /* Check for overflow. */
10053 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10056 vstart
+= ent
.vd_aux
;
10058 eaux
= (Elf_External_Verdaux
*) vstart
;
10060 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10061 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10063 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10064 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10066 printf (_("Name index: %ld\n"), aux
.vda_name
);
10068 isum
= idx
+ ent
.vd_aux
;
10070 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10072 /* Check for overflow. */
10073 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10076 isum
+= aux
.vda_next
;
10077 vstart
+= aux
.vda_next
;
10079 eaux
= (Elf_External_Verdaux
*) vstart
;
10080 if (vstart
+ sizeof (*eaux
) > endbuf
)
10083 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10084 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10086 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10087 printf (_(" %#06x: Parent %d: %s\n"),
10088 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10090 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10091 isum
, j
, aux
.vda_name
);
10094 if (j
< ent
.vd_cnt
)
10095 printf (_(" Version def aux past end of section\n"));
10097 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10098 if (idx
+ ent
.vd_next
<= idx
)
10101 idx
+= ent
.vd_next
;
10104 if (cnt
< section
->sh_info
)
10105 printf (_(" Version definition past end of section\n"));
10111 case SHT_GNU_verneed
:
10113 Elf_External_Verneed
* eneed
;
10120 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10121 printable_section_name (section
), section
->sh_info
);
10123 printf (_(" Addr: 0x"));
10124 printf_vma (section
->sh_addr
);
10125 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10126 (unsigned long) section
->sh_offset
, section
->sh_link
,
10127 printable_section_name_from_index (section
->sh_link
));
10129 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10130 section
->sh_offset
, 1,
10132 _("Version Needs section"));
10135 endbuf
= (char *) eneed
+ section
->sh_size
;
10137 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10139 Elf_External_Verneed
* entry
;
10140 Elf_Internal_Verneed ent
;
10145 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10148 vstart
= ((char *) eneed
) + idx
;
10149 if (vstart
+ sizeof (*entry
) > endbuf
)
10152 entry
= (Elf_External_Verneed
*) vstart
;
10154 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10155 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10156 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10157 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10158 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10160 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10162 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10163 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10165 printf (_(" File: %lx"), ent
.vn_file
);
10167 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10169 /* Check for overflow. */
10170 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10172 vstart
+= ent
.vn_aux
;
10174 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10176 Elf_External_Vernaux
* eaux
;
10177 Elf_Internal_Vernaux aux
;
10179 if (vstart
+ sizeof (*eaux
) > endbuf
)
10181 eaux
= (Elf_External_Vernaux
*) vstart
;
10183 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10184 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10185 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10186 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10187 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10189 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10190 printf (_(" %#06x: Name: %s"),
10191 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10193 printf (_(" %#06x: Name index: %lx"),
10194 isum
, aux
.vna_name
);
10196 printf (_(" Flags: %s Version: %d\n"),
10197 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10199 /* Check for overflow. */
10200 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10201 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10203 warn (_("Invalid vna_next field of %lx\n"),
10208 isum
+= aux
.vna_next
;
10209 vstart
+= aux
.vna_next
;
10212 if (j
< ent
.vn_cnt
)
10213 warn (_("Missing Version Needs auxillary information\n"));
10215 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10217 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10218 cnt
= section
->sh_info
;
10221 idx
+= ent
.vn_next
;
10224 if (cnt
< section
->sh_info
)
10225 warn (_("Missing Version Needs information\n"));
10231 case SHT_GNU_versym
:
10233 Elf_Internal_Shdr
* link_section
;
10236 unsigned char * edata
;
10237 unsigned short * data
;
10239 Elf_Internal_Sym
* symbols
;
10240 Elf_Internal_Shdr
* string_sec
;
10241 unsigned long num_syms
;
10244 if (section
->sh_link
>= elf_header
.e_shnum
)
10247 link_section
= section_headers
+ section
->sh_link
;
10248 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10250 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10255 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10256 if (symbols
== NULL
)
10259 string_sec
= section_headers
+ link_section
->sh_link
;
10261 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10262 string_sec
->sh_size
,
10263 _("version string table"));
10270 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10271 printable_section_name (section
), (unsigned long) total
);
10273 printf (_(" Addr: "));
10274 printf_vma (section
->sh_addr
);
10275 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10276 (unsigned long) section
->sh_offset
, section
->sh_link
,
10277 printable_section_name (link_section
));
10279 off
= offset_from_vma (file
,
10280 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10281 total
* sizeof (short));
10282 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10284 _("version symbol data"));
10292 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10294 for (cnt
= total
; cnt
--;)
10295 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10300 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10304 char *invalid
= _("*invalid*");
10306 printf (" %03x:", cnt
);
10308 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10309 switch (data
[cnt
+ j
])
10312 fputs (_(" 0 (*local*) "), stdout
);
10316 fputs (_(" 1 (*global*) "), stdout
);
10320 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10321 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10323 /* If this index value is greater than the size of the symbols
10324 array, break to avoid an out-of-bounds read. */
10325 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10327 warn (_("invalid index into symbol array\n"));
10332 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10334 Elf_Internal_Verneed ivn
;
10335 unsigned long offset
;
10337 offset
= offset_from_vma
10338 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10339 sizeof (Elf_External_Verneed
));
10343 Elf_Internal_Vernaux ivna
;
10344 Elf_External_Verneed evn
;
10345 Elf_External_Vernaux evna
;
10346 unsigned long a_off
;
10348 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10349 _("version need")) == NULL
)
10352 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10353 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10355 a_off
= offset
+ ivn
.vn_aux
;
10359 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10360 1, _("version need aux (2)")) == NULL
)
10363 ivna
.vna_other
= 0;
10367 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10368 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10371 a_off
+= ivna
.vna_next
;
10373 while (ivna
.vna_other
!= data
[cnt
+ j
]
10374 && ivna
.vna_next
!= 0);
10376 if (ivna
.vna_other
== data
[cnt
+ j
])
10378 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10380 if (ivna
.vna_name
>= string_sec
->sh_size
)
10383 name
= strtab
+ ivna
.vna_name
;
10387 offset
+= ivn
.vn_next
;
10389 while (ivn
.vn_next
);
10392 if (data
[cnt
+ j
] != 0x8001
10393 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10395 Elf_Internal_Verdef ivd
;
10396 Elf_External_Verdef evd
;
10397 unsigned long offset
;
10399 offset
= offset_from_vma
10400 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10405 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10406 _("version def")) == NULL
)
10409 /* PR 17531: file: 046-1082287-0.004. */
10410 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10415 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10416 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10419 offset
+= ivd
.vd_next
;
10421 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10422 && ivd
.vd_next
!= 0);
10424 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10426 Elf_External_Verdaux evda
;
10427 Elf_Internal_Verdaux ivda
;
10429 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10431 if (get_data (&evda
, file
,
10432 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10434 _("version def aux")) == NULL
)
10437 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10439 if (ivda
.vda_name
>= string_sec
->sh_size
)
10441 else if (name
!= NULL
&& name
!= invalid
)
10442 name
= _("*both*");
10444 name
= strtab
+ ivda
.vda_name
;
10448 nn
+= printf ("(%s%-*s",
10450 12 - (int) strlen (name
),
10454 printf ("%*c", 18 - nn
, ' ');
10472 printf (_("\nNo version information found in this file.\n"));
10477 static const char *
10478 get_symbol_binding (unsigned int binding
)
10480 static char buff
[32];
10484 case STB_LOCAL
: return "LOCAL";
10485 case STB_GLOBAL
: return "GLOBAL";
10486 case STB_WEAK
: return "WEAK";
10488 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10489 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10491 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10493 if (binding
== STB_GNU_UNIQUE
10494 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10495 /* GNU is still using the default value 0. */
10496 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10498 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10501 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10506 static const char *
10507 get_symbol_type (unsigned int type
)
10509 static char buff
[32];
10513 case STT_NOTYPE
: return "NOTYPE";
10514 case STT_OBJECT
: return "OBJECT";
10515 case STT_FUNC
: return "FUNC";
10516 case STT_SECTION
: return "SECTION";
10517 case STT_FILE
: return "FILE";
10518 case STT_COMMON
: return "COMMON";
10519 case STT_TLS
: return "TLS";
10520 case STT_RELC
: return "RELC";
10521 case STT_SRELC
: return "SRELC";
10523 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10525 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10526 return "THUMB_FUNC";
10528 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10531 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10532 return "PARISC_MILLI";
10534 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10536 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10538 if (elf_header
.e_machine
== EM_PARISC
)
10540 if (type
== STT_HP_OPAQUE
)
10541 return "HP_OPAQUE";
10542 if (type
== STT_HP_STUB
)
10546 if (type
== STT_GNU_IFUNC
10547 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10548 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10549 /* GNU is still using the default value 0. */
10550 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10553 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10556 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10561 static const char *
10562 get_symbol_visibility (unsigned int visibility
)
10564 switch (visibility
)
10566 case STV_DEFAULT
: return "DEFAULT";
10567 case STV_INTERNAL
: return "INTERNAL";
10568 case STV_HIDDEN
: return "HIDDEN";
10569 case STV_PROTECTED
: return "PROTECTED";
10571 error (_("Unrecognized visibility value: %u"), visibility
);
10572 return _("<unknown>");
10576 static const char *
10577 get_solaris_symbol_visibility (unsigned int visibility
)
10579 switch (visibility
)
10581 case 4: return "EXPORTED";
10582 case 5: return "SINGLETON";
10583 case 6: return "ELIMINATE";
10584 default: return get_symbol_visibility (visibility
);
10588 static const char *
10589 get_mips_symbol_other (unsigned int other
)
10599 case STO_MICROMIPS
:
10600 return "MICROMIPS";
10601 case STO_MICROMIPS
| STO_MIPS_PIC
:
10602 return "MICROMIPS, MIPS PIC";
10610 static const char *
10611 get_ia64_symbol_other (unsigned int other
)
10613 if (is_ia64_vms ())
10615 static char res
[32];
10619 /* Function types is for images and .STB files only. */
10620 switch (elf_header
.e_type
)
10624 switch (VMS_ST_FUNC_TYPE (other
))
10626 case VMS_SFT_CODE_ADDR
:
10627 strcat (res
, " CA");
10629 case VMS_SFT_SYMV_IDX
:
10630 strcat (res
, " VEC");
10633 strcat (res
, " FD");
10635 case VMS_SFT_RESERVE
:
10636 strcat (res
, " RSV");
10639 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10640 VMS_ST_FUNC_TYPE (other
));
10641 strcat (res
, " <unknown>");
10648 switch (VMS_ST_LINKAGE (other
))
10650 case VMS_STL_IGNORE
:
10651 strcat (res
, " IGN");
10653 case VMS_STL_RESERVE
:
10654 strcat (res
, " RSV");
10657 strcat (res
, " STD");
10660 strcat (res
, " LNK");
10663 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10664 VMS_ST_LINKAGE (other
));
10665 strcat (res
, " <unknown>");
10677 static const char *
10678 get_ppc64_symbol_other (unsigned int other
)
10680 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10682 static char buf
[32];
10683 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10684 PPC64_LOCAL_ENTRY_OFFSET (other
));
10690 static const char *
10691 get_symbol_other (unsigned int other
)
10693 const char * result
= NULL
;
10694 static char buff
[32];
10699 switch (elf_header
.e_machine
)
10702 result
= get_mips_symbol_other (other
);
10705 result
= get_ia64_symbol_other (other
);
10708 result
= get_ppc64_symbol_other (other
);
10718 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10722 static const char *
10723 get_symbol_index_type (unsigned int type
)
10725 static char buff
[32];
10729 case SHN_UNDEF
: return "UND";
10730 case SHN_ABS
: return "ABS";
10731 case SHN_COMMON
: return "COM";
10733 if (type
== SHN_IA_64_ANSI_COMMON
10734 && elf_header
.e_machine
== EM_IA_64
10735 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10737 else if ((elf_header
.e_machine
== EM_X86_64
10738 || elf_header
.e_machine
== EM_L1OM
10739 || elf_header
.e_machine
== EM_K1OM
)
10740 && type
== SHN_X86_64_LCOMMON
)
10741 return "LARGE_COM";
10742 else if ((type
== SHN_MIPS_SCOMMON
10743 && elf_header
.e_machine
== EM_MIPS
)
10744 || (type
== SHN_TIC6X_SCOMMON
10745 && elf_header
.e_machine
== EM_TI_C6000
))
10747 else if (type
== SHN_MIPS_SUNDEFINED
10748 && elf_header
.e_machine
== EM_MIPS
)
10750 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10751 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10752 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10753 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10754 else if (type
>= SHN_LORESERVE
)
10755 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10756 else if (type
>= elf_header
.e_shnum
)
10757 sprintf (buff
, _("bad section index[%3d]"), type
);
10759 sprintf (buff
, "%3d", type
);
10767 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10769 unsigned char * e_data
;
10772 /* If the size_t type is smaller than the bfd_size_type, eg because
10773 you are building a 32-bit tool on a 64-bit host, then make sure
10774 that when (number) is cast to (size_t) no information is lost. */
10775 if (sizeof (size_t) < sizeof (bfd_size_type
)
10776 && (bfd_size_type
) ((size_t) number
) != number
)
10778 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10779 " elements of size %u\n"),
10784 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10785 attempting to allocate memory when the read is bound to fail. */
10786 if (ent_size
* number
> current_file_size
)
10788 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10793 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10794 if (e_data
== NULL
)
10796 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10801 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10803 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10804 number
* ent_size
);
10809 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10810 if (i_data
== NULL
)
10812 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10813 " dynamic entries\n"),
10820 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10828 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10830 Elf_Internal_Sym
* psym
;
10833 n
= print_vma (si
, DEC_5
);
10835 fputs (&" "[n
], stdout
);
10836 printf (" %3lu: ", hn
);
10838 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10840 printf (_("<No info available for dynamic symbol number %lu>\n"),
10841 (unsigned long) si
);
10845 psym
= dynamic_symbols
+ si
;
10846 print_vma (psym
->st_value
, LONG_HEX
);
10848 print_vma (psym
->st_size
, DEC_5
);
10850 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10851 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10853 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10854 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10857 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10859 printf (" %-7s", get_symbol_visibility (vis
));
10860 /* Check to see if any other bits in the st_other field are set.
10861 Note - displaying this information disrupts the layout of the
10862 table being generated, but for the moment this case is very
10864 if (psym
->st_other
^ vis
)
10865 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10868 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10869 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10870 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10872 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10876 static const char *
10877 get_symbol_version_string (FILE * file
,
10878 bfd_boolean is_dynsym
,
10879 const char * strtab
,
10880 unsigned long int strtab_size
,
10882 Elf_Internal_Sym
* psym
,
10883 enum versioned_symbol_info
* sym_info
,
10884 unsigned short * vna_other
)
10886 unsigned char data
[2];
10887 unsigned short vers_data
;
10888 unsigned long offset
;
10891 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10894 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10895 sizeof data
+ si
* sizeof (vers_data
));
10897 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10898 sizeof (data
), 1, _("version data")) == NULL
)
10901 vers_data
= byte_get (data
, 2);
10903 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10906 /* Usually we'd only see verdef for defined symbols, and verneed for
10907 undefined symbols. However, symbols defined by the linker in
10908 .dynbss for variables copied from a shared library in order to
10909 avoid text relocations are defined yet have verneed. We could
10910 use a heuristic to detect the special case, for example, check
10911 for verneed first on symbols defined in SHT_NOBITS sections, but
10912 it is simpler and more reliable to just look for both verdef and
10913 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10915 if (psym
->st_shndx
!= SHN_UNDEF
10916 && vers_data
!= 0x8001
10917 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10919 Elf_Internal_Verdef ivd
;
10920 Elf_Internal_Verdaux ivda
;
10921 Elf_External_Verdaux evda
;
10924 off
= offset_from_vma (file
,
10925 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10926 sizeof (Elf_External_Verdef
));
10930 Elf_External_Verdef evd
;
10932 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10933 _("version def")) == NULL
)
10941 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10942 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10943 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10946 off
+= ivd
.vd_next
;
10948 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10950 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10952 off
-= ivd
.vd_next
;
10955 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10956 _("version def aux")) != NULL
)
10958 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10960 if (psym
->st_name
!= ivda
.vda_name
)
10962 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10963 ? symbol_hidden
: symbol_public
);
10964 return (ivda
.vda_name
< strtab_size
10965 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10971 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10973 Elf_External_Verneed evn
;
10974 Elf_Internal_Verneed ivn
;
10975 Elf_Internal_Vernaux ivna
;
10977 offset
= offset_from_vma (file
,
10978 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10982 unsigned long vna_off
;
10984 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10985 _("version need")) == NULL
)
10988 ivna
.vna_other
= 0;
10993 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10994 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10996 vna_off
= offset
+ ivn
.vn_aux
;
11000 Elf_External_Vernaux evna
;
11002 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11003 _("version need aux (3)")) == NULL
)
11006 ivna
.vna_other
= 0;
11011 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11012 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11013 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11016 vna_off
+= ivna
.vna_next
;
11018 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11020 if (ivna
.vna_other
== vers_data
)
11023 offset
+= ivn
.vn_next
;
11025 while (ivn
.vn_next
!= 0);
11027 if (ivna
.vna_other
== vers_data
)
11029 *sym_info
= symbol_undefined
;
11030 *vna_other
= ivna
.vna_other
;
11031 return (ivna
.vna_name
< strtab_size
11032 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11038 /* Dump the symbol table. */
11040 process_symbol_table (FILE * file
)
11042 Elf_Internal_Shdr
* section
;
11043 bfd_size_type nbuckets
= 0;
11044 bfd_size_type nchains
= 0;
11045 bfd_vma
* buckets
= NULL
;
11046 bfd_vma
* chains
= NULL
;
11047 bfd_vma ngnubuckets
= 0;
11048 bfd_vma
* gnubuckets
= NULL
;
11049 bfd_vma
* gnuchains
= NULL
;
11050 bfd_vma gnusymidx
= 0;
11051 bfd_size_type ngnuchains
= 0;
11053 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11056 if (dynamic_info
[DT_HASH
]
11058 || (do_using_dynamic
11060 && dynamic_strings
!= NULL
)))
11062 unsigned char nb
[8];
11063 unsigned char nc
[8];
11064 unsigned int hash_ent_size
= 4;
11066 if ((elf_header
.e_machine
== EM_ALPHA
11067 || elf_header
.e_machine
== EM_S390
11068 || elf_header
.e_machine
== EM_S390_OLD
)
11069 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11073 (archive_file_offset
11074 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11075 sizeof nb
+ sizeof nc
)),
11078 error (_("Unable to seek to start of dynamic information\n"));
11082 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11084 error (_("Failed to read in number of buckets\n"));
11088 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11090 error (_("Failed to read in number of chains\n"));
11094 nbuckets
= byte_get (nb
, hash_ent_size
);
11095 nchains
= byte_get (nc
, hash_ent_size
);
11097 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11098 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11101 if (buckets
== NULL
|| chains
== NULL
)
11103 if (do_using_dynamic
)
11114 if (dynamic_info_DT_GNU_HASH
11116 || (do_using_dynamic
11118 && dynamic_strings
!= NULL
)))
11120 unsigned char nb
[16];
11121 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11122 bfd_vma buckets_vma
;
11125 (archive_file_offset
11126 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11130 error (_("Unable to seek to start of dynamic information\n"));
11134 if (fread (nb
, 16, 1, file
) != 1)
11136 error (_("Failed to read in number of buckets\n"));
11140 ngnubuckets
= byte_get (nb
, 4);
11141 gnusymidx
= byte_get (nb
+ 4, 4);
11142 bitmaskwords
= byte_get (nb
+ 8, 4);
11143 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11145 buckets_vma
+= bitmaskwords
* 4;
11147 buckets_vma
+= bitmaskwords
* 8;
11150 (archive_file_offset
11151 + offset_from_vma (file
, buckets_vma
, 4)),
11154 error (_("Unable to seek to start of dynamic information\n"));
11158 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11160 if (gnubuckets
== NULL
)
11163 for (i
= 0; i
< ngnubuckets
; i
++)
11164 if (gnubuckets
[i
] != 0)
11166 if (gnubuckets
[i
] < gnusymidx
)
11169 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11170 maxchain
= gnubuckets
[i
];
11173 if (maxchain
== 0xffffffff)
11176 maxchain
-= gnusymidx
;
11179 (archive_file_offset
11180 + offset_from_vma (file
, buckets_vma
11181 + 4 * (ngnubuckets
+ maxchain
), 4)),
11184 error (_("Unable to seek to start of dynamic information\n"));
11190 if (fread (nb
, 4, 1, file
) != 1)
11192 error (_("Failed to determine last chain length\n"));
11196 if (maxchain
+ 1 == 0)
11201 while ((byte_get (nb
, 4) & 1) == 0);
11204 (archive_file_offset
11205 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11208 error (_("Unable to seek to start of dynamic information\n"));
11212 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11213 ngnuchains
= maxchain
;
11216 if (gnuchains
== NULL
)
11221 if (do_using_dynamic
)
11226 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11228 && do_using_dynamic
11229 && dynamic_strings
!= NULL
11230 && dynamic_symbols
!= NULL
)
11234 if (dynamic_info
[DT_HASH
])
11238 printf (_("\nSymbol table for image:\n"));
11240 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11242 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11244 for (hn
= 0; hn
< nbuckets
; hn
++)
11249 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11250 print_dynamic_symbol (si
, hn
);
11254 if (dynamic_info_DT_GNU_HASH
)
11256 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11258 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11260 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11262 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11263 if (gnubuckets
[hn
] != 0)
11265 bfd_vma si
= gnubuckets
[hn
];
11266 bfd_vma off
= si
- gnusymidx
;
11270 print_dynamic_symbol (si
, hn
);
11273 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11277 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11278 && section_headers
!= NULL
)
11282 for (i
= 0, section
= section_headers
;
11283 i
< elf_header
.e_shnum
;
11287 char * strtab
= NULL
;
11288 unsigned long int strtab_size
= 0;
11289 Elf_Internal_Sym
* symtab
;
11290 Elf_Internal_Sym
* psym
;
11291 unsigned long num_syms
;
11293 if ((section
->sh_type
!= SHT_SYMTAB
11294 && section
->sh_type
!= SHT_DYNSYM
)
11296 && section
->sh_type
== SHT_SYMTAB
))
11299 if (section
->sh_entsize
== 0)
11301 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11302 printable_section_name (section
));
11306 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11307 printable_section_name (section
),
11308 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11311 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11313 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11315 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11316 if (symtab
== NULL
)
11319 if (section
->sh_link
== elf_header
.e_shstrndx
)
11321 strtab
= string_table
;
11322 strtab_size
= string_table_length
;
11324 else if (section
->sh_link
< elf_header
.e_shnum
)
11326 Elf_Internal_Shdr
* string_sec
;
11328 string_sec
= section_headers
+ section
->sh_link
;
11330 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11331 1, string_sec
->sh_size
,
11332 _("string table"));
11333 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11336 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11338 const char *version_string
;
11339 enum versioned_symbol_info sym_info
;
11340 unsigned short vna_other
;
11342 printf ("%6d: ", si
);
11343 print_vma (psym
->st_value
, LONG_HEX
);
11345 print_vma (psym
->st_size
, DEC_5
);
11346 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11347 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11348 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11349 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11352 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11354 printf (" %-7s", get_symbol_visibility (vis
));
11355 /* Check to see if any other bits in the st_other field are set.
11356 Note - displaying this information disrupts the layout of the
11357 table being generated, but for the moment this case is very rare. */
11358 if (psym
->st_other
^ vis
)
11359 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11361 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11362 print_symbol (25, psym
->st_name
< strtab_size
11363 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11366 = get_symbol_version_string (file
,
11367 section
->sh_type
== SHT_DYNSYM
,
11368 strtab
, strtab_size
, si
,
11369 psym
, &sym_info
, &vna_other
);
11370 if (version_string
)
11372 if (sym_info
== symbol_undefined
)
11373 printf ("@%s (%d)", version_string
, vna_other
);
11375 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11381 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11382 && si
>= section
->sh_info
11383 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11384 && elf_header
.e_machine
!= EM_MIPS
11385 /* Solaris binaries have been found to violate this requirement as
11386 well. Not sure if this is a bug or an ABI requirement. */
11387 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11388 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11389 si
, printable_section_name (section
), section
->sh_info
);
11393 if (strtab
!= string_table
)
11399 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11401 if (do_histogram
&& buckets
!= NULL
)
11403 unsigned long * lengths
;
11404 unsigned long * counts
;
11407 unsigned long maxlength
= 0;
11408 unsigned long nzero_counts
= 0;
11409 unsigned long nsyms
= 0;
11410 unsigned long chained
;
11412 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11413 (unsigned long) nbuckets
);
11415 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11416 if (lengths
== NULL
)
11418 error (_("Out of memory allocating space for histogram buckets\n"));
11422 printf (_(" Length Number %% of total Coverage\n"));
11423 for (hn
= 0; hn
< nbuckets
; ++hn
)
11425 for (si
= buckets
[hn
], chained
= 0;
11426 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11427 si
= chains
[si
], ++chained
)
11430 if (maxlength
< ++lengths
[hn
])
11434 /* PR binutils/17531: A corrupt binary could contain broken
11435 histogram data. Do not go into an infinite loop trying
11437 if (chained
> nchains
)
11439 error (_("histogram chain is corrupt\n"));
11444 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11445 if (counts
== NULL
)
11448 error (_("Out of memory allocating space for histogram counts\n"));
11452 for (hn
= 0; hn
< nbuckets
; ++hn
)
11453 ++counts
[lengths
[hn
]];
11458 printf (" 0 %-10lu (%5.1f%%)\n",
11459 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11460 for (i
= 1; i
<= maxlength
; ++i
)
11462 nzero_counts
+= counts
[i
] * i
;
11463 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11464 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11465 (nzero_counts
* 100.0) / nsyms
);
11473 if (buckets
!= NULL
)
11479 if (do_histogram
&& gnubuckets
!= NULL
)
11481 unsigned long * lengths
;
11482 unsigned long * counts
;
11484 unsigned long maxlength
= 0;
11485 unsigned long nzero_counts
= 0;
11486 unsigned long nsyms
= 0;
11488 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11489 (unsigned long) ngnubuckets
);
11491 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11492 if (lengths
== NULL
)
11494 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11498 printf (_(" Length Number %% of total Coverage\n"));
11500 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11501 if (gnubuckets
[hn
] != 0)
11503 bfd_vma off
, length
= 1;
11505 for (off
= gnubuckets
[hn
] - gnusymidx
;
11506 /* PR 17531 file: 010-77222-0.004. */
11507 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11510 lengths
[hn
] = length
;
11511 if (length
> maxlength
)
11512 maxlength
= length
;
11516 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11517 if (counts
== NULL
)
11520 error (_("Out of memory allocating space for gnu histogram counts\n"));
11524 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11525 ++counts
[lengths
[hn
]];
11527 if (ngnubuckets
> 0)
11530 printf (" 0 %-10lu (%5.1f%%)\n",
11531 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11532 for (j
= 1; j
<= maxlength
; ++j
)
11534 nzero_counts
+= counts
[j
] * j
;
11535 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11536 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11537 (nzero_counts
* 100.0) / nsyms
);
11551 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11555 if (dynamic_syminfo
== NULL
11557 /* No syminfo, this is ok. */
11560 /* There better should be a dynamic symbol section. */
11561 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11565 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11566 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11568 printf (_(" Num: Name BoundTo Flags\n"));
11569 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11571 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11573 printf ("%4d: ", i
);
11574 if (i
>= num_dynamic_syms
)
11575 printf (_("<corrupt index>"));
11576 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11577 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11579 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11582 switch (dynamic_syminfo
[i
].si_boundto
)
11584 case SYMINFO_BT_SELF
:
11585 fputs ("SELF ", stdout
);
11587 case SYMINFO_BT_PARENT
:
11588 fputs ("PARENT ", stdout
);
11591 if (dynamic_syminfo
[i
].si_boundto
> 0
11592 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11593 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11595 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11599 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11603 if (flags
& SYMINFO_FLG_DIRECT
)
11604 printf (" DIRECT");
11605 if (flags
& SYMINFO_FLG_PASSTHRU
)
11606 printf (" PASSTHRU");
11607 if (flags
& SYMINFO_FLG_COPY
)
11609 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11610 printf (" LAZYLOAD");
11618 #define IN_RANGE(START,END,ADDR,OFF) \
11619 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11621 /* Check to see if the given reloc needs to be handled in a target specific
11622 manner. If so then process the reloc and return TRUE otherwise return
11625 If called with reloc == NULL, then this is a signal that reloc processing
11626 for the current section has finished, and any saved state should be
11630 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11631 unsigned char * start
,
11632 unsigned char * end
,
11633 Elf_Internal_Sym
* symtab
,
11634 unsigned long num_syms
)
11636 unsigned int reloc_type
= 0;
11637 unsigned long sym_index
= 0;
11641 reloc_type
= get_reloc_type (reloc
->r_info
);
11642 sym_index
= get_reloc_symindex (reloc
->r_info
);
11645 switch (elf_header
.e_machine
)
11648 case EM_MSP430_OLD
:
11650 static Elf_Internal_Sym
* saved_sym
= NULL
;
11658 switch (reloc_type
)
11660 case 10: /* R_MSP430_SYM_DIFF */
11661 if (uses_msp430x_relocs ())
11663 /* Fall through. */
11664 case 21: /* R_MSP430X_SYM_DIFF */
11666 if (sym_index
>= num_syms
)
11667 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11670 saved_sym
= symtab
+ sym_index
;
11673 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11674 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11675 goto handle_sym_diff
;
11677 case 5: /* R_MSP430_16_BYTE */
11678 case 9: /* R_MSP430_8 */
11679 if (uses_msp430x_relocs ())
11681 goto handle_sym_diff
;
11683 case 2: /* R_MSP430_ABS16 */
11684 case 15: /* R_MSP430X_ABS16 */
11685 if (! uses_msp430x_relocs ())
11687 goto handle_sym_diff
;
11690 if (saved_sym
!= NULL
)
11692 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11695 if (sym_index
>= num_syms
)
11696 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11700 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11701 - saved_sym
->st_value
);
11703 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11704 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11707 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11708 (long) reloc
->r_offset
);
11717 if (saved_sym
!= NULL
)
11718 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11725 case EM_CYGNUS_MN10300
:
11727 static Elf_Internal_Sym
* saved_sym
= NULL
;
11735 switch (reloc_type
)
11737 case 34: /* R_MN10300_ALIGN */
11739 case 33: /* R_MN10300_SYM_DIFF */
11740 if (sym_index
>= num_syms
)
11741 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11744 saved_sym
= symtab
+ sym_index
;
11747 case 1: /* R_MN10300_32 */
11748 case 2: /* R_MN10300_16 */
11749 if (saved_sym
!= NULL
)
11751 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11754 if (sym_index
>= num_syms
)
11755 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11759 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11760 - saved_sym
->st_value
);
11762 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11763 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11765 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11766 (long) reloc
->r_offset
);
11774 if (saved_sym
!= NULL
)
11775 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11783 static bfd_vma saved_sym1
= 0;
11784 static bfd_vma saved_sym2
= 0;
11785 static bfd_vma value
;
11789 saved_sym1
= saved_sym2
= 0;
11793 switch (reloc_type
)
11795 case 0x80: /* R_RL78_SYM. */
11796 saved_sym1
= saved_sym2
;
11797 if (sym_index
>= num_syms
)
11798 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11802 saved_sym2
= symtab
[sym_index
].st_value
;
11803 saved_sym2
+= reloc
->r_addend
;
11807 case 0x83: /* R_RL78_OPsub. */
11808 value
= saved_sym1
- saved_sym2
;
11809 saved_sym2
= saved_sym1
= 0;
11813 case 0x41: /* R_RL78_ABS32. */
11814 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11815 byte_put (start
+ reloc
->r_offset
, value
, 4);
11817 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11818 (long) reloc
->r_offset
);
11822 case 0x43: /* R_RL78_ABS16. */
11823 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11824 byte_put (start
+ reloc
->r_offset
, value
, 2);
11826 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11827 (long) reloc
->r_offset
);
11841 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11842 DWARF debug sections. This is a target specific test. Note - we do not
11843 go through the whole including-target-headers-multiple-times route, (as
11844 we have already done with <elf/h8.h>) because this would become very
11845 messy and even then this function would have to contain target specific
11846 information (the names of the relocs instead of their numeric values).
11847 FIXME: This is not the correct way to solve this problem. The proper way
11848 is to have target specific reloc sizing and typing functions created by
11849 the reloc-macros.h header, in the same way that it already creates the
11850 reloc naming functions. */
11853 is_32bit_abs_reloc (unsigned int reloc_type
)
11855 /* Please keep this table alpha-sorted for ease of visual lookup. */
11856 switch (elf_header
.e_machine
)
11860 return reloc_type
== 1; /* R_386_32. */
11862 return reloc_type
== 1; /* R_68K_32. */
11864 return reloc_type
== 1; /* R_860_32. */
11866 return reloc_type
== 2; /* R_960_32. */
11868 return (reloc_type
== 258
11869 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11870 case EM_ADAPTEVA_EPIPHANY
:
11871 return reloc_type
== 3;
11873 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11875 return reloc_type
== 1; /* R_ARC_32. */
11876 case EM_ARC_COMPACT
:
11877 case EM_ARC_COMPACT2
:
11878 return reloc_type
== 4; /* R_ARC_32. */
11880 return reloc_type
== 2; /* R_ARM_ABS32 */
11883 return reloc_type
== 1;
11885 return reloc_type
== 0x12; /* R_byte4_data. */
11887 return reloc_type
== 3; /* R_CRIS_32. */
11889 return reloc_type
== 3; /* R_CR16_NUM32. */
11891 return reloc_type
== 15; /* R_CRX_NUM32. */
11892 case EM_CYGNUS_FRV
:
11893 return reloc_type
== 1;
11894 case EM_CYGNUS_D10V
:
11896 return reloc_type
== 6; /* R_D10V_32. */
11897 case EM_CYGNUS_D30V
:
11899 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11901 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11902 case EM_CYGNUS_FR30
:
11904 return reloc_type
== 3; /* R_FR30_32. */
11906 return reloc_type
== 1; /* R_FT32_32. */
11910 return reloc_type
== 1; /* R_H8_DIR32. */
11912 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11913 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11916 return reloc_type
== 2; /* R_IP2K_32. */
11918 return reloc_type
== 2; /* R_IQ2000_32. */
11919 case EM_LATTICEMICO32
:
11920 return reloc_type
== 3; /* R_LM32_32. */
11923 return reloc_type
== 3; /* R_M32C_32. */
11925 return reloc_type
== 34; /* R_M32R_32_RELA. */
11928 return reloc_type
== 6; /* R_M68HC11_32. */
11930 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11931 case EM_CYGNUS_MEP
:
11932 return reloc_type
== 4; /* R_MEP_32. */
11934 return reloc_type
== 2; /* R_METAG_ADDR32. */
11935 case EM_MICROBLAZE
:
11936 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11938 return reloc_type
== 2; /* R_MIPS_32. */
11940 return reloc_type
== 4; /* R_MMIX_32. */
11941 case EM_CYGNUS_MN10200
:
11943 return reloc_type
== 1; /* R_MN10200_32. */
11944 case EM_CYGNUS_MN10300
:
11946 return reloc_type
== 1; /* R_MN10300_32. */
11948 return reloc_type
== 1; /* R_MOXIE_32. */
11949 case EM_MSP430_OLD
:
11951 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11953 return reloc_type
== 2; /* R_MT_32. */
11955 return reloc_type
== 20; /* R_NDS32_RELA. */
11956 case EM_ALTERA_NIOS2
:
11957 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11959 return reloc_type
== 1; /* R_NIOS_32. */
11961 return reloc_type
== 1; /* R_OR1K_32. */
11963 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11964 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11967 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11969 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11971 return reloc_type
== 1; /* R_PPC_ADDR32. */
11973 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
11975 return reloc_type
== 1; /* R_RISCV_32. */
11977 return reloc_type
== 1; /* R_RL78_DIR32. */
11979 return reloc_type
== 1; /* R_RX_DIR32. */
11981 return reloc_type
== 1; /* R_I370_ADDR31. */
11984 return reloc_type
== 4; /* R_S390_32. */
11986 return reloc_type
== 8; /* R_SCORE_ABS32. */
11988 return reloc_type
== 1; /* R_SH_DIR32. */
11989 case EM_SPARC32PLUS
:
11992 return reloc_type
== 3 /* R_SPARC_32. */
11993 || reloc_type
== 23; /* R_SPARC_UA32. */
11995 return reloc_type
== 6; /* R_SPU_ADDR32 */
11997 return reloc_type
== 1; /* R_C6000_ABS32. */
11999 return reloc_type
== 2; /* R_TILEGX_32. */
12001 return reloc_type
== 1; /* R_TILEPRO_32. */
12002 case EM_CYGNUS_V850
:
12004 return reloc_type
== 6; /* R_V850_ABS32. */
12006 return reloc_type
== 0x33; /* R_V810_WORD. */
12008 return reloc_type
== 1; /* R_VAX_32. */
12010 return reloc_type
== 3; /* R_VISIUM_32. */
12014 return reloc_type
== 10; /* R_X86_64_32. */
12017 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12019 return reloc_type
== 4; /* R_XGATE_32. */
12021 return reloc_type
== 1; /* R_XSTROMY16_32. */
12022 case EM_XTENSA_OLD
:
12024 return reloc_type
== 1; /* R_XTENSA_32. */
12027 static unsigned int prev_warn
= 0;
12029 /* Avoid repeating the same warning multiple times. */
12030 if (prev_warn
!= elf_header
.e_machine
)
12031 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12032 elf_header
.e_machine
);
12033 prev_warn
= elf_header
.e_machine
;
12039 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12040 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12043 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12045 switch (elf_header
.e_machine
)
12046 /* Please keep this table alpha-sorted for ease of visual lookup. */
12050 return reloc_type
== 2; /* R_386_PC32. */
12052 return reloc_type
== 4; /* R_68K_PC32. */
12054 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12055 case EM_ADAPTEVA_EPIPHANY
:
12056 return reloc_type
== 6;
12058 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12059 case EM_ARC_COMPACT
:
12060 case EM_ARC_COMPACT2
:
12061 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12063 return reloc_type
== 3; /* R_ARM_REL32 */
12066 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12067 case EM_MICROBLAZE
:
12068 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12070 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12072 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12074 return reloc_type
== 26; /* R_PPC_REL32. */
12076 return reloc_type
== 26; /* R_PPC64_REL32. */
12079 return reloc_type
== 5; /* R_390_PC32. */
12081 return reloc_type
== 2; /* R_SH_REL32. */
12082 case EM_SPARC32PLUS
:
12085 return reloc_type
== 6; /* R_SPARC_DISP32. */
12087 return reloc_type
== 13; /* R_SPU_REL32. */
12089 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12091 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12093 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12097 return reloc_type
== 2; /* R_X86_64_PC32. */
12098 case EM_XTENSA_OLD
:
12100 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12102 /* Do not abort or issue an error message here. Not all targets use
12103 pc-relative 32-bit relocs in their DWARF debug information and we
12104 have already tested for target coverage in is_32bit_abs_reloc. A
12105 more helpful warning message will be generated by apply_relocations
12106 anyway, so just return. */
12111 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12112 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12115 is_64bit_abs_reloc (unsigned int reloc_type
)
12117 switch (elf_header
.e_machine
)
12120 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12122 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12124 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12126 return reloc_type
== 80; /* R_PARISC_DIR64. */
12128 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12130 return reloc_type
== 2; /* R_RISCV_64. */
12131 case EM_SPARC32PLUS
:
12134 return reloc_type
== 54; /* R_SPARC_UA64. */
12138 return reloc_type
== 1; /* R_X86_64_64. */
12141 return reloc_type
== 22; /* R_S390_64. */
12143 return reloc_type
== 1; /* R_TILEGX_64. */
12145 return reloc_type
== 18; /* R_MIPS_64. */
12151 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12152 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12155 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12157 switch (elf_header
.e_machine
)
12160 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12162 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12164 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12166 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12168 return reloc_type
== 44; /* R_PPC64_REL64. */
12169 case EM_SPARC32PLUS
:
12172 return reloc_type
== 46; /* R_SPARC_DISP64. */
12176 return reloc_type
== 24; /* R_X86_64_PC64. */
12179 return reloc_type
== 23; /* R_S390_PC64. */
12181 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12187 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12188 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12191 is_24bit_abs_reloc (unsigned int reloc_type
)
12193 switch (elf_header
.e_machine
)
12195 case EM_CYGNUS_MN10200
:
12197 return reloc_type
== 4; /* R_MN10200_24. */
12199 return reloc_type
== 5; /* R_FT32_20. */
12205 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12206 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12209 is_16bit_abs_reloc (unsigned int reloc_type
)
12211 /* Please keep this table alpha-sorted for ease of visual lookup. */
12212 switch (elf_header
.e_machine
)
12215 case EM_ARC_COMPACT
:
12216 case EM_ARC_COMPACT2
:
12217 return reloc_type
== 2; /* R_ARC_16. */
12218 case EM_ADAPTEVA_EPIPHANY
:
12219 return reloc_type
== 5;
12222 return reloc_type
== 4; /* R_AVR_16. */
12223 case EM_CYGNUS_D10V
:
12225 return reloc_type
== 3; /* R_D10V_16. */
12229 return reloc_type
== R_H8_DIR16
;
12232 return reloc_type
== 1; /* R_IP2K_16. */
12235 return reloc_type
== 1; /* R_M32C_16 */
12236 case EM_CYGNUS_MN10200
:
12238 return reloc_type
== 2; /* R_MN10200_16. */
12239 case EM_CYGNUS_MN10300
:
12241 return reloc_type
== 2; /* R_MN10300_16. */
12243 if (uses_msp430x_relocs ())
12244 return reloc_type
== 2; /* R_MSP430_ABS16. */
12245 /* Fall through. */
12246 case EM_MSP430_OLD
:
12247 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12249 return reloc_type
== 19; /* R_NDS32_RELA. */
12250 case EM_ALTERA_NIOS2
:
12251 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12253 return reloc_type
== 9; /* R_NIOS_16. */
12255 return reloc_type
== 2; /* R_OR1K_16. */
12257 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12259 return reloc_type
== 2; /* R_C6000_ABS16. */
12261 return reloc_type
== 2; /* R_VISIUM_16. */
12264 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12266 return reloc_type
== 3; /* R_XGATE_16. */
12272 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12273 relocation entries (possibly formerly used for SHT_GROUP sections). */
12276 is_none_reloc (unsigned int reloc_type
)
12278 switch (elf_header
.e_machine
)
12280 case EM_386
: /* R_386_NONE. */
12281 case EM_68K
: /* R_68K_NONE. */
12282 case EM_ADAPTEVA_EPIPHANY
:
12283 case EM_ALPHA
: /* R_ALPHA_NONE. */
12284 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12285 case EM_ARC
: /* R_ARC_NONE. */
12286 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12287 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12288 case EM_ARM
: /* R_ARM_NONE. */
12289 case EM_C166
: /* R_XC16X_NONE. */
12290 case EM_CRIS
: /* R_CRIS_NONE. */
12291 case EM_FT32
: /* R_FT32_NONE. */
12292 case EM_IA_64
: /* R_IA64_NONE. */
12293 case EM_K1OM
: /* R_X86_64_NONE. */
12294 case EM_L1OM
: /* R_X86_64_NONE. */
12295 case EM_M32R
: /* R_M32R_NONE. */
12296 case EM_MIPS
: /* R_MIPS_NONE. */
12297 case EM_MN10300
: /* R_MN10300_NONE. */
12298 case EM_MOXIE
: /* R_MOXIE_NONE. */
12299 case EM_NIOS32
: /* R_NIOS_NONE. */
12300 case EM_OR1K
: /* R_OR1K_NONE. */
12301 case EM_PARISC
: /* R_PARISC_NONE. */
12302 case EM_PPC64
: /* R_PPC64_NONE. */
12303 case EM_PPC
: /* R_PPC_NONE. */
12304 case EM_RISCV
: /* R_RISCV_NONE. */
12305 case EM_S390
: /* R_390_NONE. */
12307 case EM_SH
: /* R_SH_NONE. */
12308 case EM_SPARC32PLUS
:
12309 case EM_SPARC
: /* R_SPARC_NONE. */
12311 case EM_TILEGX
: /* R_TILEGX_NONE. */
12312 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12313 case EM_TI_C6000
:/* R_C6000_NONE. */
12314 case EM_X86_64
: /* R_X86_64_NONE. */
12316 return reloc_type
== 0;
12319 return reloc_type
== 0 || reloc_type
== 256;
12322 return (reloc_type
== 0 /* R_AVR_NONE. */
12323 || reloc_type
== 30 /* R_AVR_DIFF8. */
12324 || reloc_type
== 31 /* R_AVR_DIFF16. */
12325 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12327 return reloc_type
== 3; /* R_METAG_NONE. */
12329 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12330 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12331 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12332 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12333 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12335 return (reloc_type
== 0 /* R_PRU_NONE. */
12336 || reloc_type
== 65 /* R_PRU_DIFF8. */
12337 || reloc_type
== 66 /* R_PRU_DIFF16. */
12338 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12339 case EM_XTENSA_OLD
:
12341 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12342 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12343 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12344 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12349 /* Returns TRUE if there is a relocation against
12350 section NAME at OFFSET bytes. */
12353 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12355 Elf_Internal_Rela
* relocs
;
12356 Elf_Internal_Rela
* rp
;
12358 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12361 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12363 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12364 if (rp
->r_offset
== offset
)
12370 /* Apply relocations to a section.
12371 Note: So far support has been added only for those relocations
12372 which can be found in debug sections.
12373 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12374 loaded relocs. It is then the caller's responsibility to free them.
12375 FIXME: Add support for more relocations ? */
12378 apply_relocations (void * file
,
12379 const Elf_Internal_Shdr
* section
,
12380 unsigned char * start
,
12381 bfd_size_type size
,
12382 void ** relocs_return
,
12383 unsigned long * num_relocs_return
)
12385 Elf_Internal_Shdr
* relsec
;
12386 unsigned char * end
= start
+ size
;
12388 if (relocs_return
!= NULL
)
12390 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12391 * num_relocs_return
= 0;
12394 if (elf_header
.e_type
!= ET_REL
)
12397 /* Find the reloc section associated with the section. */
12398 for (relsec
= section_headers
;
12399 relsec
< section_headers
+ elf_header
.e_shnum
;
12402 bfd_boolean is_rela
;
12403 unsigned long num_relocs
;
12404 Elf_Internal_Rela
* relocs
;
12405 Elf_Internal_Rela
* rp
;
12406 Elf_Internal_Shdr
* symsec
;
12407 Elf_Internal_Sym
* symtab
;
12408 unsigned long num_syms
;
12409 Elf_Internal_Sym
* sym
;
12411 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12412 || relsec
->sh_info
>= elf_header
.e_shnum
12413 || section_headers
+ relsec
->sh_info
!= section
12414 || relsec
->sh_size
== 0
12415 || relsec
->sh_link
>= elf_header
.e_shnum
)
12418 is_rela
= relsec
->sh_type
== SHT_RELA
;
12422 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12423 relsec
->sh_size
, & relocs
, & num_relocs
))
12428 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12429 relsec
->sh_size
, & relocs
, & num_relocs
))
12433 /* SH uses RELA but uses in place value instead of the addend field. */
12434 if (elf_header
.e_machine
== EM_SH
)
12437 symsec
= section_headers
+ relsec
->sh_link
;
12438 if (symsec
->sh_type
!= SHT_SYMTAB
12439 && symsec
->sh_type
!= SHT_DYNSYM
)
12441 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12443 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12446 unsigned int reloc_type
;
12447 unsigned int reloc_size
;
12448 unsigned char * rloc
;
12449 unsigned long sym_index
;
12451 reloc_type
= get_reloc_type (rp
->r_info
);
12453 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12455 else if (is_none_reloc (reloc_type
))
12457 else if (is_32bit_abs_reloc (reloc_type
)
12458 || is_32bit_pcrel_reloc (reloc_type
))
12460 else if (is_64bit_abs_reloc (reloc_type
)
12461 || is_64bit_pcrel_reloc (reloc_type
))
12463 else if (is_24bit_abs_reloc (reloc_type
))
12465 else if (is_16bit_abs_reloc (reloc_type
))
12469 static unsigned int prev_reloc
= 0;
12470 if (reloc_type
!= prev_reloc
)
12471 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12472 reloc_type
, printable_section_name (section
));
12473 prev_reloc
= reloc_type
;
12477 rloc
= start
+ rp
->r_offset
;
12478 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12480 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12481 (unsigned long) rp
->r_offset
,
12482 printable_section_name (section
));
12486 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12487 if (sym_index
>= num_syms
)
12489 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12490 sym_index
, printable_section_name (section
));
12493 sym
= symtab
+ sym_index
;
12495 /* If the reloc has a symbol associated with it,
12496 make sure that it is of an appropriate type.
12498 Relocations against symbols without type can happen.
12499 Gcc -feliminate-dwarf2-dups may generate symbols
12500 without type for debug info.
12502 Icc generates relocations against function symbols
12503 instead of local labels.
12505 Relocations against object symbols can happen, eg when
12506 referencing a global array. For an example of this see
12507 the _clz.o binary in libgcc.a. */
12509 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12510 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12512 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12513 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12514 (long int)(rp
- relocs
),
12515 printable_section_name (relsec
));
12521 addend
+= rp
->r_addend
;
12522 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12523 partial_inplace. */
12525 || (elf_header
.e_machine
== EM_XTENSA
12526 && reloc_type
== 1)
12527 || ((elf_header
.e_machine
== EM_PJ
12528 || elf_header
.e_machine
== EM_PJ_OLD
)
12529 && reloc_type
== 1)
12530 || ((elf_header
.e_machine
== EM_D30V
12531 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12532 && reloc_type
== 12))
12533 addend
+= byte_get (rloc
, reloc_size
);
12535 if (is_32bit_pcrel_reloc (reloc_type
)
12536 || is_64bit_pcrel_reloc (reloc_type
))
12538 /* On HPPA, all pc-relative relocations are biased by 8. */
12539 if (elf_header
.e_machine
== EM_PARISC
)
12541 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12545 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12549 /* Let the target specific reloc processing code know that
12550 we have finished with these relocs. */
12551 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12555 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12556 * num_relocs_return
= num_relocs
;
12565 #ifdef SUPPORT_DISASSEMBLY
12567 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12569 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12571 /* FIXME: XXX -- to be done --- XXX */
12577 /* Reads in the contents of SECTION from FILE, returning a pointer
12578 to a malloc'ed buffer or NULL if something went wrong. */
12581 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12583 bfd_size_type num_bytes
;
12585 num_bytes
= section
->sh_size
;
12587 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12589 printf (_("\nSection '%s' has no data to dump.\n"),
12590 printable_section_name (section
));
12594 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12595 _("section contents"));
12598 /* Uncompresses a section that was compressed using zlib, in place. */
12601 uncompress_section_contents (unsigned char **buffer
,
12602 dwarf_size_type uncompressed_size
,
12603 dwarf_size_type
*size
)
12605 dwarf_size_type compressed_size
= *size
;
12606 unsigned char * compressed_buffer
= *buffer
;
12607 unsigned char * uncompressed_buffer
;
12611 /* It is possible the section consists of several compressed
12612 buffers concatenated together, so we uncompress in a loop. */
12613 /* PR 18313: The state field in the z_stream structure is supposed
12614 to be invisible to the user (ie us), but some compilers will
12615 still complain about it being used without initialisation. So
12616 we first zero the entire z_stream structure and then set the fields
12618 memset (& strm
, 0, sizeof strm
);
12619 strm
.avail_in
= compressed_size
;
12620 strm
.next_in
= (Bytef
*) compressed_buffer
;
12621 strm
.avail_out
= uncompressed_size
;
12622 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12624 rc
= inflateInit (& strm
);
12625 while (strm
.avail_in
> 0)
12629 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12630 + (uncompressed_size
- strm
.avail_out
));
12631 rc
= inflate (&strm
, Z_FINISH
);
12632 if (rc
!= Z_STREAM_END
)
12634 rc
= inflateReset (& strm
);
12636 rc
= inflateEnd (& strm
);
12638 || strm
.avail_out
!= 0)
12641 *buffer
= uncompressed_buffer
;
12642 *size
= uncompressed_size
;
12646 free (uncompressed_buffer
);
12647 /* Indicate decompression failure. */
12653 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12655 Elf_Internal_Shdr
* relsec
;
12656 bfd_size_type num_bytes
;
12657 unsigned char * data
;
12658 unsigned char * end
;
12659 unsigned char * real_start
;
12660 unsigned char * start
;
12661 bfd_boolean some_strings_shown
;
12663 real_start
= start
= (unsigned char *) get_section_contents (section
,
12667 num_bytes
= section
->sh_size
;
12669 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12671 if (decompress_dumps
)
12673 dwarf_size_type new_size
= num_bytes
;
12674 dwarf_size_type uncompressed_size
= 0;
12676 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12678 Elf_Internal_Chdr chdr
;
12679 unsigned int compression_header_size
12680 = get_compression_header (& chdr
, (unsigned char *) start
,
12683 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12685 warn (_("section '%s' has unsupported compress type: %d\n"),
12686 printable_section_name (section
), chdr
.ch_type
);
12689 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12691 warn (_("compressed section '%s' is corrupted\n"),
12692 printable_section_name (section
));
12695 uncompressed_size
= chdr
.ch_size
;
12696 start
+= compression_header_size
;
12697 new_size
-= compression_header_size
;
12699 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12701 /* Read the zlib header. In this case, it should be "ZLIB"
12702 followed by the uncompressed section size, 8 bytes in
12703 big-endian order. */
12704 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12705 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12706 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12707 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12708 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12709 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12710 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12711 uncompressed_size
+= start
[11];
12716 if (uncompressed_size
)
12718 if (uncompress_section_contents (& start
,
12719 uncompressed_size
, & new_size
))
12720 num_bytes
= new_size
;
12723 error (_("Unable to decompress section %s\n"),
12724 printable_section_name (section
));
12729 start
= real_start
;
12732 /* If the section being dumped has relocations against it the user might
12733 be expecting these relocations to have been applied. Check for this
12734 case and issue a warning message in order to avoid confusion.
12735 FIXME: Maybe we ought to have an option that dumps a section with
12736 relocs applied ? */
12737 for (relsec
= section_headers
;
12738 relsec
< section_headers
+ elf_header
.e_shnum
;
12741 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12742 || relsec
->sh_info
>= elf_header
.e_shnum
12743 || section_headers
+ relsec
->sh_info
!= section
12744 || relsec
->sh_size
== 0
12745 || relsec
->sh_link
>= elf_header
.e_shnum
)
12748 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12753 end
= start
+ num_bytes
;
12754 some_strings_shown
= FALSE
;
12758 while (!ISPRINT (* data
))
12759 if (++ data
>= end
)
12764 size_t maxlen
= end
- data
;
12767 /* PR 11128: Use two separate invocations in order to work
12768 around bugs in the Solaris 8 implementation of printf. */
12769 printf (" [%6tx] ", data
- start
);
12771 printf (" [%6Ix] ", (size_t) (data
- start
));
12775 print_symbol ((int) maxlen
, (const char *) data
);
12777 data
+= strnlen ((const char *) data
, maxlen
);
12781 printf (_("<corrupt>\n"));
12784 some_strings_shown
= TRUE
;
12788 if (! some_strings_shown
)
12789 printf (_(" No strings found in this section."));
12797 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12799 bfd_boolean relocate
)
12801 Elf_Internal_Shdr
* relsec
;
12802 bfd_size_type bytes
;
12803 bfd_size_type section_size
;
12805 unsigned char * data
;
12806 unsigned char * real_start
;
12807 unsigned char * start
;
12809 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12812 section_size
= section
->sh_size
;
12814 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12816 if (decompress_dumps
)
12818 dwarf_size_type new_size
= section_size
;
12819 dwarf_size_type uncompressed_size
= 0;
12821 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12823 Elf_Internal_Chdr chdr
;
12824 unsigned int compression_header_size
12825 = get_compression_header (& chdr
, start
, section_size
);
12827 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12829 warn (_("section '%s' has unsupported compress type: %d\n"),
12830 printable_section_name (section
), chdr
.ch_type
);
12833 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12835 warn (_("compressed section '%s' is corrupted\n"),
12836 printable_section_name (section
));
12839 uncompressed_size
= chdr
.ch_size
;
12840 start
+= compression_header_size
;
12841 new_size
-= compression_header_size
;
12843 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12845 /* Read the zlib header. In this case, it should be "ZLIB"
12846 followed by the uncompressed section size, 8 bytes in
12847 big-endian order. */
12848 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12849 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12850 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12851 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12852 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12853 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12854 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12855 uncompressed_size
+= start
[11];
12860 if (uncompressed_size
)
12862 if (uncompress_section_contents (& start
, uncompressed_size
,
12865 section_size
= new_size
;
12869 error (_("Unable to decompress section %s\n"),
12870 printable_section_name (section
));
12871 /* FIXME: Print the section anyway ? */
12876 start
= real_start
;
12881 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12885 /* If the section being dumped has relocations against it the user might
12886 be expecting these relocations to have been applied. Check for this
12887 case and issue a warning message in order to avoid confusion.
12888 FIXME: Maybe we ought to have an option that dumps a section with
12889 relocs applied ? */
12890 for (relsec
= section_headers
;
12891 relsec
< section_headers
+ elf_header
.e_shnum
;
12894 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12895 || relsec
->sh_info
>= elf_header
.e_shnum
12896 || section_headers
+ relsec
->sh_info
!= section
12897 || relsec
->sh_size
== 0
12898 || relsec
->sh_link
>= elf_header
.e_shnum
)
12901 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12906 addr
= section
->sh_addr
;
12907 bytes
= section_size
;
12916 lbytes
= (bytes
> 16 ? 16 : bytes
);
12918 printf (" 0x%8.8lx ", (unsigned long) addr
);
12920 for (j
= 0; j
< 16; j
++)
12923 printf ("%2.2x", data
[j
]);
12931 for (j
= 0; j
< lbytes
; j
++)
12934 if (k
>= ' ' && k
< 0x7f)
12953 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12954 const Elf_Internal_Shdr
* sec
, void * file
)
12956 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12959 /* If it is already loaded, do nothing. */
12960 if (section
->start
!= NULL
)
12963 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12964 section
->address
= sec
->sh_addr
;
12965 section
->user_data
= NULL
;
12966 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12968 sec
->sh_size
, buf
);
12969 if (section
->start
== NULL
)
12973 unsigned char *start
= section
->start
;
12974 dwarf_size_type size
= sec
->sh_size
;
12975 dwarf_size_type uncompressed_size
= 0;
12977 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12979 Elf_Internal_Chdr chdr
;
12980 unsigned int compression_header_size
;
12982 if (size
< (is_32bit_elf
12983 ? sizeof (Elf32_External_Chdr
)
12984 : sizeof (Elf64_External_Chdr
)))
12986 warn (_("compressed section %s is too small to contain a compression header"),
12991 compression_header_size
= get_compression_header (&chdr
, start
, size
);
12993 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12995 warn (_("section '%s' has unsupported compress type: %d\n"),
12996 section
->name
, chdr
.ch_type
);
12999 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13001 warn (_("compressed section '%s' is corrupted\n"),
13005 uncompressed_size
= chdr
.ch_size
;
13006 start
+= compression_header_size
;
13007 size
-= compression_header_size
;
13009 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13011 /* Read the zlib header. In this case, it should be "ZLIB"
13012 followed by the uncompressed section size, 8 bytes in
13013 big-endian order. */
13014 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13015 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13016 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13017 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13018 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13019 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13020 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13021 uncompressed_size
+= start
[11];
13026 if (uncompressed_size
)
13028 if (uncompress_section_contents (&start
, uncompressed_size
,
13031 /* Free the compressed buffer, update the section buffer
13032 and the section size if uncompress is successful. */
13033 free (section
->start
);
13034 section
->start
= start
;
13038 error (_("Unable to decompress section %s\n"),
13039 printable_section_name (sec
));
13044 section
->size
= size
;
13047 if (section
->start
== NULL
)
13050 if (debug_displays
[debug
].relocate
)
13051 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13052 & section
->reloc_info
, & section
->num_relocs
);
13055 section
->reloc_info
= NULL
;
13056 section
->num_relocs
= 0;
13062 /* If this is not NULL, load_debug_section will only look for sections
13063 within the list of sections given here. */
13064 unsigned int *section_subset
= NULL
;
13067 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13069 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13070 Elf_Internal_Shdr
* sec
;
13072 /* Locate the debug section. */
13073 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13075 section
->name
= section
->uncompressed_name
;
13078 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13080 section
->name
= section
->compressed_name
;
13085 /* If we're loading from a subset of sections, and we've loaded
13086 a section matching this name before, it's likely that it's a
13088 if (section_subset
!= NULL
)
13089 free_debug_section (debug
);
13091 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13095 free_debug_section (enum dwarf_section_display_enum debug
)
13097 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13099 if (section
->start
== NULL
)
13102 free ((char *) section
->start
);
13103 section
->start
= NULL
;
13104 section
->address
= 0;
13109 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13111 char * name
= SECTION_NAME (section
);
13112 const char * print_name
= printable_section_name (section
);
13113 bfd_size_type length
;
13117 length
= section
->sh_size
;
13120 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13123 if (section
->sh_type
== SHT_NOBITS
)
13125 /* There is no point in dumping the contents of a debugging section
13126 which has the NOBITS type - the bits in the file will be random.
13127 This can happen when a file containing a .eh_frame section is
13128 stripped with the --only-keep-debug command line option. */
13129 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13134 if (const_strneq (name
, ".gnu.linkonce.wi."))
13135 name
= ".debug_info";
13137 /* See if we know how to display the contents of this section. */
13138 for (i
= 0; i
< max
; i
++)
13139 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13140 || (i
== line
&& const_strneq (name
, ".debug_line."))
13141 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13143 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13144 int secondary
= (section
!= find_section (name
));
13147 free_debug_section ((enum dwarf_section_display_enum
) i
);
13149 if (i
== line
&& const_strneq (name
, ".debug_line."))
13151 else if (streq (sec
->uncompressed_name
, name
))
13152 sec
->name
= sec
->uncompressed_name
;
13154 sec
->name
= sec
->compressed_name
;
13155 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13158 /* If this debug section is part of a CU/TU set in a .dwp file,
13159 restrict load_debug_section to the sections in that set. */
13160 section_subset
= find_cu_tu_set (file
, shndx
);
13162 result
&= debug_displays
[i
].display (sec
, file
);
13164 section_subset
= NULL
;
13166 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13167 free_debug_section ((enum dwarf_section_display_enum
) i
);
13175 printf (_("Unrecognized debug section: %s\n"), print_name
);
13182 /* Set DUMP_SECTS for all sections where dumps were requested
13183 based on section name. */
13186 initialise_dumps_byname (void)
13188 struct dump_list_entry
* cur
;
13190 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13195 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13196 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13198 request_dump_bynumber (i
, cur
->type
);
13203 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13209 process_section_contents (FILE * file
)
13211 Elf_Internal_Shdr
* section
;
13217 initialise_dumps_byname ();
13219 for (i
= 0, section
= section_headers
;
13220 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13223 #ifdef SUPPORT_DISASSEMBLY
13224 if (dump_sects
[i
] & DISASS_DUMP
)
13225 disassemble_section (section
, file
);
13227 if (dump_sects
[i
] & HEX_DUMP
)
13228 dump_section_as_bytes (section
, file
, FALSE
);
13230 if (dump_sects
[i
] & RELOC_DUMP
)
13231 dump_section_as_bytes (section
, file
, TRUE
);
13233 if (dump_sects
[i
] & STRING_DUMP
)
13234 dump_section_as_strings (section
, file
);
13236 if (dump_sects
[i
] & DEBUG_DUMP
)
13237 display_debug_section (i
, section
, file
);
13240 /* Check to see if the user requested a
13241 dump of a section that does not exist. */
13242 while (i
< num_dump_sects
)
13245 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13251 process_mips_fpe_exception (int mask
)
13256 if (mask
& OEX_FPU_INEX
)
13257 fputs ("INEX", stdout
), first
= 0;
13258 if (mask
& OEX_FPU_UFLO
)
13259 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13260 if (mask
& OEX_FPU_OFLO
)
13261 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13262 if (mask
& OEX_FPU_DIV0
)
13263 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13264 if (mask
& OEX_FPU_INVAL
)
13265 printf ("%sINVAL", first
? "" : "|");
13268 fputs ("0", stdout
);
13271 /* Display's the value of TAG at location P. If TAG is
13272 greater than 0 it is assumed to be an unknown tag, and
13273 a message is printed to this effect. Otherwise it is
13274 assumed that a message has already been printed.
13276 If the bottom bit of TAG is set it assumed to have a
13277 string value, otherwise it is assumed to have an integer
13280 Returns an updated P pointing to the first unread byte
13281 beyond the end of TAG's value.
13283 Reads at or beyond END will not be made. */
13285 static unsigned char *
13286 display_tag_value (signed int tag
,
13288 const unsigned char * const end
)
13293 printf (" Tag_unknown_%d: ", tag
);
13297 warn (_("<corrupt tag>\n"));
13301 /* PR 17531 file: 027-19978-0.004. */
13302 size_t maxlen
= (end
- p
) - 1;
13307 print_symbol ((int) maxlen
, (const char *) p
);
13308 p
+= strnlen ((char *) p
, maxlen
) + 1;
13312 printf (_("<corrupt string tag>"));
13313 p
= (unsigned char *) end
;
13321 val
= read_uleb128 (p
, &len
, end
);
13323 printf ("%ld (0x%lx)\n", val
, val
);
13330 /* ARM EABI attributes section. */
13335 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13337 const char ** table
;
13338 } arm_attr_public_tag
;
13340 static const char * arm_attr_tag_CPU_arch
[] =
13341 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13342 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13344 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13345 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13346 {"No", "Thumb-1", "Thumb-2", "Yes"};
13347 static const char * arm_attr_tag_FP_arch
[] =
13348 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13349 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13350 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13351 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13352 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13353 "NEON for ARMv8.1"};
13354 static const char * arm_attr_tag_PCS_config
[] =
13355 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13356 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13357 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13358 {"V6", "SB", "TLS", "Unused"};
13359 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13360 {"Absolute", "PC-relative", "SB-relative", "None"};
13361 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13362 {"Absolute", "PC-relative", "None"};
13363 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13364 {"None", "direct", "GOT-indirect"};
13365 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13366 {"None", "??? 1", "2", "??? 3", "4"};
13367 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13368 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13369 {"Unused", "Needed", "Sign only"};
13370 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13371 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13372 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13373 {"Unused", "Finite", "RTABI", "IEEE 754"};
13374 static const char * arm_attr_tag_ABI_enum_size
[] =
13375 {"Unused", "small", "int", "forced to int"};
13376 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13377 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13378 static const char * arm_attr_tag_ABI_VFP_args
[] =
13379 {"AAPCS", "VFP registers", "custom", "compatible"};
13380 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13381 {"AAPCS", "WMMX registers", "custom"};
13382 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13383 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13384 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13385 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13386 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13387 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13388 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13389 static const char * arm_attr_tag_FP_HP_extension
[] =
13390 {"Not Allowed", "Allowed"};
13391 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13392 {"None", "IEEE 754", "Alternative Format"};
13393 static const char * arm_attr_tag_DSP_extension
[] =
13394 {"Follow architecture", "Allowed"};
13395 static const char * arm_attr_tag_MPextension_use
[] =
13396 {"Not Allowed", "Allowed"};
13397 static const char * arm_attr_tag_DIV_use
[] =
13398 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13399 "Allowed in v7-A with integer division extension"};
13400 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13401 static const char * arm_attr_tag_Virtualization_use
[] =
13402 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13403 "TrustZone and Virtualization Extensions"};
13404 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13405 {"Not Allowed", "Allowed"};
13407 #define LOOKUP(id, name) \
13408 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13409 static arm_attr_public_tag arm_attr_public_tags
[] =
13411 {4, "CPU_raw_name", 1, NULL
},
13412 {5, "CPU_name", 1, NULL
},
13413 LOOKUP(6, CPU_arch
),
13414 {7, "CPU_arch_profile", 0, NULL
},
13415 LOOKUP(8, ARM_ISA_use
),
13416 LOOKUP(9, THUMB_ISA_use
),
13417 LOOKUP(10, FP_arch
),
13418 LOOKUP(11, WMMX_arch
),
13419 LOOKUP(12, Advanced_SIMD_arch
),
13420 LOOKUP(13, PCS_config
),
13421 LOOKUP(14, ABI_PCS_R9_use
),
13422 LOOKUP(15, ABI_PCS_RW_data
),
13423 LOOKUP(16, ABI_PCS_RO_data
),
13424 LOOKUP(17, ABI_PCS_GOT_use
),
13425 LOOKUP(18, ABI_PCS_wchar_t
),
13426 LOOKUP(19, ABI_FP_rounding
),
13427 LOOKUP(20, ABI_FP_denormal
),
13428 LOOKUP(21, ABI_FP_exceptions
),
13429 LOOKUP(22, ABI_FP_user_exceptions
),
13430 LOOKUP(23, ABI_FP_number_model
),
13431 {24, "ABI_align_needed", 0, NULL
},
13432 {25, "ABI_align_preserved", 0, NULL
},
13433 LOOKUP(26, ABI_enum_size
),
13434 LOOKUP(27, ABI_HardFP_use
),
13435 LOOKUP(28, ABI_VFP_args
),
13436 LOOKUP(29, ABI_WMMX_args
),
13437 LOOKUP(30, ABI_optimization_goals
),
13438 LOOKUP(31, ABI_FP_optimization_goals
),
13439 {32, "compatibility", 0, NULL
},
13440 LOOKUP(34, CPU_unaligned_access
),
13441 LOOKUP(36, FP_HP_extension
),
13442 LOOKUP(38, ABI_FP_16bit_format
),
13443 LOOKUP(42, MPextension_use
),
13444 LOOKUP(44, DIV_use
),
13445 LOOKUP(46, DSP_extension
),
13446 {64, "nodefaults", 0, NULL
},
13447 {65, "also_compatible_with", 0, NULL
},
13448 LOOKUP(66, T2EE_use
),
13449 {67, "conformance", 1, NULL
},
13450 LOOKUP(68, Virtualization_use
),
13451 LOOKUP(70, MPextension_use_legacy
)
13455 static unsigned char *
13456 display_arm_attribute (unsigned char * p
,
13457 const unsigned char * const end
)
13462 arm_attr_public_tag
* attr
;
13466 tag
= read_uleb128 (p
, &len
, end
);
13469 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13471 if (arm_attr_public_tags
[i
].tag
== tag
)
13473 attr
= &arm_attr_public_tags
[i
];
13480 printf (" Tag_%s: ", attr
->name
);
13481 switch (attr
->type
)
13486 case 7: /* Tag_CPU_arch_profile. */
13487 val
= read_uleb128 (p
, &len
, end
);
13491 case 0: printf (_("None\n")); break;
13492 case 'A': printf (_("Application\n")); break;
13493 case 'R': printf (_("Realtime\n")); break;
13494 case 'M': printf (_("Microcontroller\n")); break;
13495 case 'S': printf (_("Application or Realtime\n")); break;
13496 default: printf ("??? (%d)\n", val
); break;
13500 case 24: /* Tag_align_needed. */
13501 val
= read_uleb128 (p
, &len
, end
);
13505 case 0: printf (_("None\n")); break;
13506 case 1: printf (_("8-byte\n")); break;
13507 case 2: printf (_("4-byte\n")); break;
13508 case 3: printf ("??? 3\n"); break;
13511 printf (_("8-byte and up to %d-byte extended\n"),
13514 printf ("??? (%d)\n", val
);
13519 case 25: /* Tag_align_preserved. */
13520 val
= read_uleb128 (p
, &len
, end
);
13524 case 0: printf (_("None\n")); break;
13525 case 1: printf (_("8-byte, except leaf SP\n")); break;
13526 case 2: printf (_("8-byte\n")); break;
13527 case 3: printf ("??? 3\n"); break;
13530 printf (_("8-byte and up to %d-byte extended\n"),
13533 printf ("??? (%d)\n", val
);
13538 case 32: /* Tag_compatibility. */
13540 val
= read_uleb128 (p
, &len
, end
);
13542 printf (_("flag = %d, vendor = "), val
);
13545 size_t maxlen
= (end
- p
) - 1;
13547 print_symbol ((int) maxlen
, (const char *) p
);
13548 p
+= strnlen ((char *) p
, maxlen
) + 1;
13552 printf (_("<corrupt>"));
13553 p
= (unsigned char *) end
;
13559 case 64: /* Tag_nodefaults. */
13560 /* PR 17531: file: 001-505008-0.01. */
13563 printf (_("True\n"));
13566 case 65: /* Tag_also_compatible_with. */
13567 val
= read_uleb128 (p
, &len
, end
);
13569 if (val
== 6 /* Tag_CPU_arch. */)
13571 val
= read_uleb128 (p
, &len
, end
);
13573 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13574 printf ("??? (%d)\n", val
);
13576 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13580 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13585 printf (_("<unknown: %d>\n"), tag
);
13591 return display_tag_value (-1, p
, end
);
13593 return display_tag_value (0, p
, end
);
13596 assert (attr
->type
& 0x80);
13597 val
= read_uleb128 (p
, &len
, end
);
13599 type
= attr
->type
& 0x7f;
13601 printf ("??? (%d)\n", val
);
13603 printf ("%s\n", attr
->table
[val
]);
13608 return display_tag_value (tag
, p
, end
);
13611 static unsigned char *
13612 display_gnu_attribute (unsigned char * p
,
13613 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13614 const unsigned char * const end
)
13620 tag
= read_uleb128 (p
, &len
, end
);
13623 /* Tag_compatibility is the only generic GNU attribute defined at
13627 val
= read_uleb128 (p
, &len
, end
);
13630 printf (_("flag = %d, vendor = "), val
);
13633 printf (_("<corrupt>\n"));
13634 warn (_("corrupt vendor attribute\n"));
13640 size_t maxlen
= (end
- p
) - 1;
13642 print_symbol ((int) maxlen
, (const char *) p
);
13643 p
+= strnlen ((char *) p
, maxlen
) + 1;
13647 printf (_("<corrupt>"));
13648 p
= (unsigned char *) end
;
13655 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13656 return display_proc_gnu_attribute (p
, tag
, end
);
13658 return display_tag_value (tag
, p
, end
);
13661 static unsigned char *
13662 display_power_gnu_attribute (unsigned char * p
,
13664 const unsigned char * const end
)
13669 if (tag
== Tag_GNU_Power_ABI_FP
)
13671 val
= read_uleb128 (p
, &len
, end
);
13673 printf (" Tag_GNU_Power_ABI_FP: ");
13676 printf (_("<corrupt>\n"));
13681 printf ("(%#x), ", val
);
13686 printf (_("unspecified hard/soft float, "));
13689 printf (_("hard float, "));
13692 printf (_("soft float, "));
13695 printf (_("single-precision hard float, "));
13702 printf (_("unspecified long double\n"));
13705 printf (_("128-bit IBM long double\n"));
13708 printf (_("64-bit long double\n"));
13711 printf (_("128-bit IEEE long double\n"));
13717 if (tag
== Tag_GNU_Power_ABI_Vector
)
13719 val
= read_uleb128 (p
, &len
, end
);
13721 printf (" Tag_GNU_Power_ABI_Vector: ");
13724 printf (_("<corrupt>\n"));
13729 printf ("(%#x), ", val
);
13734 printf (_("unspecified\n"));
13737 printf (_("generic\n"));
13740 printf ("AltiVec\n");
13749 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13751 val
= read_uleb128 (p
, &len
, end
);
13753 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13756 printf (_("<corrupt>\n"));
13761 printf ("(%#x), ", val
);
13766 printf (_("unspecified\n"));
13769 printf ("r3/r4\n");
13772 printf (_("memory\n"));
13781 return display_tag_value (tag
& 1, p
, end
);
13784 static unsigned char *
13785 display_s390_gnu_attribute (unsigned char * p
,
13787 const unsigned char * const end
)
13792 if (tag
== Tag_GNU_S390_ABI_Vector
)
13794 val
= read_uleb128 (p
, &len
, end
);
13796 printf (" Tag_GNU_S390_ABI_Vector: ");
13801 printf (_("any\n"));
13804 printf (_("software\n"));
13807 printf (_("hardware\n"));
13810 printf ("??? (%d)\n", val
);
13816 return display_tag_value (tag
& 1, p
, end
);
13820 display_sparc_hwcaps (unsigned int mask
)
13826 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13827 fputs ("mul32", stdout
), first
= 0;
13828 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13829 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13830 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13831 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13832 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13833 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13834 if (mask
& ELF_SPARC_HWCAP_POPC
)
13835 printf ("%spopc", first
? "" : "|"), first
= 0;
13836 if (mask
& ELF_SPARC_HWCAP_VIS
)
13837 printf ("%svis", first
? "" : "|"), first
= 0;
13838 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13839 printf ("%svis2", first
? "" : "|"), first
= 0;
13840 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13841 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13842 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13843 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13844 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13845 printf ("%svis3", first
? "" : "|"), first
= 0;
13846 if (mask
& ELF_SPARC_HWCAP_HPC
)
13847 printf ("%shpc", first
? "" : "|"), first
= 0;
13848 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13849 printf ("%srandom", first
? "" : "|"), first
= 0;
13850 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13851 printf ("%strans", first
? "" : "|"), first
= 0;
13852 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13853 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13854 if (mask
& ELF_SPARC_HWCAP_IMA
)
13855 printf ("%sima", first
? "" : "|"), first
= 0;
13856 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13857 printf ("%scspare", first
? "" : "|"), first
= 0;
13860 fputc ('0', stdout
);
13861 fputc ('\n', stdout
);
13865 display_sparc_hwcaps2 (unsigned int mask
)
13871 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13872 fputs ("fjathplus", stdout
), first
= 0;
13873 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13874 printf ("%svis3b", first
? "" : "|"), first
= 0;
13875 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13876 printf ("%sadp", first
? "" : "|"), first
= 0;
13877 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13878 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13879 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13880 printf ("%smwait", first
? "" : "|"), first
= 0;
13881 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13882 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13883 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13884 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13885 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13886 printf ("%snsec", first
? "" : "|"), first
= 0;
13887 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13888 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13889 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13890 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13891 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13892 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13895 fputc ('0', stdout
);
13896 fputc ('\n', stdout
);
13899 static unsigned char *
13900 display_sparc_gnu_attribute (unsigned char * p
,
13902 const unsigned char * const end
)
13907 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13909 val
= read_uleb128 (p
, &len
, end
);
13911 printf (" Tag_GNU_Sparc_HWCAPS: ");
13912 display_sparc_hwcaps (val
);
13915 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13917 val
= read_uleb128 (p
, &len
, end
);
13919 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13920 display_sparc_hwcaps2 (val
);
13924 return display_tag_value (tag
, p
, end
);
13928 print_mips_fp_abi_value (int val
)
13932 case Val_GNU_MIPS_ABI_FP_ANY
:
13933 printf (_("Hard or soft float\n"));
13935 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13936 printf (_("Hard float (double precision)\n"));
13938 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13939 printf (_("Hard float (single precision)\n"));
13941 case Val_GNU_MIPS_ABI_FP_SOFT
:
13942 printf (_("Soft float\n"));
13944 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13945 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13947 case Val_GNU_MIPS_ABI_FP_XX
:
13948 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13950 case Val_GNU_MIPS_ABI_FP_64
:
13951 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13953 case Val_GNU_MIPS_ABI_FP_64A
:
13954 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13956 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13957 printf (_("NaN 2008 compatibility\n"));
13960 printf ("??? (%d)\n", val
);
13965 static unsigned char *
13966 display_mips_gnu_attribute (unsigned char * p
,
13968 const unsigned char * const end
)
13970 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13975 val
= read_uleb128 (p
, &len
, end
);
13977 printf (" Tag_GNU_MIPS_ABI_FP: ");
13979 print_mips_fp_abi_value (val
);
13984 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13989 val
= read_uleb128 (p
, &len
, end
);
13991 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13995 case Val_GNU_MIPS_ABI_MSA_ANY
:
13996 printf (_("Any MSA or not\n"));
13998 case Val_GNU_MIPS_ABI_MSA_128
:
13999 printf (_("128-bit MSA\n"));
14002 printf ("??? (%d)\n", val
);
14008 return display_tag_value (tag
& 1, p
, end
);
14011 static unsigned char *
14012 display_tic6x_attribute (unsigned char * p
,
14013 const unsigned char * const end
)
14019 tag
= read_uleb128 (p
, &len
, end
);
14025 val
= read_uleb128 (p
, &len
, end
);
14027 printf (" Tag_ISA: ");
14031 case C6XABI_Tag_ISA_none
:
14032 printf (_("None\n"));
14034 case C6XABI_Tag_ISA_C62X
:
14037 case C6XABI_Tag_ISA_C67X
:
14040 case C6XABI_Tag_ISA_C67XP
:
14041 printf ("C67x+\n");
14043 case C6XABI_Tag_ISA_C64X
:
14046 case C6XABI_Tag_ISA_C64XP
:
14047 printf ("C64x+\n");
14049 case C6XABI_Tag_ISA_C674X
:
14050 printf ("C674x\n");
14053 printf ("??? (%d)\n", val
);
14058 case Tag_ABI_wchar_t
:
14059 val
= read_uleb128 (p
, &len
, end
);
14061 printf (" Tag_ABI_wchar_t: ");
14065 printf (_("Not used\n"));
14068 printf (_("2 bytes\n"));
14071 printf (_("4 bytes\n"));
14074 printf ("??? (%d)\n", val
);
14079 case Tag_ABI_stack_align_needed
:
14080 val
= read_uleb128 (p
, &len
, end
);
14082 printf (" Tag_ABI_stack_align_needed: ");
14086 printf (_("8-byte\n"));
14089 printf (_("16-byte\n"));
14092 printf ("??? (%d)\n", val
);
14097 case Tag_ABI_stack_align_preserved
:
14098 val
= read_uleb128 (p
, &len
, end
);
14100 printf (" Tag_ABI_stack_align_preserved: ");
14104 printf (_("8-byte\n"));
14107 printf (_("16-byte\n"));
14110 printf ("??? (%d)\n", val
);
14116 val
= read_uleb128 (p
, &len
, end
);
14118 printf (" Tag_ABI_DSBT: ");
14122 printf (_("DSBT addressing not used\n"));
14125 printf (_("DSBT addressing used\n"));
14128 printf ("??? (%d)\n", val
);
14134 val
= read_uleb128 (p
, &len
, end
);
14136 printf (" Tag_ABI_PID: ");
14140 printf (_("Data addressing position-dependent\n"));
14143 printf (_("Data addressing position-independent, GOT near DP\n"));
14146 printf (_("Data addressing position-independent, GOT far from DP\n"));
14149 printf ("??? (%d)\n", val
);
14155 val
= read_uleb128 (p
, &len
, end
);
14157 printf (" Tag_ABI_PIC: ");
14161 printf (_("Code addressing position-dependent\n"));
14164 printf (_("Code addressing position-independent\n"));
14167 printf ("??? (%d)\n", val
);
14172 case Tag_ABI_array_object_alignment
:
14173 val
= read_uleb128 (p
, &len
, end
);
14175 printf (" Tag_ABI_array_object_alignment: ");
14179 printf (_("8-byte\n"));
14182 printf (_("4-byte\n"));
14185 printf (_("16-byte\n"));
14188 printf ("??? (%d)\n", val
);
14193 case Tag_ABI_array_object_align_expected
:
14194 val
= read_uleb128 (p
, &len
, end
);
14196 printf (" Tag_ABI_array_object_align_expected: ");
14200 printf (_("8-byte\n"));
14203 printf (_("4-byte\n"));
14206 printf (_("16-byte\n"));
14209 printf ("??? (%d)\n", val
);
14214 case Tag_ABI_compatibility
:
14216 val
= read_uleb128 (p
, &len
, end
);
14218 printf (" Tag_ABI_compatibility: ");
14219 printf (_("flag = %d, vendor = "), val
);
14222 size_t maxlen
= (end
- p
) - 1;
14224 print_symbol ((int) maxlen
, (const char *) p
);
14225 p
+= strnlen ((char *) p
, maxlen
) + 1;
14229 printf (_("<corrupt>"));
14230 p
= (unsigned char *) end
;
14236 case Tag_ABI_conformance
:
14238 printf (" Tag_ABI_conformance: \"");
14241 size_t maxlen
= (end
- p
) - 1;
14243 print_symbol ((int) maxlen
, (const char *) p
);
14244 p
+= strnlen ((char *) p
, maxlen
) + 1;
14248 printf (_("<corrupt>"));
14249 p
= (unsigned char *) end
;
14256 return display_tag_value (tag
, p
, end
);
14260 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14262 unsigned long addr
= 0;
14263 size_t bytes
= end
- p
;
14270 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14272 printf (" 0x%8.8lx ", addr
);
14274 for (j
= 0; j
< 16; j
++)
14277 printf ("%2.2x", p
[j
]);
14285 for (j
= 0; j
< lbytes
; j
++)
14288 if (k
>= ' ' && k
< 0x7f)
14304 static unsigned char *
14305 display_msp430x_attribute (unsigned char * p
,
14306 const unsigned char * const end
)
14312 tag
= read_uleb128 (p
, & len
, end
);
14317 case OFBA_MSPABI_Tag_ISA
:
14318 val
= read_uleb128 (p
, &len
, end
);
14320 printf (" Tag_ISA: ");
14323 case 0: printf (_("None\n")); break;
14324 case 1: printf (_("MSP430\n")); break;
14325 case 2: printf (_("MSP430X\n")); break;
14326 default: printf ("??? (%d)\n", val
); break;
14330 case OFBA_MSPABI_Tag_Code_Model
:
14331 val
= read_uleb128 (p
, &len
, end
);
14333 printf (" Tag_Code_Model: ");
14336 case 0: printf (_("None\n")); break;
14337 case 1: printf (_("Small\n")); break;
14338 case 2: printf (_("Large\n")); break;
14339 default: printf ("??? (%d)\n", val
); break;
14343 case OFBA_MSPABI_Tag_Data_Model
:
14344 val
= read_uleb128 (p
, &len
, end
);
14346 printf (" Tag_Data_Model: ");
14349 case 0: printf (_("None\n")); break;
14350 case 1: printf (_("Small\n")); break;
14351 case 2: printf (_("Large\n")); break;
14352 case 3: printf (_("Restricted Large\n")); break;
14353 default: printf ("??? (%d)\n", val
); break;
14358 printf (_(" <unknown tag %d>: "), tag
);
14365 size_t maxlen
= (end
- p
) - 1;
14367 print_symbol ((int) maxlen
, (const char *) p
);
14368 p
+= strnlen ((char *) p
, maxlen
) + 1;
14372 printf (_("<corrupt>"));
14373 p
= (unsigned char *) end
;
14379 val
= read_uleb128 (p
, &len
, end
);
14381 printf ("%d (0x%x)\n", val
, val
);
14391 process_attributes (FILE * file
,
14392 const char * public_name
,
14393 unsigned int proc_type
,
14394 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14395 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14397 Elf_Internal_Shdr
* sect
;
14400 /* Find the section header so that we get the size. */
14401 for (i
= 0, sect
= section_headers
;
14402 i
< elf_header
.e_shnum
;
14405 unsigned char * contents
;
14408 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14411 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14412 sect
->sh_size
, _("attributes"));
14413 if (contents
== NULL
)
14417 /* The first character is the version of the attributes.
14418 Currently only version 1, (aka 'A') is recognised here. */
14420 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14423 bfd_vma section_len
;
14425 section_len
= sect
->sh_size
- 1;
14428 while (section_len
> 0)
14431 unsigned int namelen
;
14432 bfd_boolean public_section
;
14433 bfd_boolean gnu_section
;
14435 if (section_len
<= 4)
14437 error (_("Tag section ends prematurely\n"));
14440 attr_len
= byte_get (p
, 4);
14443 if (attr_len
> section_len
)
14445 error (_("Bad attribute length (%u > %u)\n"),
14446 (unsigned) attr_len
, (unsigned) section_len
);
14447 attr_len
= section_len
;
14449 /* PR 17531: file: 001-101425-0.004 */
14450 else if (attr_len
< 5)
14452 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14456 section_len
-= attr_len
;
14459 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14460 if (namelen
== 0 || namelen
>= attr_len
)
14462 error (_("Corrupt attribute section name\n"));
14466 printf (_("Attribute Section: "));
14467 print_symbol (INT_MAX
, (const char *) p
);
14470 if (public_name
&& streq ((char *) p
, public_name
))
14471 public_section
= TRUE
;
14473 public_section
= FALSE
;
14475 if (streq ((char *) p
, "gnu"))
14476 gnu_section
= TRUE
;
14478 gnu_section
= FALSE
;
14481 attr_len
-= namelen
;
14483 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14488 unsigned char * end
;
14490 /* PR binutils/17531: Safe handling of corrupt files. */
14493 error (_("Unused bytes at end of section\n"));
14499 size
= byte_get (p
, 4);
14500 if (size
> attr_len
)
14502 error (_("Bad subsection length (%u > %u)\n"),
14503 (unsigned) size
, (unsigned) attr_len
);
14506 /* PR binutils/17531: Safe handling of corrupt files. */
14509 error (_("Bad subsection length (%u < 6)\n"),
14516 end
= p
+ size
- 1;
14517 assert (end
<= contents
+ sect
->sh_size
);
14523 printf (_("File Attributes\n"));
14526 printf (_("Section Attributes:"));
14529 printf (_("Symbol Attributes:"));
14530 /* Fall through. */
14536 val
= read_uleb128 (p
, &j
, end
);
14540 printf (" %d", val
);
14545 printf (_("Unknown tag: %d\n"), tag
);
14546 public_section
= FALSE
;
14550 if (public_section
&& display_pub_attribute
!= NULL
)
14553 p
= display_pub_attribute (p
, end
);
14556 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14559 p
= display_gnu_attribute (p
,
14560 display_proc_gnu_attribute
,
14566 printf (_(" Unknown attribute:\n"));
14567 display_raw_attribute (p
, end
);
14581 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14582 Print the Address, Access and Initial fields of an entry at VMA ADDR
14583 and return the VMA of the next entry, or -1 if there was a problem.
14584 Does not read from DATA_END or beyond. */
14587 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14588 unsigned char * data_end
)
14591 print_vma (addr
, LONG_HEX
);
14593 if (addr
< pltgot
+ 0xfff0)
14594 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14596 printf ("%10s", "");
14599 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14603 unsigned char * from
= data
+ addr
- pltgot
;
14605 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14607 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14608 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14609 return (bfd_vma
) -1;
14613 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14614 print_vma (entry
, LONG_HEX
);
14617 return addr
+ (is_32bit_elf
? 4 : 8);
14620 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14621 PLTGOT. Print the Address and Initial fields of an entry at VMA
14622 ADDR and return the VMA of the next entry. */
14625 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14628 print_vma (addr
, LONG_HEX
);
14631 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14636 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14637 print_vma (entry
, LONG_HEX
);
14639 return addr
+ (is_32bit_elf
? 4 : 8);
14643 print_mips_ases (unsigned int mask
)
14645 if (mask
& AFL_ASE_DSP
)
14646 fputs ("\n\tDSP ASE", stdout
);
14647 if (mask
& AFL_ASE_DSPR2
)
14648 fputs ("\n\tDSP R2 ASE", stdout
);
14649 if (mask
& AFL_ASE_DSPR3
)
14650 fputs ("\n\tDSP R3 ASE", stdout
);
14651 if (mask
& AFL_ASE_EVA
)
14652 fputs ("\n\tEnhanced VA Scheme", stdout
);
14653 if (mask
& AFL_ASE_MCU
)
14654 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14655 if (mask
& AFL_ASE_MDMX
)
14656 fputs ("\n\tMDMX ASE", stdout
);
14657 if (mask
& AFL_ASE_MIPS3D
)
14658 fputs ("\n\tMIPS-3D ASE", stdout
);
14659 if (mask
& AFL_ASE_MT
)
14660 fputs ("\n\tMT ASE", stdout
);
14661 if (mask
& AFL_ASE_SMARTMIPS
)
14662 fputs ("\n\tSmartMIPS ASE", stdout
);
14663 if (mask
& AFL_ASE_VIRT
)
14664 fputs ("\n\tVZ ASE", stdout
);
14665 if (mask
& AFL_ASE_MSA
)
14666 fputs ("\n\tMSA ASE", stdout
);
14667 if (mask
& AFL_ASE_MIPS16
)
14668 fputs ("\n\tMIPS16 ASE", stdout
);
14669 if (mask
& AFL_ASE_MICROMIPS
)
14670 fputs ("\n\tMICROMIPS ASE", stdout
);
14671 if (mask
& AFL_ASE_XPA
)
14672 fputs ("\n\tXPA ASE", stdout
);
14674 fprintf (stdout
, "\n\t%s", _("None"));
14675 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14676 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14680 print_mips_isa_ext (unsigned int isa_ext
)
14685 fputs (_("None"), stdout
);
14688 fputs ("RMI XLR", stdout
);
14690 case AFL_EXT_OCTEON3
:
14691 fputs ("Cavium Networks Octeon3", stdout
);
14693 case AFL_EXT_OCTEON2
:
14694 fputs ("Cavium Networks Octeon2", stdout
);
14696 case AFL_EXT_OCTEONP
:
14697 fputs ("Cavium Networks OcteonP", stdout
);
14699 case AFL_EXT_LOONGSON_3A
:
14700 fputs ("Loongson 3A", stdout
);
14702 case AFL_EXT_OCTEON
:
14703 fputs ("Cavium Networks Octeon", stdout
);
14706 fputs ("Toshiba R5900", stdout
);
14709 fputs ("MIPS R4650", stdout
);
14712 fputs ("LSI R4010", stdout
);
14715 fputs ("NEC VR4100", stdout
);
14718 fputs ("Toshiba R3900", stdout
);
14720 case AFL_EXT_10000
:
14721 fputs ("MIPS R10000", stdout
);
14724 fputs ("Broadcom SB-1", stdout
);
14727 fputs ("NEC VR4111/VR4181", stdout
);
14730 fputs ("NEC VR4120", stdout
);
14733 fputs ("NEC VR5400", stdout
);
14736 fputs ("NEC VR5500", stdout
);
14738 case AFL_EXT_LOONGSON_2E
:
14739 fputs ("ST Microelectronics Loongson 2E", stdout
);
14741 case AFL_EXT_LOONGSON_2F
:
14742 fputs ("ST Microelectronics Loongson 2F", stdout
);
14745 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14750 get_mips_reg_size (int reg_size
)
14752 return (reg_size
== AFL_REG_NONE
) ? 0
14753 : (reg_size
== AFL_REG_32
) ? 32
14754 : (reg_size
== AFL_REG_64
) ? 64
14755 : (reg_size
== AFL_REG_128
) ? 128
14760 process_mips_specific (FILE * file
)
14762 Elf_Internal_Dyn
* entry
;
14763 Elf_Internal_Shdr
*sect
= NULL
;
14764 size_t liblist_offset
= 0;
14765 size_t liblistno
= 0;
14766 size_t conflictsno
= 0;
14767 size_t options_offset
= 0;
14768 size_t conflicts_offset
= 0;
14769 size_t pltrelsz
= 0;
14771 bfd_vma pltgot
= 0;
14772 bfd_vma mips_pltgot
= 0;
14773 bfd_vma jmprel
= 0;
14774 bfd_vma local_gotno
= 0;
14775 bfd_vma gotsym
= 0;
14776 bfd_vma symtabno
= 0;
14778 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14779 display_mips_gnu_attribute
);
14781 sect
= find_section (".MIPS.abiflags");
14785 Elf_External_ABIFlags_v0
*abiflags_ext
;
14786 Elf_Internal_ABIFlags_v0 abiflags_in
;
14788 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14789 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14792 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14793 sect
->sh_size
, _("MIPS ABI Flags section"));
14796 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14797 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14798 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14799 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14800 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14801 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14802 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14803 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14804 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14805 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14806 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14808 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14809 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14810 if (abiflags_in
.isa_rev
> 1)
14811 printf ("r%d", abiflags_in
.isa_rev
);
14812 printf ("\nGPR size: %d",
14813 get_mips_reg_size (abiflags_in
.gpr_size
));
14814 printf ("\nCPR1 size: %d",
14815 get_mips_reg_size (abiflags_in
.cpr1_size
));
14816 printf ("\nCPR2 size: %d",
14817 get_mips_reg_size (abiflags_in
.cpr2_size
));
14818 fputs ("\nFP ABI: ", stdout
);
14819 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14820 fputs ("ISA Extension: ", stdout
);
14821 print_mips_isa_ext (abiflags_in
.isa_ext
);
14822 fputs ("\nASEs:", stdout
);
14823 print_mips_ases (abiflags_in
.ases
);
14824 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14825 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14826 fputc ('\n', stdout
);
14827 free (abiflags_ext
);
14832 /* We have a lot of special sections. Thanks SGI! */
14833 if (dynamic_section
== NULL
)
14834 /* No information available. */
14837 for (entry
= dynamic_section
;
14838 /* PR 17531 file: 012-50589-0.004. */
14839 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14841 switch (entry
->d_tag
)
14843 case DT_MIPS_LIBLIST
:
14845 = offset_from_vma (file
, entry
->d_un
.d_val
,
14846 liblistno
* sizeof (Elf32_External_Lib
));
14848 case DT_MIPS_LIBLISTNO
:
14849 liblistno
= entry
->d_un
.d_val
;
14851 case DT_MIPS_OPTIONS
:
14852 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14854 case DT_MIPS_CONFLICT
:
14856 = offset_from_vma (file
, entry
->d_un
.d_val
,
14857 conflictsno
* sizeof (Elf32_External_Conflict
));
14859 case DT_MIPS_CONFLICTNO
:
14860 conflictsno
= entry
->d_un
.d_val
;
14863 pltgot
= entry
->d_un
.d_ptr
;
14865 case DT_MIPS_LOCAL_GOTNO
:
14866 local_gotno
= entry
->d_un
.d_val
;
14868 case DT_MIPS_GOTSYM
:
14869 gotsym
= entry
->d_un
.d_val
;
14871 case DT_MIPS_SYMTABNO
:
14872 symtabno
= entry
->d_un
.d_val
;
14874 case DT_MIPS_PLTGOT
:
14875 mips_pltgot
= entry
->d_un
.d_ptr
;
14878 pltrel
= entry
->d_un
.d_val
;
14881 pltrelsz
= entry
->d_un
.d_val
;
14884 jmprel
= entry
->d_un
.d_ptr
;
14890 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14892 Elf32_External_Lib
* elib
;
14895 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14897 sizeof (Elf32_External_Lib
),
14898 _("liblist section data"));
14901 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14902 (unsigned long) liblistno
);
14903 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14906 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14913 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14914 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14915 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14916 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14917 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14919 tmp
= gmtime (&atime
);
14920 snprintf (timebuf
, sizeof (timebuf
),
14921 "%04u-%02u-%02uT%02u:%02u:%02u",
14922 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14923 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14925 printf ("%3lu: ", (unsigned long) cnt
);
14926 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14927 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14929 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14930 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14931 liblist
.l_version
);
14933 if (liblist
.l_flags
== 0)
14937 static const struct
14944 { " EXACT_MATCH", LL_EXACT_MATCH
},
14945 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14946 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14947 { " EXPORTS", LL_EXPORTS
},
14948 { " DELAY_LOAD", LL_DELAY_LOAD
},
14949 { " DELTA", LL_DELTA
}
14951 int flags
= liblist
.l_flags
;
14954 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14955 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14957 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14958 flags
^= l_flags_vals
[fcnt
].bit
;
14961 printf (" %#x", (unsigned int) flags
);
14971 if (options_offset
!= 0)
14973 Elf_External_Options
* eopt
;
14974 Elf_Internal_Options
* iopt
;
14975 Elf_Internal_Options
* option
;
14978 sect
= section_headers
;
14980 /* Find the section header so that we get the size. */
14981 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14982 /* PR 17533 file: 012-277276-0.004. */
14985 error (_("No MIPS_OPTIONS header found\n"));
14989 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14990 sect
->sh_size
, _("options"));
14993 iopt
= (Elf_Internal_Options
*)
14994 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14997 error (_("Out of memory allocating space for MIPS options\n"));
15004 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15006 Elf_External_Options
* eoption
;
15008 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15010 option
->kind
= BYTE_GET (eoption
->kind
);
15011 option
->size
= BYTE_GET (eoption
->size
);
15012 option
->section
= BYTE_GET (eoption
->section
);
15013 option
->info
= BYTE_GET (eoption
->info
);
15015 /* PR 17531: file: ffa0fa3b. */
15016 if (option
->size
< sizeof (* eopt
)
15017 || offset
+ option
->size
> sect
->sh_size
)
15019 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15022 offset
+= option
->size
;
15028 printf (_("\nSection '%s' contains %d entries:\n"),
15029 printable_section_name (sect
), cnt
);
15038 switch (option
->kind
)
15041 /* This shouldn't happen. */
15042 printf (" NULL %d %lx", option
->section
, option
->info
);
15045 printf (" REGINFO ");
15046 if (elf_header
.e_machine
== EM_MIPS
)
15049 Elf32_External_RegInfo
* ereg
;
15050 Elf32_RegInfo reginfo
;
15052 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15053 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15054 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15055 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15056 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15057 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15058 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15060 printf ("GPR %08lx GP 0x%lx\n",
15061 reginfo
.ri_gprmask
,
15062 (unsigned long) reginfo
.ri_gp_value
);
15063 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15064 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15065 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15070 Elf64_External_RegInfo
* ereg
;
15071 Elf64_Internal_RegInfo reginfo
;
15073 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15074 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15075 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15076 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15077 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15078 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15079 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15081 printf ("GPR %08lx GP 0x",
15082 reginfo
.ri_gprmask
);
15083 printf_vma (reginfo
.ri_gp_value
);
15086 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15087 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15088 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15092 case ODK_EXCEPTIONS
:
15093 fputs (" EXCEPTIONS fpe_min(", stdout
);
15094 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15095 fputs (") fpe_max(", stdout
);
15096 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15097 fputs (")", stdout
);
15099 if (option
->info
& OEX_PAGE0
)
15100 fputs (" PAGE0", stdout
);
15101 if (option
->info
& OEX_SMM
)
15102 fputs (" SMM", stdout
);
15103 if (option
->info
& OEX_FPDBUG
)
15104 fputs (" FPDBUG", stdout
);
15105 if (option
->info
& OEX_DISMISS
)
15106 fputs (" DISMISS", stdout
);
15109 fputs (" PAD ", stdout
);
15110 if (option
->info
& OPAD_PREFIX
)
15111 fputs (" PREFIX", stdout
);
15112 if (option
->info
& OPAD_POSTFIX
)
15113 fputs (" POSTFIX", stdout
);
15114 if (option
->info
& OPAD_SYMBOL
)
15115 fputs (" SYMBOL", stdout
);
15118 fputs (" HWPATCH ", stdout
);
15119 if (option
->info
& OHW_R4KEOP
)
15120 fputs (" R4KEOP", stdout
);
15121 if (option
->info
& OHW_R8KPFETCH
)
15122 fputs (" R8KPFETCH", stdout
);
15123 if (option
->info
& OHW_R5KEOP
)
15124 fputs (" R5KEOP", stdout
);
15125 if (option
->info
& OHW_R5KCVTL
)
15126 fputs (" R5KCVTL", stdout
);
15129 fputs (" FILL ", stdout
);
15130 /* XXX Print content of info word? */
15133 fputs (" TAGS ", stdout
);
15134 /* XXX Print content of info word? */
15137 fputs (" HWAND ", stdout
);
15138 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15139 fputs (" R4KEOP_CHECKED", stdout
);
15140 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15141 fputs (" R4KEOP_CLEAN", stdout
);
15144 fputs (" HWOR ", stdout
);
15145 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15146 fputs (" R4KEOP_CHECKED", stdout
);
15147 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15148 fputs (" R4KEOP_CLEAN", stdout
);
15151 printf (" GP_GROUP %#06lx self-contained %#06lx",
15152 option
->info
& OGP_GROUP
,
15153 (option
->info
& OGP_SELF
) >> 16);
15156 printf (" IDENT %#06lx self-contained %#06lx",
15157 option
->info
& OGP_GROUP
,
15158 (option
->info
& OGP_SELF
) >> 16);
15161 /* This shouldn't happen. */
15162 printf (" %3d ??? %d %lx",
15163 option
->kind
, option
->section
, option
->info
);
15167 len
= sizeof (* eopt
);
15168 while (len
< option
->size
)
15170 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15172 if (ISPRINT (datum
))
15173 printf ("%c", datum
);
15175 printf ("\\%03o", datum
);
15178 fputs ("\n", stdout
);
15180 offset
+= option
->size
;
15188 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15190 Elf32_Conflict
* iconf
;
15193 if (dynamic_symbols
== NULL
)
15195 error (_("conflict list found without a dynamic symbol table\n"));
15199 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15202 error (_("Out of memory allocating space for dynamic conflicts\n"));
15208 Elf32_External_Conflict
* econf32
;
15210 econf32
= (Elf32_External_Conflict
*)
15211 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15212 sizeof (* econf32
), _("conflict"));
15216 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15217 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15223 Elf64_External_Conflict
* econf64
;
15225 econf64
= (Elf64_External_Conflict
*)
15226 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15227 sizeof (* econf64
), _("conflict"));
15231 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15232 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15237 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15238 (unsigned long) conflictsno
);
15239 puts (_(" Num: Index Value Name"));
15241 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15243 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15245 if (iconf
[cnt
] >= num_dynamic_syms
)
15246 printf (_("<corrupt symbol index>"));
15249 Elf_Internal_Sym
* psym
;
15251 psym
= & dynamic_symbols
[iconf
[cnt
]];
15252 print_vma (psym
->st_value
, FULL_HEX
);
15254 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15255 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15257 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15265 if (pltgot
!= 0 && local_gotno
!= 0)
15267 bfd_vma ent
, local_end
, global_end
;
15269 unsigned char * data
;
15270 unsigned char * data_end
;
15274 addr_size
= (is_32bit_elf
? 4 : 8);
15275 local_end
= pltgot
+ local_gotno
* addr_size
;
15277 /* PR binutils/17533 file: 012-111227-0.004 */
15278 if (symtabno
< gotsym
)
15280 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15281 (unsigned long) gotsym
, (unsigned long) symtabno
);
15285 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15286 /* PR 17531: file: 54c91a34. */
15287 if (global_end
< local_end
)
15289 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15293 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15294 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15295 global_end
- pltgot
, 1,
15296 _("Global Offset Table data"));
15299 data_end
= data
+ (global_end
- pltgot
);
15301 printf (_("\nPrimary GOT:\n"));
15302 printf (_(" Canonical gp value: "));
15303 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15306 printf (_(" Reserved entries:\n"));
15307 printf (_(" %*s %10s %*s Purpose\n"),
15308 addr_size
* 2, _("Address"), _("Access"),
15309 addr_size
* 2, _("Initial"));
15310 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15311 printf (_(" Lazy resolver\n"));
15312 if (ent
== (bfd_vma
) -1)
15313 goto got_print_fail
;
15315 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15316 >> (addr_size
* 8 - 1)) != 0)
15318 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15319 printf (_(" Module pointer (GNU extension)\n"));
15320 if (ent
== (bfd_vma
) -1)
15321 goto got_print_fail
;
15325 if (ent
< local_end
)
15327 printf (_(" Local entries:\n"));
15328 printf (" %*s %10s %*s\n",
15329 addr_size
* 2, _("Address"), _("Access"),
15330 addr_size
* 2, _("Initial"));
15331 while (ent
< local_end
)
15333 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15335 if (ent
== (bfd_vma
) -1)
15336 goto got_print_fail
;
15341 if (gotsym
< symtabno
)
15345 printf (_(" Global entries:\n"));
15346 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15347 addr_size
* 2, _("Address"),
15349 addr_size
* 2, _("Initial"),
15350 addr_size
* 2, _("Sym.Val."),
15352 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15353 _("Ndx"), _("Name"));
15355 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15357 for (i
= gotsym
; i
< symtabno
; i
++)
15359 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15362 if (dynamic_symbols
== NULL
)
15363 printf (_("<no dynamic symbols>"));
15364 else if (i
< num_dynamic_syms
)
15366 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15368 print_vma (psym
->st_value
, LONG_HEX
);
15369 printf (" %-7s %3s ",
15370 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15371 get_symbol_index_type (psym
->st_shndx
));
15373 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15374 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15376 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15379 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15380 (unsigned long) i
);
15383 if (ent
== (bfd_vma
) -1)
15394 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15397 size_t offset
, rel_offset
;
15398 unsigned long count
, i
;
15399 unsigned char * data
;
15400 int addr_size
, sym_width
;
15401 Elf_Internal_Rela
* rels
;
15403 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15404 if (pltrel
== DT_RELA
)
15406 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15411 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15416 addr_size
= (is_32bit_elf
? 4 : 8);
15417 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15419 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15420 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15421 1, _("Procedure Linkage Table data"));
15425 printf ("\nPLT GOT:\n\n");
15426 printf (_(" Reserved entries:\n"));
15427 printf (_(" %*s %*s Purpose\n"),
15428 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15429 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15430 printf (_(" PLT lazy resolver\n"));
15431 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15432 printf (_(" Module pointer\n"));
15435 printf (_(" Entries:\n"));
15436 printf (" %*s %*s %*s %-7s %3s %s\n",
15437 addr_size
* 2, _("Address"),
15438 addr_size
* 2, _("Initial"),
15439 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15440 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15441 for (i
= 0; i
< count
; i
++)
15443 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15445 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15448 if (idx
>= num_dynamic_syms
)
15449 printf (_("<corrupt symbol index: %lu>"), idx
);
15452 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15454 print_vma (psym
->st_value
, LONG_HEX
);
15455 printf (" %-7s %3s ",
15456 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15457 get_symbol_index_type (psym
->st_shndx
));
15458 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15459 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15461 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15476 process_nds32_specific (FILE * file
)
15478 Elf_Internal_Shdr
*sect
= NULL
;
15480 sect
= find_section (".nds32_e_flags");
15483 unsigned int *flag
;
15485 printf ("\nNDS32 elf flags section:\n");
15486 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15487 sect
->sh_size
, _("NDS32 elf flags section"));
15489 switch ((*flag
) & 0x3)
15492 printf ("(VEC_SIZE):\tNo entry.\n");
15495 printf ("(VEC_SIZE):\t4 bytes\n");
15498 printf ("(VEC_SIZE):\t16 bytes\n");
15501 printf ("(VEC_SIZE):\treserved\n");
15510 process_gnu_liblist (FILE * file
)
15512 Elf_Internal_Shdr
* section
;
15513 Elf_Internal_Shdr
* string_sec
;
15514 Elf32_External_Lib
* elib
;
15516 size_t strtab_size
;
15523 for (i
= 0, section
= section_headers
;
15524 i
< elf_header
.e_shnum
;
15527 switch (section
->sh_type
)
15529 case SHT_GNU_LIBLIST
:
15530 if (section
->sh_link
>= elf_header
.e_shnum
)
15533 elib
= (Elf32_External_Lib
*)
15534 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15535 _("liblist section data"));
15539 string_sec
= section_headers
+ section
->sh_link
;
15541 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15542 string_sec
->sh_size
,
15543 _("liblist string table"));
15545 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15551 strtab_size
= string_sec
->sh_size
;
15553 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15554 printable_section_name (section
),
15555 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15557 puts (_(" Library Time Stamp Checksum Version Flags"));
15559 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15567 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15568 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15569 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15570 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15571 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15573 tmp
= gmtime (&atime
);
15574 snprintf (timebuf
, sizeof (timebuf
),
15575 "%04u-%02u-%02uT%02u:%02u:%02u",
15576 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15577 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15579 printf ("%3lu: ", (unsigned long) cnt
);
15581 printf ("%-20s", liblist
.l_name
< strtab_size
15582 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15584 printf ("%-20.20s", liblist
.l_name
< strtab_size
15585 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15586 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15587 liblist
.l_version
, liblist
.l_flags
);
15598 static const char *
15599 get_note_type (unsigned e_type
)
15601 static char buff
[64];
15603 if (elf_header
.e_type
== ET_CORE
)
15607 return _("NT_AUXV (auxiliary vector)");
15609 return _("NT_PRSTATUS (prstatus structure)");
15611 return _("NT_FPREGSET (floating point registers)");
15613 return _("NT_PRPSINFO (prpsinfo structure)");
15614 case NT_TASKSTRUCT
:
15615 return _("NT_TASKSTRUCT (task structure)");
15617 return _("NT_PRXFPREG (user_xfpregs structure)");
15619 return _("NT_PPC_VMX (ppc Altivec registers)");
15621 return _("NT_PPC_VSX (ppc VSX registers)");
15623 return _("NT_386_TLS (x86 TLS information)");
15624 case NT_386_IOPERM
:
15625 return _("NT_386_IOPERM (x86 I/O permissions)");
15626 case NT_X86_XSTATE
:
15627 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15628 case NT_S390_HIGH_GPRS
:
15629 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15630 case NT_S390_TIMER
:
15631 return _("NT_S390_TIMER (s390 timer register)");
15632 case NT_S390_TODCMP
:
15633 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15634 case NT_S390_TODPREG
:
15635 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15637 return _("NT_S390_CTRS (s390 control registers)");
15638 case NT_S390_PREFIX
:
15639 return _("NT_S390_PREFIX (s390 prefix register)");
15640 case NT_S390_LAST_BREAK
:
15641 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15642 case NT_S390_SYSTEM_CALL
:
15643 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15645 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15646 case NT_S390_VXRS_LOW
:
15647 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15648 case NT_S390_VXRS_HIGH
:
15649 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15651 return _("NT_ARM_VFP (arm VFP registers)");
15653 return _("NT_ARM_TLS (AArch TLS registers)");
15654 case NT_ARM_HW_BREAK
:
15655 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15656 case NT_ARM_HW_WATCH
:
15657 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15659 return _("NT_PSTATUS (pstatus structure)");
15661 return _("NT_FPREGS (floating point registers)");
15663 return _("NT_PSINFO (psinfo structure)");
15665 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15667 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15668 case NT_WIN32PSTATUS
:
15669 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15671 return _("NT_SIGINFO (siginfo_t data)");
15673 return _("NT_FILE (mapped files)");
15681 return _("NT_VERSION (version)");
15683 return _("NT_ARCH (architecture)");
15688 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15693 print_core_note (Elf_Internal_Note
*pnote
)
15695 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15696 bfd_vma count
, page_size
;
15697 unsigned char *descdata
, *filenames
, *descend
;
15699 if (pnote
->type
!= NT_FILE
)
15705 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15706 /* Still "successful". */
15711 if (pnote
->descsz
< 2 * addr_size
)
15713 printf (_(" Malformed note - too short for header\n"));
15717 descdata
= (unsigned char *) pnote
->descdata
;
15718 descend
= descdata
+ pnote
->descsz
;
15720 if (descdata
[pnote
->descsz
- 1] != '\0')
15722 printf (_(" Malformed note - does not end with \\0\n"));
15726 count
= byte_get (descdata
, addr_size
);
15727 descdata
+= addr_size
;
15729 page_size
= byte_get (descdata
, addr_size
);
15730 descdata
+= addr_size
;
15732 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15734 printf (_(" Malformed note - too short for supplied file count\n"));
15738 printf (_(" Page size: "));
15739 print_vma (page_size
, DEC
);
15742 printf (_(" %*s%*s%*s\n"),
15743 (int) (2 + 2 * addr_size
), _("Start"),
15744 (int) (4 + 2 * addr_size
), _("End"),
15745 (int) (4 + 2 * addr_size
), _("Page Offset"));
15746 filenames
= descdata
+ count
* 3 * addr_size
;
15747 while (count
-- > 0)
15749 bfd_vma start
, end
, file_ofs
;
15751 if (filenames
== descend
)
15753 printf (_(" Malformed note - filenames end too early\n"));
15757 start
= byte_get (descdata
, addr_size
);
15758 descdata
+= addr_size
;
15759 end
= byte_get (descdata
, addr_size
);
15760 descdata
+= addr_size
;
15761 file_ofs
= byte_get (descdata
, addr_size
);
15762 descdata
+= addr_size
;
15765 print_vma (start
, FULL_HEX
);
15767 print_vma (end
, FULL_HEX
);
15769 print_vma (file_ofs
, FULL_HEX
);
15770 printf ("\n %s\n", filenames
);
15772 filenames
+= 1 + strlen ((char *) filenames
);
15778 static const char *
15779 get_gnu_elf_note_type (unsigned e_type
)
15781 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15784 case NT_GNU_ABI_TAG
:
15785 return _("NT_GNU_ABI_TAG (ABI version tag)");
15787 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15788 case NT_GNU_BUILD_ID
:
15789 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15790 case NT_GNU_GOLD_VERSION
:
15791 return _("NT_GNU_GOLD_VERSION (gold version)");
15794 static char buff
[64];
15796 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15803 print_gnu_note (Elf_Internal_Note
*pnote
)
15805 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15806 switch (pnote
->type
)
15808 case NT_GNU_BUILD_ID
:
15812 printf (_(" Build ID: "));
15813 for (i
= 0; i
< pnote
->descsz
; ++i
)
15814 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15819 case NT_GNU_ABI_TAG
:
15821 unsigned long os
, major
, minor
, subminor
;
15822 const char *osname
;
15824 /* PR 17531: file: 030-599401-0.004. */
15825 if (pnote
->descsz
< 16)
15827 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15831 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15832 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15833 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15834 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15838 case GNU_ABI_TAG_LINUX
:
15841 case GNU_ABI_TAG_HURD
:
15844 case GNU_ABI_TAG_SOLARIS
:
15845 osname
= "Solaris";
15847 case GNU_ABI_TAG_FREEBSD
:
15848 osname
= "FreeBSD";
15850 case GNU_ABI_TAG_NETBSD
:
15853 case GNU_ABI_TAG_SYLLABLE
:
15854 osname
= "Syllable";
15856 case GNU_ABI_TAG_NACL
:
15860 osname
= "Unknown";
15864 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15865 major
, minor
, subminor
);
15869 case NT_GNU_GOLD_VERSION
:
15873 printf (_(" Version: "));
15874 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15875 printf ("%c", pnote
->descdata
[i
]);
15882 unsigned long num_entries
, mask
;
15884 /* Hardware capabilities information. Word 0 is the number of entries.
15885 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15886 is a series of entries, where each entry is a single byte followed
15887 by a nul terminated string. The byte gives the bit number to test
15888 if enabled in the bitmask. */
15889 printf (_(" Hardware Capabilities: "));
15890 if (pnote
->descsz
< 8)
15892 printf (_("<corrupt GNU_HWCAP>\n"));
15895 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15896 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15897 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15898 /* FIXME: Add code to display the entries... */
15903 /* Handle unrecognised types. An error message should have already been
15904 created by get_gnu_elf_note_type(), so all that we need to do is to
15905 display the data. */
15909 printf (_(" Description data: "));
15910 for (i
= 0; i
< pnote
->descsz
; ++i
)
15911 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15920 static const char *
15921 get_v850_elf_note_type (enum v850_notes n_type
)
15923 static char buff
[64];
15927 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15928 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15929 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15930 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15931 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15932 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15934 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15940 print_v850_note (Elf_Internal_Note
* pnote
)
15944 if (pnote
->descsz
!= 4)
15946 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15950 printf (_("not set\n"));
15954 switch (pnote
->type
)
15956 case V850_NOTE_ALIGNMENT
:
15959 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15960 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15964 case V850_NOTE_DATA_SIZE
:
15967 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15968 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15972 case V850_NOTE_FPU_INFO
:
15975 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15976 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15980 case V850_NOTE_MMU_INFO
:
15981 case V850_NOTE_CACHE_INFO
:
15982 case V850_NOTE_SIMD_INFO
:
15983 if (val
== EF_RH850_SIMD
)
15985 printf (_("yes\n"));
15991 /* An 'unknown note type' message will already have been displayed. */
15995 printf (_("unknown value: %x\n"), val
);
16000 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16002 unsigned int version
;
16004 switch (pnote
->type
)
16006 case NT_NETBSD_IDENT
:
16007 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16008 if ((version
/ 10000) % 100)
16009 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16010 version
, version
/ 100000000, (version
/ 1000000) % 100,
16011 (version
/ 10000) % 100 > 26 ? "Z" : "",
16012 'A' + (version
/ 10000) % 26);
16014 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16015 version
, version
/ 100000000, (version
/ 1000000) % 100,
16016 (version
/ 100) % 100);
16019 case NT_NETBSD_MARCH
:
16020 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16028 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16033 static const char *
16034 get_freebsd_elfcore_note_type (unsigned e_type
)
16038 case NT_FREEBSD_THRMISC
:
16039 return _("NT_THRMISC (thrmisc structure)");
16040 case NT_FREEBSD_PROCSTAT_PROC
:
16041 return _("NT_PROCSTAT_PROC (proc data)");
16042 case NT_FREEBSD_PROCSTAT_FILES
:
16043 return _("NT_PROCSTAT_FILES (files data)");
16044 case NT_FREEBSD_PROCSTAT_VMMAP
:
16045 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16046 case NT_FREEBSD_PROCSTAT_GROUPS
:
16047 return _("NT_PROCSTAT_GROUPS (groups data)");
16048 case NT_FREEBSD_PROCSTAT_UMASK
:
16049 return _("NT_PROCSTAT_UMASK (umask data)");
16050 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16051 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16052 case NT_FREEBSD_PROCSTAT_OSREL
:
16053 return _("NT_PROCSTAT_OSREL (osreldate data)");
16054 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16055 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16056 case NT_FREEBSD_PROCSTAT_AUXV
:
16057 return _("NT_PROCSTAT_AUXV (auxv data)");
16059 return get_note_type (e_type
);
16062 static const char *
16063 get_netbsd_elfcore_note_type (unsigned e_type
)
16065 static char buff
[64];
16067 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16069 /* NetBSD core "procinfo" structure. */
16070 return _("NetBSD procinfo structure");
16073 /* As of Jan 2002 there are no other machine-independent notes
16074 defined for NetBSD core files. If the note type is less
16075 than the start of the machine-dependent note types, we don't
16078 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16080 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16084 switch (elf_header
.e_machine
)
16086 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16087 and PT_GETFPREGS == mach+2. */
16092 case EM_SPARC32PLUS
:
16096 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16097 return _("PT_GETREGS (reg structure)");
16098 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16099 return _("PT_GETFPREGS (fpreg structure)");
16105 /* On all other arch's, PT_GETREGS == mach+1 and
16106 PT_GETFPREGS == mach+3. */
16110 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16111 return _("PT_GETREGS (reg structure)");
16112 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16113 return _("PT_GETFPREGS (fpreg structure)");
16119 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16120 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16124 static const char *
16125 get_stapsdt_note_type (unsigned e_type
)
16127 static char buff
[64];
16132 return _("NT_STAPSDT (SystemTap probe descriptors)");
16138 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16143 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16145 int addr_size
= is_32bit_elf
? 4 : 8;
16146 char *data
= pnote
->descdata
;
16147 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16148 bfd_vma pc
, base_addr
, semaphore
;
16149 char *provider
, *probe
, *arg_fmt
;
16151 pc
= byte_get ((unsigned char *) data
, addr_size
);
16153 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16155 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16159 data
+= strlen (data
) + 1;
16161 data
+= strlen (data
) + 1;
16163 data
+= strlen (data
) + 1;
16165 printf (_(" Provider: %s\n"), provider
);
16166 printf (_(" Name: %s\n"), probe
);
16167 printf (_(" Location: "));
16168 print_vma (pc
, FULL_HEX
);
16169 printf (_(", Base: "));
16170 print_vma (base_addr
, FULL_HEX
);
16171 printf (_(", Semaphore: "));
16172 print_vma (semaphore
, FULL_HEX
);
16174 printf (_(" Arguments: %s\n"), arg_fmt
);
16176 return data
== data_end
;
16179 static const char *
16180 get_ia64_vms_note_type (unsigned e_type
)
16182 static char buff
[64];
16187 return _("NT_VMS_MHD (module header)");
16189 return _("NT_VMS_LNM (language name)");
16191 return _("NT_VMS_SRC (source files)");
16193 return "NT_VMS_TITLE";
16195 return _("NT_VMS_EIDC (consistency check)");
16196 case NT_VMS_FPMODE
:
16197 return _("NT_VMS_FPMODE (FP mode)");
16198 case NT_VMS_LINKTIME
:
16199 return "NT_VMS_LINKTIME";
16200 case NT_VMS_IMGNAM
:
16201 return _("NT_VMS_IMGNAM (image name)");
16203 return _("NT_VMS_IMGID (image id)");
16204 case NT_VMS_LINKID
:
16205 return _("NT_VMS_LINKID (link id)");
16206 case NT_VMS_IMGBID
:
16207 return _("NT_VMS_IMGBID (build id)");
16208 case NT_VMS_GSTNAM
:
16209 return _("NT_VMS_GSTNAM (sym table name)");
16210 case NT_VMS_ORIG_DYN
:
16211 return "NT_VMS_ORIG_DYN";
16212 case NT_VMS_PATCHTIME
:
16213 return "NT_VMS_PATCHTIME";
16215 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16221 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16223 switch (pnote
->type
)
16226 if (pnote
->descsz
> 36)
16228 size_t l
= strlen (pnote
->descdata
+ 34);
16229 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16230 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16231 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16232 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16235 printf (_(" Invalid size\n"));
16238 printf (_(" Language: %s\n"), pnote
->descdata
);
16241 case NT_VMS_FPMODE
:
16242 printf (_(" Floating Point mode: "));
16243 printf ("0x%016" BFD_VMA_FMT
"x\n",
16244 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16246 case NT_VMS_LINKTIME
:
16247 printf (_(" Link time: "));
16249 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16252 case NT_VMS_PATCHTIME
:
16253 printf (_(" Patch time: "));
16255 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16258 case NT_VMS_ORIG_DYN
:
16259 printf (_(" Major id: %u, minor id: %u\n"),
16260 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16261 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16262 printf (_(" Last modified : "));
16264 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16265 printf (_("\n Link flags : "));
16266 printf ("0x%016" BFD_VMA_FMT
"x\n",
16267 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16268 printf (_(" Header flags: 0x%08x\n"),
16269 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16270 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16273 case NT_VMS_IMGNAM
:
16274 printf (_(" Image name: %s\n"), pnote
->descdata
);
16276 case NT_VMS_GSTNAM
:
16277 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16280 printf (_(" Image id: %s\n"), pnote
->descdata
);
16282 case NT_VMS_LINKID
:
16283 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16291 /* Note that by the ELF standard, the name field is already null byte
16292 terminated, and namesz includes the terminating null byte.
16293 I.E. the value of namesz for the name "FSF" is 4.
16295 If the value of namesz is zero, there is no name present. */
16297 process_note (Elf_Internal_Note
* pnote
,
16298 FILE * file ATTRIBUTE_UNUSED
,
16299 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16301 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16304 if (pnote
->namesz
== 0)
16305 /* If there is no note name, then use the default set of
16306 note type strings. */
16307 nt
= get_note_type (pnote
->type
);
16309 else if (const_strneq (pnote
->namedata
, "GNU"))
16310 /* GNU-specific object file notes. */
16311 nt
= get_gnu_elf_note_type (pnote
->type
);
16313 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16314 /* FreeBSD-specific core file notes. */
16315 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16317 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16318 /* NetBSD-specific core file notes. */
16319 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16321 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16322 /* NetBSD-specific core file notes. */
16323 return process_netbsd_elf_note (pnote
);
16325 else if (strneq (pnote
->namedata
, "SPU/", 4))
16327 /* SPU-specific core file notes. */
16328 nt
= pnote
->namedata
+ 4;
16332 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16333 /* VMS/ia64-specific file notes. */
16334 nt
= get_ia64_vms_note_type (pnote
->type
);
16336 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16337 nt
= get_stapsdt_note_type (pnote
->type
);
16340 /* Don't recognize this note name; just use the default set of
16341 note type strings. */
16342 nt
= get_note_type (pnote
->type
);
16345 print_symbol (-20, name
);
16346 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16348 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16349 return print_ia64_vms_note (pnote
);
16350 else if (const_strneq (pnote
->namedata
, "GNU"))
16351 return print_gnu_note (pnote
);
16352 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16353 return print_stapsdt_note (pnote
);
16354 else if (const_strneq (pnote
->namedata
, "CORE"))
16355 return print_core_note (pnote
);
16357 else if (pnote
->descsz
)
16361 printf (_(" description data: "));
16362 for (i
= 0; i
< pnote
->descsz
; i
++)
16363 printf ("%02x ", pnote
->descdata
[i
]);
16371 process_notes_at (FILE * file
,
16372 Elf_Internal_Shdr
* section
,
16376 Elf_External_Note
* pnotes
;
16377 Elf_External_Note
* external
;
16386 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16388 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16391 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16393 if (pnotes
== NULL
)
16399 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16401 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16402 (unsigned long) offset
, (unsigned long) length
);
16404 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16406 end
= (char *) pnotes
+ length
;
16407 while ((char *) external
< end
)
16409 Elf_Internal_Note inote
;
16412 char * temp
= NULL
;
16413 size_t data_remaining
= end
- (char *) external
;
16415 if (!is_ia64_vms ())
16417 /* PR binutils/15191
16418 Make sure that there is enough data to read. */
16419 min_notesz
= offsetof (Elf_External_Note
, name
);
16420 if (data_remaining
< min_notesz
)
16422 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16423 (int) data_remaining
);
16426 inote
.type
= BYTE_GET (external
->type
);
16427 inote
.namesz
= BYTE_GET (external
->namesz
);
16428 inote
.namedata
= external
->name
;
16429 inote
.descsz
= BYTE_GET (external
->descsz
);
16430 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16431 /* PR 17531: file: 3443835e. */
16432 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16434 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16435 inote
.descdata
= inote
.namedata
;
16439 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16440 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16444 Elf64_External_VMS_Note
*vms_external
;
16446 /* PR binutils/15191
16447 Make sure that there is enough data to read. */
16448 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16449 if (data_remaining
< min_notesz
)
16451 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16452 (int) data_remaining
);
16456 vms_external
= (Elf64_External_VMS_Note
*) external
;
16457 inote
.type
= BYTE_GET (vms_external
->type
);
16458 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16459 inote
.namedata
= vms_external
->name
;
16460 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16461 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16462 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16463 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16466 if (inote
.descdata
< (char *) external
+ min_notesz
16467 || next
< (char *) external
+ min_notesz
16468 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16469 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16470 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16471 || data_remaining
< (size_t)(next
- (char *) external
))
16473 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16474 (unsigned long) ((char *) external
- (char *) pnotes
));
16475 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16476 inote
.type
, inote
.namesz
, inote
.descsz
);
16480 external
= (Elf_External_Note
*) next
;
16482 /* Verify that name is null terminated. It appears that at least
16483 one version of Linux (RedHat 6.0) generates corefiles that don't
16484 comply with the ELF spec by failing to include the null byte in
16486 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16488 temp
= (char *) malloc (inote
.namesz
+ 1);
16491 error (_("Out of memory allocating space for inote name\n"));
16496 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16497 temp
[inote
.namesz
] = 0;
16499 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16500 inote
.namedata
= temp
;
16503 res
&= process_note (& inote
, file
, section
);
16518 process_corefile_note_segments (FILE * file
)
16520 Elf_Internal_Phdr
* segment
;
16524 if (! get_program_headers (file
))
16527 for (i
= 0, segment
= program_headers
;
16528 i
< elf_header
.e_phnum
;
16531 if (segment
->p_type
== PT_NOTE
)
16532 res
&= process_notes_at (file
, NULL
,
16533 (bfd_vma
) segment
->p_offset
,
16534 (bfd_vma
) segment
->p_filesz
);
16541 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16543 Elf_External_Note
* pnotes
;
16544 Elf_External_Note
* external
;
16551 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16553 if (pnotes
== NULL
)
16557 end
= (char*) pnotes
+ length
;
16559 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16560 (unsigned long) offset
, (unsigned long) length
);
16562 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16564 Elf_External_Note
* next
;
16565 Elf_Internal_Note inote
;
16567 inote
.type
= BYTE_GET (external
->type
);
16568 inote
.namesz
= BYTE_GET (external
->namesz
);
16569 inote
.namedata
= external
->name
;
16570 inote
.descsz
= BYTE_GET (external
->descsz
);
16571 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16572 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16574 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16576 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16577 inote
.descdata
= inote
.namedata
;
16581 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16583 if ( ((char *) next
> end
)
16584 || ((char *) next
< (char *) pnotes
))
16586 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16587 (unsigned long) ((char *) external
- (char *) pnotes
));
16588 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16589 inote
.type
, inote
.namesz
, inote
.descsz
);
16595 /* Prevent out-of-bounds indexing. */
16596 if ( inote
.namedata
+ inote
.namesz
> end
16597 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16599 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16600 (unsigned long) ((char *) external
- (char *) pnotes
));
16601 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16602 inote
.type
, inote
.namesz
, inote
.descsz
);
16606 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16608 if (! print_v850_note (& inote
))
16611 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16612 inote
.namesz
, inote
.descsz
);
16622 process_note_sections (FILE * file
)
16624 Elf_Internal_Shdr
* section
;
16629 for (i
= 0, section
= section_headers
;
16630 i
< elf_header
.e_shnum
&& section
!= NULL
;
16633 if (section
->sh_type
== SHT_NOTE
)
16635 res
&= process_notes_at (file
, section
,
16636 (bfd_vma
) section
->sh_offset
,
16637 (bfd_vma
) section
->sh_size
);
16641 if (( elf_header
.e_machine
== EM_V800
16642 || elf_header
.e_machine
== EM_V850
16643 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16644 && section
->sh_type
== SHT_RENESAS_INFO
)
16646 res
&= process_v850_notes (file
,
16647 (bfd_vma
) section
->sh_offset
,
16648 (bfd_vma
) section
->sh_size
);
16654 /* Try processing NOTE segments instead. */
16655 return process_corefile_note_segments (file
);
16661 process_notes (FILE * file
)
16663 /* If we have not been asked to display the notes then do nothing. */
16667 if (elf_header
.e_type
!= ET_CORE
)
16668 return process_note_sections (file
);
16670 /* No program headers means no NOTE segment. */
16671 if (elf_header
.e_phnum
> 0)
16672 return process_corefile_note_segments (file
);
16674 printf (_("No note segments present in the core file.\n"));
16678 static unsigned char *
16679 display_public_gnu_attributes (unsigned char * start
,
16680 const unsigned char * const end
)
16682 printf (_(" Unknown GNU attribute: %s\n"), start
);
16684 start
+= strnlen ((char *) start
, end
- start
);
16685 display_raw_attribute (start
, end
);
16687 return (unsigned char *) end
;
16690 static unsigned char *
16691 display_generic_attribute (unsigned char * start
,
16693 const unsigned char * const end
)
16696 return (unsigned char *) end
;
16698 return display_tag_value (tag
, start
, end
);
16702 process_arch_specific (FILE * file
)
16707 switch (elf_header
.e_machine
)
16710 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
16711 display_arm_attribute
,
16712 display_generic_attribute
);
16715 case EM_MIPS_RS3_LE
:
16716 return process_mips_specific (file
);
16719 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
16720 display_msp430x_attribute
,
16721 display_generic_attribute
);
16724 return process_nds32_specific (file
);
16728 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16729 display_power_gnu_attribute
);
16733 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16734 display_s390_gnu_attribute
);
16737 case EM_SPARC32PLUS
:
16739 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16740 display_sparc_gnu_attribute
);
16743 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
16744 display_tic6x_attribute
,
16745 display_generic_attribute
);
16748 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
16749 display_public_gnu_attributes
,
16750 display_generic_attribute
);
16755 get_file_header (FILE * file
)
16757 /* Read in the identity array. */
16758 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16761 /* Determine how to read the rest of the header. */
16762 switch (elf_header
.e_ident
[EI_DATA
])
16767 byte_get
= byte_get_little_endian
;
16768 byte_put
= byte_put_little_endian
;
16771 byte_get
= byte_get_big_endian
;
16772 byte_put
= byte_put_big_endian
;
16776 /* For now we only support 32 bit and 64 bit ELF files. */
16777 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16779 /* Read in the rest of the header. */
16782 Elf32_External_Ehdr ehdr32
;
16784 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16787 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16788 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16789 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16790 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16791 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16792 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16793 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16794 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16795 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16796 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16797 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16798 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16799 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16803 Elf64_External_Ehdr ehdr64
;
16805 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16806 we will not be able to cope with the 64bit data found in
16807 64 ELF files. Detect this now and abort before we start
16808 overwriting things. */
16809 if (sizeof (bfd_vma
) < 8)
16811 error (_("This instance of readelf has been built without support for a\n\
16812 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16816 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16819 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16820 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16821 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16822 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16823 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16824 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16825 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16826 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16827 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16828 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16829 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16830 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16831 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16834 if (elf_header
.e_shoff
)
16836 /* There may be some extensions in the first section header. Don't
16837 bomb if we can't read it. */
16839 get_32bit_section_headers (file
, TRUE
);
16841 get_64bit_section_headers (file
, TRUE
);
16847 /* Process one ELF object file according to the command line options.
16848 This file may actually be stored in an archive. The file is
16849 positioned at the start of the ELF object. */
16852 process_object (char * file_name
, FILE * file
)
16856 if (! get_file_header (file
))
16858 error (_("%s: Failed to read file header\n"), file_name
);
16862 /* Initialise per file variables. */
16863 for (i
= ARRAY_SIZE (version_info
); i
--;)
16864 version_info
[i
] = 0;
16866 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16867 dynamic_info
[i
] = 0;
16868 dynamic_info_DT_GNU_HASH
= 0;
16870 /* Process the file. */
16872 printf (_("\nFile: %s\n"), file_name
);
16874 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16875 Note we do this even if cmdline_dump_sects is empty because we
16876 must make sure that the dump_sets array is zeroed out before each
16877 object file is processed. */
16878 if (num_dump_sects
> num_cmdline_dump_sects
)
16879 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16881 if (num_cmdline_dump_sects
> 0)
16883 if (num_dump_sects
== 0)
16884 /* A sneaky way of allocating the dump_sects array. */
16885 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16887 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16888 memcpy (dump_sects
, cmdline_dump_sects
,
16889 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16892 if (! process_file_header ())
16895 if (! process_section_headers (file
))
16897 /* Without loaded section headers we cannot process lots of
16899 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16901 if (! do_using_dynamic
)
16902 do_syms
= do_dyn_syms
= do_reloc
= 0;
16905 if (! process_section_groups (file
))
16907 /* Without loaded section groups we cannot process unwind. */
16911 if (process_program_headers (file
))
16912 process_dynamic_section (file
);
16914 process_relocs (file
);
16916 process_unwind (file
);
16918 process_symbol_table (file
);
16920 process_syminfo (file
);
16922 process_version_sections (file
);
16924 process_section_contents (file
);
16926 process_notes (file
);
16928 process_gnu_liblist (file
);
16930 process_arch_specific (file
);
16932 if (program_headers
)
16934 free (program_headers
);
16935 program_headers
= NULL
;
16938 if (section_headers
)
16940 free (section_headers
);
16941 section_headers
= NULL
;
16946 free (string_table
);
16947 string_table
= NULL
;
16948 string_table_length
= 0;
16951 if (dynamic_strings
)
16953 free (dynamic_strings
);
16954 dynamic_strings
= NULL
;
16955 dynamic_strings_length
= 0;
16958 if (dynamic_symbols
)
16960 free (dynamic_symbols
);
16961 dynamic_symbols
= NULL
;
16962 num_dynamic_syms
= 0;
16965 if (dynamic_syminfo
)
16967 free (dynamic_syminfo
);
16968 dynamic_syminfo
= NULL
;
16971 if (dynamic_section
)
16973 free (dynamic_section
);
16974 dynamic_section
= NULL
;
16977 if (section_headers_groups
)
16979 free (section_headers_groups
);
16980 section_headers_groups
= NULL
;
16983 if (section_groups
)
16985 struct group_list
* g
;
16986 struct group_list
* next
;
16988 for (i
= 0; i
< group_count
; i
++)
16990 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16997 free (section_groups
);
16998 section_groups
= NULL
;
17001 free_debug_memory ();
17006 /* Process an ELF archive.
17007 On entry the file is positioned just after the ARMAG string. */
17010 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17012 struct archive_info arch
;
17013 struct archive_info nested_arch
;
17019 /* The ARCH structure is used to hold information about this archive. */
17020 arch
.file_name
= NULL
;
17022 arch
.index_array
= NULL
;
17023 arch
.sym_table
= NULL
;
17024 arch
.longnames
= NULL
;
17026 /* The NESTED_ARCH structure is used as a single-item cache of information
17027 about a nested archive (when members of a thin archive reside within
17028 another regular archive file). */
17029 nested_arch
.file_name
= NULL
;
17030 nested_arch
.file
= NULL
;
17031 nested_arch
.index_array
= NULL
;
17032 nested_arch
.sym_table
= NULL
;
17033 nested_arch
.longnames
= NULL
;
17035 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17041 if (do_archive_index
)
17043 if (arch
.sym_table
== NULL
)
17044 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17047 unsigned long i
, l
;
17048 unsigned long current_pos
;
17050 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17051 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17052 current_pos
= ftell (file
);
17054 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17056 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17058 char * member_name
;
17060 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17062 if (member_name
!= NULL
)
17064 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17066 if (qualified_name
!= NULL
)
17068 printf (_("Contents of binary %s at offset "), qualified_name
);
17069 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17071 free (qualified_name
);
17076 if (l
>= arch
.sym_size
)
17078 error (_("%s: end of the symbol table reached before the end of the index\n"),
17082 /* PR 17531: file: 0b6630b2. */
17083 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17084 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17087 if (arch
.uses_64bit_indicies
)
17092 if (l
< arch
.sym_size
)
17093 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17094 file_name
, arch
.sym_size
- l
);
17096 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17098 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17104 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17105 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17106 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17107 && !do_section_groups
&& !do_dyn_syms
)
17109 ret
= 0; /* Archive index only. */
17120 char * qualified_name
;
17122 /* Read the next archive header. */
17123 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17125 error (_("%s: failed to seek to next archive header\n"), file_name
);
17128 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17129 if (got
!= sizeof arch
.arhdr
)
17133 error (_("%s: failed to read archive header\n"), file_name
);
17137 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17139 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17144 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17146 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17147 if (archive_file_size
& 01)
17148 ++archive_file_size
;
17150 name
= get_archive_member_name (&arch
, &nested_arch
);
17153 error (_("%s: bad archive file name\n"), file_name
);
17157 namelen
= strlen (name
);
17159 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17160 if (qualified_name
== NULL
)
17162 error (_("%s: bad archive file name\n"), file_name
);
17167 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17169 /* This is a proxy for an external member of a thin archive. */
17170 FILE * member_file
;
17171 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17172 if (member_file_name
== NULL
)
17178 member_file
= fopen (member_file_name
, "rb");
17179 if (member_file
== NULL
)
17181 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17182 free (member_file_name
);
17187 archive_file_offset
= arch
.nested_member_origin
;
17189 ret
|= process_object (qualified_name
, member_file
);
17191 fclose (member_file
);
17192 free (member_file_name
);
17194 else if (is_thin_archive
)
17196 /* PR 15140: Allow for corrupt thin archives. */
17197 if (nested_arch
.file
== NULL
)
17199 error (_("%s: contains corrupt thin archive: %s\n"),
17205 /* This is a proxy for a member of a nested archive. */
17206 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17208 /* The nested archive file will have been opened and setup by
17209 get_archive_member_name. */
17210 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17212 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17217 ret
|= process_object (qualified_name
, nested_arch
.file
);
17221 archive_file_offset
= arch
.next_arhdr_offset
;
17222 arch
.next_arhdr_offset
+= archive_file_size
;
17224 ret
|= process_object (qualified_name
, file
);
17227 if (dump_sects
!= NULL
)
17231 num_dump_sects
= 0;
17234 free (qualified_name
);
17238 if (nested_arch
.file
!= NULL
)
17239 fclose (nested_arch
.file
);
17240 release_archive (&nested_arch
);
17241 release_archive (&arch
);
17247 process_file (char * file_name
)
17250 struct stat statbuf
;
17251 char armag
[SARMAG
];
17254 if (stat (file_name
, &statbuf
) < 0)
17256 if (errno
== ENOENT
)
17257 error (_("'%s': No such file\n"), file_name
);
17259 error (_("Could not locate '%s'. System error message: %s\n"),
17260 file_name
, strerror (errno
));
17264 if (! S_ISREG (statbuf
.st_mode
))
17266 error (_("'%s' is not an ordinary file\n"), file_name
);
17270 file
= fopen (file_name
, "rb");
17273 error (_("Input file '%s' is not readable.\n"), file_name
);
17277 if (fread (armag
, SARMAG
, 1, file
) != 1)
17279 error (_("%s: Failed to read file's magic number\n"), file_name
);
17284 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17286 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17287 ret
= process_archive (file_name
, file
, FALSE
);
17288 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17289 ret
= process_archive (file_name
, file
, TRUE
);
17292 if (do_archive_index
)
17293 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17297 archive_file_size
= archive_file_offset
= 0;
17298 ret
= process_object (file_name
, file
);
17303 current_file_size
= 0;
17307 #ifdef SUPPORT_DISASSEMBLY
17308 /* Needed by the i386 disassembler. For extra credit, someone could
17309 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17313 print_address (unsigned int addr
, FILE * outfile
)
17315 fprintf (outfile
,"0x%8.8x", addr
);
17318 /* Needed by the i386 disassembler. */
17320 db_task_printsym (unsigned int addr
)
17322 print_address (addr
, stderr
);
17327 main (int argc
, char ** argv
)
17331 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17332 setlocale (LC_MESSAGES
, "");
17334 #if defined (HAVE_SETLOCALE)
17335 setlocale (LC_CTYPE
, "");
17337 bindtextdomain (PACKAGE
, LOCALEDIR
);
17338 textdomain (PACKAGE
);
17340 expandargv (&argc
, &argv
);
17342 parse_args (argc
, argv
);
17344 if (num_dump_sects
> 0)
17346 /* Make a copy of the dump_sects array. */
17347 cmdline_dump_sects
= (dump_type
*)
17348 malloc (num_dump_sects
* sizeof (* dump_sects
));
17349 if (cmdline_dump_sects
== NULL
)
17350 error (_("Out of memory allocating dump request table.\n"));
17353 memcpy (cmdline_dump_sects
, dump_sects
,
17354 num_dump_sects
* sizeof (* dump_sects
));
17355 num_cmdline_dump_sects
= num_dump_sects
;
17359 if (optind
< (argc
- 1))
17361 else if (optind
>= argc
)
17363 warn (_("Nothing to do.\n"));
17368 while (optind
< argc
)
17369 err
|= process_file (argv
[optind
++]);
17371 if (dump_sects
!= NULL
)
17373 if (cmdline_dump_sects
!= NULL
)
17374 free (cmdline_dump_sects
);