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)
679 if (streq (SECTION_NAME (section_headers
+ i
), name
))
680 return section_headers
+ i
;
683 return find_section (name
);
686 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
689 static inline unsigned long
690 read_uleb128 (unsigned char *data
,
691 unsigned int *length_return
,
692 const unsigned char * const end
)
694 return read_leb128 (data
, length_return
, FALSE
, end
);
697 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
698 This OS has so many departures from the ELF standard that we test it at
704 return elf_header
.e_machine
== EM_IA_64
705 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
708 /* Guess the relocation size commonly used by the specific machines. */
711 guess_is_rela (unsigned int e_machine
)
715 /* Targets that use REL relocations. */
730 /* Targets that use RELA relocations. */
734 case EM_ADAPTEVA_EPIPHANY
:
736 case EM_ALTERA_NIOS2
:
739 case EM_ARC_COMPACT2
:
759 case EM_LATTICEMICO32
:
768 case EM_CYGNUS_MN10200
:
770 case EM_CYGNUS_MN10300
:
806 case EM_MICROBLAZE_OLD
:
827 warn (_("Don't know about relocations on this machine architecture\n"));
833 slurp_rela_relocs (FILE * file
,
834 unsigned long rel_offset
,
835 unsigned long rel_size
,
836 Elf_Internal_Rela
** relasp
,
837 unsigned long * nrelasp
)
839 Elf_Internal_Rela
* relas
;
845 Elf32_External_Rela
* erelas
;
847 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
848 rel_size
, _("32-bit relocation data"));
852 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
854 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
855 sizeof (Elf_Internal_Rela
));
860 error (_("out of memory parsing relocs\n"));
864 for (i
= 0; i
< nrelas
; i
++)
866 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
867 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
868 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
875 Elf64_External_Rela
* erelas
;
877 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
878 rel_size
, _("64-bit relocation data"));
882 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
884 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
885 sizeof (Elf_Internal_Rela
));
890 error (_("out of memory parsing relocs\n"));
894 for (i
= 0; i
< nrelas
; i
++)
896 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
897 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
898 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
900 /* The #ifdef BFD64 below is to prevent a compile time
901 warning. We know that if we do not have a 64 bit data
902 type that we will never execute this code anyway. */
904 if (elf_header
.e_machine
== EM_MIPS
905 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
907 /* In little-endian objects, r_info isn't really a
908 64-bit little-endian value: it has a 32-bit
909 little-endian symbol index followed by four
910 individual byte fields. Reorder INFO
912 bfd_vma inf
= relas
[i
].r_info
;
913 inf
= (((inf
& 0xffffffff) << 32)
914 | ((inf
>> 56) & 0xff)
915 | ((inf
>> 40) & 0xff00)
916 | ((inf
>> 24) & 0xff0000)
917 | ((inf
>> 8) & 0xff000000));
918 relas
[i
].r_info
= inf
;
931 slurp_rel_relocs (FILE * file
,
932 unsigned long rel_offset
,
933 unsigned long rel_size
,
934 Elf_Internal_Rela
** relsp
,
935 unsigned long * nrelsp
)
937 Elf_Internal_Rela
* rels
;
943 Elf32_External_Rel
* erels
;
945 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
946 rel_size
, _("32-bit relocation data"));
950 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
952 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
957 error (_("out of memory parsing relocs\n"));
961 for (i
= 0; i
< nrels
; i
++)
963 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
964 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
965 rels
[i
].r_addend
= 0;
972 Elf64_External_Rel
* erels
;
974 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
975 rel_size
, _("64-bit relocation data"));
979 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
981 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
986 error (_("out of memory parsing relocs\n"));
990 for (i
= 0; i
< nrels
; i
++)
992 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
993 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
994 rels
[i
].r_addend
= 0;
996 /* The #ifdef BFD64 below is to prevent a compile time
997 warning. We know that if we do not have a 64 bit data
998 type that we will never execute this code anyway. */
1000 if (elf_header
.e_machine
== EM_MIPS
1001 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1003 /* In little-endian objects, r_info isn't really a
1004 64-bit little-endian value: it has a 32-bit
1005 little-endian symbol index followed by four
1006 individual byte fields. Reorder INFO
1008 bfd_vma inf
= rels
[i
].r_info
;
1009 inf
= (((inf
& 0xffffffff) << 32)
1010 | ((inf
>> 56) & 0xff)
1011 | ((inf
>> 40) & 0xff00)
1012 | ((inf
>> 24) & 0xff0000)
1013 | ((inf
>> 8) & 0xff000000));
1014 rels
[i
].r_info
= inf
;
1026 /* Returns the reloc type extracted from the reloc info field. */
1029 get_reloc_type (bfd_vma reloc_info
)
1032 return ELF32_R_TYPE (reloc_info
);
1034 switch (elf_header
.e_machine
)
1037 /* Note: We assume that reloc_info has already been adjusted for us. */
1038 return ELF64_MIPS_R_TYPE (reloc_info
);
1041 return ELF64_R_TYPE_ID (reloc_info
);
1044 return ELF64_R_TYPE (reloc_info
);
1048 /* Return the symbol index extracted from the reloc info field. */
1051 get_reloc_symindex (bfd_vma reloc_info
)
1053 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1056 static inline bfd_boolean
1057 uses_msp430x_relocs (void)
1060 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1061 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1062 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1063 /* TI compiler uses ELFOSABI_NONE. */
1064 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1067 /* Display the contents of the relocation data found at the specified
1071 dump_relocations (FILE * file
,
1072 unsigned long rel_offset
,
1073 unsigned long rel_size
,
1074 Elf_Internal_Sym
* symtab
,
1075 unsigned long nsyms
,
1077 unsigned long strtablen
,
1082 Elf_Internal_Rela
* rels
;
1084 if (is_rela
== UNKNOWN
)
1085 is_rela
= guess_is_rela (elf_header
.e_machine
);
1089 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1094 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1103 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1105 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1110 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1112 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1120 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1122 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1127 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1129 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1133 for (i
= 0; i
< rel_size
; i
++)
1138 bfd_vma symtab_index
;
1141 offset
= rels
[i
].r_offset
;
1142 inf
= rels
[i
].r_info
;
1144 type
= get_reloc_type (inf
);
1145 symtab_index
= get_reloc_symindex (inf
);
1149 printf ("%8.8lx %8.8lx ",
1150 (unsigned long) offset
& 0xffffffff,
1151 (unsigned long) inf
& 0xffffffff);
1155 #if BFD_HOST_64BIT_LONG
1157 ? "%16.16lx %16.16lx "
1158 : "%12.12lx %12.12lx ",
1160 #elif BFD_HOST_64BIT_LONG_LONG
1163 ? "%16.16llx %16.16llx "
1164 : "%12.12llx %12.12llx ",
1168 ? "%16.16I64x %16.16I64x "
1169 : "%12.12I64x %12.12I64x ",
1174 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1175 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1176 _bfd_int64_high (offset
),
1177 _bfd_int64_low (offset
),
1178 _bfd_int64_high (inf
),
1179 _bfd_int64_low (inf
));
1183 switch (elf_header
.e_machine
)
1190 rtype
= elf_aarch64_reloc_type (type
);
1194 case EM_CYGNUS_M32R
:
1195 rtype
= elf_m32r_reloc_type (type
);
1200 rtype
= elf_i386_reloc_type (type
);
1205 rtype
= elf_m68hc11_reloc_type (type
);
1209 rtype
= elf_m68k_reloc_type (type
);
1213 rtype
= elf_i960_reloc_type (type
);
1218 rtype
= elf_avr_reloc_type (type
);
1221 case EM_OLD_SPARCV9
:
1222 case EM_SPARC32PLUS
:
1225 rtype
= elf_sparc_reloc_type (type
);
1229 rtype
= elf_spu_reloc_type (type
);
1233 rtype
= v800_reloc_type (type
);
1236 case EM_CYGNUS_V850
:
1237 rtype
= v850_reloc_type (type
);
1241 case EM_CYGNUS_D10V
:
1242 rtype
= elf_d10v_reloc_type (type
);
1246 case EM_CYGNUS_D30V
:
1247 rtype
= elf_d30v_reloc_type (type
);
1251 rtype
= elf_dlx_reloc_type (type
);
1255 rtype
= elf_sh_reloc_type (type
);
1259 case EM_CYGNUS_MN10300
:
1260 rtype
= elf_mn10300_reloc_type (type
);
1264 case EM_CYGNUS_MN10200
:
1265 rtype
= elf_mn10200_reloc_type (type
);
1269 case EM_CYGNUS_FR30
:
1270 rtype
= elf_fr30_reloc_type (type
);
1274 rtype
= elf_frv_reloc_type (type
);
1278 rtype
= elf_ft32_reloc_type (type
);
1282 rtype
= elf_mcore_reloc_type (type
);
1286 rtype
= elf_mmix_reloc_type (type
);
1290 rtype
= elf_moxie_reloc_type (type
);
1294 if (uses_msp430x_relocs ())
1296 rtype
= elf_msp430x_reloc_type (type
);
1301 rtype
= elf_msp430_reloc_type (type
);
1305 rtype
= elf_nds32_reloc_type (type
);
1309 rtype
= elf_ppc_reloc_type (type
);
1313 rtype
= elf_ppc64_reloc_type (type
);
1317 case EM_MIPS_RS3_LE
:
1318 rtype
= elf_mips_reloc_type (type
);
1322 rtype
= elf_riscv_reloc_type (type
);
1326 rtype
= elf_alpha_reloc_type (type
);
1330 rtype
= elf_arm_reloc_type (type
);
1334 case EM_ARC_COMPACT
:
1335 case EM_ARC_COMPACT2
:
1336 rtype
= elf_arc_reloc_type (type
);
1340 rtype
= elf_hppa_reloc_type (type
);
1346 rtype
= elf_h8_reloc_type (type
);
1350 rtype
= elf_or1k_reloc_type (type
);
1355 rtype
= elf_pj_reloc_type (type
);
1358 rtype
= elf_ia64_reloc_type (type
);
1362 rtype
= elf_cris_reloc_type (type
);
1366 rtype
= elf_i860_reloc_type (type
);
1372 rtype
= elf_x86_64_reloc_type (type
);
1376 rtype
= i370_reloc_type (type
);
1381 rtype
= elf_s390_reloc_type (type
);
1385 rtype
= elf_score_reloc_type (type
);
1389 rtype
= elf_xstormy16_reloc_type (type
);
1393 rtype
= elf_crx_reloc_type (type
);
1397 rtype
= elf_vax_reloc_type (type
);
1401 rtype
= elf_visium_reloc_type (type
);
1404 case EM_ADAPTEVA_EPIPHANY
:
1405 rtype
= elf_epiphany_reloc_type (type
);
1410 rtype
= elf_ip2k_reloc_type (type
);
1414 rtype
= elf_iq2000_reloc_type (type
);
1419 rtype
= elf_xtensa_reloc_type (type
);
1422 case EM_LATTICEMICO32
:
1423 rtype
= elf_lm32_reloc_type (type
);
1428 rtype
= elf_m32c_reloc_type (type
);
1432 rtype
= elf_mt_reloc_type (type
);
1436 rtype
= elf_bfin_reloc_type (type
);
1440 rtype
= elf_mep_reloc_type (type
);
1444 rtype
= elf_cr16_reloc_type (type
);
1448 case EM_MICROBLAZE_OLD
:
1449 rtype
= elf_microblaze_reloc_type (type
);
1453 rtype
= elf_rl78_reloc_type (type
);
1457 rtype
= elf_rx_reloc_type (type
);
1461 rtype
= elf_metag_reloc_type (type
);
1466 rtype
= elf_xc16x_reloc_type (type
);
1470 rtype
= elf_tic6x_reloc_type (type
);
1474 rtype
= elf_tilegx_reloc_type (type
);
1478 rtype
= elf_tilepro_reloc_type (type
);
1482 rtype
= elf_xgate_reloc_type (type
);
1485 case EM_ALTERA_NIOS2
:
1486 rtype
= elf_nios2_reloc_type (type
);
1490 rtype
= elf_pru_reloc_type (type
);
1495 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1497 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1499 if (elf_header
.e_machine
== EM_ALPHA
1501 && streq (rtype
, "R_ALPHA_LITUSE")
1504 switch (rels
[i
].r_addend
)
1506 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1507 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1508 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1509 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1510 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1511 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1512 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1513 default: rtype
= NULL
;
1516 printf (" (%s)", rtype
);
1520 printf (_("<unknown addend: %lx>"),
1521 (unsigned long) rels
[i
].r_addend
);
1524 else if (symtab_index
)
1526 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1527 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1530 Elf_Internal_Sym
* psym
;
1531 const char * version_string
;
1532 enum versioned_symbol_info sym_info
;
1533 unsigned short vna_other
;
1535 psym
= symtab
+ symtab_index
;
1538 = get_symbol_version_string (file
, is_dynsym
,
1547 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1551 unsigned int width
= is_32bit_elf
? 8 : 14;
1553 /* Relocations against GNU_IFUNC symbols do not use the value
1554 of the symbol as the address to relocate against. Instead
1555 they invoke the function named by the symbol and use its
1556 result as the address for relocation.
1558 To indicate this to the user, do not display the value of
1559 the symbol in the "Symbols's Value" field. Instead show
1560 its name followed by () as a hint that the symbol is
1564 || psym
->st_name
== 0
1565 || psym
->st_name
>= strtablen
)
1568 name
= strtab
+ psym
->st_name
;
1570 len
= print_symbol (width
, name
);
1572 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1574 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1578 print_vma (psym
->st_value
, LONG_HEX
);
1580 printf (is_32bit_elf
? " " : " ");
1583 if (psym
->st_name
== 0)
1585 const char * sec_name
= "<null>";
1588 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1590 if (psym
->st_shndx
< elf_header
.e_shnum
)
1591 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1592 else if (psym
->st_shndx
== SHN_ABS
)
1594 else if (psym
->st_shndx
== SHN_COMMON
)
1595 sec_name
= "COMMON";
1596 else if ((elf_header
.e_machine
== EM_MIPS
1597 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1598 || (elf_header
.e_machine
== EM_TI_C6000
1599 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1600 sec_name
= "SCOMMON";
1601 else if (elf_header
.e_machine
== EM_MIPS
1602 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1603 sec_name
= "SUNDEF";
1604 else if ((elf_header
.e_machine
== EM_X86_64
1605 || elf_header
.e_machine
== EM_L1OM
1606 || elf_header
.e_machine
== EM_K1OM
)
1607 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1608 sec_name
= "LARGE_COMMON";
1609 else if (elf_header
.e_machine
== EM_IA_64
1610 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1611 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1612 sec_name
= "ANSI_COM";
1613 else if (is_ia64_vms ()
1614 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1615 sec_name
= "VMS_SYMVEC";
1618 sprintf (name_buf
, "<section 0x%x>",
1619 (unsigned int) psym
->st_shndx
);
1620 sec_name
= name_buf
;
1623 print_symbol (22, sec_name
);
1625 else if (strtab
== NULL
)
1626 printf (_("<string table index: %3ld>"), psym
->st_name
);
1627 else if (psym
->st_name
>= strtablen
)
1628 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1631 print_symbol (22, strtab
+ psym
->st_name
);
1633 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1639 bfd_vma off
= rels
[i
].r_addend
;
1641 if ((bfd_signed_vma
) off
< 0)
1642 printf (" - %" BFD_VMA_FMT
"x", - off
);
1644 printf (" + %" BFD_VMA_FMT
"x", off
);
1650 bfd_vma off
= rels
[i
].r_addend
;
1652 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1653 if ((bfd_signed_vma
) off
< 0)
1654 printf ("-%" BFD_VMA_FMT
"x", - off
);
1656 printf ("%" BFD_VMA_FMT
"x", off
);
1659 if (elf_header
.e_machine
== EM_SPARCV9
1661 && streq (rtype
, "R_SPARC_OLO10"))
1662 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1667 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1669 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1670 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1671 const char * rtype2
= elf_mips_reloc_type (type2
);
1672 const char * rtype3
= elf_mips_reloc_type (type3
);
1674 printf (" Type2: ");
1677 printf (_("unrecognized: %-7lx"),
1678 (unsigned long) type2
& 0xffffffff);
1680 printf ("%-17.17s", rtype2
);
1682 printf ("\n Type3: ");
1685 printf (_("unrecognized: %-7lx"),
1686 (unsigned long) type3
& 0xffffffff);
1688 printf ("%-17.17s", rtype3
);
1699 get_mips_dynamic_type (unsigned long type
)
1703 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1704 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1705 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1706 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1707 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1708 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1709 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1710 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1711 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1712 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1713 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1714 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1715 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1716 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1717 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1718 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1719 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1720 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1721 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1722 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1723 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1724 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1725 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1726 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1727 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1728 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1729 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1730 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1731 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1732 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1733 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1734 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1735 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1736 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1737 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1738 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1739 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1740 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1741 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1742 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1743 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1744 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1745 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1746 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1747 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1748 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1755 get_sparc64_dynamic_type (unsigned long type
)
1759 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1766 get_ppc_dynamic_type (unsigned long type
)
1770 case DT_PPC_GOT
: return "PPC_GOT";
1771 case DT_PPC_OPT
: return "PPC_OPT";
1778 get_ppc64_dynamic_type (unsigned long type
)
1782 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1783 case DT_PPC64_OPD
: return "PPC64_OPD";
1784 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1785 case DT_PPC64_OPT
: return "PPC64_OPT";
1792 get_parisc_dynamic_type (unsigned long type
)
1796 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1797 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1798 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1799 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1800 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1801 case DT_HP_PREINIT
: return "HP_PREINIT";
1802 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1803 case DT_HP_NEEDED
: return "HP_NEEDED";
1804 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1805 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1806 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1807 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1808 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1809 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1810 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1811 case DT_HP_FILTERED
: return "HP_FILTERED";
1812 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1813 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1814 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1815 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1816 case DT_PLT
: return "PLT";
1817 case DT_PLT_SIZE
: return "PLT_SIZE";
1818 case DT_DLT
: return "DLT";
1819 case DT_DLT_SIZE
: return "DLT_SIZE";
1826 get_ia64_dynamic_type (unsigned long type
)
1830 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1831 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1832 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1833 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1834 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1835 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1836 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1837 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1838 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1839 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1840 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1841 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1842 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1843 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1844 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1845 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1846 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1847 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1848 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1849 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1850 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1851 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1852 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1853 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1854 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1855 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1856 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1857 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1858 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1859 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1860 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1867 get_solaris_section_type (unsigned long type
)
1871 case 0x6fffffee: return "SUNW_ancillary";
1872 case 0x6fffffef: return "SUNW_capchain";
1873 case 0x6ffffff0: return "SUNW_capinfo";
1874 case 0x6ffffff1: return "SUNW_symsort";
1875 case 0x6ffffff2: return "SUNW_tlssort";
1876 case 0x6ffffff3: return "SUNW_LDYNSYM";
1877 case 0x6ffffff4: return "SUNW_dof";
1878 case 0x6ffffff5: return "SUNW_cap";
1879 case 0x6ffffff6: return "SUNW_SIGNATURE";
1880 case 0x6ffffff7: return "SUNW_ANNOTATE";
1881 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1882 case 0x6ffffff9: return "SUNW_DEBUG";
1883 case 0x6ffffffa: return "SUNW_move";
1884 case 0x6ffffffb: return "SUNW_COMDAT";
1885 case 0x6ffffffc: return "SUNW_syminfo";
1886 case 0x6ffffffd: return "SUNW_verdef";
1887 case 0x6ffffffe: return "SUNW_verneed";
1888 case 0x6fffffff: return "SUNW_versym";
1889 case 0x70000000: return "SPARC_GOTDATA";
1890 default: return NULL
;
1895 get_alpha_dynamic_type (unsigned long type
)
1899 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1906 get_score_dynamic_type (unsigned long type
)
1910 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1911 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1912 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1913 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1914 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1915 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1922 get_tic6x_dynamic_type (unsigned long type
)
1926 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1927 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1928 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1929 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1930 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1931 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1938 get_nios2_dynamic_type (unsigned long type
)
1942 case DT_NIOS2_GP
: return "NIOS2_GP";
1949 get_solaris_dynamic_type (unsigned long type
)
1953 case 0x6000000d: return "SUNW_AUXILIARY";
1954 case 0x6000000e: return "SUNW_RTLDINF";
1955 case 0x6000000f: return "SUNW_FILTER";
1956 case 0x60000010: return "SUNW_CAP";
1957 case 0x60000011: return "SUNW_SYMTAB";
1958 case 0x60000012: return "SUNW_SYMSZ";
1959 case 0x60000013: return "SUNW_SORTENT";
1960 case 0x60000014: return "SUNW_SYMSORT";
1961 case 0x60000015: return "SUNW_SYMSORTSZ";
1962 case 0x60000016: return "SUNW_TLSSORT";
1963 case 0x60000017: return "SUNW_TLSSORTSZ";
1964 case 0x60000018: return "SUNW_CAPINFO";
1965 case 0x60000019: return "SUNW_STRPAD";
1966 case 0x6000001a: return "SUNW_CAPCHAIN";
1967 case 0x6000001b: return "SUNW_LDMACH";
1968 case 0x6000001d: return "SUNW_CAPCHAINENT";
1969 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1970 case 0x60000021: return "SUNW_PARENT";
1971 case 0x60000023: return "SUNW_ASLR";
1972 case 0x60000025: return "SUNW_RELAX";
1973 case 0x60000029: return "SUNW_NXHEAP";
1974 case 0x6000002b: return "SUNW_NXSTACK";
1976 case 0x70000001: return "SPARC_REGISTER";
1977 case 0x7ffffffd: return "AUXILIARY";
1978 case 0x7ffffffe: return "USED";
1979 case 0x7fffffff: return "FILTER";
1981 default: return NULL
;
1986 get_dynamic_type (unsigned long type
)
1988 static char buff
[64];
1992 case DT_NULL
: return "NULL";
1993 case DT_NEEDED
: return "NEEDED";
1994 case DT_PLTRELSZ
: return "PLTRELSZ";
1995 case DT_PLTGOT
: return "PLTGOT";
1996 case DT_HASH
: return "HASH";
1997 case DT_STRTAB
: return "STRTAB";
1998 case DT_SYMTAB
: return "SYMTAB";
1999 case DT_RELA
: return "RELA";
2000 case DT_RELASZ
: return "RELASZ";
2001 case DT_RELAENT
: return "RELAENT";
2002 case DT_STRSZ
: return "STRSZ";
2003 case DT_SYMENT
: return "SYMENT";
2004 case DT_INIT
: return "INIT";
2005 case DT_FINI
: return "FINI";
2006 case DT_SONAME
: return "SONAME";
2007 case DT_RPATH
: return "RPATH";
2008 case DT_SYMBOLIC
: return "SYMBOLIC";
2009 case DT_REL
: return "REL";
2010 case DT_RELSZ
: return "RELSZ";
2011 case DT_RELENT
: return "RELENT";
2012 case DT_PLTREL
: return "PLTREL";
2013 case DT_DEBUG
: return "DEBUG";
2014 case DT_TEXTREL
: return "TEXTREL";
2015 case DT_JMPREL
: return "JMPREL";
2016 case DT_BIND_NOW
: return "BIND_NOW";
2017 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2018 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2019 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2020 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2021 case DT_RUNPATH
: return "RUNPATH";
2022 case DT_FLAGS
: return "FLAGS";
2024 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2025 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2026 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2028 case DT_CHECKSUM
: return "CHECKSUM";
2029 case DT_PLTPADSZ
: return "PLTPADSZ";
2030 case DT_MOVEENT
: return "MOVEENT";
2031 case DT_MOVESZ
: return "MOVESZ";
2032 case DT_FEATURE
: return "FEATURE";
2033 case DT_POSFLAG_1
: return "POSFLAG_1";
2034 case DT_SYMINSZ
: return "SYMINSZ";
2035 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2037 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2038 case DT_CONFIG
: return "CONFIG";
2039 case DT_DEPAUDIT
: return "DEPAUDIT";
2040 case DT_AUDIT
: return "AUDIT";
2041 case DT_PLTPAD
: return "PLTPAD";
2042 case DT_MOVETAB
: return "MOVETAB";
2043 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2045 case DT_VERSYM
: return "VERSYM";
2047 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2048 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2049 case DT_RELACOUNT
: return "RELACOUNT";
2050 case DT_RELCOUNT
: return "RELCOUNT";
2051 case DT_FLAGS_1
: return "FLAGS_1";
2052 case DT_VERDEF
: return "VERDEF";
2053 case DT_VERDEFNUM
: return "VERDEFNUM";
2054 case DT_VERNEED
: return "VERNEED";
2055 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2057 case DT_AUXILIARY
: return "AUXILIARY";
2058 case DT_USED
: return "USED";
2059 case DT_FILTER
: return "FILTER";
2061 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2062 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2063 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2064 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2065 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2066 case DT_GNU_HASH
: return "GNU_HASH";
2069 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2071 const char * result
;
2073 switch (elf_header
.e_machine
)
2076 case EM_MIPS_RS3_LE
:
2077 result
= get_mips_dynamic_type (type
);
2080 result
= get_sparc64_dynamic_type (type
);
2083 result
= get_ppc_dynamic_type (type
);
2086 result
= get_ppc64_dynamic_type (type
);
2089 result
= get_ia64_dynamic_type (type
);
2092 result
= get_alpha_dynamic_type (type
);
2095 result
= get_score_dynamic_type (type
);
2098 result
= get_tic6x_dynamic_type (type
);
2100 case EM_ALTERA_NIOS2
:
2101 result
= get_nios2_dynamic_type (type
);
2104 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2105 result
= get_solaris_dynamic_type (type
);
2114 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2116 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2117 || (elf_header
.e_machine
== EM_PARISC
2118 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2120 const char * result
;
2122 switch (elf_header
.e_machine
)
2125 result
= get_parisc_dynamic_type (type
);
2128 result
= get_ia64_dynamic_type (type
);
2131 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2132 result
= get_solaris_dynamic_type (type
);
2141 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2145 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2152 get_file_type (unsigned e_type
)
2154 static char buff
[32];
2158 case ET_NONE
: return _("NONE (None)");
2159 case ET_REL
: return _("REL (Relocatable file)");
2160 case ET_EXEC
: return _("EXEC (Executable file)");
2161 case ET_DYN
: return _("DYN (Shared object file)");
2162 case ET_CORE
: return _("CORE (Core file)");
2165 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2166 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2167 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2168 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2170 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2176 get_machine_name (unsigned e_machine
)
2178 static char buff
[64]; /* XXX */
2182 case EM_NONE
: return _("None");
2183 case EM_AARCH64
: return "AArch64";
2184 case EM_M32
: return "WE32100";
2185 case EM_SPARC
: return "Sparc";
2186 case EM_SPU
: return "SPU";
2187 case EM_386
: return "Intel 80386";
2188 case EM_68K
: return "MC68000";
2189 case EM_88K
: return "MC88000";
2190 case EM_IAMCU
: return "Intel MCU";
2191 case EM_860
: return "Intel 80860";
2192 case EM_MIPS
: return "MIPS R3000";
2193 case EM_S370
: return "IBM System/370";
2194 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2195 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2196 case EM_PARISC
: return "HPPA";
2197 case EM_PPC_OLD
: return "Power PC (old)";
2198 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2199 case EM_960
: return "Intel 90860";
2200 case EM_PPC
: return "PowerPC";
2201 case EM_PPC64
: return "PowerPC64";
2202 case EM_FR20
: return "Fujitsu FR20";
2203 case EM_FT32
: return "FTDI FT32";
2204 case EM_RH32
: return "TRW RH32";
2205 case EM_MCORE
: return "MCORE";
2206 case EM_ARM
: return "ARM";
2207 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2208 case EM_SH
: return "Renesas / SuperH SH";
2209 case EM_SPARCV9
: return "Sparc v9";
2210 case EM_TRICORE
: return "Siemens Tricore";
2211 case EM_ARC
: return "ARC";
2212 case EM_ARC_COMPACT
: return "ARCompact";
2213 case EM_ARC_COMPACT2
: return "ARCv2";
2214 case EM_H8_300
: return "Renesas H8/300";
2215 case EM_H8_300H
: return "Renesas H8/300H";
2216 case EM_H8S
: return "Renesas H8S";
2217 case EM_H8_500
: return "Renesas H8/500";
2218 case EM_IA_64
: return "Intel IA-64";
2219 case EM_MIPS_X
: return "Stanford MIPS-X";
2220 case EM_COLDFIRE
: return "Motorola Coldfire";
2221 case EM_ALPHA
: return "Alpha";
2222 case EM_CYGNUS_D10V
:
2223 case EM_D10V
: return "d10v";
2224 case EM_CYGNUS_D30V
:
2225 case EM_D30V
: return "d30v";
2226 case EM_CYGNUS_M32R
:
2227 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2228 case EM_CYGNUS_V850
:
2229 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2230 case EM_V850
: return "Renesas V850";
2231 case EM_CYGNUS_MN10300
:
2232 case EM_MN10300
: return "mn10300";
2233 case EM_CYGNUS_MN10200
:
2234 case EM_MN10200
: return "mn10200";
2235 case EM_MOXIE
: return "Moxie";
2236 case EM_CYGNUS_FR30
:
2237 case EM_FR30
: return "Fujitsu FR30";
2238 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2240 case EM_PJ
: return "picoJava";
2241 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2242 case EM_PCP
: return "Siemens PCP";
2243 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2244 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2245 case EM_STARCORE
: return "Motorola Star*Core processor";
2246 case EM_ME16
: return "Toyota ME16 processor";
2247 case EM_ST100
: return "STMicroelectronics ST100 processor";
2248 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2249 case EM_PDSP
: return "Sony DSP processor";
2250 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2251 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2252 case EM_FX66
: return "Siemens FX66 microcontroller";
2253 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2254 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2255 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2256 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2257 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2258 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2259 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2260 case EM_SVX
: return "Silicon Graphics SVx";
2261 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2262 case EM_VAX
: return "Digital VAX";
2263 case EM_VISIUM
: return "CDS VISIUMcore processor";
2265 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2266 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2267 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2268 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2269 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2270 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2271 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2272 case EM_PRISM
: return "Vitesse Prism";
2273 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2274 case EM_L1OM
: return "Intel L1OM";
2275 case EM_K1OM
: return "Intel K1OM";
2277 case EM_S390
: return "IBM S/390";
2278 case EM_SCORE
: return "SUNPLUS S+Core";
2279 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2280 case EM_OR1K
: return "OpenRISC 1000";
2281 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2282 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2283 case EM_DLX
: return "OpenDLX";
2285 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2286 case EM_IQ2000
: return "Vitesse IQ2000";
2288 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2289 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2290 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2291 case EM_NS32K
: return "National Semiconductor 32000 series";
2292 case EM_TPC
: return "Tenor Network TPC processor";
2293 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2294 case EM_MAX
: return "MAX Processor";
2295 case EM_CR
: return "National Semiconductor CompactRISC";
2296 case EM_F2MC16
: return "Fujitsu F2MC16";
2297 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2298 case EM_LATTICEMICO32
: return "Lattice Mico32";
2300 case EM_M32C
: return "Renesas M32c";
2301 case EM_MT
: return "Morpho Techologies MT processor";
2302 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2303 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2304 case EM_SEP
: return "Sharp embedded microprocessor";
2305 case EM_ARCA
: return "Arca RISC microprocessor";
2306 case EM_UNICORE
: return "Unicore";
2307 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2308 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2309 case EM_NIOS32
: return "Altera Nios";
2310 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2312 case EM_XC16X
: return "Infineon Technologies xc16x";
2313 case EM_M16C
: return "Renesas M16C series microprocessors";
2314 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2315 case EM_CE
: return "Freescale Communication Engine RISC core";
2316 case EM_TSK3000
: return "Altium TSK3000 core";
2317 case EM_RS08
: return "Freescale RS08 embedded processor";
2318 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2319 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2320 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2321 case EM_SE_C17
: return "Seiko Epson C17 family";
2322 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2323 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2324 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2325 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2326 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2327 case EM_R32C
: return "Renesas R32C series microprocessors";
2328 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2329 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2330 case EM_8051
: return "Intel 8051 and variants";
2331 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2332 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2333 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2334 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2335 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2336 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2337 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2338 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2341 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2342 case EM_RISCV
: return "RISC-V";
2343 case EM_RL78
: return "Renesas RL78";
2344 case EM_RX
: return "Renesas RX";
2345 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2346 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2347 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2348 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2349 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2350 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2351 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2352 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2353 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2354 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2355 case EM_CUDA
: return "NVIDIA CUDA architecture";
2356 case EM_XGATE
: return "Motorola XGATE embedded processor";
2357 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2358 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2359 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2360 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2361 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2362 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2363 case EM_BA1
: return "Beyond BA1 CPU architecture";
2364 case EM_BA2
: return "Beyond BA2 CPU architecture";
2365 case EM_XCORE
: return "XMOS xCORE processor family";
2366 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2367 case EM_KM32
: return "KM211 KM32 32-bit processor";
2368 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2369 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2370 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2371 case EM_KVARC
: return "KM211 KVARC processor";
2372 case EM_CDP
: return "Paneve CDP architecture family";
2373 case EM_COGE
: return "Cognitive Smart Memory Processor";
2374 case EM_COOL
: return "Bluechip Systems CoolEngine";
2375 case EM_NORC
: return "Nanoradio Optimized RISC";
2376 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2377 case EM_Z80
: return "Zilog Z80";
2378 case EM_AMDGPU
: return "AMD GPU architecture";
2379 case EM_TI_PRU
: return "TI PRU I/O processor";
2381 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2387 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2389 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2390 other compilers don't a specific architecture type in the e_flags, and
2391 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2392 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2395 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2396 but also sets a specific architecture type in the e_flags field.
2398 However, when decoding the flags we don't worry if we see an
2399 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2400 ARCEM architecture type. */
2402 switch (e_flags
& EF_ARC_MACH_MSK
)
2404 /* We only expect these to occur for EM_ARC_COMPACT2. */
2405 case EF_ARC_CPU_ARCV2EM
:
2406 strcat (buf
, ", ARC EM");
2408 case EF_ARC_CPU_ARCV2HS
:
2409 strcat (buf
, ", ARC HS");
2412 /* We only expect these to occur for EM_ARC_COMPACT. */
2413 case E_ARC_MACH_ARC600
:
2414 strcat (buf
, ", ARC600");
2416 case E_ARC_MACH_ARC601
:
2417 strcat (buf
, ", ARC601");
2419 case E_ARC_MACH_ARC700
:
2420 strcat (buf
, ", ARC700");
2423 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2424 new ELF with new architecture being read by an old version of
2425 readelf, or (c) An ELF built with non-GNU compiler that does not
2426 set the architecture in the e_flags. */
2428 if (e_machine
== EM_ARC_COMPACT
)
2429 strcat (buf
, ", Unknown ARCompact");
2431 strcat (buf
, ", Unknown ARC");
2435 switch (e_flags
& EF_ARC_OSABI_MSK
)
2437 case E_ARC_OSABI_ORIG
:
2438 strcat (buf
, ", (ABI:legacy)");
2440 case E_ARC_OSABI_V2
:
2441 strcat (buf
, ", (ABI:v2)");
2443 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2444 case E_ARC_OSABI_V3
:
2445 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2448 strcat (buf
, ", unrecognised ARC OSABI flag");
2454 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2459 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2460 e_flags
&= ~ EF_ARM_EABIMASK
;
2462 /* Handle "generic" ARM flags. */
2463 if (e_flags
& EF_ARM_RELEXEC
)
2465 strcat (buf
, ", relocatable executable");
2466 e_flags
&= ~ EF_ARM_RELEXEC
;
2469 /* Now handle EABI specific flags. */
2473 strcat (buf
, ", <unrecognized EABI>");
2478 case EF_ARM_EABI_VER1
:
2479 strcat (buf
, ", Version1 EABI");
2484 /* Process flags one bit at a time. */
2485 flag
= e_flags
& - e_flags
;
2490 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2491 strcat (buf
, ", sorted symbol tables");
2501 case EF_ARM_EABI_VER2
:
2502 strcat (buf
, ", Version2 EABI");
2507 /* Process flags one bit at a time. */
2508 flag
= e_flags
& - e_flags
;
2513 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2514 strcat (buf
, ", sorted symbol tables");
2517 case EF_ARM_DYNSYMSUSESEGIDX
:
2518 strcat (buf
, ", dynamic symbols use segment index");
2521 case EF_ARM_MAPSYMSFIRST
:
2522 strcat (buf
, ", mapping symbols precede others");
2532 case EF_ARM_EABI_VER3
:
2533 strcat (buf
, ", Version3 EABI");
2536 case EF_ARM_EABI_VER4
:
2537 strcat (buf
, ", Version4 EABI");
2542 /* Process flags one bit at a time. */
2543 flag
= e_flags
& - e_flags
;
2549 strcat (buf
, ", BE8");
2553 strcat (buf
, ", LE8");
2564 case EF_ARM_EABI_VER5
:
2565 strcat (buf
, ", Version5 EABI");
2570 /* Process flags one bit at a time. */
2571 flag
= e_flags
& - e_flags
;
2577 strcat (buf
, ", BE8");
2581 strcat (buf
, ", LE8");
2584 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2585 strcat (buf
, ", soft-float ABI");
2588 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2589 strcat (buf
, ", hard-float ABI");
2599 case EF_ARM_EABI_UNKNOWN
:
2600 strcat (buf
, ", GNU EABI");
2605 /* Process flags one bit at a time. */
2606 flag
= e_flags
& - e_flags
;
2611 case EF_ARM_INTERWORK
:
2612 strcat (buf
, ", interworking enabled");
2615 case EF_ARM_APCS_26
:
2616 strcat (buf
, ", uses APCS/26");
2619 case EF_ARM_APCS_FLOAT
:
2620 strcat (buf
, ", uses APCS/float");
2624 strcat (buf
, ", position independent");
2628 strcat (buf
, ", 8 bit structure alignment");
2631 case EF_ARM_NEW_ABI
:
2632 strcat (buf
, ", uses new ABI");
2635 case EF_ARM_OLD_ABI
:
2636 strcat (buf
, ", uses old ABI");
2639 case EF_ARM_SOFT_FLOAT
:
2640 strcat (buf
, ", software FP");
2643 case EF_ARM_VFP_FLOAT
:
2644 strcat (buf
, ", VFP");
2647 case EF_ARM_MAVERICK_FLOAT
:
2648 strcat (buf
, ", Maverick FP");
2659 strcat (buf
,_(", <unknown>"));
2663 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2665 --size
; /* Leave space for null terminator. */
2667 switch (e_flags
& EF_AVR_MACH
)
2669 case E_AVR_MACH_AVR1
:
2670 strncat (buf
, ", avr:1", size
);
2672 case E_AVR_MACH_AVR2
:
2673 strncat (buf
, ", avr:2", size
);
2675 case E_AVR_MACH_AVR25
:
2676 strncat (buf
, ", avr:25", size
);
2678 case E_AVR_MACH_AVR3
:
2679 strncat (buf
, ", avr:3", size
);
2681 case E_AVR_MACH_AVR31
:
2682 strncat (buf
, ", avr:31", size
);
2684 case E_AVR_MACH_AVR35
:
2685 strncat (buf
, ", avr:35", size
);
2687 case E_AVR_MACH_AVR4
:
2688 strncat (buf
, ", avr:4", size
);
2690 case E_AVR_MACH_AVR5
:
2691 strncat (buf
, ", avr:5", size
);
2693 case E_AVR_MACH_AVR51
:
2694 strncat (buf
, ", avr:51", size
);
2696 case E_AVR_MACH_AVR6
:
2697 strncat (buf
, ", avr:6", size
);
2699 case E_AVR_MACH_AVRTINY
:
2700 strncat (buf
, ", avr:100", size
);
2702 case E_AVR_MACH_XMEGA1
:
2703 strncat (buf
, ", avr:101", size
);
2705 case E_AVR_MACH_XMEGA2
:
2706 strncat (buf
, ", avr:102", size
);
2708 case E_AVR_MACH_XMEGA3
:
2709 strncat (buf
, ", avr:103", size
);
2711 case E_AVR_MACH_XMEGA4
:
2712 strncat (buf
, ", avr:104", size
);
2714 case E_AVR_MACH_XMEGA5
:
2715 strncat (buf
, ", avr:105", size
);
2717 case E_AVR_MACH_XMEGA6
:
2718 strncat (buf
, ", avr:106", size
);
2720 case E_AVR_MACH_XMEGA7
:
2721 strncat (buf
, ", avr:107", size
);
2724 strncat (buf
, ", avr:<unknown>", size
);
2728 size
-= strlen (buf
);
2729 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2730 strncat (buf
, ", link-relax", size
);
2734 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2743 static const char *ABI_STRINGS
[] =
2745 "ABI v0", /* use r5 as return register; only used in N1213HC */
2746 "ABI v1", /* use r0 as return register */
2747 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2748 "ABI v2fp", /* for FPU */
2752 static const char *VER_STRINGS
[] =
2754 "Andes ELF V1.3 or older",
2758 static const char *ARCH_STRINGS
[] =
2767 abi
= EF_NDS_ABI
& e_flags
;
2768 arch
= EF_NDS_ARCH
& e_flags
;
2769 config
= EF_NDS_INST
& e_flags
;
2770 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2772 memset (buf
, 0, size
);
2779 case E_NDS_ABI_V2FP
:
2780 case E_NDS_ABI_AABI
:
2781 case E_NDS_ABI_V2FP_PLUS
:
2782 /* In case there are holes in the array. */
2783 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2787 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2793 case E_NDS32_ELF_VER_1_2
:
2794 case E_NDS32_ELF_VER_1_3
:
2795 case E_NDS32_ELF_VER_1_4
:
2796 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2800 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2804 if (E_NDS_ABI_V0
== abi
)
2806 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2807 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2808 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2809 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2815 case E_NDS_ARCH_STAR_V1_0
:
2816 case E_NDS_ARCH_STAR_V2_0
:
2817 case E_NDS_ARCH_STAR_V3_0
:
2818 case E_NDS_ARCH_STAR_V3_M
:
2819 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2823 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2824 /* ARCH version determines how the e_flags are interpreted.
2825 If it is unknown, we cannot proceed. */
2829 /* Newer ABI; Now handle architecture specific flags. */
2830 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2832 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2833 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2835 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2836 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2838 if (config
& E_NDS32_HAS_DIV_INST
)
2839 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2841 if (config
& E_NDS32_HAS_16BIT_INST
)
2842 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2846 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2848 if (version
<= E_NDS32_ELF_VER_1_3
)
2849 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2851 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2854 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2855 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2857 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2858 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2860 if (config
& E_NDS32_HAS_16BIT_INST
)
2862 if (version
<= E_NDS32_ELF_VER_1_3
)
2863 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2865 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2869 if (config
& E_NDS32_HAS_EXT_INST
)
2870 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2872 if (config
& E_NDS32_HAS_EXT2_INST
)
2873 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2875 if (config
& E_NDS32_HAS_FPU_INST
)
2878 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2881 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2884 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2887 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2890 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2895 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2897 case E_NDS32_FPU_REG_8SP_4DP
:
2898 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2900 case E_NDS32_FPU_REG_16SP_8DP
:
2901 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2903 case E_NDS32_FPU_REG_32SP_16DP
:
2904 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2906 case E_NDS32_FPU_REG_32SP_32DP
:
2907 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2912 if (config
& E_NDS32_HAS_AUDIO_INST
)
2913 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2915 if (config
& E_NDS32_HAS_STRING_INST
)
2916 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2918 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2919 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2921 if (config
& E_NDS32_HAS_VIDEO_INST
)
2923 if (version
<= E_NDS32_ELF_VER_1_3
)
2924 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2926 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2929 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2932 if (config
& E_NDS32_HAS_L2C_INST
)
2933 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2937 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2939 static char buf
[1024];
2950 case EM_ARC_COMPACT2
:
2951 case EM_ARC_COMPACT
:
2952 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2956 decode_ARM_machine_flags (e_flags
, buf
);
2960 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2964 if (e_flags
& EF_BFIN_PIC
)
2965 strcat (buf
, ", PIC");
2967 if (e_flags
& EF_BFIN_FDPIC
)
2968 strcat (buf
, ", FDPIC");
2970 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2971 strcat (buf
, ", code in L1");
2973 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2974 strcat (buf
, ", data in L1");
2979 switch (e_flags
& EF_FRV_CPU_MASK
)
2981 case EF_FRV_CPU_GENERIC
:
2985 strcat (buf
, ", fr???");
2988 case EF_FRV_CPU_FR300
:
2989 strcat (buf
, ", fr300");
2992 case EF_FRV_CPU_FR400
:
2993 strcat (buf
, ", fr400");
2995 case EF_FRV_CPU_FR405
:
2996 strcat (buf
, ", fr405");
2999 case EF_FRV_CPU_FR450
:
3000 strcat (buf
, ", fr450");
3003 case EF_FRV_CPU_FR500
:
3004 strcat (buf
, ", fr500");
3006 case EF_FRV_CPU_FR550
:
3007 strcat (buf
, ", fr550");
3010 case EF_FRV_CPU_SIMPLE
:
3011 strcat (buf
, ", simple");
3013 case EF_FRV_CPU_TOMCAT
:
3014 strcat (buf
, ", tomcat");
3020 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3021 strcat (buf
, ", m68000");
3022 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3023 strcat (buf
, ", cpu32");
3024 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3025 strcat (buf
, ", fido_a");
3028 char const * isa
= _("unknown");
3029 char const * mac
= _("unknown mac");
3030 char const * additional
= NULL
;
3032 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3034 case EF_M68K_CF_ISA_A_NODIV
:
3036 additional
= ", nodiv";
3038 case EF_M68K_CF_ISA_A
:
3041 case EF_M68K_CF_ISA_A_PLUS
:
3044 case EF_M68K_CF_ISA_B_NOUSP
:
3046 additional
= ", nousp";
3048 case EF_M68K_CF_ISA_B
:
3051 case EF_M68K_CF_ISA_C
:
3054 case EF_M68K_CF_ISA_C_NODIV
:
3056 additional
= ", nodiv";
3059 strcat (buf
, ", cf, isa ");
3062 strcat (buf
, additional
);
3063 if (e_flags
& EF_M68K_CF_FLOAT
)
3064 strcat (buf
, ", float");
3065 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3070 case EF_M68K_CF_MAC
:
3073 case EF_M68K_CF_EMAC
:
3076 case EF_M68K_CF_EMAC_B
:
3089 switch (e_flags
& EF_MEP_CPU_MASK
)
3091 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3092 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3093 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3094 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3095 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3096 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3097 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3100 switch (e_flags
& EF_MEP_COP_MASK
)
3102 case EF_MEP_COP_NONE
: break;
3103 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3104 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3105 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3106 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3107 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3110 if (e_flags
& EF_MEP_LIBRARY
)
3111 strcat (buf
, ", Built for Library");
3113 if (e_flags
& EF_MEP_INDEX_MASK
)
3114 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3115 e_flags
& EF_MEP_INDEX_MASK
);
3117 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3118 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3119 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3123 if (e_flags
& EF_PPC_EMB
)
3124 strcat (buf
, ", emb");
3126 if (e_flags
& EF_PPC_RELOCATABLE
)
3127 strcat (buf
, _(", relocatable"));
3129 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3130 strcat (buf
, _(", relocatable-lib"));
3134 if (e_flags
& EF_PPC64_ABI
)
3136 char abi
[] = ", abiv0";
3138 abi
[6] += e_flags
& EF_PPC64_ABI
;
3144 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3145 strcat (buf
, ", RH850 ABI");
3147 if (e_flags
& EF_V800_850E3
)
3148 strcat (buf
, ", V3 architecture");
3150 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3151 strcat (buf
, ", FPU not used");
3153 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3154 strcat (buf
, ", regmode: COMMON");
3156 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3157 strcat (buf
, ", r4 not used");
3159 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3160 strcat (buf
, ", r30 not used");
3162 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3163 strcat (buf
, ", r5 not used");
3165 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3166 strcat (buf
, ", r2 not used");
3168 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3170 switch (e_flags
& - e_flags
)
3172 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3173 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3174 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3175 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3176 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3177 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3178 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3179 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3180 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3181 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3182 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3183 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3190 case EM_CYGNUS_V850
:
3191 switch (e_flags
& EF_V850_ARCH
)
3193 case E_V850E3V5_ARCH
:
3194 strcat (buf
, ", v850e3v5");
3196 case E_V850E2V3_ARCH
:
3197 strcat (buf
, ", v850e2v3");
3200 strcat (buf
, ", v850e2");
3203 strcat (buf
, ", v850e1");
3206 strcat (buf
, ", v850e");
3209 strcat (buf
, ", v850");
3212 strcat (buf
, _(", unknown v850 architecture variant"));
3218 case EM_CYGNUS_M32R
:
3219 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3220 strcat (buf
, ", m32r");
3224 case EM_MIPS_RS3_LE
:
3225 if (e_flags
& EF_MIPS_NOREORDER
)
3226 strcat (buf
, ", noreorder");
3228 if (e_flags
& EF_MIPS_PIC
)
3229 strcat (buf
, ", pic");
3231 if (e_flags
& EF_MIPS_CPIC
)
3232 strcat (buf
, ", cpic");
3234 if (e_flags
& EF_MIPS_UCODE
)
3235 strcat (buf
, ", ugen_reserved");
3237 if (e_flags
& EF_MIPS_ABI2
)
3238 strcat (buf
, ", abi2");
3240 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3241 strcat (buf
, ", odk first");
3243 if (e_flags
& EF_MIPS_32BITMODE
)
3244 strcat (buf
, ", 32bitmode");
3246 if (e_flags
& EF_MIPS_NAN2008
)
3247 strcat (buf
, ", nan2008");
3249 if (e_flags
& EF_MIPS_FP64
)
3250 strcat (buf
, ", fp64");
3252 switch ((e_flags
& EF_MIPS_MACH
))
3254 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3255 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3256 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3257 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3258 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3259 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3260 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3261 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3262 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3263 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3264 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3265 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3266 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3267 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3268 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3269 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3270 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3272 /* We simply ignore the field in this case to avoid confusion:
3273 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3276 default: strcat (buf
, _(", unknown CPU")); break;
3279 switch ((e_flags
& EF_MIPS_ABI
))
3281 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3282 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3283 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3284 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3286 /* We simply ignore the field in this case to avoid confusion:
3287 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3288 This means it is likely to be an o32 file, but not for
3291 default: strcat (buf
, _(", unknown ABI")); break;
3294 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3295 strcat (buf
, ", mdmx");
3297 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3298 strcat (buf
, ", mips16");
3300 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3301 strcat (buf
, ", micromips");
3303 switch ((e_flags
& EF_MIPS_ARCH
))
3305 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3306 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3307 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3308 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3309 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3310 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3311 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3312 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3313 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3314 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3315 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3316 default: strcat (buf
, _(", unknown ISA")); break;
3321 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3325 if (e_flags
& EF_RISCV_RVC
)
3326 strcat (buf
, ", RVC");
3328 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3330 case EF_RISCV_FLOAT_ABI_SOFT
:
3331 strcat (buf
, ", soft-float ABI");
3334 case EF_RISCV_FLOAT_ABI_SINGLE
:
3335 strcat (buf
, ", single-float ABI");
3338 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3339 strcat (buf
, ", double-float ABI");
3342 case EF_RISCV_FLOAT_ABI_QUAD
:
3343 strcat (buf
, ", quad-float ABI");
3349 switch ((e_flags
& EF_SH_MACH_MASK
))
3351 case EF_SH1
: strcat (buf
, ", sh1"); break;
3352 case EF_SH2
: strcat (buf
, ", sh2"); break;
3353 case EF_SH3
: strcat (buf
, ", sh3"); break;
3354 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3355 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3356 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3357 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3358 case EF_SH4
: strcat (buf
, ", sh4"); break;
3359 case EF_SH5
: strcat (buf
, ", sh5"); break;
3360 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3361 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3362 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3363 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3364 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3365 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3366 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3367 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3368 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3369 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3370 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3371 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3372 default: strcat (buf
, _(", unknown ISA")); break;
3375 if (e_flags
& EF_SH_PIC
)
3376 strcat (buf
, ", pic");
3378 if (e_flags
& EF_SH_FDPIC
)
3379 strcat (buf
, ", fdpic");
3383 if (e_flags
& EF_OR1K_NODELAY
)
3384 strcat (buf
, ", no delay");
3388 if (e_flags
& EF_SPARC_32PLUS
)
3389 strcat (buf
, ", v8+");
3391 if (e_flags
& EF_SPARC_SUN_US1
)
3392 strcat (buf
, ", ultrasparcI");
3394 if (e_flags
& EF_SPARC_SUN_US3
)
3395 strcat (buf
, ", ultrasparcIII");
3397 if (e_flags
& EF_SPARC_HAL_R1
)
3398 strcat (buf
, ", halr1");
3400 if (e_flags
& EF_SPARC_LEDATA
)
3401 strcat (buf
, ", ledata");
3403 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3404 strcat (buf
, ", tso");
3406 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3407 strcat (buf
, ", pso");
3409 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3410 strcat (buf
, ", rmo");
3414 switch (e_flags
& EF_PARISC_ARCH
)
3416 case EFA_PARISC_1_0
:
3417 strcpy (buf
, ", PA-RISC 1.0");
3419 case EFA_PARISC_1_1
:
3420 strcpy (buf
, ", PA-RISC 1.1");
3422 case EFA_PARISC_2_0
:
3423 strcpy (buf
, ", PA-RISC 2.0");
3428 if (e_flags
& EF_PARISC_TRAPNIL
)
3429 strcat (buf
, ", trapnil");
3430 if (e_flags
& EF_PARISC_EXT
)
3431 strcat (buf
, ", ext");
3432 if (e_flags
& EF_PARISC_LSB
)
3433 strcat (buf
, ", lsb");
3434 if (e_flags
& EF_PARISC_WIDE
)
3435 strcat (buf
, ", wide");
3436 if (e_flags
& EF_PARISC_NO_KABP
)
3437 strcat (buf
, ", no kabp");
3438 if (e_flags
& EF_PARISC_LAZYSWAP
)
3439 strcat (buf
, ", lazyswap");
3444 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3445 strcat (buf
, ", new calling convention");
3447 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3448 strcat (buf
, ", gnu calling convention");
3452 if ((e_flags
& EF_IA_64_ABI64
))
3453 strcat (buf
, ", 64-bit");
3455 strcat (buf
, ", 32-bit");
3456 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3457 strcat (buf
, ", reduced fp model");
3458 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3459 strcat (buf
, ", no function descriptors, constant gp");
3460 else if ((e_flags
& EF_IA_64_CONS_GP
))
3461 strcat (buf
, ", constant gp");
3462 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3463 strcat (buf
, ", absolute");
3464 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3466 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3467 strcat (buf
, ", vms_linkages");
3468 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3470 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3472 case EF_IA_64_VMS_COMCOD_WARNING
:
3473 strcat (buf
, ", warning");
3475 case EF_IA_64_VMS_COMCOD_ERROR
:
3476 strcat (buf
, ", error");
3478 case EF_IA_64_VMS_COMCOD_ABORT
:
3479 strcat (buf
, ", abort");
3482 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3483 e_flags
& EF_IA_64_VMS_COMCOD
);
3484 strcat (buf
, ", <unknown>");
3490 if ((e_flags
& EF_VAX_NONPIC
))
3491 strcat (buf
, ", non-PIC");
3492 if ((e_flags
& EF_VAX_DFLOAT
))
3493 strcat (buf
, ", D-Float");
3494 if ((e_flags
& EF_VAX_GFLOAT
))
3495 strcat (buf
, ", G-Float");
3499 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3500 strcat (buf
, ", mcm");
3501 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3502 strcat (buf
, ", mcm24");
3503 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3504 strcat (buf
, ", gr6");
3508 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3510 case E_FLAG_RL78_ANY_CPU
: break;
3511 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3512 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3513 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3515 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3516 strcat (buf
, ", 64-bit doubles");
3520 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3521 strcat (buf
, ", 64-bit doubles");
3522 if (e_flags
& E_FLAG_RX_DSP
)
3523 strcat (buf
, ", dsp");
3524 if (e_flags
& E_FLAG_RX_PID
)
3525 strcat (buf
, ", pid");
3526 if (e_flags
& E_FLAG_RX_ABI
)
3527 strcat (buf
, ", RX ABI");
3528 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3529 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3530 ? ", uses String instructions" : ", bans String instructions");
3531 if (e_flags
& E_FLAG_RX_V2
)
3532 strcat (buf
, ", V2");
3536 if (e_flags
& EF_S390_HIGH_GPRS
)
3537 strcat (buf
, ", highgprs");
3541 if ((e_flags
& EF_C6000_REL
))
3542 strcat (buf
, ", relocatable module");
3546 strcat (buf
, _(": architecture variant: "));
3547 switch (e_flags
& EF_MSP430_MACH
)
3549 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3550 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3551 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3552 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3553 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3554 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3555 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3556 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3557 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3558 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3559 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3560 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3561 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3562 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3563 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3565 strcat (buf
, _(": unknown")); break;
3568 if (e_flags
& ~ EF_MSP430_MACH
)
3569 strcat (buf
, _(": unknown extra flag bits also present"));
3577 get_osabi_name (unsigned int osabi
)
3579 static char buff
[32];
3583 case ELFOSABI_NONE
: return "UNIX - System V";
3584 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3585 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3586 case ELFOSABI_GNU
: return "UNIX - GNU";
3587 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3588 case ELFOSABI_AIX
: return "UNIX - AIX";
3589 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3590 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3591 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3592 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3593 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3594 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3595 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3596 case ELFOSABI_AROS
: return "AROS";
3597 case ELFOSABI_FENIXOS
: return "FenixOS";
3598 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3599 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3602 switch (elf_header
.e_machine
)
3607 case ELFOSABI_ARM
: return "ARM";
3618 case ELFOSABI_STANDALONE
: return _("Standalone App");
3627 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3628 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3637 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3643 get_aarch64_segment_type (unsigned long type
)
3647 case PT_AARCH64_ARCHEXT
:
3648 return "AARCH64_ARCHEXT";
3657 get_arm_segment_type (unsigned long type
)
3671 get_mips_segment_type (unsigned long type
)
3675 case PT_MIPS_REGINFO
:
3677 case PT_MIPS_RTPROC
:
3679 case PT_MIPS_OPTIONS
:
3681 case PT_MIPS_ABIFLAGS
:
3691 get_parisc_segment_type (unsigned long type
)
3695 case PT_HP_TLS
: return "HP_TLS";
3696 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3697 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3698 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3699 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3700 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3701 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3702 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3703 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3704 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3705 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3706 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3707 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3708 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3709 case PT_HP_STACK
: return "HP_STACK";
3710 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3711 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3712 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3713 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3722 get_ia64_segment_type (unsigned long type
)
3726 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3727 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3728 case PT_HP_TLS
: return "HP_TLS";
3729 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3730 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3731 case PT_IA_64_HP_STACK
: return "HP_STACK";
3740 get_tic6x_segment_type (unsigned long type
)
3744 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3753 get_solaris_segment_type (unsigned long type
)
3757 case 0x6464e550: return "PT_SUNW_UNWIND";
3758 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3759 case 0x6ffffff7: return "PT_LOSUNW";
3760 case 0x6ffffffa: return "PT_SUNWBSS";
3761 case 0x6ffffffb: return "PT_SUNWSTACK";
3762 case 0x6ffffffc: return "PT_SUNWDTRACE";
3763 case 0x6ffffffd: return "PT_SUNWCAP";
3764 case 0x6fffffff: return "PT_HISUNW";
3765 default: return NULL
;
3770 get_segment_type (unsigned long p_type
)
3772 static char buff
[32];
3776 case PT_NULL
: return "NULL";
3777 case PT_LOAD
: return "LOAD";
3778 case PT_DYNAMIC
: return "DYNAMIC";
3779 case PT_INTERP
: return "INTERP";
3780 case PT_NOTE
: return "NOTE";
3781 case PT_SHLIB
: return "SHLIB";
3782 case PT_PHDR
: return "PHDR";
3783 case PT_TLS
: return "TLS";
3785 case PT_GNU_EH_FRAME
:
3786 return "GNU_EH_FRAME";
3787 case PT_GNU_STACK
: return "GNU_STACK";
3788 case PT_GNU_RELRO
: return "GNU_RELRO";
3791 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3793 const char * result
;
3795 switch (elf_header
.e_machine
)
3798 result
= get_aarch64_segment_type (p_type
);
3801 result
= get_arm_segment_type (p_type
);
3804 case EM_MIPS_RS3_LE
:
3805 result
= get_mips_segment_type (p_type
);
3808 result
= get_parisc_segment_type (p_type
);
3811 result
= get_ia64_segment_type (p_type
);
3814 result
= get_tic6x_segment_type (p_type
);
3824 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3826 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3828 const char * result
;
3830 switch (elf_header
.e_machine
)
3833 result
= get_parisc_segment_type (p_type
);
3836 result
= get_ia64_segment_type (p_type
);
3839 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3840 result
= get_solaris_segment_type (p_type
);
3849 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3852 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3859 get_mips_section_type_name (unsigned int sh_type
)
3863 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3864 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3865 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3866 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3867 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3868 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3869 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3870 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3871 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3872 case SHT_MIPS_RELD
: return "MIPS_RELD";
3873 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3874 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3875 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3876 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3877 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3878 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3879 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3880 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3881 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3882 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3883 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3884 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3885 case SHT_MIPS_LINE
: return "MIPS_LINE";
3886 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3887 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3888 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3889 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3890 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3891 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3892 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3893 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3894 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3895 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3896 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3897 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3898 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3899 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3900 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3901 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3902 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3910 get_parisc_section_type_name (unsigned int sh_type
)
3914 case SHT_PARISC_EXT
: return "PARISC_EXT";
3915 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3916 case SHT_PARISC_DOC
: return "PARISC_DOC";
3917 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3918 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3919 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3920 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3928 get_ia64_section_type_name (unsigned int sh_type
)
3930 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3931 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3932 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3936 case SHT_IA_64_EXT
: return "IA_64_EXT";
3937 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3938 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3939 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3940 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3941 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3942 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3943 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3944 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3945 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3953 get_x86_64_section_type_name (unsigned int sh_type
)
3957 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3965 get_aarch64_section_type_name (unsigned int sh_type
)
3969 case SHT_AARCH64_ATTRIBUTES
:
3970 return "AARCH64_ATTRIBUTES";
3978 get_arm_section_type_name (unsigned int sh_type
)
3982 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3983 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3984 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3985 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3986 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3994 get_tic6x_section_type_name (unsigned int sh_type
)
3998 case SHT_C6000_UNWIND
:
3999 return "C6000_UNWIND";
4000 case SHT_C6000_PREEMPTMAP
:
4001 return "C6000_PREEMPTMAP";
4002 case SHT_C6000_ATTRIBUTES
:
4003 return "C6000_ATTRIBUTES";
4008 case SHT_TI_HANDLER
:
4009 return "TI_HANDLER";
4010 case SHT_TI_INITINFO
:
4011 return "TI_INITINFO";
4012 case SHT_TI_PHATTRS
:
4013 return "TI_PHATTRS";
4021 get_msp430x_section_type_name (unsigned int sh_type
)
4025 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4026 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4027 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4028 default: return NULL
;
4033 get_v850_section_type_name (unsigned int sh_type
)
4037 case SHT_V850_SCOMMON
: return "V850 Small Common";
4038 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4039 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4040 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4041 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4042 default: return NULL
;
4047 get_section_type_name (unsigned int sh_type
)
4049 static char buff
[32];
4050 const char * result
;
4054 case SHT_NULL
: return "NULL";
4055 case SHT_PROGBITS
: return "PROGBITS";
4056 case SHT_SYMTAB
: return "SYMTAB";
4057 case SHT_STRTAB
: return "STRTAB";
4058 case SHT_RELA
: return "RELA";
4059 case SHT_HASH
: return "HASH";
4060 case SHT_DYNAMIC
: return "DYNAMIC";
4061 case SHT_NOTE
: return "NOTE";
4062 case SHT_NOBITS
: return "NOBITS";
4063 case SHT_REL
: return "REL";
4064 case SHT_SHLIB
: return "SHLIB";
4065 case SHT_DYNSYM
: return "DYNSYM";
4066 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4067 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4068 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4069 case SHT_GNU_HASH
: return "GNU_HASH";
4070 case SHT_GROUP
: return "GROUP";
4071 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4072 case SHT_GNU_verdef
: return "VERDEF";
4073 case SHT_GNU_verneed
: return "VERNEED";
4074 case SHT_GNU_versym
: return "VERSYM";
4075 case 0x6ffffff0: return "VERSYM";
4076 case 0x6ffffffc: return "VERDEF";
4077 case 0x7ffffffd: return "AUXILIARY";
4078 case 0x7fffffff: return "FILTER";
4079 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4082 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4084 switch (elf_header
.e_machine
)
4087 case EM_MIPS_RS3_LE
:
4088 result
= get_mips_section_type_name (sh_type
);
4091 result
= get_parisc_section_type_name (sh_type
);
4094 result
= get_ia64_section_type_name (sh_type
);
4099 result
= get_x86_64_section_type_name (sh_type
);
4102 result
= get_aarch64_section_type_name (sh_type
);
4105 result
= get_arm_section_type_name (sh_type
);
4108 result
= get_tic6x_section_type_name (sh_type
);
4111 result
= get_msp430x_section_type_name (sh_type
);
4115 case EM_CYGNUS_V850
:
4116 result
= get_v850_section_type_name (sh_type
);
4126 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4128 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4130 switch (elf_header
.e_machine
)
4133 result
= get_ia64_section_type_name (sh_type
);
4136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4137 result
= get_solaris_section_type (sh_type
);
4142 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4143 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4144 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4145 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4157 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4159 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4161 switch (elf_header
.e_machine
)
4165 case EM_CYGNUS_V850
:
4166 result
= get_v850_section_type_name (sh_type
);
4176 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4179 /* This message is probably going to be displayed in a 15
4180 character wide field, so put the hex value first. */
4181 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4187 #define OPTION_DEBUG_DUMP 512
4188 #define OPTION_DYN_SYMS 513
4189 #define OPTION_DWARF_DEPTH 514
4190 #define OPTION_DWARF_START 515
4191 #define OPTION_DWARF_CHECK 516
4193 static struct option options
[] =
4195 {"all", no_argument
, 0, 'a'},
4196 {"file-header", no_argument
, 0, 'h'},
4197 {"program-headers", no_argument
, 0, 'l'},
4198 {"headers", no_argument
, 0, 'e'},
4199 {"histogram", no_argument
, 0, 'I'},
4200 {"segments", no_argument
, 0, 'l'},
4201 {"sections", no_argument
, 0, 'S'},
4202 {"section-headers", no_argument
, 0, 'S'},
4203 {"section-groups", no_argument
, 0, 'g'},
4204 {"section-details", no_argument
, 0, 't'},
4205 {"full-section-name",no_argument
, 0, 'N'},
4206 {"symbols", no_argument
, 0, 's'},
4207 {"syms", no_argument
, 0, 's'},
4208 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4209 {"relocs", no_argument
, 0, 'r'},
4210 {"notes", no_argument
, 0, 'n'},
4211 {"dynamic", no_argument
, 0, 'd'},
4212 {"arch-specific", no_argument
, 0, 'A'},
4213 {"version-info", no_argument
, 0, 'V'},
4214 {"use-dynamic", no_argument
, 0, 'D'},
4215 {"unwind", no_argument
, 0, 'u'},
4216 {"archive-index", no_argument
, 0, 'c'},
4217 {"hex-dump", required_argument
, 0, 'x'},
4218 {"relocated-dump", required_argument
, 0, 'R'},
4219 {"string-dump", required_argument
, 0, 'p'},
4220 {"decompress", no_argument
, 0, 'z'},
4221 #ifdef SUPPORT_DISASSEMBLY
4222 {"instruction-dump", required_argument
, 0, 'i'},
4224 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4226 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4227 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4228 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4230 {"version", no_argument
, 0, 'v'},
4231 {"wide", no_argument
, 0, 'W'},
4232 {"help", no_argument
, 0, 'H'},
4233 {0, no_argument
, 0, 0}
4237 usage (FILE * stream
)
4239 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4240 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4241 fprintf (stream
, _(" Options are:\n\
4242 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4243 -h --file-header Display the ELF file header\n\
4244 -l --program-headers Display the program headers\n\
4245 --segments An alias for --program-headers\n\
4246 -S --section-headers Display the sections' header\n\
4247 --sections An alias for --section-headers\n\
4248 -g --section-groups Display the section groups\n\
4249 -t --section-details Display the section details\n\
4250 -e --headers Equivalent to: -h -l -S\n\
4251 -s --syms Display the symbol table\n\
4252 --symbols An alias for --syms\n\
4253 --dyn-syms Display the dynamic symbol table\n\
4254 -n --notes Display the core notes (if present)\n\
4255 -r --relocs Display the relocations (if present)\n\
4256 -u --unwind Display the unwind info (if present)\n\
4257 -d --dynamic Display the dynamic section (if present)\n\
4258 -V --version-info Display the version sections (if present)\n\
4259 -A --arch-specific Display architecture specific information (if any)\n\
4260 -c --archive-index Display the symbol/file index in an archive\n\
4261 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4262 -x --hex-dump=<number|name>\n\
4263 Dump the contents of section <number|name> as bytes\n\
4264 -p --string-dump=<number|name>\n\
4265 Dump the contents of section <number|name> as strings\n\
4266 -R --relocated-dump=<number|name>\n\
4267 Dump the contents of section <number|name> as relocated bytes\n\
4268 -z --decompress Decompress section before dumping it\n\
4269 -w[lLiaprmfFsoRt] or\n\
4270 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4271 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4272 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4274 Display the contents of DWARF2 debug sections\n"));
4275 fprintf (stream
, _("\
4276 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4277 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4279 #ifdef SUPPORT_DISASSEMBLY
4280 fprintf (stream
, _("\
4281 -i --instruction-dump=<number|name>\n\
4282 Disassemble the contents of section <number|name>\n"));
4284 fprintf (stream
, _("\
4285 -I --histogram Display histogram of bucket list lengths\n\
4286 -W --wide Allow output width to exceed 80 characters\n\
4287 @<file> Read options from <file>\n\
4288 -H --help Display this information\n\
4289 -v --version Display the version number of readelf\n"));
4291 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4292 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4294 exit (stream
== stdout
? 0 : 1);
4297 /* Record the fact that the user wants the contents of section number
4298 SECTION to be displayed using the method(s) encoded as flags bits
4299 in TYPE. Note, TYPE can be zero if we are creating the array for
4303 request_dump_bynumber (unsigned int section
, dump_type type
)
4305 if (section
>= num_dump_sects
)
4307 dump_type
* new_dump_sects
;
4309 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4310 sizeof (* dump_sects
));
4312 if (new_dump_sects
== NULL
)
4313 error (_("Out of memory allocating dump request table.\n"));
4318 /* Copy current flag settings. */
4319 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4324 dump_sects
= new_dump_sects
;
4325 num_dump_sects
= section
+ 1;
4330 dump_sects
[section
] |= type
;
4335 /* Request a dump by section name. */
4338 request_dump_byname (const char * section
, dump_type type
)
4340 struct dump_list_entry
* new_request
;
4342 new_request
= (struct dump_list_entry
*)
4343 malloc (sizeof (struct dump_list_entry
));
4345 error (_("Out of memory allocating dump request table.\n"));
4347 new_request
->name
= strdup (section
);
4348 if (!new_request
->name
)
4349 error (_("Out of memory allocating dump request table.\n"));
4351 new_request
->type
= type
;
4353 new_request
->next
= dump_sects_byname
;
4354 dump_sects_byname
= new_request
;
4358 request_dump (dump_type type
)
4364 section
= strtoul (optarg
, & cp
, 0);
4366 if (! *cp
&& section
>= 0)
4367 request_dump_bynumber (section
, type
);
4369 request_dump_byname (optarg
, type
);
4374 parse_args (int argc
, char ** argv
)
4381 while ((c
= getopt_long
4382 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4400 do_section_groups
++;
4408 do_section_groups
++;
4413 do_section_details
++;
4457 request_dump (HEX_DUMP
);
4460 request_dump (STRING_DUMP
);
4463 request_dump (RELOC_DUMP
);
4473 dwarf_select_sections_all ();
4478 dwarf_select_sections_by_letters (optarg
);
4481 case OPTION_DEBUG_DUMP
:
4488 dwarf_select_sections_by_names (optarg
);
4491 case OPTION_DWARF_DEPTH
:
4495 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4498 case OPTION_DWARF_START
:
4502 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4505 case OPTION_DWARF_CHECK
:
4508 case OPTION_DYN_SYMS
:
4511 #ifdef SUPPORT_DISASSEMBLY
4513 request_dump (DISASS_DUMP
);
4517 print_version (program_name
);
4526 /* xgettext:c-format */
4527 error (_("Invalid option '-%c'\n"), c
);
4534 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4535 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4536 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4537 && !do_section_groups
&& !do_archive_index
4543 get_elf_class (unsigned int elf_class
)
4545 static char buff
[32];
4549 case ELFCLASSNONE
: return _("none");
4550 case ELFCLASS32
: return "ELF32";
4551 case ELFCLASS64
: return "ELF64";
4553 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4559 get_data_encoding (unsigned int encoding
)
4561 static char buff
[32];
4565 case ELFDATANONE
: return _("none");
4566 case ELFDATA2LSB
: return _("2's complement, little endian");
4567 case ELFDATA2MSB
: return _("2's complement, big endian");
4569 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4574 /* Decode the data held in 'elf_header'. */
4577 process_file_header (void)
4579 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4580 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4581 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4582 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4585 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4589 init_dwarf_regnames (elf_header
.e_machine
);
4595 printf (_("ELF Header:\n"));
4596 printf (_(" Magic: "));
4597 for (i
= 0; i
< EI_NIDENT
; i
++)
4598 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4600 printf (_(" Class: %s\n"),
4601 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4602 printf (_(" Data: %s\n"),
4603 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4604 printf (_(" Version: %d %s\n"),
4605 elf_header
.e_ident
[EI_VERSION
],
4606 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4608 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4609 ? _("<unknown: %lx>")
4611 printf (_(" OS/ABI: %s\n"),
4612 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4613 printf (_(" ABI Version: %d\n"),
4614 elf_header
.e_ident
[EI_ABIVERSION
]);
4615 printf (_(" Type: %s\n"),
4616 get_file_type (elf_header
.e_type
));
4617 printf (_(" Machine: %s\n"),
4618 get_machine_name (elf_header
.e_machine
));
4619 printf (_(" Version: 0x%lx\n"),
4620 (unsigned long) elf_header
.e_version
);
4622 printf (_(" Entry point address: "));
4623 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4624 printf (_("\n Start of program headers: "));
4625 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4626 printf (_(" (bytes into file)\n Start of section headers: "));
4627 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4628 printf (_(" (bytes into file)\n"));
4630 printf (_(" Flags: 0x%lx%s\n"),
4631 (unsigned long) elf_header
.e_flags
,
4632 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4633 printf (_(" Size of this header: %ld (bytes)\n"),
4634 (long) elf_header
.e_ehsize
);
4635 printf (_(" Size of program headers: %ld (bytes)\n"),
4636 (long) elf_header
.e_phentsize
);
4637 printf (_(" Number of program headers: %ld"),
4638 (long) elf_header
.e_phnum
);
4639 if (section_headers
!= NULL
4640 && elf_header
.e_phnum
== PN_XNUM
4641 && section_headers
[0].sh_info
!= 0)
4642 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4643 putc ('\n', stdout
);
4644 printf (_(" Size of section headers: %ld (bytes)\n"),
4645 (long) elf_header
.e_shentsize
);
4646 printf (_(" Number of section headers: %ld"),
4647 (long) elf_header
.e_shnum
);
4648 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4649 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4650 putc ('\n', stdout
);
4651 printf (_(" Section header string table index: %ld"),
4652 (long) elf_header
.e_shstrndx
);
4653 if (section_headers
!= NULL
4654 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4655 printf (" (%u)", section_headers
[0].sh_link
);
4656 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4657 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4658 printf (_(" <corrupt: out of range>"));
4659 putc ('\n', stdout
);
4662 if (section_headers
!= NULL
)
4664 if (elf_header
.e_phnum
== PN_XNUM
4665 && section_headers
[0].sh_info
!= 0)
4666 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4667 if (elf_header
.e_shnum
== SHN_UNDEF
)
4668 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4669 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4670 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4671 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4672 elf_header
.e_shstrndx
= SHN_UNDEF
;
4673 free (section_headers
);
4674 section_headers
= NULL
;
4681 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4683 Elf32_External_Phdr
* phdrs
;
4684 Elf32_External_Phdr
* external
;
4685 Elf_Internal_Phdr
* internal
;
4687 unsigned int size
= elf_header
.e_phentsize
;
4688 unsigned int num
= elf_header
.e_phnum
;
4690 /* PR binutils/17531: Cope with unexpected section header sizes. */
4691 if (size
== 0 || num
== 0)
4693 if (size
< sizeof * phdrs
)
4695 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4698 if (size
> sizeof * phdrs
)
4699 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4701 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4702 size
, num
, _("program headers"));
4706 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4707 i
< elf_header
.e_phnum
;
4708 i
++, internal
++, external
++)
4710 internal
->p_type
= BYTE_GET (external
->p_type
);
4711 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4712 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4713 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4714 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4715 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4716 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4717 internal
->p_align
= BYTE_GET (external
->p_align
);
4725 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4727 Elf64_External_Phdr
* phdrs
;
4728 Elf64_External_Phdr
* external
;
4729 Elf_Internal_Phdr
* internal
;
4731 unsigned int size
= elf_header
.e_phentsize
;
4732 unsigned int num
= elf_header
.e_phnum
;
4734 /* PR binutils/17531: Cope with unexpected section header sizes. */
4735 if (size
== 0 || num
== 0)
4737 if (size
< sizeof * phdrs
)
4739 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4742 if (size
> sizeof * phdrs
)
4743 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4745 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4746 size
, num
, _("program headers"));
4750 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4751 i
< elf_header
.e_phnum
;
4752 i
++, internal
++, external
++)
4754 internal
->p_type
= BYTE_GET (external
->p_type
);
4755 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4756 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4757 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4758 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4759 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4760 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4761 internal
->p_align
= BYTE_GET (external
->p_align
);
4768 /* Returns 1 if the program headers were read into `program_headers'. */
4771 get_program_headers (FILE * file
)
4773 Elf_Internal_Phdr
* phdrs
;
4775 /* Check cache of prior read. */
4776 if (program_headers
!= NULL
)
4779 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4780 sizeof (Elf_Internal_Phdr
));
4784 error (_("Out of memory reading %u program headers\n"),
4785 elf_header
.e_phnum
);
4790 ? get_32bit_program_headers (file
, phdrs
)
4791 : get_64bit_program_headers (file
, phdrs
))
4793 program_headers
= phdrs
;
4801 /* Returns 1 if the program headers were loaded. */
4804 process_program_headers (FILE * file
)
4806 Elf_Internal_Phdr
* segment
;
4808 Elf_Internal_Phdr
* previous_load
= NULL
;
4810 if (elf_header
.e_phnum
== 0)
4812 /* PR binutils/12467. */
4813 if (elf_header
.e_phoff
!= 0)
4814 warn (_("possibly corrupt ELF header - it has a non-zero program"
4815 " header offset, but no program headers\n"));
4816 else if (do_segments
)
4817 printf (_("\nThere are no program headers in this file.\n"));
4821 if (do_segments
&& !do_header
)
4823 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4824 printf (_("Entry point "));
4825 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4826 printf (_("\nThere are %d program headers, starting at offset "),
4827 elf_header
.e_phnum
);
4828 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4832 if (! get_program_headers (file
))
4837 if (elf_header
.e_phnum
> 1)
4838 printf (_("\nProgram Headers:\n"));
4840 printf (_("\nProgram Headers:\n"));
4844 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4847 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4851 (_(" Type Offset VirtAddr PhysAddr\n"));
4853 (_(" FileSiz MemSiz Flags Align\n"));
4860 for (i
= 0, segment
= program_headers
;
4861 i
< elf_header
.e_phnum
;
4866 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4870 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4871 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4872 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4873 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4874 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4876 (segment
->p_flags
& PF_R
? 'R' : ' '),
4877 (segment
->p_flags
& PF_W
? 'W' : ' '),
4878 (segment
->p_flags
& PF_X
? 'E' : ' '));
4879 printf ("%#lx", (unsigned long) segment
->p_align
);
4883 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4884 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4887 print_vma (segment
->p_offset
, FULL_HEX
);
4891 print_vma (segment
->p_vaddr
, FULL_HEX
);
4893 print_vma (segment
->p_paddr
, FULL_HEX
);
4896 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4897 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4900 print_vma (segment
->p_filesz
, FULL_HEX
);
4904 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4905 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4908 print_vma (segment
->p_memsz
, FULL_HEX
);
4912 (segment
->p_flags
& PF_R
? 'R' : ' '),
4913 (segment
->p_flags
& PF_W
? 'W' : ' '),
4914 (segment
->p_flags
& PF_X
? 'E' : ' '));
4916 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4917 printf ("%#lx", (unsigned long) segment
->p_align
);
4920 print_vma (segment
->p_align
, PREFIX_HEX
);
4925 print_vma (segment
->p_offset
, FULL_HEX
);
4927 print_vma (segment
->p_vaddr
, FULL_HEX
);
4929 print_vma (segment
->p_paddr
, FULL_HEX
);
4931 print_vma (segment
->p_filesz
, FULL_HEX
);
4933 print_vma (segment
->p_memsz
, FULL_HEX
);
4935 (segment
->p_flags
& PF_R
? 'R' : ' '),
4936 (segment
->p_flags
& PF_W
? 'W' : ' '),
4937 (segment
->p_flags
& PF_X
? 'E' : ' '));
4938 print_vma (segment
->p_align
, PREFIX_HEX
);
4941 putc ('\n', stdout
);
4944 switch (segment
->p_type
)
4947 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4948 required by the ELF standard, several programs, including the Linux
4949 kernel, make use of non-ordered segments. */
4951 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4952 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4954 if (segment
->p_memsz
< segment
->p_filesz
)
4955 error (_("the segment's file size is larger than its memory size\n"));
4956 previous_load
= segment
;
4960 /* PR 20815 - Verify that the program header is loaded into memory. */
4961 if (i
> 0 && previous_load
!= NULL
)
4962 error (_("the PHDR segment must occur before any LOAD segment\n"));
4963 if (elf_header
.e_machine
!= EM_PARISC
)
4967 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4968 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4969 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4970 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4972 if (j
== elf_header
.e_phnum
)
4973 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4979 error (_("more than one dynamic segment\n"));
4981 /* By default, assume that the .dynamic section is the first
4982 section in the DYNAMIC segment. */
4983 dynamic_addr
= segment
->p_offset
;
4984 dynamic_size
= segment
->p_filesz
;
4985 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4986 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4988 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4989 dynamic_addr
= dynamic_size
= 0;
4992 /* Try to locate the .dynamic section. If there is
4993 a section header table, we can easily locate it. */
4994 if (section_headers
!= NULL
)
4996 Elf_Internal_Shdr
* sec
;
4998 sec
= find_section (".dynamic");
4999 if (sec
== NULL
|| sec
->sh_size
== 0)
5001 /* A corresponding .dynamic section is expected, but on
5002 IA-64/OpenVMS it is OK for it to be missing. */
5003 if (!is_ia64_vms ())
5004 error (_("no .dynamic section in the dynamic segment\n"));
5008 if (sec
->sh_type
== SHT_NOBITS
)
5014 dynamic_addr
= sec
->sh_offset
;
5015 dynamic_size
= sec
->sh_size
;
5017 if (dynamic_addr
< segment
->p_offset
5018 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5019 warn (_("the .dynamic section is not contained"
5020 " within the dynamic segment\n"));
5021 else if (dynamic_addr
> segment
->p_offset
)
5022 warn (_("the .dynamic section is not the first section"
5023 " in the dynamic segment.\n"));
5028 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5030 error (_("Unable to find program interpreter name\n"));
5034 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5036 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5037 error (_("Internal error: failed to create format string to display program interpreter\n"));
5039 program_interpreter
[0] = 0;
5040 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5041 error (_("Unable to read program interpreter name\n"));
5044 printf (_(" [Requesting program interpreter: %s]\n"),
5045 program_interpreter
);
5051 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5053 printf (_("\n Section to Segment mapping:\n"));
5054 printf (_(" Segment Sections...\n"));
5056 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5059 Elf_Internal_Shdr
* section
;
5061 segment
= program_headers
+ i
;
5062 section
= section_headers
+ 1;
5064 printf (" %2.2d ", i
);
5066 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5068 if (!ELF_TBSS_SPECIAL (section
, segment
)
5069 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5070 printf ("%s ", printable_section_name (section
));
5081 /* Find the file offset corresponding to VMA by using the program headers. */
5084 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5086 Elf_Internal_Phdr
* seg
;
5088 if (! get_program_headers (file
))
5090 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5094 for (seg
= program_headers
;
5095 seg
< program_headers
+ elf_header
.e_phnum
;
5098 if (seg
->p_type
!= PT_LOAD
)
5101 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5102 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5103 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5106 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5107 (unsigned long) vma
);
5112 /* Allocate memory and load the sections headers into the global pointer
5113 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5114 generate any error messages if the load fails. */
5117 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5119 Elf32_External_Shdr
* shdrs
;
5120 Elf_Internal_Shdr
* internal
;
5122 unsigned int size
= elf_header
.e_shentsize
;
5123 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5125 /* PR binutils/17531: Cope with unexpected section header sizes. */
5126 if (size
== 0 || num
== 0)
5128 if (size
< sizeof * shdrs
)
5131 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5134 if (!probe
&& size
> sizeof * shdrs
)
5135 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5137 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5139 probe
? NULL
: _("section headers"));
5143 if (section_headers
!= NULL
)
5144 free (section_headers
);
5145 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5146 sizeof (Elf_Internal_Shdr
));
5147 if (section_headers
== NULL
)
5150 error (_("Out of memory reading %u section headers\n"), num
);
5154 for (i
= 0, internal
= section_headers
;
5158 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5159 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5160 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5161 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5162 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5163 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5164 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5165 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5166 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5167 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5168 if (!probe
&& internal
->sh_link
> num
)
5169 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5170 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5171 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5179 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5181 Elf64_External_Shdr
* shdrs
;
5182 Elf_Internal_Shdr
* internal
;
5184 unsigned int size
= elf_header
.e_shentsize
;
5185 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5187 /* PR binutils/17531: Cope with unexpected section header sizes. */
5188 if (size
== 0 || num
== 0)
5190 if (size
< sizeof * shdrs
)
5193 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5196 if (! probe
&& size
> sizeof * shdrs
)
5197 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5199 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5201 probe
? NULL
: _("section headers"));
5205 if (section_headers
!= NULL
)
5206 free (section_headers
);
5207 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5208 sizeof (Elf_Internal_Shdr
));
5209 if (section_headers
== NULL
)
5212 error (_("Out of memory reading %u section headers\n"), num
);
5216 for (i
= 0, internal
= section_headers
;
5220 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5221 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5222 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5223 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5224 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5225 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5226 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5227 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5228 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5229 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5230 if (!probe
&& internal
->sh_link
> num
)
5231 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5232 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5233 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5240 static Elf_Internal_Sym
*
5241 get_32bit_elf_symbols (FILE * file
,
5242 Elf_Internal_Shdr
* section
,
5243 unsigned long * num_syms_return
)
5245 unsigned long number
= 0;
5246 Elf32_External_Sym
* esyms
= NULL
;
5247 Elf_External_Sym_Shndx
* shndx
= NULL
;
5248 Elf_Internal_Sym
* isyms
= NULL
;
5249 Elf_Internal_Sym
* psym
;
5252 if (section
->sh_size
== 0)
5254 if (num_syms_return
!= NULL
)
5255 * num_syms_return
= 0;
5259 /* Run some sanity checks first. */
5260 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5262 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5263 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5267 if (section
->sh_size
> current_file_size
)
5269 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5270 printable_section_name (section
), (unsigned long) section
->sh_size
);
5274 number
= section
->sh_size
/ section
->sh_entsize
;
5276 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5278 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5279 (unsigned long) section
->sh_size
,
5280 printable_section_name (section
),
5281 (unsigned long) section
->sh_entsize
);
5285 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5286 section
->sh_size
, _("symbols"));
5291 elf_section_list
* entry
;
5294 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5295 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5297 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5298 entry
->hdr
->sh_offset
,
5299 1, entry
->hdr
->sh_size
,
5300 _("symbol table section indicies"));
5303 /* PR17531: file: heap-buffer-overflow */
5304 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5306 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5307 printable_section_name (entry
->hdr
),
5308 (unsigned long) entry
->hdr
->sh_size
,
5309 (unsigned long) section
->sh_size
);
5315 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5319 error (_("Out of memory reading %lu symbols\n"),
5320 (unsigned long) number
);
5324 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5326 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5327 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5328 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5329 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5330 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5332 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5333 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5334 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5335 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5336 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5345 if (num_syms_return
!= NULL
)
5346 * num_syms_return
= isyms
== NULL
? 0 : number
;
5351 static Elf_Internal_Sym
*
5352 get_64bit_elf_symbols (FILE * file
,
5353 Elf_Internal_Shdr
* section
,
5354 unsigned long * num_syms_return
)
5356 unsigned long number
= 0;
5357 Elf64_External_Sym
* esyms
= NULL
;
5358 Elf_External_Sym_Shndx
* shndx
= NULL
;
5359 Elf_Internal_Sym
* isyms
= NULL
;
5360 Elf_Internal_Sym
* psym
;
5363 if (section
->sh_size
== 0)
5365 if (num_syms_return
!= NULL
)
5366 * num_syms_return
= 0;
5370 /* Run some sanity checks first. */
5371 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5373 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5374 printable_section_name (section
),
5375 (unsigned long) section
->sh_entsize
);
5379 if (section
->sh_size
> current_file_size
)
5381 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5382 printable_section_name (section
),
5383 (unsigned long) section
->sh_size
);
5387 number
= section
->sh_size
/ section
->sh_entsize
;
5389 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5391 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5392 (unsigned long) section
->sh_size
,
5393 printable_section_name (section
),
5394 (unsigned long) section
->sh_entsize
);
5398 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5399 section
->sh_size
, _("symbols"));
5404 elf_section_list
* entry
;
5407 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5408 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5410 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5411 entry
->hdr
->sh_offset
,
5412 1, entry
->hdr
->sh_size
,
5413 _("symbol table section indicies"));
5416 /* PR17531: file: heap-buffer-overflow */
5417 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5419 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5420 printable_section_name (entry
->hdr
),
5421 (unsigned long) entry
->hdr
->sh_size
,
5422 (unsigned long) section
->sh_size
);
5428 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5432 error (_("Out of memory reading %lu symbols\n"),
5433 (unsigned long) number
);
5437 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5439 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5440 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5441 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5442 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5444 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5446 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5447 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5448 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5450 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5451 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5460 if (num_syms_return
!= NULL
)
5461 * num_syms_return
= isyms
== NULL
? 0 : number
;
5467 get_elf_section_flags (bfd_vma sh_flags
)
5469 static char buff
[1024];
5471 int field_size
= is_32bit_elf
? 8 : 16;
5473 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5474 bfd_vma os_flags
= 0;
5475 bfd_vma proc_flags
= 0;
5476 bfd_vma unknown_flags
= 0;
5484 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5485 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5486 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5487 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5488 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5489 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5490 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5491 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5492 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5493 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5494 /* IA-64 specific. */
5495 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5496 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5497 /* IA-64 OpenVMS specific. */
5498 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5499 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5500 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5501 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5502 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5503 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5505 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5506 /* SPARC specific. */
5507 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5508 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5510 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5511 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5512 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5515 if (do_section_details
)
5517 sprintf (buff
, "[%*.*lx]: ",
5518 field_size
, field_size
, (unsigned long) sh_flags
);
5519 p
+= field_size
+ 4;
5526 flag
= sh_flags
& - sh_flags
;
5529 if (do_section_details
)
5533 case SHF_WRITE
: sindex
= 0; break;
5534 case SHF_ALLOC
: sindex
= 1; break;
5535 case SHF_EXECINSTR
: sindex
= 2; break;
5536 case SHF_MERGE
: sindex
= 3; break;
5537 case SHF_STRINGS
: sindex
= 4; break;
5538 case SHF_INFO_LINK
: sindex
= 5; break;
5539 case SHF_LINK_ORDER
: sindex
= 6; break;
5540 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5541 case SHF_GROUP
: sindex
= 8; break;
5542 case SHF_TLS
: sindex
= 9; break;
5543 case SHF_EXCLUDE
: sindex
= 18; break;
5544 case SHF_COMPRESSED
: sindex
= 20; break;
5548 switch (elf_header
.e_machine
)
5551 if (flag
== SHF_IA_64_SHORT
)
5553 else if (flag
== SHF_IA_64_NORECOV
)
5556 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5559 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5560 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5561 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5562 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5563 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5564 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5575 case EM_OLD_SPARCV9
:
5576 case EM_SPARC32PLUS
:
5579 if (flag
== SHF_ORDERED
)
5586 case SHF_ENTRYSECT
: sindex
= 21; break;
5587 case SHF_ARM_PURECODE
: sindex
= 22; break;
5588 case SHF_COMDEF
: sindex
= 23; break;
5600 if (p
!= buff
+ field_size
+ 4)
5602 if (size
< (10 + 2))
5604 warn (_("Internal error: not enough buffer room for section flag info"));
5605 return _("<unknown>");
5612 size
-= flags
[sindex
].len
;
5613 p
= stpcpy (p
, flags
[sindex
].str
);
5615 else if (flag
& SHF_MASKOS
)
5617 else if (flag
& SHF_MASKPROC
)
5620 unknown_flags
|= flag
;
5626 case SHF_WRITE
: *p
= 'W'; break;
5627 case SHF_ALLOC
: *p
= 'A'; break;
5628 case SHF_EXECINSTR
: *p
= 'X'; break;
5629 case SHF_MERGE
: *p
= 'M'; break;
5630 case SHF_STRINGS
: *p
= 'S'; break;
5631 case SHF_INFO_LINK
: *p
= 'I'; break;
5632 case SHF_LINK_ORDER
: *p
= 'L'; break;
5633 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5634 case SHF_GROUP
: *p
= 'G'; break;
5635 case SHF_TLS
: *p
= 'T'; break;
5636 case SHF_EXCLUDE
: *p
= 'E'; break;
5637 case SHF_COMPRESSED
: *p
= 'C'; break;
5640 if ((elf_header
.e_machine
== EM_X86_64
5641 || elf_header
.e_machine
== EM_L1OM
5642 || elf_header
.e_machine
== EM_K1OM
)
5643 && flag
== SHF_X86_64_LARGE
)
5645 else if (elf_header
.e_machine
== EM_ARM
5646 && flag
== SHF_ARM_PURECODE
)
5648 else if (flag
& SHF_MASKOS
)
5651 sh_flags
&= ~ SHF_MASKOS
;
5653 else if (flag
& SHF_MASKPROC
)
5656 sh_flags
&= ~ SHF_MASKPROC
;
5666 if (do_section_details
)
5670 size
-= 5 + field_size
;
5671 if (p
!= buff
+ field_size
+ 4)
5675 warn (_("Internal error: not enough buffer room for section flag info"));
5676 return _("<unknown>");
5682 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5683 (unsigned long) os_flags
);
5684 p
+= 5 + field_size
;
5688 size
-= 7 + field_size
;
5689 if (p
!= buff
+ field_size
+ 4)
5693 warn (_("Internal error: not enough buffer room for section flag info"));
5694 return _("<unknown>");
5700 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5701 (unsigned long) proc_flags
);
5702 p
+= 7 + field_size
;
5706 size
-= 10 + field_size
;
5707 if (p
!= buff
+ field_size
+ 4)
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5718 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5719 (unsigned long) unknown_flags
);
5720 p
+= 10 + field_size
;
5729 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5733 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5735 if (size
< sizeof (* echdr
))
5737 error (_("Compressed section is too small even for a compression header\n"));
5741 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5742 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5743 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5744 return sizeof (*echdr
);
5748 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5750 if (size
< sizeof (* echdr
))
5752 error (_("Compressed section is too small even for a compression header\n"));
5756 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5757 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5758 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5759 return sizeof (*echdr
);
5764 process_section_headers (FILE * file
)
5766 Elf_Internal_Shdr
* section
;
5769 section_headers
= NULL
;
5771 if (elf_header
.e_shnum
== 0)
5773 /* PR binutils/12467. */
5774 if (elf_header
.e_shoff
!= 0)
5775 warn (_("possibly corrupt ELF file header - it has a non-zero"
5776 " section header offset, but no section headers\n"));
5777 else if (do_sections
)
5778 printf (_("\nThere are no sections in this file.\n"));
5783 if (do_sections
&& !do_header
)
5784 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5785 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5789 if (! get_32bit_section_headers (file
, FALSE
))
5792 else if (! get_64bit_section_headers (file
, FALSE
))
5795 /* Read in the string table, so that we have names to display. */
5796 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5797 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5799 section
= section_headers
+ elf_header
.e_shstrndx
;
5801 if (section
->sh_size
!= 0)
5803 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5804 1, section
->sh_size
,
5807 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5811 /* Scan the sections for the dynamic symbol table
5812 and dynamic string table and debug sections. */
5813 dynamic_symbols
= NULL
;
5814 dynamic_strings
= NULL
;
5815 dynamic_syminfo
= NULL
;
5816 symtab_shndx_list
= NULL
;
5818 eh_addr_size
= is_32bit_elf
? 4 : 8;
5819 switch (elf_header
.e_machine
)
5822 case EM_MIPS_RS3_LE
:
5823 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5824 FDE addresses. However, the ABI also has a semi-official ILP32
5825 variant for which the normal FDE address size rules apply.
5827 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5828 section, where XX is the size of longs in bits. Unfortunately,
5829 earlier compilers provided no way of distinguishing ILP32 objects
5830 from LP64 objects, so if there's any doubt, we should assume that
5831 the official LP64 form is being used. */
5832 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5833 && find_section (".gcc_compiled_long32") == NULL
)
5839 switch (elf_header
.e_flags
& EF_H8_MACH
)
5841 case E_H8_MACH_H8300
:
5842 case E_H8_MACH_H8300HN
:
5843 case E_H8_MACH_H8300SN
:
5844 case E_H8_MACH_H8300SXN
:
5847 case E_H8_MACH_H8300H
:
5848 case E_H8_MACH_H8300S
:
5849 case E_H8_MACH_H8300SX
:
5857 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5859 case EF_M32C_CPU_M16C
:
5866 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5869 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5870 if (section->sh_entsize != expected_entsize) \
5873 sprintf_vma (buf, section->sh_entsize); \
5874 /* Note: coded this way so that there is a single string for \
5876 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5877 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5878 (unsigned) expected_entsize); \
5879 section->sh_entsize = expected_entsize; \
5884 #define CHECK_ENTSIZE(section, i, type) \
5885 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5886 sizeof (Elf64_External_##type))
5888 for (i
= 0, section
= section_headers
;
5889 i
< elf_header
.e_shnum
;
5892 char * name
= SECTION_NAME (section
);
5894 if (section
->sh_type
== SHT_DYNSYM
)
5896 if (dynamic_symbols
!= NULL
)
5898 error (_("File contains multiple dynamic symbol tables\n"));
5902 CHECK_ENTSIZE (section
, i
, Sym
);
5903 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5905 else if (section
->sh_type
== SHT_STRTAB
5906 && streq (name
, ".dynstr"))
5908 if (dynamic_strings
!= NULL
)
5910 error (_("File contains multiple dynamic string tables\n"));
5914 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5915 1, section
->sh_size
,
5916 _("dynamic strings"));
5917 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5919 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5921 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5922 entry
->hdr
= section
;
5923 entry
->next
= symtab_shndx_list
;
5924 symtab_shndx_list
= entry
;
5926 else if (section
->sh_type
== SHT_SYMTAB
)
5927 CHECK_ENTSIZE (section
, i
, Sym
);
5928 else if (section
->sh_type
== SHT_GROUP
)
5929 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5930 else if (section
->sh_type
== SHT_REL
)
5931 CHECK_ENTSIZE (section
, i
, Rel
);
5932 else if (section
->sh_type
== SHT_RELA
)
5933 CHECK_ENTSIZE (section
, i
, Rela
);
5934 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5935 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5936 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5937 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5938 || do_debug_addr
|| do_debug_cu_index
)
5939 && (const_strneq (name
, ".debug_")
5940 || const_strneq (name
, ".zdebug_")))
5943 name
+= sizeof (".zdebug_") - 1;
5945 name
+= sizeof (".debug_") - 1;
5948 || (do_debug_info
&& const_strneq (name
, "info"))
5949 || (do_debug_info
&& const_strneq (name
, "types"))
5950 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5951 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5952 || (do_debug_lines
&& const_strneq (name
, "line."))
5953 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5954 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5955 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5956 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5957 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5958 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5959 || (do_debug_frames
&& const_strneq (name
, "frame"))
5960 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5961 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5962 || (do_debug_str
&& const_strneq (name
, "str"))
5963 || (do_debug_loc
&& const_strneq (name
, "loc"))
5964 || (do_debug_addr
&& const_strneq (name
, "addr"))
5965 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5966 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5968 request_dump_bynumber (i
, DEBUG_DUMP
);
5970 /* Linkonce section to be combined with .debug_info at link time. */
5971 else if ((do_debugging
|| do_debug_info
)
5972 && const_strneq (name
, ".gnu.linkonce.wi."))
5973 request_dump_bynumber (i
, DEBUG_DUMP
);
5974 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5975 request_dump_bynumber (i
, DEBUG_DUMP
);
5976 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5977 request_dump_bynumber (i
, DEBUG_DUMP
);
5978 /* Trace sections for Itanium VMS. */
5979 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5980 || do_trace_aranges
)
5981 && const_strneq (name
, ".trace_"))
5983 name
+= sizeof (".trace_") - 1;
5986 || (do_trace_info
&& streq (name
, "info"))
5987 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5988 || (do_trace_aranges
&& streq (name
, "aranges"))
5990 request_dump_bynumber (i
, DEBUG_DUMP
);
5997 if (elf_header
.e_shnum
> 1)
5998 printf (_("\nSection Headers:\n"));
6000 printf (_("\nSection Header:\n"));
6004 if (do_section_details
)
6006 printf (_(" [Nr] Name\n"));
6007 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6011 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6015 if (do_section_details
)
6017 printf (_(" [Nr] Name\n"));
6018 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6022 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6026 if (do_section_details
)
6028 printf (_(" [Nr] Name\n"));
6029 printf (_(" Type Address Offset Link\n"));
6030 printf (_(" Size EntSize Info Align\n"));
6034 printf (_(" [Nr] Name Type Address Offset\n"));
6035 printf (_(" Size EntSize Flags Link Info Align\n"));
6039 if (do_section_details
)
6040 printf (_(" Flags\n"));
6042 for (i
= 0, section
= section_headers
;
6043 i
< elf_header
.e_shnum
;
6046 /* Run some sanity checks on the section header. */
6048 /* Check the sh_link field. */
6049 switch (section
->sh_type
)
6051 case SHT_SYMTAB_SHNDX
:
6055 case SHT_GNU_versym
:
6058 if (section
->sh_link
< 1
6059 || section
->sh_link
>= elf_header
.e_shnum
6060 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6061 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6062 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6063 i
, section
->sh_link
);
6069 case SHT_GNU_verneed
:
6070 case SHT_GNU_verdef
:
6071 case SHT_GNU_LIBLIST
:
6072 if (section
->sh_link
< 1
6073 || section
->sh_link
>= elf_header
.e_shnum
6074 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6075 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6076 i
, section
->sh_link
);
6079 case SHT_INIT_ARRAY
:
6080 case SHT_FINI_ARRAY
:
6081 case SHT_PREINIT_ARRAY
:
6082 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6083 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6084 i
, section
->sh_link
);
6088 /* FIXME: Add support for target specific section types. */
6089 #if 0 /* Currently we do not check other section types as there are too
6090 many special cases. Stab sections for example have a type
6091 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6093 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6094 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6095 i
, section
->sh_link
);
6100 /* Check the sh_info field. */
6101 switch (section
->sh_type
)
6105 if (section
->sh_info
< 1
6106 || section
->sh_info
>= elf_header
.e_shnum
6107 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6108 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6109 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6110 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6111 /* FIXME: Are other section types valid ? */
6112 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6114 if (section
->sh_info
== 0
6115 && (streq (SECTION_NAME (section
), ".rel.dyn")
6116 || streq (SECTION_NAME (section
), ".rela.dyn")))
6117 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6118 of zero. The relocations in these sections may apply
6119 to many different sections. */
6122 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6123 i
, section
->sh_info
);
6129 case SHT_SYMTAB_SHNDX
:
6130 case SHT_INIT_ARRAY
:
6131 case SHT_FINI_ARRAY
:
6132 case SHT_PREINIT_ARRAY
:
6133 if (section
->sh_info
!= 0)
6134 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6135 i
, section
->sh_info
);
6141 /* A symbol index - we assume that it is valid. */
6145 /* FIXME: Add support for target specific section types. */
6146 if (section
->sh_type
== SHT_NOBITS
)
6147 /* NOBITS section headers with non-zero sh_info fields can be
6148 created when a binary is stripped of everything but its debug
6149 information. The stripped sections have their headers
6150 preserved but their types set to SHT_NOBITS. So do not check
6151 this type of section. */
6153 else if (section
->sh_flags
& SHF_INFO_LINK
)
6155 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6156 warn (_("[%2u]: Expected link to another section in info field"), i
);
6158 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6159 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6160 i
, section
->sh_info
);
6164 printf (" [%2u] ", i
);
6165 if (do_section_details
)
6166 printf ("%s\n ", printable_section_name (section
));
6168 print_symbol (-17, SECTION_NAME (section
));
6170 printf (do_wide
? " %-15s " : " %-15.15s ",
6171 get_section_type_name (section
->sh_type
));
6175 const char * link_too_big
= NULL
;
6177 print_vma (section
->sh_addr
, LONG_HEX
);
6179 printf ( " %6.6lx %6.6lx %2.2lx",
6180 (unsigned long) section
->sh_offset
,
6181 (unsigned long) section
->sh_size
,
6182 (unsigned long) section
->sh_entsize
);
6184 if (do_section_details
)
6185 fputs (" ", stdout
);
6187 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6189 if (section
->sh_link
>= elf_header
.e_shnum
)
6192 /* The sh_link value is out of range. Normally this indicates
6193 an error but it can have special values in Solaris binaries. */
6194 switch (elf_header
.e_machine
)
6201 case EM_OLD_SPARCV9
:
6202 case EM_SPARC32PLUS
:
6205 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6206 link_too_big
= "BEFORE";
6207 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6208 link_too_big
= "AFTER";
6215 if (do_section_details
)
6217 if (link_too_big
!= NULL
&& * link_too_big
)
6218 printf ("<%s> ", link_too_big
);
6220 printf ("%2u ", section
->sh_link
);
6221 printf ("%3u %2lu\n", section
->sh_info
,
6222 (unsigned long) section
->sh_addralign
);
6225 printf ("%2u %3u %2lu\n",
6228 (unsigned long) section
->sh_addralign
);
6230 if (link_too_big
&& ! * link_too_big
)
6231 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6232 i
, section
->sh_link
);
6236 print_vma (section
->sh_addr
, LONG_HEX
);
6238 if ((long) section
->sh_offset
== section
->sh_offset
)
6239 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6243 print_vma (section
->sh_offset
, LONG_HEX
);
6246 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6247 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6251 print_vma (section
->sh_size
, LONG_HEX
);
6254 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6255 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6259 print_vma (section
->sh_entsize
, LONG_HEX
);
6262 if (do_section_details
)
6263 fputs (" ", stdout
);
6265 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6267 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6269 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6270 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6273 print_vma (section
->sh_addralign
, DEC
);
6277 else if (do_section_details
)
6279 printf (" %-15.15s ",
6280 get_section_type_name (section
->sh_type
));
6281 print_vma (section
->sh_addr
, LONG_HEX
);
6282 if ((long) section
->sh_offset
== section
->sh_offset
)
6283 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6287 print_vma (section
->sh_offset
, LONG_HEX
);
6289 printf (" %u\n ", section
->sh_link
);
6290 print_vma (section
->sh_size
, LONG_HEX
);
6292 print_vma (section
->sh_entsize
, LONG_HEX
);
6294 printf (" %-16u %lu\n",
6296 (unsigned long) section
->sh_addralign
);
6301 print_vma (section
->sh_addr
, LONG_HEX
);
6302 if ((long) section
->sh_offset
== section
->sh_offset
)
6303 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6307 print_vma (section
->sh_offset
, LONG_HEX
);
6310 print_vma (section
->sh_size
, LONG_HEX
);
6312 print_vma (section
->sh_entsize
, LONG_HEX
);
6314 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6316 printf (" %2u %3u %lu\n",
6319 (unsigned long) section
->sh_addralign
);
6322 if (do_section_details
)
6324 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6325 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6327 /* Minimum section size is 12 bytes for 32-bit compression
6328 header + 12 bytes for compressed data header. */
6329 unsigned char buf
[24];
6331 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6332 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6333 sizeof (buf
), _("compression header")))
6335 Elf_Internal_Chdr chdr
;
6337 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6339 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6342 printf (_(" [<unknown>: 0x%x], "),
6344 print_vma (chdr
.ch_size
, LONG_HEX
);
6345 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6351 if (!do_section_details
)
6353 /* The ordering of the letters shown here matches the ordering of the
6354 corresponding SHF_xxx values, and hence the order in which these
6355 letters will be displayed to the user. */
6356 printf (_("Key to Flags:\n\
6357 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6358 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6359 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6360 if (elf_header
.e_machine
== EM_X86_64
6361 || elf_header
.e_machine
== EM_L1OM
6362 || elf_header
.e_machine
== EM_K1OM
)
6363 printf (_("l (large), "));
6364 else if (elf_header
.e_machine
== EM_ARM
)
6365 printf (_("y (purecode), "));
6366 printf ("p (processor specific)\n");
6373 get_group_flags (unsigned int flags
)
6375 static char buff
[128];
6379 else if (flags
== GRP_COMDAT
)
6382 snprintf (buff
, 14, _("[0x%x: "), flags
);
6384 flags
&= ~ GRP_COMDAT
;
6385 if (flags
& GRP_MASKOS
)
6387 strcat (buff
, "<OS specific>");
6388 flags
&= ~ GRP_MASKOS
;
6391 if (flags
& GRP_MASKPROC
)
6393 strcat (buff
, "<PROC specific>");
6394 flags
&= ~ GRP_MASKPROC
;
6398 strcat (buff
, "<unknown>");
6405 process_section_groups (FILE * file
)
6407 Elf_Internal_Shdr
* section
;
6409 struct group
* group
;
6410 Elf_Internal_Shdr
* symtab_sec
;
6411 Elf_Internal_Shdr
* strtab_sec
;
6412 Elf_Internal_Sym
* symtab
;
6413 unsigned long num_syms
;
6417 /* Don't process section groups unless needed. */
6418 if (!do_unwind
&& !do_section_groups
)
6421 if (elf_header
.e_shnum
== 0)
6423 if (do_section_groups
)
6424 printf (_("\nThere are no sections to group in this file.\n"));
6429 if (section_headers
== NULL
)
6431 error (_("Section headers are not available!\n"));
6432 /* PR 13622: This can happen with a corrupt ELF header. */
6436 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6437 sizeof (struct group
*));
6439 if (section_headers_groups
== NULL
)
6441 error (_("Out of memory reading %u section group headers\n"),
6442 elf_header
.e_shnum
);
6446 /* Scan the sections for the group section. */
6448 for (i
= 0, section
= section_headers
;
6449 i
< elf_header
.e_shnum
;
6451 if (section
->sh_type
== SHT_GROUP
)
6454 if (group_count
== 0)
6456 if (do_section_groups
)
6457 printf (_("\nThere are no section groups in this file.\n"));
6462 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6464 if (section_groups
== NULL
)
6466 error (_("Out of memory reading %lu groups\n"),
6467 (unsigned long) group_count
);
6477 for (i
= 0, section
= section_headers
, group
= section_groups
;
6478 i
< elf_header
.e_shnum
;
6481 if (section
->sh_type
== SHT_GROUP
)
6483 const char * name
= printable_section_name (section
);
6484 const char * group_name
;
6485 unsigned char * start
;
6486 unsigned char * indices
;
6487 unsigned int entry
, j
, size
;
6488 Elf_Internal_Shdr
* sec
;
6489 Elf_Internal_Sym
* sym
;
6491 /* Get the symbol table. */
6492 if (section
->sh_link
>= elf_header
.e_shnum
6493 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6496 error (_("Bad sh_link in group section `%s'\n"), name
);
6500 if (symtab_sec
!= sec
)
6505 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6510 error (_("Corrupt header in group section `%s'\n"), name
);
6514 if (section
->sh_info
>= num_syms
)
6516 error (_("Bad sh_info in group section `%s'\n"), name
);
6520 sym
= symtab
+ section
->sh_info
;
6522 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6524 if (sym
->st_shndx
== 0
6525 || sym
->st_shndx
>= elf_header
.e_shnum
)
6527 error (_("Bad sh_info in group section `%s'\n"), name
);
6531 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6540 /* Get the string table. */
6541 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6550 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6556 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6557 1, strtab_sec
->sh_size
,
6559 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6561 group_name
= sym
->st_name
< strtab_size
6562 ? strtab
+ sym
->st_name
: _("<corrupt>");
6565 /* PR 17531: file: loop. */
6566 if (section
->sh_entsize
> section
->sh_size
)
6568 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6569 printable_section_name (section
),
6570 (unsigned long) section
->sh_entsize
,
6571 (unsigned long) section
->sh_size
);
6575 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6576 1, section
->sh_size
,
6582 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6583 entry
= byte_get (indices
, 4);
6586 if (do_section_groups
)
6588 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6589 get_group_flags (entry
), i
, name
, group_name
, size
);
6591 printf (_(" [Index] Name\n"));
6594 group
->group_index
= i
;
6596 for (j
= 0; j
< size
; j
++)
6598 struct group_list
* g
;
6600 entry
= byte_get (indices
, 4);
6603 if (entry
>= elf_header
.e_shnum
)
6605 static unsigned num_group_errors
= 0;
6607 if (num_group_errors
++ < 10)
6609 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6610 entry
, i
, elf_header
.e_shnum
- 1);
6611 if (num_group_errors
== 10)
6612 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6617 if (section_headers_groups
[entry
] != NULL
)
6621 static unsigned num_errs
= 0;
6623 if (num_errs
++ < 10)
6625 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6627 section_headers_groups
[entry
]->group_index
);
6629 warn (_("Further error messages about already contained group sections suppressed\n"));
6635 /* Intel C/C++ compiler may put section 0 in a
6636 section group. We just warn it the first time
6637 and ignore it afterwards. */
6638 static int warned
= 0;
6641 error (_("section 0 in group section [%5u]\n"),
6642 section_headers_groups
[entry
]->group_index
);
6648 section_headers_groups
[entry
] = group
;
6650 if (do_section_groups
)
6652 sec
= section_headers
+ entry
;
6653 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6656 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6657 g
->section_index
= entry
;
6658 g
->next
= group
->root
;
6676 /* Data used to display dynamic fixups. */
6678 struct ia64_vms_dynfixup
6680 bfd_vma needed_ident
; /* Library ident number. */
6681 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6682 bfd_vma fixup_needed
; /* Index of the library. */
6683 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6684 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6687 /* Data used to display dynamic relocations. */
6689 struct ia64_vms_dynimgrela
6691 bfd_vma img_rela_cnt
; /* Number of relocations. */
6692 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6695 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6699 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6700 const char *strtab
, unsigned int strtab_sz
)
6702 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6704 const char *lib_name
;
6706 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6707 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6708 _("dynamic section image fixups"));
6712 if (fixup
->needed
< strtab_sz
)
6713 lib_name
= strtab
+ fixup
->needed
;
6716 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6717 (unsigned long) fixup
->needed
);
6720 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6721 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6723 (_("Seg Offset Type SymVec DataType\n"));
6725 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6730 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6731 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6732 type
= BYTE_GET (imfs
[i
].type
);
6733 rtype
= elf_ia64_reloc_type (type
);
6735 printf (" 0x%08x ", type
);
6737 printf (" %-32s ", rtype
);
6738 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6739 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6745 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6748 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6750 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6753 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6754 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6755 _("dynamic section image relocations"));
6759 printf (_("\nImage relocs\n"));
6761 (_("Seg Offset Type Addend Seg Sym Off\n"));
6763 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6768 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6769 printf ("%08" BFD_VMA_FMT
"x ",
6770 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6771 type
= BYTE_GET (imrs
[i
].type
);
6772 rtype
= elf_ia64_reloc_type (type
);
6774 printf ("0x%08x ", type
);
6776 printf ("%-31s ", rtype
);
6777 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6778 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6779 printf ("%08" BFD_VMA_FMT
"x\n",
6780 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6786 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6789 process_ia64_vms_dynamic_relocs (FILE *file
)
6791 struct ia64_vms_dynfixup fixup
;
6792 struct ia64_vms_dynimgrela imgrela
;
6793 Elf_Internal_Dyn
*entry
;
6795 bfd_vma strtab_off
= 0;
6796 bfd_vma strtab_sz
= 0;
6797 char *strtab
= NULL
;
6799 memset (&fixup
, 0, sizeof (fixup
));
6800 memset (&imgrela
, 0, sizeof (imgrela
));
6802 /* Note: the order of the entries is specified by the OpenVMS specs. */
6803 for (entry
= dynamic_section
;
6804 entry
< dynamic_section
+ dynamic_nent
;
6807 switch (entry
->d_tag
)
6809 case DT_IA_64_VMS_STRTAB_OFFSET
:
6810 strtab_off
= entry
->d_un
.d_val
;
6813 strtab_sz
= entry
->d_un
.d_val
;
6815 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6816 1, strtab_sz
, _("dynamic string section"));
6819 case DT_IA_64_VMS_NEEDED_IDENT
:
6820 fixup
.needed_ident
= entry
->d_un
.d_val
;
6823 fixup
.needed
= entry
->d_un
.d_val
;
6825 case DT_IA_64_VMS_FIXUP_NEEDED
:
6826 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6828 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6829 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6831 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6832 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6834 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6837 case DT_IA_64_VMS_IMG_RELA_CNT
:
6838 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6840 case DT_IA_64_VMS_IMG_RELA_OFF
:
6841 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6843 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6863 } dynamic_relocations
[] =
6865 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6866 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6867 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6870 /* Process the reloc section. */
6873 process_relocs (FILE * file
)
6875 unsigned long rel_size
;
6876 unsigned long rel_offset
;
6882 if (do_using_dynamic
)
6886 int has_dynamic_reloc
;
6889 has_dynamic_reloc
= 0;
6891 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6893 is_rela
= dynamic_relocations
[i
].rela
;
6894 name
= dynamic_relocations
[i
].name
;
6895 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6896 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6898 has_dynamic_reloc
|= rel_size
;
6900 if (is_rela
== UNKNOWN
)
6902 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6903 switch (dynamic_info
[DT_PLTREL
])
6917 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6918 name
, rel_offset
, rel_size
);
6920 dump_relocations (file
,
6921 offset_from_vma (file
, rel_offset
, rel_size
),
6923 dynamic_symbols
, num_dynamic_syms
,
6924 dynamic_strings
, dynamic_strings_length
,
6930 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6932 if (! has_dynamic_reloc
)
6933 printf (_("\nThere are no dynamic relocations in this file.\n"));
6937 Elf_Internal_Shdr
* section
;
6941 for (i
= 0, section
= section_headers
;
6942 i
< elf_header
.e_shnum
;
6945 if ( section
->sh_type
!= SHT_RELA
6946 && section
->sh_type
!= SHT_REL
)
6949 rel_offset
= section
->sh_offset
;
6950 rel_size
= section
->sh_size
;
6954 Elf_Internal_Shdr
* strsec
;
6957 printf (_("\nRelocation section "));
6959 if (string_table
== NULL
)
6960 printf ("%d", section
->sh_name
);
6962 printf ("'%s'", printable_section_name (section
));
6964 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6965 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6967 is_rela
= section
->sh_type
== SHT_RELA
;
6969 if (section
->sh_link
!= 0
6970 && section
->sh_link
< elf_header
.e_shnum
)
6972 Elf_Internal_Shdr
* symsec
;
6973 Elf_Internal_Sym
* symtab
;
6974 unsigned long nsyms
;
6975 unsigned long strtablen
= 0;
6976 char * strtab
= NULL
;
6978 symsec
= section_headers
+ section
->sh_link
;
6979 if (symsec
->sh_type
!= SHT_SYMTAB
6980 && symsec
->sh_type
!= SHT_DYNSYM
)
6983 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6988 if (symsec
->sh_link
!= 0
6989 && symsec
->sh_link
< elf_header
.e_shnum
)
6991 strsec
= section_headers
+ symsec
->sh_link
;
6993 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6996 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6999 dump_relocations (file
, rel_offset
, rel_size
,
7000 symtab
, nsyms
, strtab
, strtablen
,
7002 symsec
->sh_type
== SHT_DYNSYM
);
7008 dump_relocations (file
, rel_offset
, rel_size
,
7009 NULL
, 0, NULL
, 0, is_rela
, 0);
7016 printf (_("\nThere are no relocations in this file.\n"));
7022 /* An absolute address consists of a section and an offset. If the
7023 section is NULL, the offset itself is the address, otherwise, the
7024 address equals to LOAD_ADDRESS(section) + offset. */
7028 unsigned short section
;
7032 #define ABSADDR(a) \
7034 ? section_headers [(a).section].sh_addr + (a).offset \
7037 /* Find the nearest symbol at or below ADDR. Returns the symbol
7038 name, if found, and the offset from the symbol to ADDR. */
7041 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7042 unsigned long nsyms
,
7043 const char * strtab
,
7044 unsigned long strtab_size
,
7045 struct absaddr addr
,
7046 const char ** symname
,
7049 bfd_vma dist
= 0x100000;
7050 Elf_Internal_Sym
* sym
;
7051 Elf_Internal_Sym
* beg
;
7052 Elf_Internal_Sym
* end
;
7053 Elf_Internal_Sym
* best
= NULL
;
7055 REMOVE_ARCH_BITS (addr
.offset
);
7057 end
= symtab
+ nsyms
;
7063 sym
= beg
+ (end
- beg
) / 2;
7065 value
= sym
->st_value
;
7066 REMOVE_ARCH_BITS (value
);
7068 if (sym
->st_name
!= 0
7069 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7070 && addr
.offset
>= value
7071 && addr
.offset
- value
< dist
)
7074 dist
= addr
.offset
- value
;
7079 if (addr
.offset
< value
)
7087 *symname
= (best
->st_name
>= strtab_size
7088 ? _("<corrupt>") : strtab
+ best
->st_name
);
7094 *offset
= addr
.offset
;
7098 symcmp (const void *p
, const void *q
)
7100 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7101 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7103 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7106 /* Process the unwind section. */
7108 #include "unwind-ia64.h"
7110 struct ia64_unw_table_entry
7112 struct absaddr start
;
7114 struct absaddr info
;
7117 struct ia64_unw_aux_info
7119 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7120 unsigned long table_len
; /* Length of unwind table. */
7121 unsigned char * info
; /* Unwind info. */
7122 unsigned long info_size
; /* Size of unwind info. */
7123 bfd_vma info_addr
; /* Starting address of unwind info. */
7124 bfd_vma seg_base
; /* Starting address of segment. */
7125 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7126 unsigned long nsyms
; /* Number of symbols. */
7127 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7128 unsigned long nfuns
; /* Number of entries in funtab. */
7129 char * strtab
; /* The string table. */
7130 unsigned long strtab_size
; /* Size of string table. */
7134 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7136 struct ia64_unw_table_entry
* tp
;
7137 unsigned long j
, nfuns
;
7140 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7141 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7142 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7143 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7145 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7147 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7151 const unsigned char * dp
;
7152 const unsigned char * head
;
7153 const unsigned char * end
;
7154 const char * procname
;
7156 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7157 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7159 fputs ("\n<", stdout
);
7163 fputs (procname
, stdout
);
7166 printf ("+%lx", (unsigned long) offset
);
7169 fputs (">: [", stdout
);
7170 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7171 fputc ('-', stdout
);
7172 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7173 printf ("], info at +0x%lx\n",
7174 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7176 /* PR 17531: file: 86232b32. */
7177 if (aux
->info
== NULL
)
7180 /* PR 17531: file: 0997b4d1. */
7181 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7183 warn (_("Invalid offset %lx in table entry %ld\n"),
7184 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7188 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7189 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7191 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7192 (unsigned) UNW_VER (stamp
),
7193 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7194 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7195 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7196 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7198 if (UNW_VER (stamp
) != 1)
7200 printf (_("\tUnknown version.\n"));
7205 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7206 /* PR 17531: file: 16ceda89. */
7207 if (end
> aux
->info
+ aux
->info_size
)
7208 end
= aux
->info
+ aux
->info_size
;
7209 for (dp
= head
+ 8; dp
< end
;)
7210 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7217 slurp_ia64_unwind_table (FILE * file
,
7218 struct ia64_unw_aux_info
* aux
,
7219 Elf_Internal_Shdr
* sec
)
7221 unsigned long size
, nrelas
, i
;
7222 Elf_Internal_Phdr
* seg
;
7223 struct ia64_unw_table_entry
* tep
;
7224 Elf_Internal_Shdr
* relsec
;
7225 Elf_Internal_Rela
* rela
;
7226 Elf_Internal_Rela
* rp
;
7227 unsigned char * table
;
7229 Elf_Internal_Sym
* sym
;
7230 const char * relname
;
7234 /* First, find the starting address of the segment that includes
7237 if (elf_header
.e_phnum
)
7239 if (! get_program_headers (file
))
7242 for (seg
= program_headers
;
7243 seg
< program_headers
+ elf_header
.e_phnum
;
7246 if (seg
->p_type
!= PT_LOAD
)
7249 if (sec
->sh_addr
>= seg
->p_vaddr
7250 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7252 aux
->seg_base
= seg
->p_vaddr
;
7258 /* Second, build the unwind table from the contents of the unwind section: */
7259 size
= sec
->sh_size
;
7260 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7265 aux
->table_len
= size
/ (3 * eh_addr_size
);
7266 aux
->table
= (struct ia64_unw_table_entry
*)
7267 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7270 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7272 tep
->start
.section
= SHN_UNDEF
;
7273 tep
->end
.section
= SHN_UNDEF
;
7274 tep
->info
.section
= SHN_UNDEF
;
7275 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7276 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7277 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7278 tep
->start
.offset
+= aux
->seg_base
;
7279 tep
->end
.offset
+= aux
->seg_base
;
7280 tep
->info
.offset
+= aux
->seg_base
;
7284 /* Third, apply any relocations to the unwind table: */
7285 for (relsec
= section_headers
;
7286 relsec
< section_headers
+ elf_header
.e_shnum
;
7289 if (relsec
->sh_type
!= SHT_RELA
7290 || relsec
->sh_info
>= elf_header
.e_shnum
7291 || section_headers
+ relsec
->sh_info
!= sec
)
7294 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7303 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7305 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7306 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7308 /* PR 17531: file: 9fa67536. */
7309 if (relname
== NULL
)
7311 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7315 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7317 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7321 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7323 /* PR 17531: file: 5bc8d9bf. */
7324 if (i
>= aux
->table_len
)
7326 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7330 switch (rp
->r_offset
/ eh_addr_size
% 3)
7333 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7334 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7337 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7338 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7341 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7342 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7356 ia64_process_unwind (FILE * file
)
7358 Elf_Internal_Shdr
* sec
;
7359 Elf_Internal_Shdr
* unwsec
= NULL
;
7360 Elf_Internal_Shdr
* strsec
;
7361 unsigned long i
, unwcount
= 0, unwstart
= 0;
7362 struct ia64_unw_aux_info aux
;
7364 memset (& aux
, 0, sizeof (aux
));
7366 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7368 if (sec
->sh_type
== SHT_SYMTAB
7369 && sec
->sh_link
< elf_header
.e_shnum
)
7371 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7373 strsec
= section_headers
+ sec
->sh_link
;
7374 if (aux
.strtab
!= NULL
)
7376 error (_("Multiple auxillary string tables encountered\n"));
7379 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7382 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7384 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7389 printf (_("\nThere are no unwind sections in this file.\n"));
7391 while (unwcount
-- > 0)
7396 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7397 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7398 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7403 /* We have already counted the number of SHT_IA64_UNWIND
7404 sections so the loop above should never fail. */
7405 assert (unwsec
!= NULL
);
7408 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7410 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7412 /* We need to find which section group it is in. */
7413 struct group_list
* g
;
7415 if (section_headers_groups
== NULL
7416 || section_headers_groups
[i
] == NULL
)
7417 i
= elf_header
.e_shnum
;
7420 g
= section_headers_groups
[i
]->root
;
7422 for (; g
!= NULL
; g
= g
->next
)
7424 sec
= section_headers
+ g
->section_index
;
7426 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7431 i
= elf_header
.e_shnum
;
7434 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7436 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7437 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7438 suffix
= SECTION_NAME (unwsec
) + len
;
7439 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7441 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7442 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7447 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7448 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7449 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7450 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7452 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7453 suffix
= SECTION_NAME (unwsec
) + len
;
7454 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7456 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7457 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7461 if (i
== elf_header
.e_shnum
)
7463 printf (_("\nCould not find unwind info section for "));
7465 if (string_table
== NULL
)
7466 printf ("%d", unwsec
->sh_name
);
7468 printf ("'%s'", printable_section_name (unwsec
));
7472 aux
.info_addr
= sec
->sh_addr
;
7473 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7476 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7478 printf (_("\nUnwind section "));
7480 if (string_table
== NULL
)
7481 printf ("%d", unwsec
->sh_name
);
7483 printf ("'%s'", printable_section_name (unwsec
));
7485 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7486 (unsigned long) unwsec
->sh_offset
,
7487 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7489 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7490 && aux
.table_len
> 0)
7491 dump_ia64_unwind (& aux
);
7494 free ((char *) aux
.table
);
7496 free ((char *) aux
.info
);
7505 free ((char *) aux
.strtab
);
7508 struct hppa_unw_table_entry
7510 struct absaddr start
;
7512 unsigned int Cannot_unwind
:1; /* 0 */
7513 unsigned int Millicode
:1; /* 1 */
7514 unsigned int Millicode_save_sr0
:1; /* 2 */
7515 unsigned int Region_description
:2; /* 3..4 */
7516 unsigned int reserved1
:1; /* 5 */
7517 unsigned int Entry_SR
:1; /* 6 */
7518 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7519 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7520 unsigned int Args_stored
:1; /* 16 */
7521 unsigned int Variable_Frame
:1; /* 17 */
7522 unsigned int Separate_Package_Body
:1; /* 18 */
7523 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7524 unsigned int Stack_Overflow_Check
:1; /* 20 */
7525 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7526 unsigned int Ada_Region
:1; /* 22 */
7527 unsigned int cxx_info
:1; /* 23 */
7528 unsigned int cxx_try_catch
:1; /* 24 */
7529 unsigned int sched_entry_seq
:1; /* 25 */
7530 unsigned int reserved2
:1; /* 26 */
7531 unsigned int Save_SP
:1; /* 27 */
7532 unsigned int Save_RP
:1; /* 28 */
7533 unsigned int Save_MRP_in_frame
:1; /* 29 */
7534 unsigned int extn_ptr_defined
:1; /* 30 */
7535 unsigned int Cleanup_defined
:1; /* 31 */
7537 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7538 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7539 unsigned int Large_frame
:1; /* 2 */
7540 unsigned int Pseudo_SP_Set
:1; /* 3 */
7541 unsigned int reserved4
:1; /* 4 */
7542 unsigned int Total_frame_size
:27; /* 5..31 */
7545 struct hppa_unw_aux_info
7547 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7548 unsigned long table_len
; /* Length of unwind table. */
7549 bfd_vma seg_base
; /* Starting address of segment. */
7550 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7551 unsigned long nsyms
; /* Number of symbols. */
7552 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7553 unsigned long nfuns
; /* Number of entries in funtab. */
7554 char * strtab
; /* The string table. */
7555 unsigned long strtab_size
; /* Size of string table. */
7559 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7561 struct hppa_unw_table_entry
* tp
;
7562 unsigned long j
, nfuns
;
7564 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7565 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7566 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7567 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7569 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7571 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7574 const char * procname
;
7576 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7577 aux
->strtab_size
, tp
->start
, &procname
,
7580 fputs ("\n<", stdout
);
7584 fputs (procname
, stdout
);
7587 printf ("+%lx", (unsigned long) offset
);
7590 fputs (">: [", stdout
);
7591 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7592 fputc ('-', stdout
);
7593 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7596 #define PF(_m) if (tp->_m) printf (#_m " ");
7597 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7600 PF(Millicode_save_sr0
);
7601 /* PV(Region_description); */
7607 PF(Separate_Package_Body
);
7608 PF(Frame_Extension_Millicode
);
7609 PF(Stack_Overflow_Check
);
7610 PF(Two_Instruction_SP_Increment
);
7614 PF(sched_entry_seq
);
7617 PF(Save_MRP_in_frame
);
7618 PF(extn_ptr_defined
);
7619 PF(Cleanup_defined
);
7620 PF(MPE_XL_interrupt_marker
);
7621 PF(HP_UX_interrupt_marker
);
7624 PV(Total_frame_size
);
7635 slurp_hppa_unwind_table (FILE * file
,
7636 struct hppa_unw_aux_info
* aux
,
7637 Elf_Internal_Shdr
* sec
)
7639 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7640 Elf_Internal_Phdr
* seg
;
7641 struct hppa_unw_table_entry
* tep
;
7642 Elf_Internal_Shdr
* relsec
;
7643 Elf_Internal_Rela
* rela
;
7644 Elf_Internal_Rela
* rp
;
7645 unsigned char * table
;
7647 Elf_Internal_Sym
* sym
;
7648 const char * relname
;
7650 /* First, find the starting address of the segment that includes
7653 if (elf_header
.e_phnum
)
7655 if (! get_program_headers (file
))
7658 for (seg
= program_headers
;
7659 seg
< program_headers
+ elf_header
.e_phnum
;
7662 if (seg
->p_type
!= PT_LOAD
)
7665 if (sec
->sh_addr
>= seg
->p_vaddr
7666 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7668 aux
->seg_base
= seg
->p_vaddr
;
7674 /* Second, build the unwind table from the contents of the unwind
7676 size
= sec
->sh_size
;
7677 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7683 nentries
= size
/ unw_ent_size
;
7684 size
= unw_ent_size
* nentries
;
7686 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7687 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7689 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7691 unsigned int tmp1
, tmp2
;
7693 tep
->start
.section
= SHN_UNDEF
;
7694 tep
->end
.section
= SHN_UNDEF
;
7696 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7697 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7698 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7699 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7701 tep
->start
.offset
+= aux
->seg_base
;
7702 tep
->end
.offset
+= aux
->seg_base
;
7704 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7705 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7706 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7707 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7708 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7709 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7710 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7711 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7712 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7713 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7714 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7715 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7716 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7717 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7718 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7719 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7720 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7721 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7722 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7723 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7724 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7725 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7726 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7727 tep
->Cleanup_defined
= tmp1
& 0x1;
7729 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7730 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7731 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7732 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7733 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7734 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7738 /* Third, apply any relocations to the unwind table. */
7739 for (relsec
= section_headers
;
7740 relsec
< section_headers
+ elf_header
.e_shnum
;
7743 if (relsec
->sh_type
!= SHT_RELA
7744 || relsec
->sh_info
>= elf_header
.e_shnum
7745 || section_headers
+ relsec
->sh_info
!= sec
)
7748 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7752 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7754 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7755 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7757 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7758 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7760 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7764 i
= rp
->r_offset
/ unw_ent_size
;
7766 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7769 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7770 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7773 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7774 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7784 aux
->table_len
= nentries
;
7790 hppa_process_unwind (FILE * file
)
7792 struct hppa_unw_aux_info aux
;
7793 Elf_Internal_Shdr
* unwsec
= NULL
;
7794 Elf_Internal_Shdr
* strsec
;
7795 Elf_Internal_Shdr
* sec
;
7798 if (string_table
== NULL
)
7801 memset (& aux
, 0, sizeof (aux
));
7803 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7805 if (sec
->sh_type
== SHT_SYMTAB
7806 && sec
->sh_link
< elf_header
.e_shnum
)
7808 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7810 strsec
= section_headers
+ sec
->sh_link
;
7811 if (aux
.strtab
!= NULL
)
7813 error (_("Multiple auxillary string tables encountered\n"));
7816 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7819 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7821 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7826 printf (_("\nThere are no unwind sections in this file.\n"));
7828 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7830 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7832 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7833 printable_section_name (sec
),
7834 (unsigned long) sec
->sh_offset
,
7835 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7837 slurp_hppa_unwind_table (file
, &aux
, sec
);
7838 if (aux
.table_len
> 0)
7839 dump_hppa_unwind (&aux
);
7842 free ((char *) aux
.table
);
7850 free ((char *) aux
.strtab
);
7855 unsigned char * data
; /* The unwind data. */
7856 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7857 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7858 unsigned long nrelas
; /* The number of relocations. */
7859 unsigned int rel_type
; /* REL or RELA ? */
7860 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7863 struct arm_unw_aux_info
7865 FILE * file
; /* The file containing the unwind sections. */
7866 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7867 unsigned long nsyms
; /* Number of symbols. */
7868 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7869 unsigned long nfuns
; /* Number of these symbols. */
7870 char * strtab
; /* The file's string table. */
7871 unsigned long strtab_size
; /* Size of string table. */
7875 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7876 bfd_vma fn
, struct absaddr addr
)
7878 const char *procname
;
7881 if (addr
.section
== SHN_UNDEF
)
7884 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7885 aux
->strtab_size
, addr
, &procname
,
7888 print_vma (fn
, PREFIX_HEX
);
7892 fputs (" <", stdout
);
7893 fputs (procname
, stdout
);
7896 printf ("+0x%lx", (unsigned long) sym_offset
);
7897 fputc ('>', stdout
);
7904 arm_free_section (struct arm_section
*arm_sec
)
7906 if (arm_sec
->data
!= NULL
)
7907 free (arm_sec
->data
);
7909 if (arm_sec
->rela
!= NULL
)
7910 free (arm_sec
->rela
);
7913 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7914 cached section and install SEC instead.
7915 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7916 and return its valued in * WORDP, relocating if necessary.
7917 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7918 relocation's offset in ADDR.
7919 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7920 into the string table of the symbol associated with the reloc. If no
7921 reloc was applied store -1 there.
7922 5) Return TRUE upon success, FALSE otherwise. */
7925 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7926 struct arm_section
* arm_sec
,
7927 Elf_Internal_Shdr
* sec
,
7928 bfd_vma word_offset
,
7929 unsigned int * wordp
,
7930 struct absaddr
* addr
,
7933 Elf_Internal_Rela
*rp
;
7934 Elf_Internal_Sym
*sym
;
7935 const char * relname
;
7937 bfd_boolean wrapped
;
7939 if (sec
== NULL
|| arm_sec
== NULL
)
7942 addr
->section
= SHN_UNDEF
;
7945 if (sym_name
!= NULL
)
7946 *sym_name
= (bfd_vma
) -1;
7948 /* If necessary, update the section cache. */
7949 if (sec
!= arm_sec
->sec
)
7951 Elf_Internal_Shdr
*relsec
;
7953 arm_free_section (arm_sec
);
7956 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7957 sec
->sh_size
, _("unwind data"));
7958 arm_sec
->rela
= NULL
;
7959 arm_sec
->nrelas
= 0;
7961 for (relsec
= section_headers
;
7962 relsec
< section_headers
+ elf_header
.e_shnum
;
7965 if (relsec
->sh_info
>= elf_header
.e_shnum
7966 || section_headers
+ relsec
->sh_info
!= sec
7967 /* PR 15745: Check the section type as well. */
7968 || (relsec
->sh_type
!= SHT_REL
7969 && relsec
->sh_type
!= SHT_RELA
))
7972 arm_sec
->rel_type
= relsec
->sh_type
;
7973 if (relsec
->sh_type
== SHT_REL
)
7975 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7977 & arm_sec
->rela
, & arm_sec
->nrelas
))
7980 else /* relsec->sh_type == SHT_RELA */
7982 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7984 & arm_sec
->rela
, & arm_sec
->nrelas
))
7990 arm_sec
->next_rela
= arm_sec
->rela
;
7993 /* If there is no unwind data we can do nothing. */
7994 if (arm_sec
->data
== NULL
)
7997 /* If the offset is invalid then fail. */
7998 if (word_offset
> (sec
->sh_size
- 4)
8000 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
8001 || ((bfd_signed_vma
) word_offset
) < 0)
8004 /* Get the word at the required offset. */
8005 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8007 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8008 if (arm_sec
->rela
== NULL
)
8014 /* Look through the relocs to find the one that applies to the provided offset. */
8016 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8018 bfd_vma prelval
, offset
;
8020 if (rp
->r_offset
> word_offset
&& !wrapped
)
8025 if (rp
->r_offset
> word_offset
)
8028 if (rp
->r_offset
& 3)
8030 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8031 (unsigned long) rp
->r_offset
);
8035 if (rp
->r_offset
< word_offset
)
8038 /* PR 17531: file: 027-161405-0.004 */
8039 if (aux
->symtab
== NULL
)
8042 if (arm_sec
->rel_type
== SHT_REL
)
8044 offset
= word
& 0x7fffffff;
8045 if (offset
& 0x40000000)
8046 offset
|= ~ (bfd_vma
) 0x7fffffff;
8048 else if (arm_sec
->rel_type
== SHT_RELA
)
8049 offset
= rp
->r_addend
;
8052 error (_("Unknown section relocation type %d encountered\n"),
8057 /* PR 17531 file: 027-1241568-0.004. */
8058 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8060 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8061 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8065 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8066 offset
+= sym
->st_value
;
8067 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8069 /* Check that we are processing the expected reloc type. */
8070 if (elf_header
.e_machine
== EM_ARM
)
8072 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8073 if (relname
== NULL
)
8075 warn (_("Skipping unknown ARM relocation type: %d\n"),
8076 (int) ELF32_R_TYPE (rp
->r_info
));
8080 if (streq (relname
, "R_ARM_NONE"))
8083 if (! streq (relname
, "R_ARM_PREL31"))
8085 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8089 else if (elf_header
.e_machine
== EM_TI_C6000
)
8091 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8092 if (relname
== NULL
)
8094 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8095 (int) ELF32_R_TYPE (rp
->r_info
));
8099 if (streq (relname
, "R_C6000_NONE"))
8102 if (! streq (relname
, "R_C6000_PREL31"))
8104 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8112 /* This function currently only supports ARM and TI unwinders. */
8113 warn (_("Only TI and ARM unwinders are currently supported\n"));
8117 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8118 addr
->section
= sym
->st_shndx
;
8119 addr
->offset
= offset
;
8122 * sym_name
= sym
->st_name
;
8127 arm_sec
->next_rela
= rp
;
8132 static const char *tic6x_unwind_regnames
[16] =
8134 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8135 "A14", "A13", "A12", "A11", "A10",
8136 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8140 decode_tic6x_unwind_regmask (unsigned int mask
)
8144 for (i
= 12; mask
; mask
>>= 1, i
--)
8148 fputs (tic6x_unwind_regnames
[i
], stdout
);
8150 fputs (", ", stdout
);
8156 if (remaining == 0 && more_words) \
8159 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8160 data_offset, & word, & addr, NULL)) \
8166 #define GET_OP(OP) \
8171 (OP) = word >> 24; \
8176 printf (_("[Truncated opcode]\n")); \
8179 printf ("0x%02x ", OP)
8182 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8184 unsigned int remaining
,
8185 unsigned int more_words
,
8186 bfd_vma data_offset
,
8187 Elf_Internal_Shdr
* data_sec
,
8188 struct arm_section
* data_arm_sec
)
8190 struct absaddr addr
;
8192 /* Decode the unwinding instructions. */
8195 unsigned int op
, op2
;
8204 printf (" 0x%02x ", op
);
8206 if ((op
& 0xc0) == 0x00)
8208 int offset
= ((op
& 0x3f) << 2) + 4;
8210 printf (" vsp = vsp + %d", offset
);
8212 else if ((op
& 0xc0) == 0x40)
8214 int offset
= ((op
& 0x3f) << 2) + 4;
8216 printf (" vsp = vsp - %d", offset
);
8218 else if ((op
& 0xf0) == 0x80)
8221 if (op
== 0x80 && op2
== 0)
8222 printf (_("Refuse to unwind"));
8225 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8230 for (i
= 0; i
< 12; i
++)
8231 if (mask
& (1 << i
))
8237 printf ("r%d", 4 + i
);
8242 else if ((op
& 0xf0) == 0x90)
8244 if (op
== 0x9d || op
== 0x9f)
8245 printf (_(" [Reserved]"));
8247 printf (" vsp = r%d", op
& 0x0f);
8249 else if ((op
& 0xf0) == 0xa0)
8251 int end
= 4 + (op
& 0x07);
8256 for (i
= 4; i
<= end
; i
++)
8272 else if (op
== 0xb0)
8273 printf (_(" finish"));
8274 else if (op
== 0xb1)
8277 if (op2
== 0 || (op2
& 0xf0) != 0)
8278 printf (_("[Spare]"));
8281 unsigned int mask
= op2
& 0x0f;
8286 for (i
= 0; i
< 12; i
++)
8287 if (mask
& (1 << i
))
8298 else if (op
== 0xb2)
8300 unsigned char buf
[9];
8301 unsigned int i
, len
;
8302 unsigned long offset
;
8304 for (i
= 0; i
< sizeof (buf
); i
++)
8307 if ((buf
[i
] & 0x80) == 0)
8310 if (i
== sizeof (buf
))
8311 printf (_("corrupt change to vsp"));
8314 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8315 assert (len
== i
+ 1);
8316 offset
= offset
* 4 + 0x204;
8317 printf ("vsp = vsp + %ld", offset
);
8320 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8322 unsigned int first
, last
;
8329 printf ("pop {D%d", first
);
8331 printf ("-D%d", first
+ last
);
8334 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8336 unsigned int count
= op
& 0x07;
8340 printf ("-D%d", 8 + count
);
8343 else if (op
>= 0xc0 && op
<= 0xc5)
8345 unsigned int count
= op
& 0x07;
8347 printf (" pop {wR10");
8349 printf ("-wR%d", 10 + count
);
8352 else if (op
== 0xc6)
8354 unsigned int first
, last
;
8359 printf ("pop {wR%d", first
);
8361 printf ("-wR%d", first
+ last
);
8364 else if (op
== 0xc7)
8367 if (op2
== 0 || (op2
& 0xf0) != 0)
8368 printf (_("[Spare]"));
8371 unsigned int mask
= op2
& 0x0f;
8376 for (i
= 0; i
< 4; i
++)
8377 if (mask
& (1 << i
))
8383 printf ("wCGR%d", i
);
8389 printf (_(" [unsupported opcode]"));
8395 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8397 unsigned int remaining
,
8398 unsigned int more_words
,
8399 bfd_vma data_offset
,
8400 Elf_Internal_Shdr
* data_sec
,
8401 struct arm_section
* data_arm_sec
)
8403 struct absaddr addr
;
8405 /* Decode the unwinding instructions. */
8408 unsigned int op
, op2
;
8417 printf (" 0x%02x ", op
);
8419 if ((op
& 0xc0) == 0x00)
8421 int offset
= ((op
& 0x3f) << 3) + 8;
8422 printf (" sp = sp + %d", offset
);
8424 else if ((op
& 0xc0) == 0x80)
8427 if (op
== 0x80 && op2
== 0)
8428 printf (_("Refuse to unwind"));
8431 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8433 printf ("pop compact {");
8437 decode_tic6x_unwind_regmask (mask
);
8441 else if ((op
& 0xf0) == 0xc0)
8449 unsigned int offset
;
8453 /* Scan entire instruction first so that GET_OP output is not
8454 interleaved with disassembly. */
8456 for (i
= 0; nregs
< (op
& 0xf); i
++)
8462 regpos
[nregs
].offset
= i
* 2;
8463 regpos
[nregs
].reg
= reg
;
8470 regpos
[nregs
].offset
= i
* 2 + 1;
8471 regpos
[nregs
].reg
= reg
;
8476 printf (_("pop frame {"));
8478 for (i
= i
* 2; i
> 0; i
--)
8480 if (regpos
[reg
].offset
== i
- 1)
8482 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8489 fputs (name
, stdout
);
8496 else if (op
== 0xd0)
8497 printf (" MOV FP, SP");
8498 else if (op
== 0xd1)
8499 printf (" __c6xabi_pop_rts");
8500 else if (op
== 0xd2)
8502 unsigned char buf
[9];
8503 unsigned int i
, len
;
8504 unsigned long offset
;
8506 for (i
= 0; i
< sizeof (buf
); i
++)
8509 if ((buf
[i
] & 0x80) == 0)
8512 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8513 if (i
== sizeof (buf
))
8515 printf ("<corrupt sp adjust>\n");
8516 warn (_("Corrupt stack pointer adjustment detected\n"));
8520 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8521 assert (len
== i
+ 1);
8522 offset
= offset
* 8 + 0x408;
8523 printf (_("sp = sp + %ld"), offset
);
8525 else if ((op
& 0xf0) == 0xe0)
8527 if ((op
& 0x0f) == 7)
8530 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8534 printf (_(" [unsupported opcode]"));
8541 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8545 offset
= word
& 0x7fffffff;
8546 if (offset
& 0x40000000)
8547 offset
|= ~ (bfd_vma
) 0x7fffffff;
8549 if (elf_header
.e_machine
== EM_TI_C6000
)
8552 return offset
+ where
;
8556 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8558 unsigned int remaining
,
8559 bfd_vma data_offset
,
8560 Elf_Internal_Shdr
* data_sec
,
8561 struct arm_section
* data_arm_sec
)
8564 unsigned int more_words
= 0;
8565 struct absaddr addr
;
8566 bfd_vma sym_name
= (bfd_vma
) -1;
8570 /* Fetch the first word.
8571 Note - when decoding an object file the address extracted
8572 here will always be 0. So we also pass in the sym_name
8573 parameter so that we can find the symbol associated with
8574 the personality routine. */
8575 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8576 & word
, & addr
, & sym_name
))
8582 if ((word
& 0x80000000) == 0)
8584 /* Expand prel31 for personality routine. */
8586 const char *procname
;
8588 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8589 printf (_(" Personality routine: "));
8591 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8592 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8594 procname
= aux
->strtab
+ sym_name
;
8595 print_vma (fn
, PREFIX_HEX
);
8598 fputs (" <", stdout
);
8599 fputs (procname
, stdout
);
8600 fputc ('>', stdout
);
8604 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8605 fputc ('\n', stdout
);
8607 /* The GCC personality routines use the standard compact
8608 encoding, starting with one byte giving the number of
8610 if (procname
!= NULL
8611 && (const_strneq (procname
, "__gcc_personality_v0")
8612 || const_strneq (procname
, "__gxx_personality_v0")
8613 || const_strneq (procname
, "__gcj_personality_v0")
8614 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8621 printf (_(" [Truncated data]\n"));
8624 more_words
= word
>> 24;
8634 /* ARM EHABI Section 6.3:
8636 An exception-handling table entry for the compact model looks like:
8640 1 0 index Data for personalityRoutine[index] */
8642 if (elf_header
.e_machine
== EM_ARM
8643 && (word
& 0x70000000))
8644 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8646 per_index
= (word
>> 24) & 0x7f;
8647 printf (_(" Compact model index: %d\n"), per_index
);
8654 else if (per_index
< 3)
8656 more_words
= (word
>> 16) & 0xff;
8662 switch (elf_header
.e_machine
)
8667 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8668 data_offset
, data_sec
, data_arm_sec
);
8672 warn (_("Unknown ARM compact model index encountered\n"));
8673 printf (_(" [reserved]\n"));
8680 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8681 data_offset
, data_sec
, data_arm_sec
);
8683 else if (per_index
< 5)
8685 if (((word
>> 17) & 0x7f) == 0x7f)
8686 printf (_(" Restore stack from frame pointer\n"));
8688 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8689 printf (_(" Registers restored: "));
8691 printf (" (compact) ");
8692 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8694 printf (_(" Return register: %s\n"),
8695 tic6x_unwind_regnames
[word
& 0xf]);
8698 printf (_(" [reserved (%d)]\n"), per_index
);
8702 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8703 elf_header
.e_machine
);
8706 /* Decode the descriptors. Not implemented. */
8710 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8712 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8713 unsigned int i
, exidx_len
;
8714 unsigned long j
, nfuns
;
8716 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8717 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8718 exidx_len
= exidx_sec
->sh_size
/ 8;
8720 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8721 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8722 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8723 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8725 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8727 for (i
= 0; i
< exidx_len
; i
++)
8729 unsigned int exidx_fn
, exidx_entry
;
8730 struct absaddr fn_addr
, entry_addr
;
8733 fputc ('\n', stdout
);
8735 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8736 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8737 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8738 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8741 arm_free_section (& exidx_arm_sec
);
8742 arm_free_section (& extab_arm_sec
);
8746 /* ARM EHABI, Section 5:
8747 An index table entry consists of 2 words.
8748 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8749 if (exidx_fn
& 0x80000000)
8750 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8752 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8754 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8755 fputs (": ", stdout
);
8757 if (exidx_entry
== 1)
8759 print_vma (exidx_entry
, PREFIX_HEX
);
8760 fputs (" [cantunwind]\n", stdout
);
8762 else if (exidx_entry
& 0x80000000)
8764 print_vma (exidx_entry
, PREFIX_HEX
);
8765 fputc ('\n', stdout
);
8766 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8770 bfd_vma table
, table_offset
= 0;
8771 Elf_Internal_Shdr
*table_sec
;
8773 fputs ("@", stdout
);
8774 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8775 print_vma (table
, PREFIX_HEX
);
8778 /* Locate the matching .ARM.extab. */
8779 if (entry_addr
.section
!= SHN_UNDEF
8780 && entry_addr
.section
< elf_header
.e_shnum
)
8782 table_sec
= section_headers
+ entry_addr
.section
;
8783 table_offset
= entry_addr
.offset
;
8785 if (table_offset
> table_sec
->sh_size
8786 || ((bfd_signed_vma
) table_offset
) < 0)
8788 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8789 (unsigned long) table_offset
,
8790 printable_section_name (table_sec
));
8796 table_sec
= find_section_by_address (table
);
8797 if (table_sec
!= NULL
)
8798 table_offset
= table
- table_sec
->sh_addr
;
8800 if (table_sec
== NULL
)
8802 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8803 (unsigned long) table
);
8806 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8814 arm_free_section (&exidx_arm_sec
);
8815 arm_free_section (&extab_arm_sec
);
8818 /* Used for both ARM and C6X unwinding tables. */
8821 arm_process_unwind (FILE *file
)
8823 struct arm_unw_aux_info aux
;
8824 Elf_Internal_Shdr
*unwsec
= NULL
;
8825 Elf_Internal_Shdr
*strsec
;
8826 Elf_Internal_Shdr
*sec
;
8828 unsigned int sec_type
;
8830 switch (elf_header
.e_machine
)
8833 sec_type
= SHT_ARM_EXIDX
;
8837 sec_type
= SHT_C6000_UNWIND
;
8841 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8842 elf_header
.e_machine
);
8846 if (string_table
== NULL
)
8849 memset (& aux
, 0, sizeof (aux
));
8852 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8854 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8856 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8858 strsec
= section_headers
+ sec
->sh_link
;
8860 /* PR binutils/17531 file: 011-12666-0.004. */
8861 if (aux
.strtab
!= NULL
)
8863 error (_("Multiple string tables found in file.\n"));
8866 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8867 1, strsec
->sh_size
, _("string table"));
8868 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8870 else if (sec
->sh_type
== sec_type
)
8875 printf (_("\nThere are no unwind sections in this file.\n"));
8877 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8879 if (sec
->sh_type
== sec_type
)
8881 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8882 printable_section_name (sec
),
8883 (unsigned long) sec
->sh_offset
,
8884 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8886 dump_arm_unwind (&aux
, sec
);
8893 free ((char *) aux
.strtab
);
8897 process_unwind (FILE * file
)
8899 struct unwind_handler
8902 void (* handler
)(FILE *);
8905 { EM_ARM
, arm_process_unwind
},
8906 { EM_IA_64
, ia64_process_unwind
},
8907 { EM_PARISC
, hppa_process_unwind
},
8908 { EM_TI_C6000
, arm_process_unwind
},
8916 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8917 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8919 handlers
[i
].handler (file
);
8923 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8924 get_machine_name (elf_header
.e_machine
));
8928 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8930 switch (entry
->d_tag
)
8933 if (entry
->d_un
.d_val
== 0)
8937 static const char * opts
[] =
8939 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8940 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8941 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8942 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8948 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8949 if (entry
->d_un
.d_val
& (1 << cnt
))
8951 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8957 case DT_MIPS_IVERSION
:
8958 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8959 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8963 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8964 /* Note: coded this way so that there is a single string for translation. */
8965 printf (_("<corrupt: %s>"), buf
);
8969 case DT_MIPS_TIME_STAMP
:
8973 time_t atime
= entry
->d_un
.d_val
;
8975 tmp
= gmtime (&atime
);
8976 /* PR 17531: file: 6accc532. */
8978 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8980 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8981 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8982 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8983 printf (_("Time Stamp: %s"), timebuf
);
8987 case DT_MIPS_RLD_VERSION
:
8988 case DT_MIPS_LOCAL_GOTNO
:
8989 case DT_MIPS_CONFLICTNO
:
8990 case DT_MIPS_LIBLISTNO
:
8991 case DT_MIPS_SYMTABNO
:
8992 case DT_MIPS_UNREFEXTNO
:
8993 case DT_MIPS_HIPAGENO
:
8994 case DT_MIPS_DELTA_CLASS_NO
:
8995 case DT_MIPS_DELTA_INSTANCE_NO
:
8996 case DT_MIPS_DELTA_RELOC_NO
:
8997 case DT_MIPS_DELTA_SYM_NO
:
8998 case DT_MIPS_DELTA_CLASSSYM_NO
:
8999 case DT_MIPS_COMPACT_SIZE
:
9000 print_vma (entry
->d_un
.d_val
, DEC
);
9004 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9010 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9012 switch (entry
->d_tag
)
9014 case DT_HP_DLD_FLAGS
:
9023 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9024 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9025 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9026 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9027 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9028 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9029 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9030 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9031 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9032 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9033 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9034 { DT_HP_GST
, "HP_GST" },
9035 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9036 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9037 { DT_HP_NODELETE
, "HP_NODELETE" },
9038 { DT_HP_GROUP
, "HP_GROUP" },
9039 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9043 bfd_vma val
= entry
->d_un
.d_val
;
9045 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9046 if (val
& flags
[cnt
].bit
)
9050 fputs (flags
[cnt
].str
, stdout
);
9052 val
^= flags
[cnt
].bit
;
9055 if (val
!= 0 || first
)
9059 print_vma (val
, HEX
);
9065 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9073 /* VMS vs Unix time offset and factor. */
9075 #define VMS_EPOCH_OFFSET 35067168000000000LL
9076 #define VMS_GRANULARITY_FACTOR 10000000
9078 /* Display a VMS time in a human readable format. */
9081 print_vms_time (bfd_int64_t vmstime
)
9086 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9087 tm
= gmtime (&unxtime
);
9088 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9089 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9090 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9095 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9097 switch (entry
->d_tag
)
9099 case DT_IA_64_PLT_RESERVE
:
9100 /* First 3 slots reserved. */
9101 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9103 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9106 case DT_IA_64_VMS_LINKTIME
:
9108 print_vms_time (entry
->d_un
.d_val
);
9112 case DT_IA_64_VMS_LNKFLAGS
:
9113 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9114 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9115 printf (" CALL_DEBUG");
9116 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9117 printf (" NOP0BUFS");
9118 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9119 printf (" P0IMAGE");
9120 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9121 printf (" MKTHREADS");
9122 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9123 printf (" UPCALLS");
9124 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9126 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9127 printf (" INITIALIZE");
9128 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9130 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9131 printf (" EXE_INIT");
9132 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9133 printf (" TBK_IN_IMG");
9134 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9135 printf (" DBG_IN_IMG");
9136 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9137 printf (" TBK_IN_DSF");
9138 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9139 printf (" DBG_IN_DSF");
9140 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9141 printf (" SIGNATURES");
9142 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9143 printf (" REL_SEG_OFF");
9147 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9154 get_32bit_dynamic_section (FILE * file
)
9156 Elf32_External_Dyn
* edyn
;
9157 Elf32_External_Dyn
* ext
;
9158 Elf_Internal_Dyn
* entry
;
9160 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9161 dynamic_size
, _("dynamic section"));
9165 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9166 might not have the luxury of section headers. Look for the DT_NULL
9167 terminator to determine the number of entries. */
9168 for (ext
= edyn
, dynamic_nent
= 0;
9169 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9173 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9177 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9179 if (dynamic_section
== NULL
)
9181 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9182 (unsigned long) dynamic_nent
);
9187 for (ext
= edyn
, entry
= dynamic_section
;
9188 entry
< dynamic_section
+ dynamic_nent
;
9191 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9192 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9201 get_64bit_dynamic_section (FILE * file
)
9203 Elf64_External_Dyn
* edyn
;
9204 Elf64_External_Dyn
* ext
;
9205 Elf_Internal_Dyn
* entry
;
9207 /* Read in the data. */
9208 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9209 dynamic_size
, _("dynamic section"));
9213 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9214 might not have the luxury of section headers. Look for the DT_NULL
9215 terminator to determine the number of entries. */
9216 for (ext
= edyn
, dynamic_nent
= 0;
9217 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9218 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9222 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9226 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9228 if (dynamic_section
== NULL
)
9230 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9231 (unsigned long) dynamic_nent
);
9236 /* Convert from external to internal formats. */
9237 for (ext
= edyn
, entry
= dynamic_section
;
9238 entry
< dynamic_section
+ dynamic_nent
;
9241 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9242 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9251 print_dynamic_flags (bfd_vma flags
)
9259 flag
= flags
& - flags
;
9269 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9270 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9271 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9272 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9273 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9274 default: fputs (_("unknown"), stdout
); break;
9280 /* Parse and display the contents of the dynamic section. */
9283 process_dynamic_section (FILE * file
)
9285 Elf_Internal_Dyn
* entry
;
9287 if (dynamic_size
== 0)
9290 printf (_("\nThere is no dynamic section in this file.\n"));
9297 if (! get_32bit_dynamic_section (file
))
9300 else if (! get_64bit_dynamic_section (file
))
9303 /* Find the appropriate symbol table. */
9304 if (dynamic_symbols
== NULL
)
9306 for (entry
= dynamic_section
;
9307 entry
< dynamic_section
+ dynamic_nent
;
9310 Elf_Internal_Shdr section
;
9312 if (entry
->d_tag
!= DT_SYMTAB
)
9315 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9317 /* Since we do not know how big the symbol table is,
9318 we default to reading in the entire file (!) and
9319 processing that. This is overkill, I know, but it
9321 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9323 if (archive_file_offset
!= 0)
9324 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9327 if (fseek (file
, 0, SEEK_END
))
9328 error (_("Unable to seek to end of file!\n"));
9330 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9334 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9336 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9337 section
.sh_name
= string_table_length
;
9339 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9340 if (num_dynamic_syms
< 1)
9342 error (_("Unable to determine the number of symbols to load\n"));
9348 /* Similarly find a string table. */
9349 if (dynamic_strings
== NULL
)
9351 for (entry
= dynamic_section
;
9352 entry
< dynamic_section
+ dynamic_nent
;
9355 unsigned long offset
;
9358 if (entry
->d_tag
!= DT_STRTAB
)
9361 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9363 /* Since we do not know how big the string table is,
9364 we default to reading in the entire file (!) and
9365 processing that. This is overkill, I know, but it
9368 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9370 if (archive_file_offset
!= 0)
9371 str_tab_len
= archive_file_size
- offset
;
9374 if (fseek (file
, 0, SEEK_END
))
9375 error (_("Unable to seek to end of file\n"));
9376 str_tab_len
= ftell (file
) - offset
;
9379 if (str_tab_len
< 1)
9382 (_("Unable to determine the length of the dynamic string table\n"));
9386 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9388 _("dynamic string table"));
9389 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9394 /* And find the syminfo section if available. */
9395 if (dynamic_syminfo
== NULL
)
9397 unsigned long syminsz
= 0;
9399 for (entry
= dynamic_section
;
9400 entry
< dynamic_section
+ dynamic_nent
;
9403 if (entry
->d_tag
== DT_SYMINENT
)
9405 /* Note: these braces are necessary to avoid a syntax
9406 error from the SunOS4 C compiler. */
9407 /* PR binutils/17531: A corrupt file can trigger this test.
9408 So do not use an assert, instead generate an error message. */
9409 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9410 error (_("Bad value (%d) for SYMINENT entry\n"),
9411 (int) entry
->d_un
.d_val
);
9413 else if (entry
->d_tag
== DT_SYMINSZ
)
9414 syminsz
= entry
->d_un
.d_val
;
9415 else if (entry
->d_tag
== DT_SYMINFO
)
9416 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9420 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9422 Elf_External_Syminfo
* extsyminfo
;
9423 Elf_External_Syminfo
* extsym
;
9424 Elf_Internal_Syminfo
* syminfo
;
9426 /* There is a syminfo section. Read the data. */
9427 extsyminfo
= (Elf_External_Syminfo
*)
9428 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9429 _("symbol information"));
9433 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9434 if (dynamic_syminfo
== NULL
)
9436 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9437 (unsigned long) syminsz
);
9441 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9442 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9443 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9444 ++syminfo
, ++extsym
)
9446 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9447 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9454 if (do_dynamic
&& dynamic_addr
)
9455 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9456 dynamic_addr
, (unsigned long) dynamic_nent
);
9458 printf (_(" Tag Type Name/Value\n"));
9460 for (entry
= dynamic_section
;
9461 entry
< dynamic_section
+ dynamic_nent
;
9469 print_vma (entry
->d_tag
, FULL_HEX
);
9470 dtype
= get_dynamic_type (entry
->d_tag
);
9471 printf (" (%s)%*s", dtype
,
9472 ((is_32bit_elf
? 27 : 19)
9473 - (int) strlen (dtype
)),
9477 switch (entry
->d_tag
)
9481 print_dynamic_flags (entry
->d_un
.d_val
);
9491 switch (entry
->d_tag
)
9494 printf (_("Auxiliary library"));
9498 printf (_("Filter library"));
9502 printf (_("Configuration file"));
9506 printf (_("Dependency audit library"));
9510 printf (_("Audit library"));
9514 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9515 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9519 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9528 printf (_("Flags:"));
9530 if (entry
->d_un
.d_val
== 0)
9531 printf (_(" None\n"));
9534 unsigned long int val
= entry
->d_un
.d_val
;
9536 if (val
& DTF_1_PARINIT
)
9538 printf (" PARINIT");
9539 val
^= DTF_1_PARINIT
;
9541 if (val
& DTF_1_CONFEXP
)
9543 printf (" CONFEXP");
9544 val
^= DTF_1_CONFEXP
;
9547 printf (" %lx", val
);
9556 printf (_("Flags:"));
9558 if (entry
->d_un
.d_val
== 0)
9559 printf (_(" None\n"));
9562 unsigned long int val
= entry
->d_un
.d_val
;
9564 if (val
& DF_P1_LAZYLOAD
)
9566 printf (" LAZYLOAD");
9567 val
^= DF_P1_LAZYLOAD
;
9569 if (val
& DF_P1_GROUPPERM
)
9571 printf (" GROUPPERM");
9572 val
^= DF_P1_GROUPPERM
;
9575 printf (" %lx", val
);
9584 printf (_("Flags:"));
9585 if (entry
->d_un
.d_val
== 0)
9586 printf (_(" None\n"));
9589 unsigned long int val
= entry
->d_un
.d_val
;
9596 if (val
& DF_1_GLOBAL
)
9601 if (val
& DF_1_GROUP
)
9606 if (val
& DF_1_NODELETE
)
9608 printf (" NODELETE");
9609 val
^= DF_1_NODELETE
;
9611 if (val
& DF_1_LOADFLTR
)
9613 printf (" LOADFLTR");
9614 val
^= DF_1_LOADFLTR
;
9616 if (val
& DF_1_INITFIRST
)
9618 printf (" INITFIRST");
9619 val
^= DF_1_INITFIRST
;
9621 if (val
& DF_1_NOOPEN
)
9626 if (val
& DF_1_ORIGIN
)
9631 if (val
& DF_1_DIRECT
)
9636 if (val
& DF_1_TRANS
)
9641 if (val
& DF_1_INTERPOSE
)
9643 printf (" INTERPOSE");
9644 val
^= DF_1_INTERPOSE
;
9646 if (val
& DF_1_NODEFLIB
)
9648 printf (" NODEFLIB");
9649 val
^= DF_1_NODEFLIB
;
9651 if (val
& DF_1_NODUMP
)
9656 if (val
& DF_1_CONFALT
)
9658 printf (" CONFALT");
9659 val
^= DF_1_CONFALT
;
9661 if (val
& DF_1_ENDFILTEE
)
9663 printf (" ENDFILTEE");
9664 val
^= DF_1_ENDFILTEE
;
9666 if (val
& DF_1_DISPRELDNE
)
9668 printf (" DISPRELDNE");
9669 val
^= DF_1_DISPRELDNE
;
9671 if (val
& DF_1_DISPRELPND
)
9673 printf (" DISPRELPND");
9674 val
^= DF_1_DISPRELPND
;
9676 if (val
& DF_1_NODIRECT
)
9678 printf (" NODIRECT");
9679 val
^= DF_1_NODIRECT
;
9681 if (val
& DF_1_IGNMULDEF
)
9683 printf (" IGNMULDEF");
9684 val
^= DF_1_IGNMULDEF
;
9686 if (val
& DF_1_NOKSYMS
)
9688 printf (" NOKSYMS");
9689 val
^= DF_1_NOKSYMS
;
9691 if (val
& DF_1_NOHDR
)
9696 if (val
& DF_1_EDITED
)
9701 if (val
& DF_1_NORELOC
)
9703 printf (" NORELOC");
9704 val
^= DF_1_NORELOC
;
9706 if (val
& DF_1_SYMINTPOSE
)
9708 printf (" SYMINTPOSE");
9709 val
^= DF_1_SYMINTPOSE
;
9711 if (val
& DF_1_GLOBAUDIT
)
9713 printf (" GLOBAUDIT");
9714 val
^= DF_1_GLOBAUDIT
;
9716 if (val
& DF_1_SINGLETON
)
9718 printf (" SINGLETON");
9719 val
^= DF_1_SINGLETON
;
9721 if (val
& DF_1_STUB
)
9732 printf (" %lx", val
);
9739 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9741 puts (get_dynamic_type (entry
->d_un
.d_val
));
9761 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9767 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9768 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9774 switch (entry
->d_tag
)
9777 printf (_("Shared library: [%s]"), name
);
9779 if (streq (name
, program_interpreter
))
9780 printf (_(" program interpreter"));
9784 printf (_("Library soname: [%s]"), name
);
9788 printf (_("Library rpath: [%s]"), name
);
9792 printf (_("Library runpath: [%s]"), name
);
9796 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9801 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9814 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9819 case DT_INIT_ARRAYSZ
:
9820 case DT_FINI_ARRAYSZ
:
9821 case DT_GNU_CONFLICTSZ
:
9822 case DT_GNU_LIBLISTSZ
:
9825 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9826 printf (_(" (bytes)\n"));
9836 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9849 if (entry
->d_tag
== DT_USED
9850 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9852 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9856 printf (_("Not needed object: [%s]\n"), name
);
9861 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9867 /* The value of this entry is ignored. */
9872 case DT_GNU_PRELINKED
:
9876 time_t atime
= entry
->d_un
.d_val
;
9878 tmp
= gmtime (&atime
);
9879 /* PR 17533 file: 041-1244816-0.004. */
9881 printf (_("<corrupt time val: %lx"),
9882 (unsigned long) atime
);
9884 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9885 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9886 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9892 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9895 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9901 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9902 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9907 switch (elf_header
.e_machine
)
9910 case EM_MIPS_RS3_LE
:
9911 dynamic_section_mips_val (entry
);
9914 dynamic_section_parisc_val (entry
);
9917 dynamic_section_ia64_val (entry
);
9920 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9932 get_ver_flags (unsigned int flags
)
9934 static char buff
[32];
9941 if (flags
& VER_FLG_BASE
)
9942 strcat (buff
, "BASE ");
9944 if (flags
& VER_FLG_WEAK
)
9946 if (flags
& VER_FLG_BASE
)
9947 strcat (buff
, "| ");
9949 strcat (buff
, "WEAK ");
9952 if (flags
& VER_FLG_INFO
)
9954 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9955 strcat (buff
, "| ");
9957 strcat (buff
, "INFO ");
9960 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9961 strcat (buff
, _("| <unknown>"));
9966 /* Display the contents of the version sections. */
9969 process_version_sections (FILE * file
)
9971 Elf_Internal_Shdr
* section
;
9978 for (i
= 0, section
= section_headers
;
9979 i
< elf_header
.e_shnum
;
9982 switch (section
->sh_type
)
9984 case SHT_GNU_verdef
:
9986 Elf_External_Verdef
* edefs
;
9993 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9994 printable_section_name (section
),
9997 printf (_(" Addr: 0x"));
9998 printf_vma (section
->sh_addr
);
9999 printf (_(" Offset: %#08lx Link: %u (%s)"),
10000 (unsigned long) section
->sh_offset
, section
->sh_link
,
10001 printable_section_name_from_index (section
->sh_link
));
10003 edefs
= (Elf_External_Verdef
*)
10004 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10005 _("version definition section"));
10008 endbuf
= (char *) edefs
+ section
->sh_size
;
10010 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10013 Elf_External_Verdef
* edef
;
10014 Elf_Internal_Verdef ent
;
10015 Elf_External_Verdaux
* eaux
;
10016 Elf_Internal_Verdaux aux
;
10020 /* Check for very large indices. */
10021 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10024 vstart
= ((char *) edefs
) + idx
;
10025 if (vstart
+ sizeof (*edef
) > endbuf
)
10028 edef
= (Elf_External_Verdef
*) vstart
;
10030 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10031 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10032 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10033 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10034 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10035 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10036 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10038 printf (_(" %#06x: Rev: %d Flags: %s"),
10039 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10041 printf (_(" Index: %d Cnt: %d "),
10042 ent
.vd_ndx
, ent
.vd_cnt
);
10044 /* Check for overflow. */
10045 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10048 vstart
+= ent
.vd_aux
;
10050 eaux
= (Elf_External_Verdaux
*) vstart
;
10052 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10053 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10055 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10056 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10058 printf (_("Name index: %ld\n"), aux
.vda_name
);
10060 isum
= idx
+ ent
.vd_aux
;
10062 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10064 /* Check for overflow. */
10065 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10068 isum
+= aux
.vda_next
;
10069 vstart
+= aux
.vda_next
;
10071 eaux
= (Elf_External_Verdaux
*) vstart
;
10072 if (vstart
+ sizeof (*eaux
) > endbuf
)
10075 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10076 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10078 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10079 printf (_(" %#06x: Parent %d: %s\n"),
10080 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10082 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10083 isum
, j
, aux
.vda_name
);
10086 if (j
< ent
.vd_cnt
)
10087 printf (_(" Version def aux past end of section\n"));
10089 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10090 if (idx
+ ent
.vd_next
<= idx
)
10093 idx
+= ent
.vd_next
;
10096 if (cnt
< section
->sh_info
)
10097 printf (_(" Version definition past end of section\n"));
10103 case SHT_GNU_verneed
:
10105 Elf_External_Verneed
* eneed
;
10112 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10113 printable_section_name (section
), section
->sh_info
);
10115 printf (_(" Addr: 0x"));
10116 printf_vma (section
->sh_addr
);
10117 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10118 (unsigned long) section
->sh_offset
, section
->sh_link
,
10119 printable_section_name_from_index (section
->sh_link
));
10121 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10122 section
->sh_offset
, 1,
10124 _("Version Needs section"));
10127 endbuf
= (char *) eneed
+ section
->sh_size
;
10129 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10131 Elf_External_Verneed
* entry
;
10132 Elf_Internal_Verneed ent
;
10137 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10140 vstart
= ((char *) eneed
) + idx
;
10141 if (vstart
+ sizeof (*entry
) > endbuf
)
10144 entry
= (Elf_External_Verneed
*) vstart
;
10146 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10147 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10148 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10149 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10150 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10152 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10154 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10155 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10157 printf (_(" File: %lx"), ent
.vn_file
);
10159 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10161 /* Check for overflow. */
10162 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10164 vstart
+= ent
.vn_aux
;
10166 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10168 Elf_External_Vernaux
* eaux
;
10169 Elf_Internal_Vernaux aux
;
10171 if (vstart
+ sizeof (*eaux
) > endbuf
)
10173 eaux
= (Elf_External_Vernaux
*) vstart
;
10175 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10176 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10177 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10178 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10179 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10181 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10182 printf (_(" %#06x: Name: %s"),
10183 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10185 printf (_(" %#06x: Name index: %lx"),
10186 isum
, aux
.vna_name
);
10188 printf (_(" Flags: %s Version: %d\n"),
10189 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10191 /* Check for overflow. */
10192 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10193 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10195 warn (_("Invalid vna_next field of %lx\n"),
10200 isum
+= aux
.vna_next
;
10201 vstart
+= aux
.vna_next
;
10204 if (j
< ent
.vn_cnt
)
10205 warn (_("Missing Version Needs auxillary information\n"));
10207 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10209 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10210 cnt
= section
->sh_info
;
10213 idx
+= ent
.vn_next
;
10216 if (cnt
< section
->sh_info
)
10217 warn (_("Missing Version Needs information\n"));
10223 case SHT_GNU_versym
:
10225 Elf_Internal_Shdr
* link_section
;
10228 unsigned char * edata
;
10229 unsigned short * data
;
10231 Elf_Internal_Sym
* symbols
;
10232 Elf_Internal_Shdr
* string_sec
;
10233 unsigned long num_syms
;
10236 if (section
->sh_link
>= elf_header
.e_shnum
)
10239 link_section
= section_headers
+ section
->sh_link
;
10240 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10242 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10247 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10248 if (symbols
== NULL
)
10251 string_sec
= section_headers
+ link_section
->sh_link
;
10253 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10254 string_sec
->sh_size
,
10255 _("version string table"));
10262 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10263 printable_section_name (section
), (unsigned long) total
);
10265 printf (_(" Addr: "));
10266 printf_vma (section
->sh_addr
);
10267 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10268 (unsigned long) section
->sh_offset
, section
->sh_link
,
10269 printable_section_name (link_section
));
10271 off
= offset_from_vma (file
,
10272 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10273 total
* sizeof (short));
10274 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10276 _("version symbol data"));
10284 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10286 for (cnt
= total
; cnt
--;)
10287 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10292 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10296 char *invalid
= _("*invalid*");
10298 printf (" %03x:", cnt
);
10300 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10301 switch (data
[cnt
+ j
])
10304 fputs (_(" 0 (*local*) "), stdout
);
10308 fputs (_(" 1 (*global*) "), stdout
);
10312 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10313 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10315 /* If this index value is greater than the size of the symbols
10316 array, break to avoid an out-of-bounds read. */
10317 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10319 warn (_("invalid index into symbol array\n"));
10324 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10326 Elf_Internal_Verneed ivn
;
10327 unsigned long offset
;
10329 offset
= offset_from_vma
10330 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10331 sizeof (Elf_External_Verneed
));
10335 Elf_Internal_Vernaux ivna
;
10336 Elf_External_Verneed evn
;
10337 Elf_External_Vernaux evna
;
10338 unsigned long a_off
;
10340 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10341 _("version need")) == NULL
)
10344 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10345 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10347 a_off
= offset
+ ivn
.vn_aux
;
10351 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10352 1, _("version need aux (2)")) == NULL
)
10355 ivna
.vna_other
= 0;
10359 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10360 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10363 a_off
+= ivna
.vna_next
;
10365 while (ivna
.vna_other
!= data
[cnt
+ j
]
10366 && ivna
.vna_next
!= 0);
10368 if (ivna
.vna_other
== data
[cnt
+ j
])
10370 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10372 if (ivna
.vna_name
>= string_sec
->sh_size
)
10375 name
= strtab
+ ivna
.vna_name
;
10379 offset
+= ivn
.vn_next
;
10381 while (ivn
.vn_next
);
10384 if (data
[cnt
+ j
] != 0x8001
10385 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10387 Elf_Internal_Verdef ivd
;
10388 Elf_External_Verdef evd
;
10389 unsigned long offset
;
10391 offset
= offset_from_vma
10392 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10397 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10398 _("version def")) == NULL
)
10401 /* PR 17531: file: 046-1082287-0.004. */
10402 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10407 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10408 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10411 offset
+= ivd
.vd_next
;
10413 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10414 && ivd
.vd_next
!= 0);
10416 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10418 Elf_External_Verdaux evda
;
10419 Elf_Internal_Verdaux ivda
;
10421 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10423 if (get_data (&evda
, file
,
10424 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10426 _("version def aux")) == NULL
)
10429 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10431 if (ivda
.vda_name
>= string_sec
->sh_size
)
10433 else if (name
!= NULL
&& name
!= invalid
)
10434 name
= _("*both*");
10436 name
= strtab
+ ivda
.vda_name
;
10440 nn
+= printf ("(%s%-*s",
10442 12 - (int) strlen (name
),
10446 printf ("%*c", 18 - nn
, ' ');
10464 printf (_("\nNo version information found in this file.\n"));
10469 static const char *
10470 get_symbol_binding (unsigned int binding
)
10472 static char buff
[32];
10476 case STB_LOCAL
: return "LOCAL";
10477 case STB_GLOBAL
: return "GLOBAL";
10478 case STB_WEAK
: return "WEAK";
10480 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10481 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10483 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10485 if (binding
== STB_GNU_UNIQUE
10486 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10487 /* GNU is still using the default value 0. */
10488 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10490 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10493 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10498 static const char *
10499 get_symbol_type (unsigned int type
)
10501 static char buff
[32];
10505 case STT_NOTYPE
: return "NOTYPE";
10506 case STT_OBJECT
: return "OBJECT";
10507 case STT_FUNC
: return "FUNC";
10508 case STT_SECTION
: return "SECTION";
10509 case STT_FILE
: return "FILE";
10510 case STT_COMMON
: return "COMMON";
10511 case STT_TLS
: return "TLS";
10512 case STT_RELC
: return "RELC";
10513 case STT_SRELC
: return "SRELC";
10515 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10517 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10518 return "THUMB_FUNC";
10520 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10523 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10524 return "PARISC_MILLI";
10526 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10528 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10530 if (elf_header
.e_machine
== EM_PARISC
)
10532 if (type
== STT_HP_OPAQUE
)
10533 return "HP_OPAQUE";
10534 if (type
== STT_HP_STUB
)
10538 if (type
== STT_GNU_IFUNC
10539 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10540 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10541 /* GNU is still using the default value 0. */
10542 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10545 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10548 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10553 static const char *
10554 get_symbol_visibility (unsigned int visibility
)
10556 switch (visibility
)
10558 case STV_DEFAULT
: return "DEFAULT";
10559 case STV_INTERNAL
: return "INTERNAL";
10560 case STV_HIDDEN
: return "HIDDEN";
10561 case STV_PROTECTED
: return "PROTECTED";
10563 error (_("Unrecognized visibility value: %u"), visibility
);
10564 return _("<unknown>");
10568 static const char *
10569 get_solaris_symbol_visibility (unsigned int visibility
)
10571 switch (visibility
)
10573 case 4: return "EXPORTED";
10574 case 5: return "SINGLETON";
10575 case 6: return "ELIMINATE";
10576 default: return get_symbol_visibility (visibility
);
10580 static const char *
10581 get_mips_symbol_other (unsigned int other
)
10591 case STO_MICROMIPS
:
10592 return "MICROMIPS";
10593 case STO_MICROMIPS
| STO_MIPS_PIC
:
10594 return "MICROMIPS, MIPS PIC";
10602 static const char *
10603 get_ia64_symbol_other (unsigned int other
)
10605 if (is_ia64_vms ())
10607 static char res
[32];
10611 /* Function types is for images and .STB files only. */
10612 switch (elf_header
.e_type
)
10616 switch (VMS_ST_FUNC_TYPE (other
))
10618 case VMS_SFT_CODE_ADDR
:
10619 strcat (res
, " CA");
10621 case VMS_SFT_SYMV_IDX
:
10622 strcat (res
, " VEC");
10625 strcat (res
, " FD");
10627 case VMS_SFT_RESERVE
:
10628 strcat (res
, " RSV");
10631 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10632 VMS_ST_FUNC_TYPE (other
));
10633 strcat (res
, " <unknown>");
10640 switch (VMS_ST_LINKAGE (other
))
10642 case VMS_STL_IGNORE
:
10643 strcat (res
, " IGN");
10645 case VMS_STL_RESERVE
:
10646 strcat (res
, " RSV");
10649 strcat (res
, " STD");
10652 strcat (res
, " LNK");
10655 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10656 VMS_ST_LINKAGE (other
));
10657 strcat (res
, " <unknown>");
10669 static const char *
10670 get_ppc64_symbol_other (unsigned int other
)
10672 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10674 static char buf
[32];
10675 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10676 PPC64_LOCAL_ENTRY_OFFSET (other
));
10682 static const char *
10683 get_symbol_other (unsigned int other
)
10685 const char * result
= NULL
;
10686 static char buff
[32];
10691 switch (elf_header
.e_machine
)
10694 result
= get_mips_symbol_other (other
);
10697 result
= get_ia64_symbol_other (other
);
10700 result
= get_ppc64_symbol_other (other
);
10710 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10714 static const char *
10715 get_symbol_index_type (unsigned int type
)
10717 static char buff
[32];
10721 case SHN_UNDEF
: return "UND";
10722 case SHN_ABS
: return "ABS";
10723 case SHN_COMMON
: return "COM";
10725 if (type
== SHN_IA_64_ANSI_COMMON
10726 && elf_header
.e_machine
== EM_IA_64
10727 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10729 else if ((elf_header
.e_machine
== EM_X86_64
10730 || elf_header
.e_machine
== EM_L1OM
10731 || elf_header
.e_machine
== EM_K1OM
)
10732 && type
== SHN_X86_64_LCOMMON
)
10733 return "LARGE_COM";
10734 else if ((type
== SHN_MIPS_SCOMMON
10735 && elf_header
.e_machine
== EM_MIPS
)
10736 || (type
== SHN_TIC6X_SCOMMON
10737 && elf_header
.e_machine
== EM_TI_C6000
))
10739 else if (type
== SHN_MIPS_SUNDEFINED
10740 && elf_header
.e_machine
== EM_MIPS
)
10742 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10743 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10744 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10745 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10746 else if (type
>= SHN_LORESERVE
)
10747 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10748 else if (type
>= elf_header
.e_shnum
)
10749 sprintf (buff
, _("bad section index[%3d]"), type
);
10751 sprintf (buff
, "%3d", type
);
10759 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10761 unsigned char * e_data
;
10764 /* If the size_t type is smaller than the bfd_size_type, eg because
10765 you are building a 32-bit tool on a 64-bit host, then make sure
10766 that when (number) is cast to (size_t) no information is lost. */
10767 if (sizeof (size_t) < sizeof (bfd_size_type
)
10768 && (bfd_size_type
) ((size_t) number
) != number
)
10770 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10771 " elements of size %u\n"),
10776 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10777 attempting to allocate memory when the read is bound to fail. */
10778 if (ent_size
* number
> current_file_size
)
10780 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10785 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10786 if (e_data
== NULL
)
10788 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10793 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10795 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10796 number
* ent_size
);
10801 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10802 if (i_data
== NULL
)
10804 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10805 " dynamic entries\n"),
10812 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10820 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10822 Elf_Internal_Sym
* psym
;
10825 n
= print_vma (si
, DEC_5
);
10827 fputs (&" "[n
], stdout
);
10828 printf (" %3lu: ", hn
);
10830 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10832 printf (_("<No info available for dynamic symbol number %lu>\n"),
10833 (unsigned long) si
);
10837 psym
= dynamic_symbols
+ si
;
10838 print_vma (psym
->st_value
, LONG_HEX
);
10840 print_vma (psym
->st_size
, DEC_5
);
10842 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10843 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10845 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10846 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10849 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10851 printf (" %-7s", get_symbol_visibility (vis
));
10852 /* Check to see if any other bits in the st_other field are set.
10853 Note - displaying this information disrupts the layout of the
10854 table being generated, but for the moment this case is very
10856 if (psym
->st_other
^ vis
)
10857 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10860 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10861 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10862 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10864 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10868 static const char *
10869 get_symbol_version_string (FILE * file
,
10870 bfd_boolean is_dynsym
,
10871 const char * strtab
,
10872 unsigned long int strtab_size
,
10874 Elf_Internal_Sym
* psym
,
10875 enum versioned_symbol_info
* sym_info
,
10876 unsigned short * vna_other
)
10878 unsigned char data
[2];
10879 unsigned short vers_data
;
10880 unsigned long offset
;
10883 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10886 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10887 sizeof data
+ si
* sizeof (vers_data
));
10889 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10890 sizeof (data
), 1, _("version data")) == NULL
)
10893 vers_data
= byte_get (data
, 2);
10895 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10898 /* Usually we'd only see verdef for defined symbols, and verneed for
10899 undefined symbols. However, symbols defined by the linker in
10900 .dynbss for variables copied from a shared library in order to
10901 avoid text relocations are defined yet have verneed. We could
10902 use a heuristic to detect the special case, for example, check
10903 for verneed first on symbols defined in SHT_NOBITS sections, but
10904 it is simpler and more reliable to just look for both verdef and
10905 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10907 if (psym
->st_shndx
!= SHN_UNDEF
10908 && vers_data
!= 0x8001
10909 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10911 Elf_Internal_Verdef ivd
;
10912 Elf_Internal_Verdaux ivda
;
10913 Elf_External_Verdaux evda
;
10916 off
= offset_from_vma (file
,
10917 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10918 sizeof (Elf_External_Verdef
));
10922 Elf_External_Verdef evd
;
10924 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10925 _("version def")) == NULL
)
10933 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10934 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10935 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10938 off
+= ivd
.vd_next
;
10940 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10942 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10944 off
-= ivd
.vd_next
;
10947 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10948 _("version def aux")) != NULL
)
10950 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10952 if (psym
->st_name
!= ivda
.vda_name
)
10954 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10955 ? symbol_hidden
: symbol_public
);
10956 return (ivda
.vda_name
< strtab_size
10957 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10963 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10965 Elf_External_Verneed evn
;
10966 Elf_Internal_Verneed ivn
;
10967 Elf_Internal_Vernaux ivna
;
10969 offset
= offset_from_vma (file
,
10970 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10974 unsigned long vna_off
;
10976 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10977 _("version need")) == NULL
)
10980 ivna
.vna_other
= 0;
10985 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10986 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10988 vna_off
= offset
+ ivn
.vn_aux
;
10992 Elf_External_Vernaux evna
;
10994 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10995 _("version need aux (3)")) == NULL
)
10998 ivna
.vna_other
= 0;
11003 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11004 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11005 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11008 vna_off
+= ivna
.vna_next
;
11010 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11012 if (ivna
.vna_other
== vers_data
)
11015 offset
+= ivn
.vn_next
;
11017 while (ivn
.vn_next
!= 0);
11019 if (ivna
.vna_other
== vers_data
)
11021 *sym_info
= symbol_undefined
;
11022 *vna_other
= ivna
.vna_other
;
11023 return (ivna
.vna_name
< strtab_size
11024 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11030 /* Dump the symbol table. */
11032 process_symbol_table (FILE * file
)
11034 Elf_Internal_Shdr
* section
;
11035 bfd_size_type nbuckets
= 0;
11036 bfd_size_type nchains
= 0;
11037 bfd_vma
* buckets
= NULL
;
11038 bfd_vma
* chains
= NULL
;
11039 bfd_vma ngnubuckets
= 0;
11040 bfd_vma
* gnubuckets
= NULL
;
11041 bfd_vma
* gnuchains
= NULL
;
11042 bfd_vma gnusymidx
= 0;
11043 bfd_size_type ngnuchains
= 0;
11045 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11048 if (dynamic_info
[DT_HASH
]
11050 || (do_using_dynamic
11052 && dynamic_strings
!= NULL
)))
11054 unsigned char nb
[8];
11055 unsigned char nc
[8];
11056 unsigned int hash_ent_size
= 4;
11058 if ((elf_header
.e_machine
== EM_ALPHA
11059 || elf_header
.e_machine
== EM_S390
11060 || elf_header
.e_machine
== EM_S390_OLD
)
11061 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11065 (archive_file_offset
11066 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11067 sizeof nb
+ sizeof nc
)),
11070 error (_("Unable to seek to start of dynamic information\n"));
11074 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11076 error (_("Failed to read in number of buckets\n"));
11080 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11082 error (_("Failed to read in number of chains\n"));
11086 nbuckets
= byte_get (nb
, hash_ent_size
);
11087 nchains
= byte_get (nc
, hash_ent_size
);
11089 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11090 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11093 if (buckets
== NULL
|| chains
== NULL
)
11095 if (do_using_dynamic
)
11106 if (dynamic_info_DT_GNU_HASH
11108 || (do_using_dynamic
11110 && dynamic_strings
!= NULL
)))
11112 unsigned char nb
[16];
11113 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11114 bfd_vma buckets_vma
;
11117 (archive_file_offset
11118 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11122 error (_("Unable to seek to start of dynamic information\n"));
11126 if (fread (nb
, 16, 1, file
) != 1)
11128 error (_("Failed to read in number of buckets\n"));
11132 ngnubuckets
= byte_get (nb
, 4);
11133 gnusymidx
= byte_get (nb
+ 4, 4);
11134 bitmaskwords
= byte_get (nb
+ 8, 4);
11135 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11137 buckets_vma
+= bitmaskwords
* 4;
11139 buckets_vma
+= bitmaskwords
* 8;
11142 (archive_file_offset
11143 + offset_from_vma (file
, buckets_vma
, 4)),
11146 error (_("Unable to seek to start of dynamic information\n"));
11150 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11152 if (gnubuckets
== NULL
)
11155 for (i
= 0; i
< ngnubuckets
; i
++)
11156 if (gnubuckets
[i
] != 0)
11158 if (gnubuckets
[i
] < gnusymidx
)
11161 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11162 maxchain
= gnubuckets
[i
];
11165 if (maxchain
== 0xffffffff)
11168 maxchain
-= gnusymidx
;
11171 (archive_file_offset
11172 + offset_from_vma (file
, buckets_vma
11173 + 4 * (ngnubuckets
+ maxchain
), 4)),
11176 error (_("Unable to seek to start of dynamic information\n"));
11182 if (fread (nb
, 4, 1, file
) != 1)
11184 error (_("Failed to determine last chain length\n"));
11188 if (maxchain
+ 1 == 0)
11193 while ((byte_get (nb
, 4) & 1) == 0);
11196 (archive_file_offset
11197 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11200 error (_("Unable to seek to start of dynamic information\n"));
11204 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11205 ngnuchains
= maxchain
;
11208 if (gnuchains
== NULL
)
11213 if (do_using_dynamic
)
11218 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11220 && do_using_dynamic
11221 && dynamic_strings
!= NULL
11222 && dynamic_symbols
!= NULL
)
11226 if (dynamic_info
[DT_HASH
])
11230 printf (_("\nSymbol table for image:\n"));
11232 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11234 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11236 for (hn
= 0; hn
< nbuckets
; hn
++)
11241 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11242 print_dynamic_symbol (si
, hn
);
11246 if (dynamic_info_DT_GNU_HASH
)
11248 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11250 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11252 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11254 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11255 if (gnubuckets
[hn
] != 0)
11257 bfd_vma si
= gnubuckets
[hn
];
11258 bfd_vma off
= si
- gnusymidx
;
11262 print_dynamic_symbol (si
, hn
);
11265 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11269 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11270 && section_headers
!= NULL
)
11274 for (i
= 0, section
= section_headers
;
11275 i
< elf_header
.e_shnum
;
11279 char * strtab
= NULL
;
11280 unsigned long int strtab_size
= 0;
11281 Elf_Internal_Sym
* symtab
;
11282 Elf_Internal_Sym
* psym
;
11283 unsigned long num_syms
;
11285 if ((section
->sh_type
!= SHT_SYMTAB
11286 && section
->sh_type
!= SHT_DYNSYM
)
11288 && section
->sh_type
== SHT_SYMTAB
))
11291 if (section
->sh_entsize
== 0)
11293 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11294 printable_section_name (section
));
11298 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11299 printable_section_name (section
),
11300 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11303 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11305 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11307 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11308 if (symtab
== NULL
)
11311 if (section
->sh_link
== elf_header
.e_shstrndx
)
11313 strtab
= string_table
;
11314 strtab_size
= string_table_length
;
11316 else if (section
->sh_link
< elf_header
.e_shnum
)
11318 Elf_Internal_Shdr
* string_sec
;
11320 string_sec
= section_headers
+ section
->sh_link
;
11322 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11323 1, string_sec
->sh_size
,
11324 _("string table"));
11325 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11328 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11330 const char *version_string
;
11331 enum versioned_symbol_info sym_info
;
11332 unsigned short vna_other
;
11334 printf ("%6d: ", si
);
11335 print_vma (psym
->st_value
, LONG_HEX
);
11337 print_vma (psym
->st_size
, DEC_5
);
11338 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11339 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11340 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11341 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11344 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11346 printf (" %-7s", get_symbol_visibility (vis
));
11347 /* Check to see if any other bits in the st_other field are set.
11348 Note - displaying this information disrupts the layout of the
11349 table being generated, but for the moment this case is very rare. */
11350 if (psym
->st_other
^ vis
)
11351 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11353 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11354 print_symbol (25, psym
->st_name
< strtab_size
11355 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11358 = get_symbol_version_string (file
,
11359 section
->sh_type
== SHT_DYNSYM
,
11360 strtab
, strtab_size
, si
,
11361 psym
, &sym_info
, &vna_other
);
11362 if (version_string
)
11364 if (sym_info
== symbol_undefined
)
11365 printf ("@%s (%d)", version_string
, vna_other
);
11367 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11373 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11374 && si
>= section
->sh_info
11375 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11376 && elf_header
.e_machine
!= EM_MIPS
11377 /* Solaris binaries have been found to violate this requirement as
11378 well. Not sure if this is a bug or an ABI requirement. */
11379 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11380 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11381 si
, printable_section_name (section
), section
->sh_info
);
11385 if (strtab
!= string_table
)
11391 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11393 if (do_histogram
&& buckets
!= NULL
)
11395 unsigned long * lengths
;
11396 unsigned long * counts
;
11399 unsigned long maxlength
= 0;
11400 unsigned long nzero_counts
= 0;
11401 unsigned long nsyms
= 0;
11402 unsigned long chained
;
11404 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11405 (unsigned long) nbuckets
);
11407 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11408 if (lengths
== NULL
)
11410 error (_("Out of memory allocating space for histogram buckets\n"));
11414 printf (_(" Length Number %% of total Coverage\n"));
11415 for (hn
= 0; hn
< nbuckets
; ++hn
)
11417 for (si
= buckets
[hn
], chained
= 0;
11418 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11419 si
= chains
[si
], ++chained
)
11422 if (maxlength
< ++lengths
[hn
])
11426 /* PR binutils/17531: A corrupt binary could contain broken
11427 histogram data. Do not go into an infinite loop trying
11429 if (chained
> nchains
)
11431 error (_("histogram chain is corrupt\n"));
11436 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11437 if (counts
== NULL
)
11440 error (_("Out of memory allocating space for histogram counts\n"));
11444 for (hn
= 0; hn
< nbuckets
; ++hn
)
11445 ++counts
[lengths
[hn
]];
11450 printf (" 0 %-10lu (%5.1f%%)\n",
11451 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11452 for (i
= 1; i
<= maxlength
; ++i
)
11454 nzero_counts
+= counts
[i
] * i
;
11455 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11456 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11457 (nzero_counts
* 100.0) / nsyms
);
11465 if (buckets
!= NULL
)
11471 if (do_histogram
&& gnubuckets
!= NULL
)
11473 unsigned long * lengths
;
11474 unsigned long * counts
;
11476 unsigned long maxlength
= 0;
11477 unsigned long nzero_counts
= 0;
11478 unsigned long nsyms
= 0;
11480 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11481 (unsigned long) ngnubuckets
);
11483 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11484 if (lengths
== NULL
)
11486 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11490 printf (_(" Length Number %% of total Coverage\n"));
11492 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11493 if (gnubuckets
[hn
] != 0)
11495 bfd_vma off
, length
= 1;
11497 for (off
= gnubuckets
[hn
] - gnusymidx
;
11498 /* PR 17531 file: 010-77222-0.004. */
11499 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11502 lengths
[hn
] = length
;
11503 if (length
> maxlength
)
11504 maxlength
= length
;
11508 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11509 if (counts
== NULL
)
11512 error (_("Out of memory allocating space for gnu histogram counts\n"));
11516 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11517 ++counts
[lengths
[hn
]];
11519 if (ngnubuckets
> 0)
11522 printf (" 0 %-10lu (%5.1f%%)\n",
11523 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11524 for (j
= 1; j
<= maxlength
; ++j
)
11526 nzero_counts
+= counts
[j
] * j
;
11527 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11528 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11529 (nzero_counts
* 100.0) / nsyms
);
11543 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11547 if (dynamic_syminfo
== NULL
11549 /* No syminfo, this is ok. */
11552 /* There better should be a dynamic symbol section. */
11553 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11557 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11558 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11560 printf (_(" Num: Name BoundTo Flags\n"));
11561 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11563 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11565 printf ("%4d: ", i
);
11566 if (i
>= num_dynamic_syms
)
11567 printf (_("<corrupt index>"));
11568 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11569 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11571 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11574 switch (dynamic_syminfo
[i
].si_boundto
)
11576 case SYMINFO_BT_SELF
:
11577 fputs ("SELF ", stdout
);
11579 case SYMINFO_BT_PARENT
:
11580 fputs ("PARENT ", stdout
);
11583 if (dynamic_syminfo
[i
].si_boundto
> 0
11584 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11585 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11587 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11591 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11595 if (flags
& SYMINFO_FLG_DIRECT
)
11596 printf (" DIRECT");
11597 if (flags
& SYMINFO_FLG_PASSTHRU
)
11598 printf (" PASSTHRU");
11599 if (flags
& SYMINFO_FLG_COPY
)
11601 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11602 printf (" LAZYLOAD");
11610 #define IN_RANGE(START,END,ADDR,OFF) \
11611 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11613 /* Check to see if the given reloc needs to be handled in a target specific
11614 manner. If so then process the reloc and return TRUE otherwise return
11617 If called with reloc == NULL, then this is a signal that reloc processing
11618 for the current section has finished, and any saved state should be
11622 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11623 unsigned char * start
,
11624 unsigned char * end
,
11625 Elf_Internal_Sym
* symtab
,
11626 unsigned long num_syms
)
11628 unsigned int reloc_type
= 0;
11629 unsigned long sym_index
= 0;
11633 reloc_type
= get_reloc_type (reloc
->r_info
);
11634 sym_index
= get_reloc_symindex (reloc
->r_info
);
11637 switch (elf_header
.e_machine
)
11640 case EM_MSP430_OLD
:
11642 static Elf_Internal_Sym
* saved_sym
= NULL
;
11650 switch (reloc_type
)
11652 case 10: /* R_MSP430_SYM_DIFF */
11653 if (uses_msp430x_relocs ())
11655 /* Fall through. */
11656 case 21: /* R_MSP430X_SYM_DIFF */
11658 if (sym_index
>= num_syms
)
11659 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11662 saved_sym
= symtab
+ sym_index
;
11665 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11666 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11667 goto handle_sym_diff
;
11669 case 5: /* R_MSP430_16_BYTE */
11670 case 9: /* R_MSP430_8 */
11671 if (uses_msp430x_relocs ())
11673 goto handle_sym_diff
;
11675 case 2: /* R_MSP430_ABS16 */
11676 case 15: /* R_MSP430X_ABS16 */
11677 if (! uses_msp430x_relocs ())
11679 goto handle_sym_diff
;
11682 if (saved_sym
!= NULL
)
11684 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11687 if (sym_index
>= num_syms
)
11688 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11692 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11693 - saved_sym
->st_value
);
11695 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11696 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11699 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11700 (long) reloc
->r_offset
);
11709 if (saved_sym
!= NULL
)
11710 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11717 case EM_CYGNUS_MN10300
:
11719 static Elf_Internal_Sym
* saved_sym
= NULL
;
11727 switch (reloc_type
)
11729 case 34: /* R_MN10300_ALIGN */
11731 case 33: /* R_MN10300_SYM_DIFF */
11732 if (sym_index
>= num_syms
)
11733 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11736 saved_sym
= symtab
+ sym_index
;
11739 case 1: /* R_MN10300_32 */
11740 case 2: /* R_MN10300_16 */
11741 if (saved_sym
!= NULL
)
11743 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11746 if (sym_index
>= num_syms
)
11747 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11751 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11752 - saved_sym
->st_value
);
11754 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11755 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11757 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11758 (long) reloc
->r_offset
);
11766 if (saved_sym
!= NULL
)
11767 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11775 static bfd_vma saved_sym1
= 0;
11776 static bfd_vma saved_sym2
= 0;
11777 static bfd_vma value
;
11781 saved_sym1
= saved_sym2
= 0;
11785 switch (reloc_type
)
11787 case 0x80: /* R_RL78_SYM. */
11788 saved_sym1
= saved_sym2
;
11789 if (sym_index
>= num_syms
)
11790 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11794 saved_sym2
= symtab
[sym_index
].st_value
;
11795 saved_sym2
+= reloc
->r_addend
;
11799 case 0x83: /* R_RL78_OPsub. */
11800 value
= saved_sym1
- saved_sym2
;
11801 saved_sym2
= saved_sym1
= 0;
11805 case 0x41: /* R_RL78_ABS32. */
11806 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11807 byte_put (start
+ reloc
->r_offset
, value
, 4);
11809 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11810 (long) reloc
->r_offset
);
11814 case 0x43: /* R_RL78_ABS16. */
11815 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11816 byte_put (start
+ reloc
->r_offset
, value
, 2);
11818 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11819 (long) reloc
->r_offset
);
11833 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11834 DWARF debug sections. This is a target specific test. Note - we do not
11835 go through the whole including-target-headers-multiple-times route, (as
11836 we have already done with <elf/h8.h>) because this would become very
11837 messy and even then this function would have to contain target specific
11838 information (the names of the relocs instead of their numeric values).
11839 FIXME: This is not the correct way to solve this problem. The proper way
11840 is to have target specific reloc sizing and typing functions created by
11841 the reloc-macros.h header, in the same way that it already creates the
11842 reloc naming functions. */
11845 is_32bit_abs_reloc (unsigned int reloc_type
)
11847 /* Please keep this table alpha-sorted for ease of visual lookup. */
11848 switch (elf_header
.e_machine
)
11852 return reloc_type
== 1; /* R_386_32. */
11854 return reloc_type
== 1; /* R_68K_32. */
11856 return reloc_type
== 1; /* R_860_32. */
11858 return reloc_type
== 2; /* R_960_32. */
11860 return (reloc_type
== 258
11861 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11862 case EM_ADAPTEVA_EPIPHANY
:
11863 return reloc_type
== 3;
11865 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11867 return reloc_type
== 1; /* R_ARC_32. */
11868 case EM_ARC_COMPACT
:
11869 case EM_ARC_COMPACT2
:
11870 return reloc_type
== 4; /* R_ARC_32. */
11872 return reloc_type
== 2; /* R_ARM_ABS32 */
11875 return reloc_type
== 1;
11877 return reloc_type
== 0x12; /* R_byte4_data. */
11879 return reloc_type
== 3; /* R_CRIS_32. */
11881 return reloc_type
== 3; /* R_CR16_NUM32. */
11883 return reloc_type
== 15; /* R_CRX_NUM32. */
11884 case EM_CYGNUS_FRV
:
11885 return reloc_type
== 1;
11886 case EM_CYGNUS_D10V
:
11888 return reloc_type
== 6; /* R_D10V_32. */
11889 case EM_CYGNUS_D30V
:
11891 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11893 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11894 case EM_CYGNUS_FR30
:
11896 return reloc_type
== 3; /* R_FR30_32. */
11898 return reloc_type
== 1; /* R_FT32_32. */
11902 return reloc_type
== 1; /* R_H8_DIR32. */
11904 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11905 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11908 return reloc_type
== 2; /* R_IP2K_32. */
11910 return reloc_type
== 2; /* R_IQ2000_32. */
11911 case EM_LATTICEMICO32
:
11912 return reloc_type
== 3; /* R_LM32_32. */
11915 return reloc_type
== 3; /* R_M32C_32. */
11917 return reloc_type
== 34; /* R_M32R_32_RELA. */
11920 return reloc_type
== 6; /* R_M68HC11_32. */
11922 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11923 case EM_CYGNUS_MEP
:
11924 return reloc_type
== 4; /* R_MEP_32. */
11926 return reloc_type
== 2; /* R_METAG_ADDR32. */
11927 case EM_MICROBLAZE
:
11928 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11930 return reloc_type
== 2; /* R_MIPS_32. */
11932 return reloc_type
== 4; /* R_MMIX_32. */
11933 case EM_CYGNUS_MN10200
:
11935 return reloc_type
== 1; /* R_MN10200_32. */
11936 case EM_CYGNUS_MN10300
:
11938 return reloc_type
== 1; /* R_MN10300_32. */
11940 return reloc_type
== 1; /* R_MOXIE_32. */
11941 case EM_MSP430_OLD
:
11943 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11945 return reloc_type
== 2; /* R_MT_32. */
11947 return reloc_type
== 20; /* R_NDS32_RELA. */
11948 case EM_ALTERA_NIOS2
:
11949 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11951 return reloc_type
== 1; /* R_NIOS_32. */
11953 return reloc_type
== 1; /* R_OR1K_32. */
11955 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11956 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11959 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11961 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11963 return reloc_type
== 1; /* R_PPC_ADDR32. */
11965 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
11967 return reloc_type
== 1; /* R_RISCV_32. */
11969 return reloc_type
== 1; /* R_RL78_DIR32. */
11971 return reloc_type
== 1; /* R_RX_DIR32. */
11973 return reloc_type
== 1; /* R_I370_ADDR31. */
11976 return reloc_type
== 4; /* R_S390_32. */
11978 return reloc_type
== 8; /* R_SCORE_ABS32. */
11980 return reloc_type
== 1; /* R_SH_DIR32. */
11981 case EM_SPARC32PLUS
:
11984 return reloc_type
== 3 /* R_SPARC_32. */
11985 || reloc_type
== 23; /* R_SPARC_UA32. */
11987 return reloc_type
== 6; /* R_SPU_ADDR32 */
11989 return reloc_type
== 1; /* R_C6000_ABS32. */
11991 return reloc_type
== 2; /* R_TILEGX_32. */
11993 return reloc_type
== 1; /* R_TILEPRO_32. */
11994 case EM_CYGNUS_V850
:
11996 return reloc_type
== 6; /* R_V850_ABS32. */
11998 return reloc_type
== 0x33; /* R_V810_WORD. */
12000 return reloc_type
== 1; /* R_VAX_32. */
12002 return reloc_type
== 3; /* R_VISIUM_32. */
12006 return reloc_type
== 10; /* R_X86_64_32. */
12009 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12011 return reloc_type
== 4; /* R_XGATE_32. */
12013 return reloc_type
== 1; /* R_XSTROMY16_32. */
12014 case EM_XTENSA_OLD
:
12016 return reloc_type
== 1; /* R_XTENSA_32. */
12019 static unsigned int prev_warn
= 0;
12021 /* Avoid repeating the same warning multiple times. */
12022 if (prev_warn
!= elf_header
.e_machine
)
12023 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12024 elf_header
.e_machine
);
12025 prev_warn
= elf_header
.e_machine
;
12031 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12032 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12035 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12037 switch (elf_header
.e_machine
)
12038 /* Please keep this table alpha-sorted for ease of visual lookup. */
12042 return reloc_type
== 2; /* R_386_PC32. */
12044 return reloc_type
== 4; /* R_68K_PC32. */
12046 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12047 case EM_ADAPTEVA_EPIPHANY
:
12048 return reloc_type
== 6;
12050 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12051 case EM_ARC_COMPACT
:
12052 case EM_ARC_COMPACT2
:
12053 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12055 return reloc_type
== 3; /* R_ARM_REL32 */
12058 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12059 case EM_MICROBLAZE
:
12060 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12062 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12064 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12066 return reloc_type
== 26; /* R_PPC_REL32. */
12068 return reloc_type
== 26; /* R_PPC64_REL32. */
12071 return reloc_type
== 5; /* R_390_PC32. */
12073 return reloc_type
== 2; /* R_SH_REL32. */
12074 case EM_SPARC32PLUS
:
12077 return reloc_type
== 6; /* R_SPARC_DISP32. */
12079 return reloc_type
== 13; /* R_SPU_REL32. */
12081 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12083 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12085 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12089 return reloc_type
== 2; /* R_X86_64_PC32. */
12090 case EM_XTENSA_OLD
:
12092 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12094 /* Do not abort or issue an error message here. Not all targets use
12095 pc-relative 32-bit relocs in their DWARF debug information and we
12096 have already tested for target coverage in is_32bit_abs_reloc. A
12097 more helpful warning message will be generated by apply_relocations
12098 anyway, so just return. */
12103 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12104 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12107 is_64bit_abs_reloc (unsigned int reloc_type
)
12109 switch (elf_header
.e_machine
)
12112 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12114 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12116 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12118 return reloc_type
== 80; /* R_PARISC_DIR64. */
12120 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12122 return reloc_type
== 2; /* R_RISCV_64. */
12123 case EM_SPARC32PLUS
:
12126 return reloc_type
== 54; /* R_SPARC_UA64. */
12130 return reloc_type
== 1; /* R_X86_64_64. */
12133 return reloc_type
== 22; /* R_S390_64. */
12135 return reloc_type
== 1; /* R_TILEGX_64. */
12137 return reloc_type
== 18; /* R_MIPS_64. */
12143 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12144 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12147 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12149 switch (elf_header
.e_machine
)
12152 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12154 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12156 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12158 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12160 return reloc_type
== 44; /* R_PPC64_REL64. */
12161 case EM_SPARC32PLUS
:
12164 return reloc_type
== 46; /* R_SPARC_DISP64. */
12168 return reloc_type
== 24; /* R_X86_64_PC64. */
12171 return reloc_type
== 23; /* R_S390_PC64. */
12173 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12179 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12180 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12183 is_24bit_abs_reloc (unsigned int reloc_type
)
12185 switch (elf_header
.e_machine
)
12187 case EM_CYGNUS_MN10200
:
12189 return reloc_type
== 4; /* R_MN10200_24. */
12191 return reloc_type
== 5; /* R_FT32_20. */
12197 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12198 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12201 is_16bit_abs_reloc (unsigned int reloc_type
)
12203 /* Please keep this table alpha-sorted for ease of visual lookup. */
12204 switch (elf_header
.e_machine
)
12207 case EM_ARC_COMPACT
:
12208 case EM_ARC_COMPACT2
:
12209 return reloc_type
== 2; /* R_ARC_16. */
12210 case EM_ADAPTEVA_EPIPHANY
:
12211 return reloc_type
== 5;
12214 return reloc_type
== 4; /* R_AVR_16. */
12215 case EM_CYGNUS_D10V
:
12217 return reloc_type
== 3; /* R_D10V_16. */
12221 return reloc_type
== R_H8_DIR16
;
12224 return reloc_type
== 1; /* R_IP2K_16. */
12227 return reloc_type
== 1; /* R_M32C_16 */
12228 case EM_CYGNUS_MN10200
:
12230 return reloc_type
== 2; /* R_MN10200_16. */
12231 case EM_CYGNUS_MN10300
:
12233 return reloc_type
== 2; /* R_MN10300_16. */
12235 if (uses_msp430x_relocs ())
12236 return reloc_type
== 2; /* R_MSP430_ABS16. */
12237 /* Fall through. */
12238 case EM_MSP430_OLD
:
12239 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12241 return reloc_type
== 19; /* R_NDS32_RELA. */
12242 case EM_ALTERA_NIOS2
:
12243 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12245 return reloc_type
== 9; /* R_NIOS_16. */
12247 return reloc_type
== 2; /* R_OR1K_16. */
12249 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12251 return reloc_type
== 2; /* R_C6000_ABS16. */
12253 return reloc_type
== 2; /* R_VISIUM_16. */
12256 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12258 return reloc_type
== 3; /* R_XGATE_16. */
12264 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12265 relocation entries (possibly formerly used for SHT_GROUP sections). */
12268 is_none_reloc (unsigned int reloc_type
)
12270 switch (elf_header
.e_machine
)
12272 case EM_386
: /* R_386_NONE. */
12273 case EM_68K
: /* R_68K_NONE. */
12274 case EM_ADAPTEVA_EPIPHANY
:
12275 case EM_ALPHA
: /* R_ALPHA_NONE. */
12276 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12277 case EM_ARC
: /* R_ARC_NONE. */
12278 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12279 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12280 case EM_ARM
: /* R_ARM_NONE. */
12281 case EM_C166
: /* R_XC16X_NONE. */
12282 case EM_CRIS
: /* R_CRIS_NONE. */
12283 case EM_FT32
: /* R_FT32_NONE. */
12284 case EM_IA_64
: /* R_IA64_NONE. */
12285 case EM_K1OM
: /* R_X86_64_NONE. */
12286 case EM_L1OM
: /* R_X86_64_NONE. */
12287 case EM_M32R
: /* R_M32R_NONE. */
12288 case EM_MIPS
: /* R_MIPS_NONE. */
12289 case EM_MN10300
: /* R_MN10300_NONE. */
12290 case EM_MOXIE
: /* R_MOXIE_NONE. */
12291 case EM_NIOS32
: /* R_NIOS_NONE. */
12292 case EM_OR1K
: /* R_OR1K_NONE. */
12293 case EM_PARISC
: /* R_PARISC_NONE. */
12294 case EM_PPC64
: /* R_PPC64_NONE. */
12295 case EM_PPC
: /* R_PPC_NONE. */
12296 case EM_RISCV
: /* R_RISCV_NONE. */
12297 case EM_S390
: /* R_390_NONE. */
12299 case EM_SH
: /* R_SH_NONE. */
12300 case EM_SPARC32PLUS
:
12301 case EM_SPARC
: /* R_SPARC_NONE. */
12303 case EM_TILEGX
: /* R_TILEGX_NONE. */
12304 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12305 case EM_TI_C6000
:/* R_C6000_NONE. */
12306 case EM_X86_64
: /* R_X86_64_NONE. */
12308 return reloc_type
== 0;
12311 return reloc_type
== 0 || reloc_type
== 256;
12314 return (reloc_type
== 0 /* R_AVR_NONE. */
12315 || reloc_type
== 30 /* R_AVR_DIFF8. */
12316 || reloc_type
== 31 /* R_AVR_DIFF16. */
12317 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12319 return reloc_type
== 3; /* R_METAG_NONE. */
12321 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12322 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12323 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12324 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12325 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12327 return (reloc_type
== 0 /* R_PRU_NONE. */
12328 || reloc_type
== 65 /* R_PRU_DIFF8. */
12329 || reloc_type
== 66 /* R_PRU_DIFF16. */
12330 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12331 case EM_XTENSA_OLD
:
12333 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12334 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12335 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12336 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12341 /* Returns TRUE if there is a relocation against
12342 section NAME at OFFSET bytes. */
12345 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12347 Elf_Internal_Rela
* relocs
;
12348 Elf_Internal_Rela
* rp
;
12350 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12353 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12355 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12356 if (rp
->r_offset
== offset
)
12362 /* Apply relocations to a section.
12363 Note: So far support has been added only for those relocations
12364 which can be found in debug sections.
12365 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12366 loaded relocs. It is then the caller's responsibility to free them.
12367 FIXME: Add support for more relocations ? */
12370 apply_relocations (void * file
,
12371 const Elf_Internal_Shdr
* section
,
12372 unsigned char * start
,
12373 bfd_size_type size
,
12374 void ** relocs_return
,
12375 unsigned long * num_relocs_return
)
12377 Elf_Internal_Shdr
* relsec
;
12378 unsigned char * end
= start
+ size
;
12380 if (relocs_return
!= NULL
)
12382 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12383 * num_relocs_return
= 0;
12386 if (elf_header
.e_type
!= ET_REL
)
12389 /* Find the reloc section associated with the section. */
12390 for (relsec
= section_headers
;
12391 relsec
< section_headers
+ elf_header
.e_shnum
;
12394 bfd_boolean is_rela
;
12395 unsigned long num_relocs
;
12396 Elf_Internal_Rela
* relocs
;
12397 Elf_Internal_Rela
* rp
;
12398 Elf_Internal_Shdr
* symsec
;
12399 Elf_Internal_Sym
* symtab
;
12400 unsigned long num_syms
;
12401 Elf_Internal_Sym
* sym
;
12403 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12404 || relsec
->sh_info
>= elf_header
.e_shnum
12405 || section_headers
+ relsec
->sh_info
!= section
12406 || relsec
->sh_size
== 0
12407 || relsec
->sh_link
>= elf_header
.e_shnum
)
12410 is_rela
= relsec
->sh_type
== SHT_RELA
;
12414 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12415 relsec
->sh_size
, & relocs
, & num_relocs
))
12420 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12421 relsec
->sh_size
, & relocs
, & num_relocs
))
12425 /* SH uses RELA but uses in place value instead of the addend field. */
12426 if (elf_header
.e_machine
== EM_SH
)
12429 symsec
= section_headers
+ relsec
->sh_link
;
12430 if (symsec
->sh_type
!= SHT_SYMTAB
12431 && symsec
->sh_type
!= SHT_DYNSYM
)
12433 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12435 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12438 unsigned int reloc_type
;
12439 unsigned int reloc_size
;
12440 unsigned char * rloc
;
12441 unsigned long sym_index
;
12443 reloc_type
= get_reloc_type (rp
->r_info
);
12445 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12447 else if (is_none_reloc (reloc_type
))
12449 else if (is_32bit_abs_reloc (reloc_type
)
12450 || is_32bit_pcrel_reloc (reloc_type
))
12452 else if (is_64bit_abs_reloc (reloc_type
)
12453 || is_64bit_pcrel_reloc (reloc_type
))
12455 else if (is_24bit_abs_reloc (reloc_type
))
12457 else if (is_16bit_abs_reloc (reloc_type
))
12461 static unsigned int prev_reloc
= 0;
12462 if (reloc_type
!= prev_reloc
)
12463 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12464 reloc_type
, printable_section_name (section
));
12465 prev_reloc
= reloc_type
;
12469 rloc
= start
+ rp
->r_offset
;
12470 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12472 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12473 (unsigned long) rp
->r_offset
,
12474 printable_section_name (section
));
12478 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12479 if (sym_index
>= num_syms
)
12481 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12482 sym_index
, printable_section_name (section
));
12485 sym
= symtab
+ sym_index
;
12487 /* If the reloc has a symbol associated with it,
12488 make sure that it is of an appropriate type.
12490 Relocations against symbols without type can happen.
12491 Gcc -feliminate-dwarf2-dups may generate symbols
12492 without type for debug info.
12494 Icc generates relocations against function symbols
12495 instead of local labels.
12497 Relocations against object symbols can happen, eg when
12498 referencing a global array. For an example of this see
12499 the _clz.o binary in libgcc.a. */
12501 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12502 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12504 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12505 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12506 (long int)(rp
- relocs
),
12507 printable_section_name (relsec
));
12513 addend
+= rp
->r_addend
;
12514 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12515 partial_inplace. */
12517 || (elf_header
.e_machine
== EM_XTENSA
12518 && reloc_type
== 1)
12519 || ((elf_header
.e_machine
== EM_PJ
12520 || elf_header
.e_machine
== EM_PJ_OLD
)
12521 && reloc_type
== 1)
12522 || ((elf_header
.e_machine
== EM_D30V
12523 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12524 && reloc_type
== 12))
12525 addend
+= byte_get (rloc
, reloc_size
);
12527 if (is_32bit_pcrel_reloc (reloc_type
)
12528 || is_64bit_pcrel_reloc (reloc_type
))
12530 /* On HPPA, all pc-relative relocations are biased by 8. */
12531 if (elf_header
.e_machine
== EM_PARISC
)
12533 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12537 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12541 /* Let the target specific reloc processing code know that
12542 we have finished with these relocs. */
12543 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12547 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12548 * num_relocs_return
= num_relocs
;
12557 #ifdef SUPPORT_DISASSEMBLY
12559 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12561 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12563 /* FIXME: XXX -- to be done --- XXX */
12569 /* Reads in the contents of SECTION from FILE, returning a pointer
12570 to a malloc'ed buffer or NULL if something went wrong. */
12573 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12575 bfd_size_type num_bytes
;
12577 num_bytes
= section
->sh_size
;
12579 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12581 printf (_("\nSection '%s' has no data to dump.\n"),
12582 printable_section_name (section
));
12586 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12587 _("section contents"));
12590 /* Uncompresses a section that was compressed using zlib, in place. */
12593 uncompress_section_contents (unsigned char **buffer
,
12594 dwarf_size_type uncompressed_size
,
12595 dwarf_size_type
*size
)
12597 dwarf_size_type compressed_size
= *size
;
12598 unsigned char * compressed_buffer
= *buffer
;
12599 unsigned char * uncompressed_buffer
;
12603 /* It is possible the section consists of several compressed
12604 buffers concatenated together, so we uncompress in a loop. */
12605 /* PR 18313: The state field in the z_stream structure is supposed
12606 to be invisible to the user (ie us), but some compilers will
12607 still complain about it being used without initialisation. So
12608 we first zero the entire z_stream structure and then set the fields
12610 memset (& strm
, 0, sizeof strm
);
12611 strm
.avail_in
= compressed_size
;
12612 strm
.next_in
= (Bytef
*) compressed_buffer
;
12613 strm
.avail_out
= uncompressed_size
;
12614 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12616 rc
= inflateInit (& strm
);
12617 while (strm
.avail_in
> 0)
12621 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12622 + (uncompressed_size
- strm
.avail_out
));
12623 rc
= inflate (&strm
, Z_FINISH
);
12624 if (rc
!= Z_STREAM_END
)
12626 rc
= inflateReset (& strm
);
12628 rc
= inflateEnd (& strm
);
12630 || strm
.avail_out
!= 0)
12633 *buffer
= uncompressed_buffer
;
12634 *size
= uncompressed_size
;
12638 free (uncompressed_buffer
);
12639 /* Indicate decompression failure. */
12645 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12647 Elf_Internal_Shdr
* relsec
;
12648 bfd_size_type num_bytes
;
12649 unsigned char * data
;
12650 unsigned char * end
;
12651 unsigned char * real_start
;
12652 unsigned char * start
;
12653 bfd_boolean some_strings_shown
;
12655 real_start
= start
= (unsigned char *) get_section_contents (section
,
12659 num_bytes
= section
->sh_size
;
12661 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12663 if (decompress_dumps
)
12665 dwarf_size_type new_size
= num_bytes
;
12666 dwarf_size_type uncompressed_size
= 0;
12668 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12670 Elf_Internal_Chdr chdr
;
12671 unsigned int compression_header_size
12672 = get_compression_header (& chdr
, (unsigned char *) start
,
12675 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12677 warn (_("section '%s' has unsupported compress type: %d\n"),
12678 printable_section_name (section
), chdr
.ch_type
);
12681 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12683 warn (_("compressed section '%s' is corrupted\n"),
12684 printable_section_name (section
));
12687 uncompressed_size
= chdr
.ch_size
;
12688 start
+= compression_header_size
;
12689 new_size
-= compression_header_size
;
12691 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12693 /* Read the zlib header. In this case, it should be "ZLIB"
12694 followed by the uncompressed section size, 8 bytes in
12695 big-endian order. */
12696 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12697 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12698 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12699 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12700 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12701 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12702 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12703 uncompressed_size
+= start
[11];
12708 if (uncompressed_size
)
12710 if (uncompress_section_contents (& start
,
12711 uncompressed_size
, & new_size
))
12712 num_bytes
= new_size
;
12715 error (_("Unable to decompress section %s\n"),
12716 printable_section_name (section
));
12721 start
= real_start
;
12724 /* If the section being dumped has relocations against it the user might
12725 be expecting these relocations to have been applied. Check for this
12726 case and issue a warning message in order to avoid confusion.
12727 FIXME: Maybe we ought to have an option that dumps a section with
12728 relocs applied ? */
12729 for (relsec
= section_headers
;
12730 relsec
< section_headers
+ elf_header
.e_shnum
;
12733 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12734 || relsec
->sh_info
>= elf_header
.e_shnum
12735 || section_headers
+ relsec
->sh_info
!= section
12736 || relsec
->sh_size
== 0
12737 || relsec
->sh_link
>= elf_header
.e_shnum
)
12740 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12745 end
= start
+ num_bytes
;
12746 some_strings_shown
= FALSE
;
12750 while (!ISPRINT (* data
))
12751 if (++ data
>= end
)
12756 size_t maxlen
= end
- data
;
12759 /* PR 11128: Use two separate invocations in order to work
12760 around bugs in the Solaris 8 implementation of printf. */
12761 printf (" [%6tx] ", data
- start
);
12763 printf (" [%6Ix] ", (size_t) (data
- start
));
12767 print_symbol ((int) maxlen
, (const char *) data
);
12769 data
+= strnlen ((const char *) data
, maxlen
);
12773 printf (_("<corrupt>\n"));
12776 some_strings_shown
= TRUE
;
12780 if (! some_strings_shown
)
12781 printf (_(" No strings found in this section."));
12789 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12791 bfd_boolean relocate
)
12793 Elf_Internal_Shdr
* relsec
;
12794 bfd_size_type bytes
;
12795 bfd_size_type section_size
;
12797 unsigned char * data
;
12798 unsigned char * real_start
;
12799 unsigned char * start
;
12801 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12804 section_size
= section
->sh_size
;
12806 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12808 if (decompress_dumps
)
12810 dwarf_size_type new_size
= section_size
;
12811 dwarf_size_type uncompressed_size
= 0;
12813 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12815 Elf_Internal_Chdr chdr
;
12816 unsigned int compression_header_size
12817 = get_compression_header (& chdr
, start
, section_size
);
12819 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12821 warn (_("section '%s' has unsupported compress type: %d\n"),
12822 printable_section_name (section
), chdr
.ch_type
);
12825 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12827 warn (_("compressed section '%s' is corrupted\n"),
12828 printable_section_name (section
));
12831 uncompressed_size
= chdr
.ch_size
;
12832 start
+= compression_header_size
;
12833 new_size
-= compression_header_size
;
12835 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12837 /* Read the zlib header. In this case, it should be "ZLIB"
12838 followed by the uncompressed section size, 8 bytes in
12839 big-endian order. */
12840 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12841 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12842 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12843 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12844 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12845 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12846 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12847 uncompressed_size
+= start
[11];
12852 if (uncompressed_size
)
12854 if (uncompress_section_contents (& start
, uncompressed_size
,
12857 section_size
= new_size
;
12861 error (_("Unable to decompress section %s\n"),
12862 printable_section_name (section
));
12863 /* FIXME: Print the section anyway ? */
12868 start
= real_start
;
12873 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12877 /* If the section being dumped has relocations against it the user might
12878 be expecting these relocations to have been applied. Check for this
12879 case and issue a warning message in order to avoid confusion.
12880 FIXME: Maybe we ought to have an option that dumps a section with
12881 relocs applied ? */
12882 for (relsec
= section_headers
;
12883 relsec
< section_headers
+ elf_header
.e_shnum
;
12886 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12887 || relsec
->sh_info
>= elf_header
.e_shnum
12888 || section_headers
+ relsec
->sh_info
!= section
12889 || relsec
->sh_size
== 0
12890 || relsec
->sh_link
>= elf_header
.e_shnum
)
12893 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12898 addr
= section
->sh_addr
;
12899 bytes
= section_size
;
12908 lbytes
= (bytes
> 16 ? 16 : bytes
);
12910 printf (" 0x%8.8lx ", (unsigned long) addr
);
12912 for (j
= 0; j
< 16; j
++)
12915 printf ("%2.2x", data
[j
]);
12923 for (j
= 0; j
< lbytes
; j
++)
12926 if (k
>= ' ' && k
< 0x7f)
12945 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12946 const Elf_Internal_Shdr
* sec
, void * file
)
12948 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12951 /* If it is already loaded, do nothing. */
12952 if (section
->start
!= NULL
)
12955 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12956 section
->address
= sec
->sh_addr
;
12957 section
->user_data
= NULL
;
12958 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12960 sec
->sh_size
, buf
);
12961 if (section
->start
== NULL
)
12965 unsigned char *start
= section
->start
;
12966 dwarf_size_type size
= sec
->sh_size
;
12967 dwarf_size_type uncompressed_size
= 0;
12969 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12971 Elf_Internal_Chdr chdr
;
12972 unsigned int compression_header_size
;
12974 if (size
< (is_32bit_elf
12975 ? sizeof (Elf32_External_Chdr
)
12976 : sizeof (Elf64_External_Chdr
)))
12978 warn (_("compressed section %s is too small to contain a compression header"),
12983 compression_header_size
= get_compression_header (&chdr
, start
, size
);
12985 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12987 warn (_("section '%s' has unsupported compress type: %d\n"),
12988 section
->name
, chdr
.ch_type
);
12991 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12993 warn (_("compressed section '%s' is corrupted\n"),
12997 uncompressed_size
= chdr
.ch_size
;
12998 start
+= compression_header_size
;
12999 size
-= compression_header_size
;
13001 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13003 /* Read the zlib header. In this case, it should be "ZLIB"
13004 followed by the uncompressed section size, 8 bytes in
13005 big-endian order. */
13006 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13007 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13008 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13009 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13010 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13011 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13012 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13013 uncompressed_size
+= start
[11];
13018 if (uncompressed_size
)
13020 if (uncompress_section_contents (&start
, uncompressed_size
,
13023 /* Free the compressed buffer, update the section buffer
13024 and the section size if uncompress is successful. */
13025 free (section
->start
);
13026 section
->start
= start
;
13030 error (_("Unable to decompress section %s\n"),
13031 printable_section_name (sec
));
13036 section
->size
= size
;
13039 if (section
->start
== NULL
)
13042 if (debug_displays
[debug
].relocate
)
13043 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13044 & section
->reloc_info
, & section
->num_relocs
);
13047 section
->reloc_info
= NULL
;
13048 section
->num_relocs
= 0;
13054 /* If this is not NULL, load_debug_section will only look for sections
13055 within the list of sections given here. */
13056 unsigned int *section_subset
= NULL
;
13059 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13061 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13062 Elf_Internal_Shdr
* sec
;
13064 /* Locate the debug section. */
13065 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13067 section
->name
= section
->uncompressed_name
;
13070 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13072 section
->name
= section
->compressed_name
;
13077 /* If we're loading from a subset of sections, and we've loaded
13078 a section matching this name before, it's likely that it's a
13080 if (section_subset
!= NULL
)
13081 free_debug_section (debug
);
13083 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13087 free_debug_section (enum dwarf_section_display_enum debug
)
13089 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13091 if (section
->start
== NULL
)
13094 free ((char *) section
->start
);
13095 section
->start
= NULL
;
13096 section
->address
= 0;
13101 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13103 char * name
= SECTION_NAME (section
);
13104 const char * print_name
= printable_section_name (section
);
13105 bfd_size_type length
;
13109 length
= section
->sh_size
;
13112 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13115 if (section
->sh_type
== SHT_NOBITS
)
13117 /* There is no point in dumping the contents of a debugging section
13118 which has the NOBITS type - the bits in the file will be random.
13119 This can happen when a file containing a .eh_frame section is
13120 stripped with the --only-keep-debug command line option. */
13121 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13126 if (const_strneq (name
, ".gnu.linkonce.wi."))
13127 name
= ".debug_info";
13129 /* See if we know how to display the contents of this section. */
13130 for (i
= 0; i
< max
; i
++)
13131 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13132 || (i
== line
&& const_strneq (name
, ".debug_line."))
13133 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13135 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13136 int secondary
= (section
!= find_section (name
));
13139 free_debug_section ((enum dwarf_section_display_enum
) i
);
13141 if (i
== line
&& const_strneq (name
, ".debug_line."))
13143 else if (streq (sec
->uncompressed_name
, name
))
13144 sec
->name
= sec
->uncompressed_name
;
13146 sec
->name
= sec
->compressed_name
;
13147 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13150 /* If this debug section is part of a CU/TU set in a .dwp file,
13151 restrict load_debug_section to the sections in that set. */
13152 section_subset
= find_cu_tu_set (file
, shndx
);
13154 result
&= debug_displays
[i
].display (sec
, file
);
13156 section_subset
= NULL
;
13158 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13159 free_debug_section ((enum dwarf_section_display_enum
) i
);
13167 printf (_("Unrecognized debug section: %s\n"), print_name
);
13174 /* Set DUMP_SECTS for all sections where dumps were requested
13175 based on section name. */
13178 initialise_dumps_byname (void)
13180 struct dump_list_entry
* cur
;
13182 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13187 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
13188 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13190 request_dump_bynumber (i
, cur
->type
);
13195 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13201 process_section_contents (FILE * file
)
13203 Elf_Internal_Shdr
* section
;
13209 initialise_dumps_byname ();
13211 for (i
= 0, section
= section_headers
;
13212 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13215 #ifdef SUPPORT_DISASSEMBLY
13216 if (dump_sects
[i
] & DISASS_DUMP
)
13217 disassemble_section (section
, file
);
13219 if (dump_sects
[i
] & HEX_DUMP
)
13220 dump_section_as_bytes (section
, file
, FALSE
);
13222 if (dump_sects
[i
] & RELOC_DUMP
)
13223 dump_section_as_bytes (section
, file
, TRUE
);
13225 if (dump_sects
[i
] & STRING_DUMP
)
13226 dump_section_as_strings (section
, file
);
13228 if (dump_sects
[i
] & DEBUG_DUMP
)
13229 display_debug_section (i
, section
, file
);
13232 /* Check to see if the user requested a
13233 dump of a section that does not exist. */
13234 while (i
< num_dump_sects
)
13237 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13243 process_mips_fpe_exception (int mask
)
13248 if (mask
& OEX_FPU_INEX
)
13249 fputs ("INEX", stdout
), first
= 0;
13250 if (mask
& OEX_FPU_UFLO
)
13251 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13252 if (mask
& OEX_FPU_OFLO
)
13253 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13254 if (mask
& OEX_FPU_DIV0
)
13255 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13256 if (mask
& OEX_FPU_INVAL
)
13257 printf ("%sINVAL", first
? "" : "|");
13260 fputs ("0", stdout
);
13263 /* Display's the value of TAG at location P. If TAG is
13264 greater than 0 it is assumed to be an unknown tag, and
13265 a message is printed to this effect. Otherwise it is
13266 assumed that a message has already been printed.
13268 If the bottom bit of TAG is set it assumed to have a
13269 string value, otherwise it is assumed to have an integer
13272 Returns an updated P pointing to the first unread byte
13273 beyond the end of TAG's value.
13275 Reads at or beyond END will not be made. */
13277 static unsigned char *
13278 display_tag_value (int tag
,
13280 const unsigned char * const end
)
13285 printf (" Tag_unknown_%d: ", tag
);
13289 warn (_("<corrupt tag>\n"));
13293 /* PR 17531 file: 027-19978-0.004. */
13294 size_t maxlen
= (end
- p
) - 1;
13299 print_symbol ((int) maxlen
, (const char *) p
);
13300 p
+= strnlen ((char *) p
, maxlen
) + 1;
13304 printf (_("<corrupt string tag>"));
13305 p
= (unsigned char *) end
;
13313 val
= read_uleb128 (p
, &len
, end
);
13315 printf ("%ld (0x%lx)\n", val
, val
);
13322 /* ARM EABI attributes section. */
13327 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13329 const char ** table
;
13330 } arm_attr_public_tag
;
13332 static const char * arm_attr_tag_CPU_arch
[] =
13333 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13334 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13336 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13337 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13338 {"No", "Thumb-1", "Thumb-2", "Yes"};
13339 static const char * arm_attr_tag_FP_arch
[] =
13340 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13341 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13342 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13343 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13344 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13345 "NEON for ARMv8.1"};
13346 static const char * arm_attr_tag_PCS_config
[] =
13347 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13348 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13349 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13350 {"V6", "SB", "TLS", "Unused"};
13351 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13352 {"Absolute", "PC-relative", "SB-relative", "None"};
13353 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13354 {"Absolute", "PC-relative", "None"};
13355 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13356 {"None", "direct", "GOT-indirect"};
13357 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13358 {"None", "??? 1", "2", "??? 3", "4"};
13359 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13360 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13361 {"Unused", "Needed", "Sign only"};
13362 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13363 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13364 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13365 {"Unused", "Finite", "RTABI", "IEEE 754"};
13366 static const char * arm_attr_tag_ABI_enum_size
[] =
13367 {"Unused", "small", "int", "forced to int"};
13368 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13369 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13370 static const char * arm_attr_tag_ABI_VFP_args
[] =
13371 {"AAPCS", "VFP registers", "custom", "compatible"};
13372 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13373 {"AAPCS", "WMMX registers", "custom"};
13374 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13375 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13376 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13377 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13378 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13379 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13380 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13381 static const char * arm_attr_tag_FP_HP_extension
[] =
13382 {"Not Allowed", "Allowed"};
13383 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13384 {"None", "IEEE 754", "Alternative Format"};
13385 static const char * arm_attr_tag_DSP_extension
[] =
13386 {"Follow architecture", "Allowed"};
13387 static const char * arm_attr_tag_MPextension_use
[] =
13388 {"Not Allowed", "Allowed"};
13389 static const char * arm_attr_tag_DIV_use
[] =
13390 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13391 "Allowed in v7-A with integer division extension"};
13392 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13393 static const char * arm_attr_tag_Virtualization_use
[] =
13394 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13395 "TrustZone and Virtualization Extensions"};
13396 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13397 {"Not Allowed", "Allowed"};
13399 #define LOOKUP(id, name) \
13400 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13401 static arm_attr_public_tag arm_attr_public_tags
[] =
13403 {4, "CPU_raw_name", 1, NULL
},
13404 {5, "CPU_name", 1, NULL
},
13405 LOOKUP(6, CPU_arch
),
13406 {7, "CPU_arch_profile", 0, NULL
},
13407 LOOKUP(8, ARM_ISA_use
),
13408 LOOKUP(9, THUMB_ISA_use
),
13409 LOOKUP(10, FP_arch
),
13410 LOOKUP(11, WMMX_arch
),
13411 LOOKUP(12, Advanced_SIMD_arch
),
13412 LOOKUP(13, PCS_config
),
13413 LOOKUP(14, ABI_PCS_R9_use
),
13414 LOOKUP(15, ABI_PCS_RW_data
),
13415 LOOKUP(16, ABI_PCS_RO_data
),
13416 LOOKUP(17, ABI_PCS_GOT_use
),
13417 LOOKUP(18, ABI_PCS_wchar_t
),
13418 LOOKUP(19, ABI_FP_rounding
),
13419 LOOKUP(20, ABI_FP_denormal
),
13420 LOOKUP(21, ABI_FP_exceptions
),
13421 LOOKUP(22, ABI_FP_user_exceptions
),
13422 LOOKUP(23, ABI_FP_number_model
),
13423 {24, "ABI_align_needed", 0, NULL
},
13424 {25, "ABI_align_preserved", 0, NULL
},
13425 LOOKUP(26, ABI_enum_size
),
13426 LOOKUP(27, ABI_HardFP_use
),
13427 LOOKUP(28, ABI_VFP_args
),
13428 LOOKUP(29, ABI_WMMX_args
),
13429 LOOKUP(30, ABI_optimization_goals
),
13430 LOOKUP(31, ABI_FP_optimization_goals
),
13431 {32, "compatibility", 0, NULL
},
13432 LOOKUP(34, CPU_unaligned_access
),
13433 LOOKUP(36, FP_HP_extension
),
13434 LOOKUP(38, ABI_FP_16bit_format
),
13435 LOOKUP(42, MPextension_use
),
13436 LOOKUP(44, DIV_use
),
13437 LOOKUP(46, DSP_extension
),
13438 {64, "nodefaults", 0, NULL
},
13439 {65, "also_compatible_with", 0, NULL
},
13440 LOOKUP(66, T2EE_use
),
13441 {67, "conformance", 1, NULL
},
13442 LOOKUP(68, Virtualization_use
),
13443 LOOKUP(70, MPextension_use_legacy
)
13447 static unsigned char *
13448 display_arm_attribute (unsigned char * p
,
13449 const unsigned char * const end
)
13454 arm_attr_public_tag
* attr
;
13458 tag
= read_uleb128 (p
, &len
, end
);
13461 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13463 if (arm_attr_public_tags
[i
].tag
== tag
)
13465 attr
= &arm_attr_public_tags
[i
];
13472 printf (" Tag_%s: ", attr
->name
);
13473 switch (attr
->type
)
13478 case 7: /* Tag_CPU_arch_profile. */
13479 val
= read_uleb128 (p
, &len
, end
);
13483 case 0: printf (_("None\n")); break;
13484 case 'A': printf (_("Application\n")); break;
13485 case 'R': printf (_("Realtime\n")); break;
13486 case 'M': printf (_("Microcontroller\n")); break;
13487 case 'S': printf (_("Application or Realtime\n")); break;
13488 default: printf ("??? (%d)\n", val
); break;
13492 case 24: /* Tag_align_needed. */
13493 val
= read_uleb128 (p
, &len
, end
);
13497 case 0: printf (_("None\n")); break;
13498 case 1: printf (_("8-byte\n")); break;
13499 case 2: printf (_("4-byte\n")); break;
13500 case 3: printf ("??? 3\n"); break;
13503 printf (_("8-byte and up to %d-byte extended\n"),
13506 printf ("??? (%d)\n", val
);
13511 case 25: /* Tag_align_preserved. */
13512 val
= read_uleb128 (p
, &len
, end
);
13516 case 0: printf (_("None\n")); break;
13517 case 1: printf (_("8-byte, except leaf SP\n")); break;
13518 case 2: printf (_("8-byte\n")); break;
13519 case 3: printf ("??? 3\n"); break;
13522 printf (_("8-byte and up to %d-byte extended\n"),
13525 printf ("??? (%d)\n", val
);
13530 case 32: /* Tag_compatibility. */
13532 val
= read_uleb128 (p
, &len
, end
);
13534 printf (_("flag = %d, vendor = "), val
);
13537 size_t maxlen
= (end
- p
) - 1;
13539 print_symbol ((int) maxlen
, (const char *) p
);
13540 p
+= strnlen ((char *) p
, maxlen
) + 1;
13544 printf (_("<corrupt>"));
13545 p
= (unsigned char *) end
;
13551 case 64: /* Tag_nodefaults. */
13552 /* PR 17531: file: 001-505008-0.01. */
13555 printf (_("True\n"));
13558 case 65: /* Tag_also_compatible_with. */
13559 val
= read_uleb128 (p
, &len
, end
);
13561 if (val
== 6 /* Tag_CPU_arch. */)
13563 val
= read_uleb128 (p
, &len
, end
);
13565 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13566 printf ("??? (%d)\n", val
);
13568 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13572 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13577 printf (_("<unknown: %d>\n"), tag
);
13583 return display_tag_value (-1, p
, end
);
13585 return display_tag_value (0, p
, end
);
13588 assert (attr
->type
& 0x80);
13589 val
= read_uleb128 (p
, &len
, end
);
13591 type
= attr
->type
& 0x7f;
13593 printf ("??? (%d)\n", val
);
13595 printf ("%s\n", attr
->table
[val
]);
13600 return display_tag_value (tag
, p
, end
);
13603 static unsigned char *
13604 display_gnu_attribute (unsigned char * p
,
13605 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13606 const unsigned char * const end
)
13612 tag
= read_uleb128 (p
, &len
, end
);
13615 /* Tag_compatibility is the only generic GNU attribute defined at
13619 val
= read_uleb128 (p
, &len
, end
);
13622 printf (_("flag = %d, vendor = "), val
);
13625 printf (_("<corrupt>\n"));
13626 warn (_("corrupt vendor attribute\n"));
13632 size_t maxlen
= (end
- p
) - 1;
13634 print_symbol ((int) maxlen
, (const char *) p
);
13635 p
+= strnlen ((char *) p
, maxlen
) + 1;
13639 printf (_("<corrupt>"));
13640 p
= (unsigned char *) end
;
13647 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13648 return display_proc_gnu_attribute (p
, tag
, end
);
13650 return display_tag_value (tag
, p
, end
);
13653 static unsigned char *
13654 display_power_gnu_attribute (unsigned char * p
,
13656 const unsigned char * const end
)
13661 if (tag
== Tag_GNU_Power_ABI_FP
)
13663 val
= read_uleb128 (p
, &len
, end
);
13665 printf (" Tag_GNU_Power_ABI_FP: ");
13668 printf (_("<corrupt>\n"));
13673 printf ("(%#x), ", val
);
13678 printf (_("unspecified hard/soft float, "));
13681 printf (_("hard float, "));
13684 printf (_("soft float, "));
13687 printf (_("single-precision hard float, "));
13694 printf (_("unspecified long double\n"));
13697 printf (_("128-bit IBM long double\n"));
13700 printf (_("64-bit long double\n"));
13703 printf (_("128-bit IEEE long double\n"));
13709 if (tag
== Tag_GNU_Power_ABI_Vector
)
13711 val
= read_uleb128 (p
, &len
, end
);
13713 printf (" Tag_GNU_Power_ABI_Vector: ");
13716 printf (_("<corrupt>\n"));
13721 printf ("(%#x), ", val
);
13726 printf (_("unspecified\n"));
13729 printf (_("generic\n"));
13732 printf ("AltiVec\n");
13741 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13743 val
= read_uleb128 (p
, &len
, end
);
13745 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13748 printf (_("<corrupt>\n"));
13753 printf ("(%#x), ", val
);
13758 printf (_("unspecified\n"));
13761 printf ("r3/r4\n");
13764 printf (_("memory\n"));
13773 return display_tag_value (tag
& 1, p
, end
);
13776 static unsigned char *
13777 display_s390_gnu_attribute (unsigned char * p
,
13779 const unsigned char * const end
)
13784 if (tag
== Tag_GNU_S390_ABI_Vector
)
13786 val
= read_uleb128 (p
, &len
, end
);
13788 printf (" Tag_GNU_S390_ABI_Vector: ");
13793 printf (_("any\n"));
13796 printf (_("software\n"));
13799 printf (_("hardware\n"));
13802 printf ("??? (%d)\n", val
);
13808 return display_tag_value (tag
& 1, p
, end
);
13812 display_sparc_hwcaps (int mask
)
13818 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13819 fputs ("mul32", stdout
), first
= 0;
13820 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13821 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13822 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13823 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13824 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13825 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13826 if (mask
& ELF_SPARC_HWCAP_POPC
)
13827 printf ("%spopc", first
? "" : "|"), first
= 0;
13828 if (mask
& ELF_SPARC_HWCAP_VIS
)
13829 printf ("%svis", first
? "" : "|"), first
= 0;
13830 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13831 printf ("%svis2", first
? "" : "|"), first
= 0;
13832 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13833 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13834 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13835 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13836 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13837 printf ("%svis3", first
? "" : "|"), first
= 0;
13838 if (mask
& ELF_SPARC_HWCAP_HPC
)
13839 printf ("%shpc", first
? "" : "|"), first
= 0;
13840 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13841 printf ("%srandom", first
? "" : "|"), first
= 0;
13842 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13843 printf ("%strans", first
? "" : "|"), first
= 0;
13844 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13845 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13846 if (mask
& ELF_SPARC_HWCAP_IMA
)
13847 printf ("%sima", first
? "" : "|"), first
= 0;
13848 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13849 printf ("%scspare", first
? "" : "|"), first
= 0;
13852 fputc ('0', stdout
);
13853 fputc ('\n', stdout
);
13857 display_sparc_hwcaps2 (int mask
)
13863 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13864 fputs ("fjathplus", stdout
), first
= 0;
13865 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13866 printf ("%svis3b", first
? "" : "|"), first
= 0;
13867 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13868 printf ("%sadp", first
? "" : "|"), first
= 0;
13869 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13870 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13871 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13872 printf ("%smwait", first
? "" : "|"), first
= 0;
13873 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13874 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13875 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13876 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13877 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13878 printf ("%snsec", first
? "" : "|"), first
= 0;
13879 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13880 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13881 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13882 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13883 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13884 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13887 fputc ('0', stdout
);
13888 fputc ('\n', stdout
);
13891 static unsigned char *
13892 display_sparc_gnu_attribute (unsigned char * p
,
13894 const unsigned char * const end
)
13899 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13901 val
= read_uleb128 (p
, &len
, end
);
13903 printf (" Tag_GNU_Sparc_HWCAPS: ");
13904 display_sparc_hwcaps (val
);
13907 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13909 val
= read_uleb128 (p
, &len
, end
);
13911 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13912 display_sparc_hwcaps2 (val
);
13916 return display_tag_value (tag
, p
, end
);
13920 print_mips_fp_abi_value (int val
)
13924 case Val_GNU_MIPS_ABI_FP_ANY
:
13925 printf (_("Hard or soft float\n"));
13927 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13928 printf (_("Hard float (double precision)\n"));
13930 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13931 printf (_("Hard float (single precision)\n"));
13933 case Val_GNU_MIPS_ABI_FP_SOFT
:
13934 printf (_("Soft float\n"));
13936 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13937 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13939 case Val_GNU_MIPS_ABI_FP_XX
:
13940 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13942 case Val_GNU_MIPS_ABI_FP_64
:
13943 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13945 case Val_GNU_MIPS_ABI_FP_64A
:
13946 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13948 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13949 printf (_("NaN 2008 compatibility\n"));
13952 printf ("??? (%d)\n", val
);
13957 static unsigned char *
13958 display_mips_gnu_attribute (unsigned char * p
,
13960 const unsigned char * const end
)
13962 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13967 val
= read_uleb128 (p
, &len
, end
);
13969 printf (" Tag_GNU_MIPS_ABI_FP: ");
13971 print_mips_fp_abi_value (val
);
13976 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13981 val
= read_uleb128 (p
, &len
, end
);
13983 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13987 case Val_GNU_MIPS_ABI_MSA_ANY
:
13988 printf (_("Any MSA or not\n"));
13990 case Val_GNU_MIPS_ABI_MSA_128
:
13991 printf (_("128-bit MSA\n"));
13994 printf ("??? (%d)\n", val
);
14000 return display_tag_value (tag
& 1, p
, end
);
14003 static unsigned char *
14004 display_tic6x_attribute (unsigned char * p
,
14005 const unsigned char * const end
)
14011 tag
= read_uleb128 (p
, &len
, end
);
14017 val
= read_uleb128 (p
, &len
, end
);
14019 printf (" Tag_ISA: ");
14023 case C6XABI_Tag_ISA_none
:
14024 printf (_("None\n"));
14026 case C6XABI_Tag_ISA_C62X
:
14029 case C6XABI_Tag_ISA_C67X
:
14032 case C6XABI_Tag_ISA_C67XP
:
14033 printf ("C67x+\n");
14035 case C6XABI_Tag_ISA_C64X
:
14038 case C6XABI_Tag_ISA_C64XP
:
14039 printf ("C64x+\n");
14041 case C6XABI_Tag_ISA_C674X
:
14042 printf ("C674x\n");
14045 printf ("??? (%d)\n", val
);
14050 case Tag_ABI_wchar_t
:
14051 val
= read_uleb128 (p
, &len
, end
);
14053 printf (" Tag_ABI_wchar_t: ");
14057 printf (_("Not used\n"));
14060 printf (_("2 bytes\n"));
14063 printf (_("4 bytes\n"));
14066 printf ("??? (%d)\n", val
);
14071 case Tag_ABI_stack_align_needed
:
14072 val
= read_uleb128 (p
, &len
, end
);
14074 printf (" Tag_ABI_stack_align_needed: ");
14078 printf (_("8-byte\n"));
14081 printf (_("16-byte\n"));
14084 printf ("??? (%d)\n", val
);
14089 case Tag_ABI_stack_align_preserved
:
14090 val
= read_uleb128 (p
, &len
, end
);
14092 printf (" Tag_ABI_stack_align_preserved: ");
14096 printf (_("8-byte\n"));
14099 printf (_("16-byte\n"));
14102 printf ("??? (%d)\n", val
);
14108 val
= read_uleb128 (p
, &len
, end
);
14110 printf (" Tag_ABI_DSBT: ");
14114 printf (_("DSBT addressing not used\n"));
14117 printf (_("DSBT addressing used\n"));
14120 printf ("??? (%d)\n", val
);
14126 val
= read_uleb128 (p
, &len
, end
);
14128 printf (" Tag_ABI_PID: ");
14132 printf (_("Data addressing position-dependent\n"));
14135 printf (_("Data addressing position-independent, GOT near DP\n"));
14138 printf (_("Data addressing position-independent, GOT far from DP\n"));
14141 printf ("??? (%d)\n", val
);
14147 val
= read_uleb128 (p
, &len
, end
);
14149 printf (" Tag_ABI_PIC: ");
14153 printf (_("Code addressing position-dependent\n"));
14156 printf (_("Code addressing position-independent\n"));
14159 printf ("??? (%d)\n", val
);
14164 case Tag_ABI_array_object_alignment
:
14165 val
= read_uleb128 (p
, &len
, end
);
14167 printf (" Tag_ABI_array_object_alignment: ");
14171 printf (_("8-byte\n"));
14174 printf (_("4-byte\n"));
14177 printf (_("16-byte\n"));
14180 printf ("??? (%d)\n", val
);
14185 case Tag_ABI_array_object_align_expected
:
14186 val
= read_uleb128 (p
, &len
, end
);
14188 printf (" Tag_ABI_array_object_align_expected: ");
14192 printf (_("8-byte\n"));
14195 printf (_("4-byte\n"));
14198 printf (_("16-byte\n"));
14201 printf ("??? (%d)\n", val
);
14206 case Tag_ABI_compatibility
:
14208 val
= read_uleb128 (p
, &len
, end
);
14210 printf (" Tag_ABI_compatibility: ");
14211 printf (_("flag = %d, vendor = "), val
);
14214 size_t maxlen
= (end
- p
) - 1;
14216 print_symbol ((int) maxlen
, (const char *) p
);
14217 p
+= strnlen ((char *) p
, maxlen
) + 1;
14221 printf (_("<corrupt>"));
14222 p
= (unsigned char *) end
;
14228 case Tag_ABI_conformance
:
14230 printf (" Tag_ABI_conformance: \"");
14233 size_t maxlen
= (end
- p
) - 1;
14235 print_symbol ((int) maxlen
, (const char *) p
);
14236 p
+= strnlen ((char *) p
, maxlen
) + 1;
14240 printf (_("<corrupt>"));
14241 p
= (unsigned char *) end
;
14248 return display_tag_value (tag
, p
, end
);
14252 display_raw_attribute (unsigned char * p
, unsigned char * end
)
14254 unsigned long addr
= 0;
14255 size_t bytes
= end
- p
;
14262 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14264 printf (" 0x%8.8lx ", addr
);
14266 for (j
= 0; j
< 16; j
++)
14269 printf ("%2.2x", p
[j
]);
14277 for (j
= 0; j
< lbytes
; j
++)
14280 if (k
>= ' ' && k
< 0x7f)
14296 static unsigned char *
14297 display_msp430x_attribute (unsigned char * p
,
14298 const unsigned char * const end
)
14304 tag
= read_uleb128 (p
, & len
, end
);
14309 case OFBA_MSPABI_Tag_ISA
:
14310 val
= read_uleb128 (p
, &len
, end
);
14312 printf (" Tag_ISA: ");
14315 case 0: printf (_("None\n")); break;
14316 case 1: printf (_("MSP430\n")); break;
14317 case 2: printf (_("MSP430X\n")); break;
14318 default: printf ("??? (%d)\n", val
); break;
14322 case OFBA_MSPABI_Tag_Code_Model
:
14323 val
= read_uleb128 (p
, &len
, end
);
14325 printf (" Tag_Code_Model: ");
14328 case 0: printf (_("None\n")); break;
14329 case 1: printf (_("Small\n")); break;
14330 case 2: printf (_("Large\n")); break;
14331 default: printf ("??? (%d)\n", val
); break;
14335 case OFBA_MSPABI_Tag_Data_Model
:
14336 val
= read_uleb128 (p
, &len
, end
);
14338 printf (" Tag_Data_Model: ");
14341 case 0: printf (_("None\n")); break;
14342 case 1: printf (_("Small\n")); break;
14343 case 2: printf (_("Large\n")); break;
14344 case 3: printf (_("Restricted Large\n")); break;
14345 default: printf ("??? (%d)\n", val
); break;
14350 printf (_(" <unknown tag %d>: "), tag
);
14357 size_t maxlen
= (end
- p
) - 1;
14359 print_symbol ((int) maxlen
, (const char *) p
);
14360 p
+= strnlen ((char *) p
, maxlen
) + 1;
14364 printf (_("<corrupt>"));
14365 p
= (unsigned char *) end
;
14371 val
= read_uleb128 (p
, &len
, end
);
14373 printf ("%d (0x%x)\n", val
, val
);
14383 process_attributes (FILE * file
,
14384 const char * public_name
,
14385 unsigned int proc_type
,
14386 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14387 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14389 Elf_Internal_Shdr
* sect
;
14392 /* Find the section header so that we get the size. */
14393 for (i
= 0, sect
= section_headers
;
14394 i
< elf_header
.e_shnum
;
14397 unsigned char * contents
;
14400 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14403 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14404 sect
->sh_size
, _("attributes"));
14405 if (contents
== NULL
)
14411 bfd_vma section_len
;
14413 section_len
= sect
->sh_size
- 1;
14416 while (section_len
> 0)
14419 unsigned int namelen
;
14420 bfd_boolean public_section
;
14421 bfd_boolean gnu_section
;
14423 if (section_len
<= 4)
14425 error (_("Tag section ends prematurely\n"));
14428 attr_len
= byte_get (p
, 4);
14431 if (attr_len
> section_len
)
14433 error (_("Bad attribute length (%u > %u)\n"),
14434 (unsigned) attr_len
, (unsigned) section_len
);
14435 attr_len
= section_len
;
14437 /* PR 17531: file: 001-101425-0.004 */
14438 else if (attr_len
< 5)
14440 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14444 section_len
-= attr_len
;
14447 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14448 if (namelen
== 0 || namelen
>= attr_len
)
14450 error (_("Corrupt attribute section name\n"));
14454 printf (_("Attribute Section: "));
14455 print_symbol (INT_MAX
, (const char *) p
);
14458 if (public_name
&& streq ((char *) p
, public_name
))
14459 public_section
= TRUE
;
14461 public_section
= FALSE
;
14463 if (streq ((char *) p
, "gnu"))
14464 gnu_section
= TRUE
;
14466 gnu_section
= FALSE
;
14469 attr_len
-= namelen
;
14471 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14476 unsigned char * end
;
14478 /* PR binutils/17531: Safe handling of corrupt files. */
14481 error (_("Unused bytes at end of section\n"));
14487 size
= byte_get (p
, 4);
14488 if (size
> attr_len
)
14490 error (_("Bad subsection length (%u > %u)\n"),
14491 (unsigned) size
, (unsigned) attr_len
);
14494 /* PR binutils/17531: Safe handling of corrupt files. */
14497 error (_("Bad subsection length (%u < 6)\n"),
14504 end
= p
+ size
- 1;
14505 assert (end
<= contents
+ sect
->sh_size
);
14511 printf (_("File Attributes\n"));
14514 printf (_("Section Attributes:"));
14517 printf (_("Symbol Attributes:"));
14518 /* Fall through. */
14524 val
= read_uleb128 (p
, &j
, end
);
14528 printf (" %d", val
);
14533 printf (_("Unknown tag: %d\n"), tag
);
14534 public_section
= FALSE
;
14538 if (public_section
&& display_pub_attribute
!= NULL
)
14541 p
= display_pub_attribute (p
, end
);
14544 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14547 p
= display_gnu_attribute (p
,
14548 display_proc_gnu_attribute
,
14554 printf (_(" Unknown attribute:\n"));
14555 display_raw_attribute (p
, end
);
14564 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14572 process_arm_specific (FILE * file
)
14574 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14575 display_arm_attribute
, NULL
);
14579 process_power_specific (FILE * file
)
14581 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14582 display_power_gnu_attribute
);
14586 process_s390_specific (FILE * file
)
14588 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14589 display_s390_gnu_attribute
);
14593 process_sparc_specific (FILE * file
)
14595 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14596 display_sparc_gnu_attribute
);
14600 process_tic6x_specific (FILE * file
)
14602 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14603 display_tic6x_attribute
, NULL
);
14607 process_msp430x_specific (FILE * file
)
14609 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14610 display_msp430x_attribute
, NULL
);
14613 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14614 Print the Address, Access and Initial fields of an entry at VMA ADDR
14615 and return the VMA of the next entry, or -1 if there was a problem.
14616 Does not read from DATA_END or beyond. */
14619 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14620 unsigned char * data_end
)
14623 print_vma (addr
, LONG_HEX
);
14625 if (addr
< pltgot
+ 0xfff0)
14626 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14628 printf ("%10s", "");
14631 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14635 unsigned char * from
= data
+ addr
- pltgot
;
14637 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14639 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14640 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14641 return (bfd_vma
) -1;
14645 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14646 print_vma (entry
, LONG_HEX
);
14649 return addr
+ (is_32bit_elf
? 4 : 8);
14652 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14653 PLTGOT. Print the Address and Initial fields of an entry at VMA
14654 ADDR and return the VMA of the next entry. */
14657 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14660 print_vma (addr
, LONG_HEX
);
14663 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14668 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14669 print_vma (entry
, LONG_HEX
);
14671 return addr
+ (is_32bit_elf
? 4 : 8);
14675 print_mips_ases (unsigned int mask
)
14677 if (mask
& AFL_ASE_DSP
)
14678 fputs ("\n\tDSP ASE", stdout
);
14679 if (mask
& AFL_ASE_DSPR2
)
14680 fputs ("\n\tDSP R2 ASE", stdout
);
14681 if (mask
& AFL_ASE_DSPR3
)
14682 fputs ("\n\tDSP R3 ASE", stdout
);
14683 if (mask
& AFL_ASE_EVA
)
14684 fputs ("\n\tEnhanced VA Scheme", stdout
);
14685 if (mask
& AFL_ASE_MCU
)
14686 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14687 if (mask
& AFL_ASE_MDMX
)
14688 fputs ("\n\tMDMX ASE", stdout
);
14689 if (mask
& AFL_ASE_MIPS3D
)
14690 fputs ("\n\tMIPS-3D ASE", stdout
);
14691 if (mask
& AFL_ASE_MT
)
14692 fputs ("\n\tMT ASE", stdout
);
14693 if (mask
& AFL_ASE_SMARTMIPS
)
14694 fputs ("\n\tSmartMIPS ASE", stdout
);
14695 if (mask
& AFL_ASE_VIRT
)
14696 fputs ("\n\tVZ ASE", stdout
);
14697 if (mask
& AFL_ASE_MSA
)
14698 fputs ("\n\tMSA ASE", stdout
);
14699 if (mask
& AFL_ASE_MIPS16
)
14700 fputs ("\n\tMIPS16 ASE", stdout
);
14701 if (mask
& AFL_ASE_MICROMIPS
)
14702 fputs ("\n\tMICROMIPS ASE", stdout
);
14703 if (mask
& AFL_ASE_XPA
)
14704 fputs ("\n\tXPA ASE", stdout
);
14706 fprintf (stdout
, "\n\t%s", _("None"));
14707 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14708 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14712 print_mips_isa_ext (unsigned int isa_ext
)
14717 fputs (_("None"), stdout
);
14720 fputs ("RMI XLR", stdout
);
14722 case AFL_EXT_OCTEON3
:
14723 fputs ("Cavium Networks Octeon3", stdout
);
14725 case AFL_EXT_OCTEON2
:
14726 fputs ("Cavium Networks Octeon2", stdout
);
14728 case AFL_EXT_OCTEONP
:
14729 fputs ("Cavium Networks OcteonP", stdout
);
14731 case AFL_EXT_LOONGSON_3A
:
14732 fputs ("Loongson 3A", stdout
);
14734 case AFL_EXT_OCTEON
:
14735 fputs ("Cavium Networks Octeon", stdout
);
14738 fputs ("Toshiba R5900", stdout
);
14741 fputs ("MIPS R4650", stdout
);
14744 fputs ("LSI R4010", stdout
);
14747 fputs ("NEC VR4100", stdout
);
14750 fputs ("Toshiba R3900", stdout
);
14752 case AFL_EXT_10000
:
14753 fputs ("MIPS R10000", stdout
);
14756 fputs ("Broadcom SB-1", stdout
);
14759 fputs ("NEC VR4111/VR4181", stdout
);
14762 fputs ("NEC VR4120", stdout
);
14765 fputs ("NEC VR5400", stdout
);
14768 fputs ("NEC VR5500", stdout
);
14770 case AFL_EXT_LOONGSON_2E
:
14771 fputs ("ST Microelectronics Loongson 2E", stdout
);
14773 case AFL_EXT_LOONGSON_2F
:
14774 fputs ("ST Microelectronics Loongson 2F", stdout
);
14777 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14782 get_mips_reg_size (int reg_size
)
14784 return (reg_size
== AFL_REG_NONE
) ? 0
14785 : (reg_size
== AFL_REG_32
) ? 32
14786 : (reg_size
== AFL_REG_64
) ? 64
14787 : (reg_size
== AFL_REG_128
) ? 128
14792 process_mips_specific (FILE * file
)
14794 Elf_Internal_Dyn
* entry
;
14795 Elf_Internal_Shdr
*sect
= NULL
;
14796 size_t liblist_offset
= 0;
14797 size_t liblistno
= 0;
14798 size_t conflictsno
= 0;
14799 size_t options_offset
= 0;
14800 size_t conflicts_offset
= 0;
14801 size_t pltrelsz
= 0;
14803 bfd_vma pltgot
= 0;
14804 bfd_vma mips_pltgot
= 0;
14805 bfd_vma jmprel
= 0;
14806 bfd_vma local_gotno
= 0;
14807 bfd_vma gotsym
= 0;
14808 bfd_vma symtabno
= 0;
14810 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14811 display_mips_gnu_attribute
);
14813 sect
= find_section (".MIPS.abiflags");
14817 Elf_External_ABIFlags_v0
*abiflags_ext
;
14818 Elf_Internal_ABIFlags_v0 abiflags_in
;
14820 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14821 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14824 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14825 sect
->sh_size
, _("MIPS ABI Flags section"));
14828 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14829 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14830 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14831 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14832 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14833 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14834 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14835 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14836 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14837 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14838 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14840 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14841 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14842 if (abiflags_in
.isa_rev
> 1)
14843 printf ("r%d", abiflags_in
.isa_rev
);
14844 printf ("\nGPR size: %d",
14845 get_mips_reg_size (abiflags_in
.gpr_size
));
14846 printf ("\nCPR1 size: %d",
14847 get_mips_reg_size (abiflags_in
.cpr1_size
));
14848 printf ("\nCPR2 size: %d",
14849 get_mips_reg_size (abiflags_in
.cpr2_size
));
14850 fputs ("\nFP ABI: ", stdout
);
14851 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14852 fputs ("ISA Extension: ", stdout
);
14853 print_mips_isa_ext (abiflags_in
.isa_ext
);
14854 fputs ("\nASEs:", stdout
);
14855 print_mips_ases (abiflags_in
.ases
);
14856 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14857 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14858 fputc ('\n', stdout
);
14859 free (abiflags_ext
);
14864 /* We have a lot of special sections. Thanks SGI! */
14865 if (dynamic_section
== NULL
)
14866 /* No information available. */
14869 for (entry
= dynamic_section
;
14870 /* PR 17531 file: 012-50589-0.004. */
14871 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14873 switch (entry
->d_tag
)
14875 case DT_MIPS_LIBLIST
:
14877 = offset_from_vma (file
, entry
->d_un
.d_val
,
14878 liblistno
* sizeof (Elf32_External_Lib
));
14880 case DT_MIPS_LIBLISTNO
:
14881 liblistno
= entry
->d_un
.d_val
;
14883 case DT_MIPS_OPTIONS
:
14884 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14886 case DT_MIPS_CONFLICT
:
14888 = offset_from_vma (file
, entry
->d_un
.d_val
,
14889 conflictsno
* sizeof (Elf32_External_Conflict
));
14891 case DT_MIPS_CONFLICTNO
:
14892 conflictsno
= entry
->d_un
.d_val
;
14895 pltgot
= entry
->d_un
.d_ptr
;
14897 case DT_MIPS_LOCAL_GOTNO
:
14898 local_gotno
= entry
->d_un
.d_val
;
14900 case DT_MIPS_GOTSYM
:
14901 gotsym
= entry
->d_un
.d_val
;
14903 case DT_MIPS_SYMTABNO
:
14904 symtabno
= entry
->d_un
.d_val
;
14906 case DT_MIPS_PLTGOT
:
14907 mips_pltgot
= entry
->d_un
.d_ptr
;
14910 pltrel
= entry
->d_un
.d_val
;
14913 pltrelsz
= entry
->d_un
.d_val
;
14916 jmprel
= entry
->d_un
.d_ptr
;
14922 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14924 Elf32_External_Lib
* elib
;
14927 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14929 sizeof (Elf32_External_Lib
),
14930 _("liblist section data"));
14933 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14934 (unsigned long) liblistno
);
14935 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14938 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14945 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14946 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14947 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14948 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14949 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14951 tmp
= gmtime (&atime
);
14952 snprintf (timebuf
, sizeof (timebuf
),
14953 "%04u-%02u-%02uT%02u:%02u:%02u",
14954 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14955 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14957 printf ("%3lu: ", (unsigned long) cnt
);
14958 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14959 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14961 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14962 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14963 liblist
.l_version
);
14965 if (liblist
.l_flags
== 0)
14969 static const struct
14976 { " EXACT_MATCH", LL_EXACT_MATCH
},
14977 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14978 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14979 { " EXPORTS", LL_EXPORTS
},
14980 { " DELAY_LOAD", LL_DELAY_LOAD
},
14981 { " DELTA", LL_DELTA
}
14983 int flags
= liblist
.l_flags
;
14986 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14987 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14989 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14990 flags
^= l_flags_vals
[fcnt
].bit
;
14993 printf (" %#x", (unsigned int) flags
);
15003 if (options_offset
!= 0)
15005 Elf_External_Options
* eopt
;
15006 Elf_Internal_Options
* iopt
;
15007 Elf_Internal_Options
* option
;
15010 sect
= section_headers
;
15012 /* Find the section header so that we get the size. */
15013 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15014 /* PR 17533 file: 012-277276-0.004. */
15017 error (_("No MIPS_OPTIONS header found\n"));
15021 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15022 sect
->sh_size
, _("options"));
15025 iopt
= (Elf_Internal_Options
*)
15026 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15029 error (_("Out of memory allocating space for MIPS options\n"));
15036 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15038 Elf_External_Options
* eoption
;
15040 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15042 option
->kind
= BYTE_GET (eoption
->kind
);
15043 option
->size
= BYTE_GET (eoption
->size
);
15044 option
->section
= BYTE_GET (eoption
->section
);
15045 option
->info
= BYTE_GET (eoption
->info
);
15047 /* PR 17531: file: ffa0fa3b. */
15048 if (option
->size
< sizeof (* eopt
)
15049 || offset
+ option
->size
> sect
->sh_size
)
15051 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15054 offset
+= option
->size
;
15060 printf (_("\nSection '%s' contains %d entries:\n"),
15061 printable_section_name (sect
), cnt
);
15070 switch (option
->kind
)
15073 /* This shouldn't happen. */
15074 printf (" NULL %d %lx", option
->section
, option
->info
);
15077 printf (" REGINFO ");
15078 if (elf_header
.e_machine
== EM_MIPS
)
15081 Elf32_External_RegInfo
* ereg
;
15082 Elf32_RegInfo reginfo
;
15084 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15085 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15086 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15087 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15088 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15089 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15090 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15092 printf ("GPR %08lx GP 0x%lx\n",
15093 reginfo
.ri_gprmask
,
15094 (unsigned long) reginfo
.ri_gp_value
);
15095 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15096 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15097 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15102 Elf64_External_RegInfo
* ereg
;
15103 Elf64_Internal_RegInfo reginfo
;
15105 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15106 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15107 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15108 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15109 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15110 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15111 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15113 printf ("GPR %08lx GP 0x",
15114 reginfo
.ri_gprmask
);
15115 printf_vma (reginfo
.ri_gp_value
);
15118 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15119 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15120 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15124 case ODK_EXCEPTIONS
:
15125 fputs (" EXCEPTIONS fpe_min(", stdout
);
15126 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15127 fputs (") fpe_max(", stdout
);
15128 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15129 fputs (")", stdout
);
15131 if (option
->info
& OEX_PAGE0
)
15132 fputs (" PAGE0", stdout
);
15133 if (option
->info
& OEX_SMM
)
15134 fputs (" SMM", stdout
);
15135 if (option
->info
& OEX_FPDBUG
)
15136 fputs (" FPDBUG", stdout
);
15137 if (option
->info
& OEX_DISMISS
)
15138 fputs (" DISMISS", stdout
);
15141 fputs (" PAD ", stdout
);
15142 if (option
->info
& OPAD_PREFIX
)
15143 fputs (" PREFIX", stdout
);
15144 if (option
->info
& OPAD_POSTFIX
)
15145 fputs (" POSTFIX", stdout
);
15146 if (option
->info
& OPAD_SYMBOL
)
15147 fputs (" SYMBOL", stdout
);
15150 fputs (" HWPATCH ", stdout
);
15151 if (option
->info
& OHW_R4KEOP
)
15152 fputs (" R4KEOP", stdout
);
15153 if (option
->info
& OHW_R8KPFETCH
)
15154 fputs (" R8KPFETCH", stdout
);
15155 if (option
->info
& OHW_R5KEOP
)
15156 fputs (" R5KEOP", stdout
);
15157 if (option
->info
& OHW_R5KCVTL
)
15158 fputs (" R5KCVTL", stdout
);
15161 fputs (" FILL ", stdout
);
15162 /* XXX Print content of info word? */
15165 fputs (" TAGS ", stdout
);
15166 /* XXX Print content of info word? */
15169 fputs (" HWAND ", stdout
);
15170 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15171 fputs (" R4KEOP_CHECKED", stdout
);
15172 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15173 fputs (" R4KEOP_CLEAN", stdout
);
15176 fputs (" HWOR ", stdout
);
15177 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15178 fputs (" R4KEOP_CHECKED", stdout
);
15179 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15180 fputs (" R4KEOP_CLEAN", stdout
);
15183 printf (" GP_GROUP %#06lx self-contained %#06lx",
15184 option
->info
& OGP_GROUP
,
15185 (option
->info
& OGP_SELF
) >> 16);
15188 printf (" IDENT %#06lx self-contained %#06lx",
15189 option
->info
& OGP_GROUP
,
15190 (option
->info
& OGP_SELF
) >> 16);
15193 /* This shouldn't happen. */
15194 printf (" %3d ??? %d %lx",
15195 option
->kind
, option
->section
, option
->info
);
15199 len
= sizeof (* eopt
);
15200 while (len
< option
->size
)
15202 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15204 if (ISPRINT (datum
))
15205 printf ("%c", datum
);
15207 printf ("\\%03o", datum
);
15210 fputs ("\n", stdout
);
15212 offset
+= option
->size
;
15220 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15222 Elf32_Conflict
* iconf
;
15225 if (dynamic_symbols
== NULL
)
15227 error (_("conflict list found without a dynamic symbol table\n"));
15231 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15234 error (_("Out of memory allocating space for dynamic conflicts\n"));
15240 Elf32_External_Conflict
* econf32
;
15242 econf32
= (Elf32_External_Conflict
*)
15243 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15244 sizeof (* econf32
), _("conflict"));
15248 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15249 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15255 Elf64_External_Conflict
* econf64
;
15257 econf64
= (Elf64_External_Conflict
*)
15258 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15259 sizeof (* econf64
), _("conflict"));
15263 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15264 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15269 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15270 (unsigned long) conflictsno
);
15271 puts (_(" Num: Index Value Name"));
15273 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15275 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15277 if (iconf
[cnt
] >= num_dynamic_syms
)
15278 printf (_("<corrupt symbol index>"));
15281 Elf_Internal_Sym
* psym
;
15283 psym
= & dynamic_symbols
[iconf
[cnt
]];
15284 print_vma (psym
->st_value
, FULL_HEX
);
15286 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15287 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15289 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15297 if (pltgot
!= 0 && local_gotno
!= 0)
15299 bfd_vma ent
, local_end
, global_end
;
15301 unsigned char * data
;
15302 unsigned char * data_end
;
15306 addr_size
= (is_32bit_elf
? 4 : 8);
15307 local_end
= pltgot
+ local_gotno
* addr_size
;
15309 /* PR binutils/17533 file: 012-111227-0.004 */
15310 if (symtabno
< gotsym
)
15312 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15313 (unsigned long) gotsym
, (unsigned long) symtabno
);
15317 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15318 /* PR 17531: file: 54c91a34. */
15319 if (global_end
< local_end
)
15321 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15325 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15326 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15327 global_end
- pltgot
, 1,
15328 _("Global Offset Table data"));
15331 data_end
= data
+ (global_end
- pltgot
);
15333 printf (_("\nPrimary GOT:\n"));
15334 printf (_(" Canonical gp value: "));
15335 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15338 printf (_(" Reserved entries:\n"));
15339 printf (_(" %*s %10s %*s Purpose\n"),
15340 addr_size
* 2, _("Address"), _("Access"),
15341 addr_size
* 2, _("Initial"));
15342 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15343 printf (_(" Lazy resolver\n"));
15344 if (ent
== (bfd_vma
) -1)
15345 goto got_print_fail
;
15347 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15348 >> (addr_size
* 8 - 1)) != 0)
15350 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15351 printf (_(" Module pointer (GNU extension)\n"));
15352 if (ent
== (bfd_vma
) -1)
15353 goto got_print_fail
;
15357 if (ent
< local_end
)
15359 printf (_(" Local entries:\n"));
15360 printf (" %*s %10s %*s\n",
15361 addr_size
* 2, _("Address"), _("Access"),
15362 addr_size
* 2, _("Initial"));
15363 while (ent
< local_end
)
15365 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15367 if (ent
== (bfd_vma
) -1)
15368 goto got_print_fail
;
15373 if (gotsym
< symtabno
)
15377 printf (_(" Global entries:\n"));
15378 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15379 addr_size
* 2, _("Address"),
15381 addr_size
* 2, _("Initial"),
15382 addr_size
* 2, _("Sym.Val."),
15384 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15385 _("Ndx"), _("Name"));
15387 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15389 for (i
= gotsym
; i
< symtabno
; i
++)
15391 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15394 if (dynamic_symbols
== NULL
)
15395 printf (_("<no dynamic symbols>"));
15396 else if (i
< num_dynamic_syms
)
15398 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15400 print_vma (psym
->st_value
, LONG_HEX
);
15401 printf (" %-7s %3s ",
15402 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15403 get_symbol_index_type (psym
->st_shndx
));
15405 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15406 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15408 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15411 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15412 (unsigned long) i
);
15415 if (ent
== (bfd_vma
) -1)
15426 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15429 size_t offset
, rel_offset
;
15430 unsigned long count
, i
;
15431 unsigned char * data
;
15432 int addr_size
, sym_width
;
15433 Elf_Internal_Rela
* rels
;
15435 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15436 if (pltrel
== DT_RELA
)
15438 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15443 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15448 addr_size
= (is_32bit_elf
? 4 : 8);
15449 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15451 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15452 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15453 1, _("Procedure Linkage Table data"));
15457 printf ("\nPLT GOT:\n\n");
15458 printf (_(" Reserved entries:\n"));
15459 printf (_(" %*s %*s Purpose\n"),
15460 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15461 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15462 printf (_(" PLT lazy resolver\n"));
15463 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15464 printf (_(" Module pointer\n"));
15467 printf (_(" Entries:\n"));
15468 printf (" %*s %*s %*s %-7s %3s %s\n",
15469 addr_size
* 2, _("Address"),
15470 addr_size
* 2, _("Initial"),
15471 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15472 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15473 for (i
= 0; i
< count
; i
++)
15475 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15477 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15480 if (idx
>= num_dynamic_syms
)
15481 printf (_("<corrupt symbol index: %lu>"), idx
);
15484 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15486 print_vma (psym
->st_value
, LONG_HEX
);
15487 printf (" %-7s %3s ",
15488 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15489 get_symbol_index_type (psym
->st_shndx
));
15490 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15491 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15493 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15508 process_nds32_specific (FILE * file
)
15510 Elf_Internal_Shdr
*sect
= NULL
;
15512 sect
= find_section (".nds32_e_flags");
15515 unsigned int *flag
;
15517 printf ("\nNDS32 elf flags section:\n");
15518 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15519 sect
->sh_size
, _("NDS32 elf flags section"));
15521 switch ((*flag
) & 0x3)
15524 printf ("(VEC_SIZE):\tNo entry.\n");
15527 printf ("(VEC_SIZE):\t4 bytes\n");
15530 printf ("(VEC_SIZE):\t16 bytes\n");
15533 printf ("(VEC_SIZE):\treserved\n");
15542 process_gnu_liblist (FILE * file
)
15544 Elf_Internal_Shdr
* section
;
15545 Elf_Internal_Shdr
* string_sec
;
15546 Elf32_External_Lib
* elib
;
15548 size_t strtab_size
;
15555 for (i
= 0, section
= section_headers
;
15556 i
< elf_header
.e_shnum
;
15559 switch (section
->sh_type
)
15561 case SHT_GNU_LIBLIST
:
15562 if (section
->sh_link
>= elf_header
.e_shnum
)
15565 elib
= (Elf32_External_Lib
*)
15566 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15567 _("liblist section data"));
15571 string_sec
= section_headers
+ section
->sh_link
;
15573 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15574 string_sec
->sh_size
,
15575 _("liblist string table"));
15577 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15583 strtab_size
= string_sec
->sh_size
;
15585 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15586 printable_section_name (section
),
15587 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15589 puts (_(" Library Time Stamp Checksum Version Flags"));
15591 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15599 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15600 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15601 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15602 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15603 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15605 tmp
= gmtime (&atime
);
15606 snprintf (timebuf
, sizeof (timebuf
),
15607 "%04u-%02u-%02uT%02u:%02u:%02u",
15608 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15609 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15611 printf ("%3lu: ", (unsigned long) cnt
);
15613 printf ("%-20s", liblist
.l_name
< strtab_size
15614 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15616 printf ("%-20.20s", liblist
.l_name
< strtab_size
15617 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15618 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15619 liblist
.l_version
, liblist
.l_flags
);
15630 static const char *
15631 get_note_type (unsigned e_type
)
15633 static char buff
[64];
15635 if (elf_header
.e_type
== ET_CORE
)
15639 return _("NT_AUXV (auxiliary vector)");
15641 return _("NT_PRSTATUS (prstatus structure)");
15643 return _("NT_FPREGSET (floating point registers)");
15645 return _("NT_PRPSINFO (prpsinfo structure)");
15646 case NT_TASKSTRUCT
:
15647 return _("NT_TASKSTRUCT (task structure)");
15649 return _("NT_PRXFPREG (user_xfpregs structure)");
15651 return _("NT_PPC_VMX (ppc Altivec registers)");
15653 return _("NT_PPC_VSX (ppc VSX registers)");
15655 return _("NT_386_TLS (x86 TLS information)");
15656 case NT_386_IOPERM
:
15657 return _("NT_386_IOPERM (x86 I/O permissions)");
15658 case NT_X86_XSTATE
:
15659 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15660 case NT_S390_HIGH_GPRS
:
15661 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15662 case NT_S390_TIMER
:
15663 return _("NT_S390_TIMER (s390 timer register)");
15664 case NT_S390_TODCMP
:
15665 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15666 case NT_S390_TODPREG
:
15667 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15669 return _("NT_S390_CTRS (s390 control registers)");
15670 case NT_S390_PREFIX
:
15671 return _("NT_S390_PREFIX (s390 prefix register)");
15672 case NT_S390_LAST_BREAK
:
15673 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15674 case NT_S390_SYSTEM_CALL
:
15675 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15677 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15678 case NT_S390_VXRS_LOW
:
15679 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15680 case NT_S390_VXRS_HIGH
:
15681 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15683 return _("NT_ARM_VFP (arm VFP registers)");
15685 return _("NT_ARM_TLS (AArch TLS registers)");
15686 case NT_ARM_HW_BREAK
:
15687 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15688 case NT_ARM_HW_WATCH
:
15689 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15691 return _("NT_PSTATUS (pstatus structure)");
15693 return _("NT_FPREGS (floating point registers)");
15695 return _("NT_PSINFO (psinfo structure)");
15697 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15699 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15700 case NT_WIN32PSTATUS
:
15701 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15703 return _("NT_SIGINFO (siginfo_t data)");
15705 return _("NT_FILE (mapped files)");
15713 return _("NT_VERSION (version)");
15715 return _("NT_ARCH (architecture)");
15720 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15725 print_core_note (Elf_Internal_Note
*pnote
)
15727 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15728 bfd_vma count
, page_size
;
15729 unsigned char *descdata
, *filenames
, *descend
;
15731 if (pnote
->type
!= NT_FILE
)
15737 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15738 /* Still "successful". */
15743 if (pnote
->descsz
< 2 * addr_size
)
15745 printf (_(" Malformed note - too short for header\n"));
15749 descdata
= (unsigned char *) pnote
->descdata
;
15750 descend
= descdata
+ pnote
->descsz
;
15752 if (descdata
[pnote
->descsz
- 1] != '\0')
15754 printf (_(" Malformed note - does not end with \\0\n"));
15758 count
= byte_get (descdata
, addr_size
);
15759 descdata
+= addr_size
;
15761 page_size
= byte_get (descdata
, addr_size
);
15762 descdata
+= addr_size
;
15764 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15766 printf (_(" Malformed note - too short for supplied file count\n"));
15770 printf (_(" Page size: "));
15771 print_vma (page_size
, DEC
);
15774 printf (_(" %*s%*s%*s\n"),
15775 (int) (2 + 2 * addr_size
), _("Start"),
15776 (int) (4 + 2 * addr_size
), _("End"),
15777 (int) (4 + 2 * addr_size
), _("Page Offset"));
15778 filenames
= descdata
+ count
* 3 * addr_size
;
15779 while (count
-- > 0)
15781 bfd_vma start
, end
, file_ofs
;
15783 if (filenames
== descend
)
15785 printf (_(" Malformed note - filenames end too early\n"));
15789 start
= byte_get (descdata
, addr_size
);
15790 descdata
+= addr_size
;
15791 end
= byte_get (descdata
, addr_size
);
15792 descdata
+= addr_size
;
15793 file_ofs
= byte_get (descdata
, addr_size
);
15794 descdata
+= addr_size
;
15797 print_vma (start
, FULL_HEX
);
15799 print_vma (end
, FULL_HEX
);
15801 print_vma (file_ofs
, FULL_HEX
);
15802 printf ("\n %s\n", filenames
);
15804 filenames
+= 1 + strlen ((char *) filenames
);
15810 static const char *
15811 get_gnu_elf_note_type (unsigned e_type
)
15813 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15816 case NT_GNU_ABI_TAG
:
15817 return _("NT_GNU_ABI_TAG (ABI version tag)");
15819 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15820 case NT_GNU_BUILD_ID
:
15821 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15822 case NT_GNU_GOLD_VERSION
:
15823 return _("NT_GNU_GOLD_VERSION (gold version)");
15826 static char buff
[64];
15828 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15835 print_gnu_note (Elf_Internal_Note
*pnote
)
15837 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15838 switch (pnote
->type
)
15840 case NT_GNU_BUILD_ID
:
15844 printf (_(" Build ID: "));
15845 for (i
= 0; i
< pnote
->descsz
; ++i
)
15846 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15851 case NT_GNU_ABI_TAG
:
15853 unsigned long os
, major
, minor
, subminor
;
15854 const char *osname
;
15856 /* PR 17531: file: 030-599401-0.004. */
15857 if (pnote
->descsz
< 16)
15859 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15863 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15864 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15865 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15866 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15870 case GNU_ABI_TAG_LINUX
:
15873 case GNU_ABI_TAG_HURD
:
15876 case GNU_ABI_TAG_SOLARIS
:
15877 osname
= "Solaris";
15879 case GNU_ABI_TAG_FREEBSD
:
15880 osname
= "FreeBSD";
15882 case GNU_ABI_TAG_NETBSD
:
15885 case GNU_ABI_TAG_SYLLABLE
:
15886 osname
= "Syllable";
15888 case GNU_ABI_TAG_NACL
:
15892 osname
= "Unknown";
15896 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15897 major
, minor
, subminor
);
15901 case NT_GNU_GOLD_VERSION
:
15905 printf (_(" Version: "));
15906 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15907 printf ("%c", pnote
->descdata
[i
]);
15914 unsigned long num_entries
, mask
;
15916 /* Hardware capabilities information. Word 0 is the number of entries.
15917 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15918 is a series of entries, where each entry is a single byte followed
15919 by a nul terminated string. The byte gives the bit number to test
15920 if enabled in the bitmask. */
15921 printf (_(" Hardware Capabilities: "));
15922 if (pnote
->descsz
< 8)
15924 printf (_("<corrupt GNU_HWCAP>\n"));
15927 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15928 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15929 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
15930 /* FIXME: Add code to display the entries... */
15935 /* Handle unrecognised types. An error message should have already been
15936 created by get_gnu_elf_note_type(), so all that we need to do is to
15937 display the data. */
15941 printf (_(" Description data: "));
15942 for (i
= 0; i
< pnote
->descsz
; ++i
)
15943 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
15952 static const char *
15953 get_v850_elf_note_type (enum v850_notes n_type
)
15955 static char buff
[64];
15959 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15960 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15961 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15962 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15963 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15964 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15966 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15972 print_v850_note (Elf_Internal_Note
* pnote
)
15976 if (pnote
->descsz
!= 4)
15978 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15982 printf (_("not set\n"));
15986 switch (pnote
->type
)
15988 case V850_NOTE_ALIGNMENT
:
15991 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15992 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15996 case V850_NOTE_DATA_SIZE
:
15999 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
16000 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
16004 case V850_NOTE_FPU_INFO
:
16007 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
16008 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
16012 case V850_NOTE_MMU_INFO
:
16013 case V850_NOTE_CACHE_INFO
:
16014 case V850_NOTE_SIMD_INFO
:
16015 if (val
== EF_RH850_SIMD
)
16017 printf (_("yes\n"));
16023 /* An 'unknown note type' message will already have been displayed. */
16027 printf (_("unknown value: %x\n"), val
);
16032 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16034 unsigned int version
;
16036 switch (pnote
->type
)
16038 case NT_NETBSD_IDENT
:
16039 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16040 if ((version
/ 10000) % 100)
16041 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16042 version
, version
/ 100000000, (version
/ 1000000) % 100,
16043 (version
/ 10000) % 100 > 26 ? "Z" : "",
16044 'A' + (version
/ 10000) % 26);
16046 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16047 version
, version
/ 100000000, (version
/ 1000000) % 100,
16048 (version
/ 100) % 100);
16051 case NT_NETBSD_MARCH
:
16052 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16060 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16065 static const char *
16066 get_freebsd_elfcore_note_type (unsigned e_type
)
16070 case NT_FREEBSD_THRMISC
:
16071 return _("NT_THRMISC (thrmisc structure)");
16072 case NT_FREEBSD_PROCSTAT_PROC
:
16073 return _("NT_PROCSTAT_PROC (proc data)");
16074 case NT_FREEBSD_PROCSTAT_FILES
:
16075 return _("NT_PROCSTAT_FILES (files data)");
16076 case NT_FREEBSD_PROCSTAT_VMMAP
:
16077 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16078 case NT_FREEBSD_PROCSTAT_GROUPS
:
16079 return _("NT_PROCSTAT_GROUPS (groups data)");
16080 case NT_FREEBSD_PROCSTAT_UMASK
:
16081 return _("NT_PROCSTAT_UMASK (umask data)");
16082 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16083 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16084 case NT_FREEBSD_PROCSTAT_OSREL
:
16085 return _("NT_PROCSTAT_OSREL (osreldate data)");
16086 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16087 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16088 case NT_FREEBSD_PROCSTAT_AUXV
:
16089 return _("NT_PROCSTAT_AUXV (auxv data)");
16091 return get_note_type (e_type
);
16094 static const char *
16095 get_netbsd_elfcore_note_type (unsigned e_type
)
16097 static char buff
[64];
16099 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16101 /* NetBSD core "procinfo" structure. */
16102 return _("NetBSD procinfo structure");
16105 /* As of Jan 2002 there are no other machine-independent notes
16106 defined for NetBSD core files. If the note type is less
16107 than the start of the machine-dependent note types, we don't
16110 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16112 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16116 switch (elf_header
.e_machine
)
16118 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16119 and PT_GETFPREGS == mach+2. */
16124 case EM_SPARC32PLUS
:
16128 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16129 return _("PT_GETREGS (reg structure)");
16130 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16131 return _("PT_GETFPREGS (fpreg structure)");
16137 /* On all other arch's, PT_GETREGS == mach+1 and
16138 PT_GETFPREGS == mach+3. */
16142 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16143 return _("PT_GETREGS (reg structure)");
16144 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16145 return _("PT_GETFPREGS (fpreg structure)");
16151 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16152 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16156 static const char *
16157 get_stapsdt_note_type (unsigned e_type
)
16159 static char buff
[64];
16164 return _("NT_STAPSDT (SystemTap probe descriptors)");
16170 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16175 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16177 int addr_size
= is_32bit_elf
? 4 : 8;
16178 char *data
= pnote
->descdata
;
16179 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16180 bfd_vma pc
, base_addr
, semaphore
;
16181 char *provider
, *probe
, *arg_fmt
;
16183 pc
= byte_get ((unsigned char *) data
, addr_size
);
16185 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16187 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16191 data
+= strlen (data
) + 1;
16193 data
+= strlen (data
) + 1;
16195 data
+= strlen (data
) + 1;
16197 printf (_(" Provider: %s\n"), provider
);
16198 printf (_(" Name: %s\n"), probe
);
16199 printf (_(" Location: "));
16200 print_vma (pc
, FULL_HEX
);
16201 printf (_(", Base: "));
16202 print_vma (base_addr
, FULL_HEX
);
16203 printf (_(", Semaphore: "));
16204 print_vma (semaphore
, FULL_HEX
);
16206 printf (_(" Arguments: %s\n"), arg_fmt
);
16208 return data
== data_end
;
16211 static const char *
16212 get_ia64_vms_note_type (unsigned e_type
)
16214 static char buff
[64];
16219 return _("NT_VMS_MHD (module header)");
16221 return _("NT_VMS_LNM (language name)");
16223 return _("NT_VMS_SRC (source files)");
16225 return "NT_VMS_TITLE";
16227 return _("NT_VMS_EIDC (consistency check)");
16228 case NT_VMS_FPMODE
:
16229 return _("NT_VMS_FPMODE (FP mode)");
16230 case NT_VMS_LINKTIME
:
16231 return "NT_VMS_LINKTIME";
16232 case NT_VMS_IMGNAM
:
16233 return _("NT_VMS_IMGNAM (image name)");
16235 return _("NT_VMS_IMGID (image id)");
16236 case NT_VMS_LINKID
:
16237 return _("NT_VMS_LINKID (link id)");
16238 case NT_VMS_IMGBID
:
16239 return _("NT_VMS_IMGBID (build id)");
16240 case NT_VMS_GSTNAM
:
16241 return _("NT_VMS_GSTNAM (sym table name)");
16242 case NT_VMS_ORIG_DYN
:
16243 return "NT_VMS_ORIG_DYN";
16244 case NT_VMS_PATCHTIME
:
16245 return "NT_VMS_PATCHTIME";
16247 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16253 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16255 switch (pnote
->type
)
16258 if (pnote
->descsz
> 36)
16260 size_t l
= strlen (pnote
->descdata
+ 34);
16261 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16262 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16263 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16264 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16267 printf (_(" Invalid size\n"));
16270 printf (_(" Language: %s\n"), pnote
->descdata
);
16273 case NT_VMS_FPMODE
:
16274 printf (_(" Floating Point mode: "));
16275 printf ("0x%016" BFD_VMA_FMT
"x\n",
16276 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16278 case NT_VMS_LINKTIME
:
16279 printf (_(" Link time: "));
16281 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16284 case NT_VMS_PATCHTIME
:
16285 printf (_(" Patch time: "));
16287 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16290 case NT_VMS_ORIG_DYN
:
16291 printf (_(" Major id: %u, minor id: %u\n"),
16292 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16293 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16294 printf (_(" Last modified : "));
16296 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16297 printf (_("\n Link flags : "));
16298 printf ("0x%016" BFD_VMA_FMT
"x\n",
16299 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16300 printf (_(" Header flags: 0x%08x\n"),
16301 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16302 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16305 case NT_VMS_IMGNAM
:
16306 printf (_(" Image name: %s\n"), pnote
->descdata
);
16308 case NT_VMS_GSTNAM
:
16309 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16312 printf (_(" Image id: %s\n"), pnote
->descdata
);
16314 case NT_VMS_LINKID
:
16315 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16323 /* Note that by the ELF standard, the name field is already null byte
16324 terminated, and namesz includes the terminating null byte.
16325 I.E. the value of namesz for the name "FSF" is 4.
16327 If the value of namesz is zero, there is no name present. */
16329 process_note (Elf_Internal_Note
* pnote
,
16330 FILE * file ATTRIBUTE_UNUSED
,
16331 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16333 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16336 if (pnote
->namesz
== 0)
16337 /* If there is no note name, then use the default set of
16338 note type strings. */
16339 nt
= get_note_type (pnote
->type
);
16341 else if (const_strneq (pnote
->namedata
, "GNU"))
16342 /* GNU-specific object file notes. */
16343 nt
= get_gnu_elf_note_type (pnote
->type
);
16345 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16346 /* FreeBSD-specific core file notes. */
16347 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16349 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16350 /* NetBSD-specific core file notes. */
16351 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16353 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16354 /* NetBSD-specific core file notes. */
16355 return process_netbsd_elf_note (pnote
);
16357 else if (strneq (pnote
->namedata
, "SPU/", 4))
16359 /* SPU-specific core file notes. */
16360 nt
= pnote
->namedata
+ 4;
16364 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16365 /* VMS/ia64-specific file notes. */
16366 nt
= get_ia64_vms_note_type (pnote
->type
);
16368 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16369 nt
= get_stapsdt_note_type (pnote
->type
);
16372 /* Don't recognize this note name; just use the default set of
16373 note type strings. */
16374 nt
= get_note_type (pnote
->type
);
16377 print_symbol (-20, name
);
16378 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16380 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16381 return print_ia64_vms_note (pnote
);
16382 else if (const_strneq (pnote
->namedata
, "GNU"))
16383 return print_gnu_note (pnote
);
16384 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16385 return print_stapsdt_note (pnote
);
16386 else if (const_strneq (pnote
->namedata
, "CORE"))
16387 return print_core_note (pnote
);
16389 else if (pnote
->descsz
)
16393 printf (_(" description data: "));
16394 for (i
= 0; i
< pnote
->descsz
; i
++)
16395 printf ("%02x ", pnote
->descdata
[i
]);
16403 process_notes_at (FILE * file
,
16404 Elf_Internal_Shdr
* section
,
16408 Elf_External_Note
* pnotes
;
16409 Elf_External_Note
* external
;
16418 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
16420 apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
);
16423 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16425 if (pnotes
== NULL
)
16431 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
16433 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16434 (unsigned long) offset
, (unsigned long) length
);
16436 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16438 end
= (char *) pnotes
+ length
;
16439 while ((char *) external
< end
)
16441 Elf_Internal_Note inote
;
16444 char * temp
= NULL
;
16445 size_t data_remaining
= end
- (char *) external
;
16447 if (!is_ia64_vms ())
16449 /* PR binutils/15191
16450 Make sure that there is enough data to read. */
16451 min_notesz
= offsetof (Elf_External_Note
, name
);
16452 if (data_remaining
< min_notesz
)
16454 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16455 (int) data_remaining
);
16458 inote
.type
= BYTE_GET (external
->type
);
16459 inote
.namesz
= BYTE_GET (external
->namesz
);
16460 inote
.namedata
= external
->name
;
16461 inote
.descsz
= BYTE_GET (external
->descsz
);
16462 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16463 /* PR 17531: file: 3443835e. */
16464 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16466 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16467 inote
.descdata
= inote
.namedata
;
16471 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16472 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16476 Elf64_External_VMS_Note
*vms_external
;
16478 /* PR binutils/15191
16479 Make sure that there is enough data to read. */
16480 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16481 if (data_remaining
< min_notesz
)
16483 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16484 (int) data_remaining
);
16488 vms_external
= (Elf64_External_VMS_Note
*) external
;
16489 inote
.type
= BYTE_GET (vms_external
->type
);
16490 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16491 inote
.namedata
= vms_external
->name
;
16492 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16493 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16494 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16495 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16498 if (inote
.descdata
< (char *) external
+ min_notesz
16499 || next
< (char *) external
+ min_notesz
16500 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16501 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16502 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16503 || data_remaining
< (size_t)(next
- (char *) external
))
16505 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16506 (unsigned long) ((char *) external
- (char *) pnotes
));
16507 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16508 inote
.type
, inote
.namesz
, inote
.descsz
);
16512 external
= (Elf_External_Note
*) next
;
16514 /* Verify that name is null terminated. It appears that at least
16515 one version of Linux (RedHat 6.0) generates corefiles that don't
16516 comply with the ELF spec by failing to include the null byte in
16518 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16520 temp
= (char *) malloc (inote
.namesz
+ 1);
16523 error (_("Out of memory allocating space for inote name\n"));
16528 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16529 temp
[inote
.namesz
] = 0;
16531 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16532 inote
.namedata
= temp
;
16535 res
&= process_note (& inote
, file
, section
);
16550 process_corefile_note_segments (FILE * file
)
16552 Elf_Internal_Phdr
* segment
;
16556 if (! get_program_headers (file
))
16559 for (i
= 0, segment
= program_headers
;
16560 i
< elf_header
.e_phnum
;
16563 if (segment
->p_type
== PT_NOTE
)
16564 res
&= process_notes_at (file
, NULL
,
16565 (bfd_vma
) segment
->p_offset
,
16566 (bfd_vma
) segment
->p_filesz
);
16573 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16575 Elf_External_Note
* pnotes
;
16576 Elf_External_Note
* external
;
16583 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16585 if (pnotes
== NULL
)
16589 end
= (char*) pnotes
+ length
;
16591 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16592 (unsigned long) offset
, (unsigned long) length
);
16594 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16596 Elf_External_Note
* next
;
16597 Elf_Internal_Note inote
;
16599 inote
.type
= BYTE_GET (external
->type
);
16600 inote
.namesz
= BYTE_GET (external
->namesz
);
16601 inote
.namedata
= external
->name
;
16602 inote
.descsz
= BYTE_GET (external
->descsz
);
16603 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16604 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16606 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16608 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16609 inote
.descdata
= inote
.namedata
;
16613 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16615 if ( ((char *) next
> end
)
16616 || ((char *) next
< (char *) pnotes
))
16618 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16619 (unsigned long) ((char *) external
- (char *) pnotes
));
16620 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16621 inote
.type
, inote
.namesz
, inote
.descsz
);
16627 /* Prevent out-of-bounds indexing. */
16628 if ( inote
.namedata
+ inote
.namesz
> end
16629 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16631 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16632 (unsigned long) ((char *) external
- (char *) pnotes
));
16633 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16634 inote
.type
, inote
.namesz
, inote
.descsz
);
16638 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16640 if (! print_v850_note (& inote
))
16643 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16644 inote
.namesz
, inote
.descsz
);
16654 process_note_sections (FILE * file
)
16656 Elf_Internal_Shdr
* section
;
16661 for (i
= 0, section
= section_headers
;
16662 i
< elf_header
.e_shnum
&& section
!= NULL
;
16665 if (section
->sh_type
== SHT_NOTE
)
16667 res
&= process_notes_at (file
, section
,
16668 (bfd_vma
) section
->sh_offset
,
16669 (bfd_vma
) section
->sh_size
);
16673 if (( elf_header
.e_machine
== EM_V800
16674 || elf_header
.e_machine
== EM_V850
16675 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16676 && section
->sh_type
== SHT_RENESAS_INFO
)
16678 res
&= process_v850_notes (file
,
16679 (bfd_vma
) section
->sh_offset
,
16680 (bfd_vma
) section
->sh_size
);
16686 /* Try processing NOTE segments instead. */
16687 return process_corefile_note_segments (file
);
16693 process_notes (FILE * file
)
16695 /* If we have not been asked to display the notes then do nothing. */
16699 if (elf_header
.e_type
!= ET_CORE
)
16700 return process_note_sections (file
);
16702 /* No program headers means no NOTE segment. */
16703 if (elf_header
.e_phnum
> 0)
16704 return process_corefile_note_segments (file
);
16706 printf (_("No note segments present in the core file.\n"));
16711 process_arch_specific (FILE * file
)
16716 switch (elf_header
.e_machine
)
16719 return process_arm_specific (file
);
16721 case EM_MIPS_RS3_LE
:
16722 return process_mips_specific (file
);
16725 return process_nds32_specific (file
);
16729 return process_power_specific (file
);
16733 return process_s390_specific (file
);
16736 case EM_SPARC32PLUS
:
16738 return process_sparc_specific (file
);
16741 return process_tic6x_specific (file
);
16744 return process_msp430x_specific (file
);
16752 get_file_header (FILE * file
)
16754 /* Read in the identity array. */
16755 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16758 /* Determine how to read the rest of the header. */
16759 switch (elf_header
.e_ident
[EI_DATA
])
16764 byte_get
= byte_get_little_endian
;
16765 byte_put
= byte_put_little_endian
;
16768 byte_get
= byte_get_big_endian
;
16769 byte_put
= byte_put_big_endian
;
16773 /* For now we only support 32 bit and 64 bit ELF files. */
16774 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16776 /* Read in the rest of the header. */
16779 Elf32_External_Ehdr ehdr32
;
16781 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16784 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16785 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16786 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16787 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16788 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16789 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16790 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16791 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16792 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16793 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16794 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16795 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16796 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16800 Elf64_External_Ehdr ehdr64
;
16802 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16803 we will not be able to cope with the 64bit data found in
16804 64 ELF files. Detect this now and abort before we start
16805 overwriting things. */
16806 if (sizeof (bfd_vma
) < 8)
16808 error (_("This instance of readelf has been built without support for a\n\
16809 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16813 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16816 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16817 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16818 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16819 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16820 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16821 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16822 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16823 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16824 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16825 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16826 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16827 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16828 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16831 if (elf_header
.e_shoff
)
16833 /* There may be some extensions in the first section header. Don't
16834 bomb if we can't read it. */
16836 get_32bit_section_headers (file
, TRUE
);
16838 get_64bit_section_headers (file
, TRUE
);
16844 /* Process one ELF object file according to the command line options.
16845 This file may actually be stored in an archive. The file is
16846 positioned at the start of the ELF object. */
16849 process_object (char * file_name
, FILE * file
)
16853 if (! get_file_header (file
))
16855 error (_("%s: Failed to read file header\n"), file_name
);
16859 /* Initialise per file variables. */
16860 for (i
= ARRAY_SIZE (version_info
); i
--;)
16861 version_info
[i
] = 0;
16863 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16864 dynamic_info
[i
] = 0;
16865 dynamic_info_DT_GNU_HASH
= 0;
16867 /* Process the file. */
16869 printf (_("\nFile: %s\n"), file_name
);
16871 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16872 Note we do this even if cmdline_dump_sects is empty because we
16873 must make sure that the dump_sets array is zeroed out before each
16874 object file is processed. */
16875 if (num_dump_sects
> num_cmdline_dump_sects
)
16876 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16878 if (num_cmdline_dump_sects
> 0)
16880 if (num_dump_sects
== 0)
16881 /* A sneaky way of allocating the dump_sects array. */
16882 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16884 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16885 memcpy (dump_sects
, cmdline_dump_sects
,
16886 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16889 if (! process_file_header ())
16892 if (! process_section_headers (file
))
16894 /* Without loaded section headers we cannot process lots of
16896 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16898 if (! do_using_dynamic
)
16899 do_syms
= do_dyn_syms
= do_reloc
= 0;
16902 if (! process_section_groups (file
))
16904 /* Without loaded section groups we cannot process unwind. */
16908 if (process_program_headers (file
))
16909 process_dynamic_section (file
);
16911 process_relocs (file
);
16913 process_unwind (file
);
16915 process_symbol_table (file
);
16917 process_syminfo (file
);
16919 process_version_sections (file
);
16921 process_section_contents (file
);
16923 process_notes (file
);
16925 process_gnu_liblist (file
);
16927 process_arch_specific (file
);
16929 if (program_headers
)
16931 free (program_headers
);
16932 program_headers
= NULL
;
16935 if (section_headers
)
16937 free (section_headers
);
16938 section_headers
= NULL
;
16943 free (string_table
);
16944 string_table
= NULL
;
16945 string_table_length
= 0;
16948 if (dynamic_strings
)
16950 free (dynamic_strings
);
16951 dynamic_strings
= NULL
;
16952 dynamic_strings_length
= 0;
16955 if (dynamic_symbols
)
16957 free (dynamic_symbols
);
16958 dynamic_symbols
= NULL
;
16959 num_dynamic_syms
= 0;
16962 if (dynamic_syminfo
)
16964 free (dynamic_syminfo
);
16965 dynamic_syminfo
= NULL
;
16968 if (dynamic_section
)
16970 free (dynamic_section
);
16971 dynamic_section
= NULL
;
16974 if (section_headers_groups
)
16976 free (section_headers_groups
);
16977 section_headers_groups
= NULL
;
16980 if (section_groups
)
16982 struct group_list
* g
;
16983 struct group_list
* next
;
16985 for (i
= 0; i
< group_count
; i
++)
16987 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16994 free (section_groups
);
16995 section_groups
= NULL
;
16998 free_debug_memory ();
17003 /* Process an ELF archive.
17004 On entry the file is positioned just after the ARMAG string. */
17007 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17009 struct archive_info arch
;
17010 struct archive_info nested_arch
;
17016 /* The ARCH structure is used to hold information about this archive. */
17017 arch
.file_name
= NULL
;
17019 arch
.index_array
= NULL
;
17020 arch
.sym_table
= NULL
;
17021 arch
.longnames
= NULL
;
17023 /* The NESTED_ARCH structure is used as a single-item cache of information
17024 about a nested archive (when members of a thin archive reside within
17025 another regular archive file). */
17026 nested_arch
.file_name
= NULL
;
17027 nested_arch
.file
= NULL
;
17028 nested_arch
.index_array
= NULL
;
17029 nested_arch
.sym_table
= NULL
;
17030 nested_arch
.longnames
= NULL
;
17032 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17038 if (do_archive_index
)
17040 if (arch
.sym_table
== NULL
)
17041 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17044 unsigned long i
, l
;
17045 unsigned long current_pos
;
17047 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17048 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17049 current_pos
= ftell (file
);
17051 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17053 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17055 char * member_name
;
17057 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17059 if (member_name
!= NULL
)
17061 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17063 if (qualified_name
!= NULL
)
17065 printf (_("Contents of binary %s at offset "), qualified_name
);
17066 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17068 free (qualified_name
);
17073 if (l
>= arch
.sym_size
)
17075 error (_("%s: end of the symbol table reached before the end of the index\n"),
17079 /* PR 17531: file: 0b6630b2. */
17080 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17081 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17084 if (arch
.uses_64bit_indicies
)
17089 if (l
< arch
.sym_size
)
17090 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17091 file_name
, arch
.sym_size
- l
);
17093 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17095 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17101 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17102 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17103 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17104 && !do_section_groups
&& !do_dyn_syms
)
17106 ret
= 0; /* Archive index only. */
17117 char * qualified_name
;
17119 /* Read the next archive header. */
17120 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17122 error (_("%s: failed to seek to next archive header\n"), file_name
);
17125 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17126 if (got
!= sizeof arch
.arhdr
)
17130 error (_("%s: failed to read archive header\n"), file_name
);
17134 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17136 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17141 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17143 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17144 if (archive_file_size
& 01)
17145 ++archive_file_size
;
17147 name
= get_archive_member_name (&arch
, &nested_arch
);
17150 error (_("%s: bad archive file name\n"), file_name
);
17154 namelen
= strlen (name
);
17156 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17157 if (qualified_name
== NULL
)
17159 error (_("%s: bad archive file name\n"), file_name
);
17164 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17166 /* This is a proxy for an external member of a thin archive. */
17167 FILE * member_file
;
17168 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17169 if (member_file_name
== NULL
)
17175 member_file
= fopen (member_file_name
, "rb");
17176 if (member_file
== NULL
)
17178 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17179 free (member_file_name
);
17184 archive_file_offset
= arch
.nested_member_origin
;
17186 ret
|= process_object (qualified_name
, member_file
);
17188 fclose (member_file
);
17189 free (member_file_name
);
17191 else if (is_thin_archive
)
17193 /* PR 15140: Allow for corrupt thin archives. */
17194 if (nested_arch
.file
== NULL
)
17196 error (_("%s: contains corrupt thin archive: %s\n"),
17202 /* This is a proxy for a member of a nested archive. */
17203 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17205 /* The nested archive file will have been opened and setup by
17206 get_archive_member_name. */
17207 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17209 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17214 ret
|= process_object (qualified_name
, nested_arch
.file
);
17218 archive_file_offset
= arch
.next_arhdr_offset
;
17219 arch
.next_arhdr_offset
+= archive_file_size
;
17221 ret
|= process_object (qualified_name
, file
);
17224 if (dump_sects
!= NULL
)
17228 num_dump_sects
= 0;
17231 free (qualified_name
);
17235 if (nested_arch
.file
!= NULL
)
17236 fclose (nested_arch
.file
);
17237 release_archive (&nested_arch
);
17238 release_archive (&arch
);
17244 process_file (char * file_name
)
17247 struct stat statbuf
;
17248 char armag
[SARMAG
];
17251 if (stat (file_name
, &statbuf
) < 0)
17253 if (errno
== ENOENT
)
17254 error (_("'%s': No such file\n"), file_name
);
17256 error (_("Could not locate '%s'. System error message: %s\n"),
17257 file_name
, strerror (errno
));
17261 if (! S_ISREG (statbuf
.st_mode
))
17263 error (_("'%s' is not an ordinary file\n"), file_name
);
17267 file
= fopen (file_name
, "rb");
17270 error (_("Input file '%s' is not readable.\n"), file_name
);
17274 if (fread (armag
, SARMAG
, 1, file
) != 1)
17276 error (_("%s: Failed to read file's magic number\n"), file_name
);
17281 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17283 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17284 ret
= process_archive (file_name
, file
, FALSE
);
17285 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17286 ret
= process_archive (file_name
, file
, TRUE
);
17289 if (do_archive_index
)
17290 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17294 archive_file_size
= archive_file_offset
= 0;
17295 ret
= process_object (file_name
, file
);
17300 current_file_size
= 0;
17304 #ifdef SUPPORT_DISASSEMBLY
17305 /* Needed by the i386 disassembler. For extra credit, someone could
17306 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17310 print_address (unsigned int addr
, FILE * outfile
)
17312 fprintf (outfile
,"0x%8.8x", addr
);
17315 /* Needed by the i386 disassembler. */
17317 db_task_printsym (unsigned int addr
)
17319 print_address (addr
, stderr
);
17324 main (int argc
, char ** argv
)
17328 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17329 setlocale (LC_MESSAGES
, "");
17331 #if defined (HAVE_SETLOCALE)
17332 setlocale (LC_CTYPE
, "");
17334 bindtextdomain (PACKAGE
, LOCALEDIR
);
17335 textdomain (PACKAGE
);
17337 expandargv (&argc
, &argv
);
17339 parse_args (argc
, argv
);
17341 if (num_dump_sects
> 0)
17343 /* Make a copy of the dump_sects array. */
17344 cmdline_dump_sects
= (dump_type
*)
17345 malloc (num_dump_sects
* sizeof (* dump_sects
));
17346 if (cmdline_dump_sects
== NULL
)
17347 error (_("Out of memory allocating dump request table.\n"));
17350 memcpy (cmdline_dump_sects
, dump_sects
,
17351 num_dump_sects
* sizeof (* dump_sects
));
17352 num_cmdline_dump_sects
= num_dump_sects
;
17356 if (optind
< (argc
- 1))
17358 else if (optind
>= argc
)
17360 warn (_("Nothing to do.\n"));
17365 while (optind
< argc
)
17366 err
|= process_file (argv
[optind
++]);
17368 if (dump_sects
!= NULL
)
17370 if (cmdline_dump_sects
!= NULL
)
17371 free (cmdline_dump_sects
);