1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.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"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name
= "readelf";
168 static unsigned long archive_file_offset
;
169 static unsigned long archive_file_size
;
170 static bfd_size_type current_file_size
;
171 static unsigned long dynamic_addr
;
172 static bfd_size_type dynamic_size
;
173 static size_t dynamic_nent
;
174 static char * dynamic_strings
;
175 static unsigned long dynamic_strings_length
;
176 static char * string_table
;
177 static unsigned long string_table_length
;
178 static unsigned long num_dynamic_syms
;
179 static Elf_Internal_Sym
* dynamic_symbols
;
180 static Elf_Internal_Syminfo
* dynamic_syminfo
;
181 static unsigned long dynamic_syminfo_offset
;
182 static unsigned int dynamic_syminfo_nent
;
183 static char program_interpreter
[PATH_MAX
];
184 static bfd_vma dynamic_info
[DT_ENCODING
];
185 static bfd_vma dynamic_info_DT_GNU_HASH
;
186 static bfd_vma version_info
[16];
187 static Elf_Internal_Ehdr elf_header
;
188 static Elf_Internal_Shdr
* section_headers
;
189 static Elf_Internal_Phdr
* program_headers
;
190 static Elf_Internal_Dyn
* dynamic_section
;
191 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
192 static int show_name
;
193 static int do_dynamic
;
195 static int do_dyn_syms
;
197 static int do_sections
;
198 static int do_section_groups
;
199 static int do_section_details
;
200 static int do_segments
;
201 static int do_unwind
;
202 static int do_using_dynamic
;
203 static int do_header
;
205 static int do_version
;
206 static int do_histogram
;
207 static int do_debugging
;
210 static int do_archive_index
;
211 static int is_32bit_elf
;
215 struct group_list
* next
;
216 unsigned int section_index
;
221 struct group_list
* root
;
222 unsigned int group_index
;
225 static size_t group_count
;
226 static struct group
* section_groups
;
227 static struct group
** section_headers_groups
;
230 /* Flag bits indicating particular types of dump. */
231 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
232 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
237 typedef unsigned char dump_type
;
239 /* A linked list of the section names for which dumps were requested. */
240 struct dump_list_entry
244 struct dump_list_entry
* next
;
246 static struct dump_list_entry
* dump_sects_byname
;
248 /* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250 static dump_type
* cmdline_dump_sects
= NULL
;
251 static unsigned int num_cmdline_dump_sects
= 0;
253 /* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
258 static dump_type
* dump_sects
= NULL
;
259 static unsigned int num_dump_sects
= 0;
262 /* How to print a vma value. */
263 typedef enum print_mode
275 /* Versioned symbol info. */
276 enum versioned_symbol_info
283 static const char *get_symbol_version_string
284 (FILE *file
, int is_dynsym
, const char *strtab
,
285 unsigned long int strtab_size
, unsigned int si
,
286 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
287 unsigned short *vna_other
);
291 #define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
295 : string_table + (X)->sh_name))
297 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
299 #define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 #define REMOVE_ARCH_BITS(ADDR) \
311 if (elf_header.e_machine == EM_ARM) \
316 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
321 and REASON is not NULL then emit an error message using REASON as part of the
325 get_data (void * var
, FILE * file
, unsigned long offset
, size_t size
, size_t nmemb
,
329 size_t amt
= size
* nmemb
;
331 if (size
== 0 || nmemb
== 0)
334 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
335 attempting to allocate memory when the read is bound to fail. */
336 if (amt
> current_file_size
337 || offset
+ archive_file_offset
+ amt
> current_file_size
)
340 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
341 (unsigned long) amt
, reason
);
345 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
348 error (_("Unable to seek to 0x%lx for %s\n"),
349 (unsigned long) archive_file_offset
+ offset
, reason
);
356 /* Check for overflow. */
357 if (nmemb
< (~(size_t) 0 - 1) / size
)
358 /* + 1 so that we can '\0' terminate invalid string table sections. */
359 mvar
= malloc (size
* nmemb
+ 1);
364 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
365 (unsigned long)(size
* nmemb
), reason
);
369 ((char *) mvar
)[amt
] = '\0';
372 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
375 error (_("Unable to read in 0x%lx bytes of %s\n"),
376 (unsigned long) amt
, reason
);
385 /* Print a VMA value. */
388 print_vma (bfd_vma vma
, print_mode mode
)
401 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
408 return printf ("%5" BFD_VMA_FMT
"d", vma
);
416 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
419 return printf ("%" BFD_VMA_FMT
"d", vma
);
422 return printf ("%" BFD_VMA_FMT
"u", vma
);
427 /* Display a symbol on stdout. Handles the display of control characters and
428 multibye characters (assuming the host environment supports them).
430 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
432 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
433 padding as necessary.
435 Returns the number of emitted characters. */
438 print_symbol (int width
, const char *symbol
)
440 bfd_boolean extra_padding
= FALSE
;
442 #ifdef HAVE_MBSTATE_T
449 /* Keep the width positive. This also helps. */
451 extra_padding
= TRUE
;
456 /* Set the remaining width to a very large value.
457 This simplifies the code below. */
458 width_remaining
= INT_MAX
;
460 width_remaining
= width
;
462 #ifdef HAVE_MBSTATE_T
463 /* Initialise the multibyte conversion state. */
464 memset (& state
, 0, sizeof (state
));
467 while (width_remaining
)
470 const char c
= *symbol
++;
475 /* Do not print control characters directly as they can affect terminal
476 settings. Such characters usually appear in the names generated
477 by the assembler for local labels. */
480 if (width_remaining
< 2)
483 printf ("^%c", c
+ 0x40);
484 width_remaining
-= 2;
487 else if (ISPRINT (c
))
495 #ifdef HAVE_MBSTATE_T
498 /* Let printf do the hard work of displaying multibyte characters. */
499 printf ("%.1s", symbol
- 1);
503 #ifdef HAVE_MBSTATE_T
504 /* Try to find out how many bytes made up the character that was
505 just printed. Advance the symbol pointer past the bytes that
507 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
511 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
516 if (extra_padding
&& num_printed
< width
)
518 /* Fill in the remaining spaces. */
519 printf ("%-*s", width
- num_printed
, " ");
526 /* Returns a pointer to a static buffer containing a printable version of
527 the given section's name. Like print_symbol, except that it does not try
528 to print multibyte characters, it just interprets them as hex values. */
531 printable_section_name (Elf_Internal_Shdr
* sec
)
533 #define MAX_PRINT_SEC_NAME_LEN 128
534 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
535 const char * name
= SECTION_NAME (sec
);
536 char * buf
= sec_name_buf
;
538 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
540 while ((c
= * name
++) != 0)
551 else if (ISPRINT (c
))
558 static char hex
[17] = "0123456789ABCDEF";
563 * buf
++ = hex
[(c
& 0xf0) >> 4];
564 * buf
++ = hex
[c
& 0x0f];
578 printable_section_name_from_index (unsigned long ndx
)
580 if (ndx
>= elf_header
.e_shnum
)
581 return _("<corrupt>");
583 return printable_section_name (section_headers
+ ndx
);
586 /* Return a pointer to section NAME, or NULL if no such section exists. */
588 static Elf_Internal_Shdr
*
589 find_section (const char * name
)
593 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
594 if (streq (SECTION_NAME (section_headers
+ i
), name
))
595 return section_headers
+ i
;
600 /* Return a pointer to a section containing ADDR, or NULL if no such
603 static Elf_Internal_Shdr
*
604 find_section_by_address (bfd_vma addr
)
608 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
610 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
611 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
618 static Elf_Internal_Shdr
*
619 find_section_by_type (unsigned int type
)
623 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
625 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
626 if (sec
->sh_type
== type
)
633 /* Return a pointer to section NAME, or NULL if no such section exists,
634 restricted to the list of sections given in SET. */
636 static Elf_Internal_Shdr
*
637 find_section_in_set (const char * name
, unsigned int * set
)
643 while ((i
= *set
++) > 0)
644 if (streq (SECTION_NAME (section_headers
+ i
), name
))
645 return section_headers
+ i
;
648 return find_section (name
);
651 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
654 static inline unsigned long
655 read_uleb128 (unsigned char *data
,
656 unsigned int *length_return
,
657 const unsigned char * const end
)
659 return read_leb128 (data
, length_return
, FALSE
, end
);
662 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
663 This OS has so many departures from the ELF standard that we test it at
669 return elf_header
.e_machine
== EM_IA_64
670 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
673 /* Guess the relocation size commonly used by the specific machines. */
676 guess_is_rela (unsigned int e_machine
)
680 /* Targets that use REL relocations. */
695 /* Targets that use RELA relocations. */
699 case EM_ADAPTEVA_EPIPHANY
:
701 case EM_ALTERA_NIOS2
:
720 case EM_LATTICEMICO32
:
729 case EM_CYGNUS_MN10200
:
731 case EM_CYGNUS_MN10300
:
764 case EM_MICROBLAZE_OLD
:
785 warn (_("Don't know about relocations on this machine architecture\n"));
791 slurp_rela_relocs (FILE * file
,
792 unsigned long rel_offset
,
793 unsigned long rel_size
,
794 Elf_Internal_Rela
** relasp
,
795 unsigned long * nrelasp
)
797 Elf_Internal_Rela
* relas
;
803 Elf32_External_Rela
* erelas
;
805 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
806 rel_size
, _("32-bit relocation data"));
810 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
812 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
813 sizeof (Elf_Internal_Rela
));
818 error (_("out of memory parsing relocs\n"));
822 for (i
= 0; i
< nrelas
; i
++)
824 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
825 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
826 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
833 Elf64_External_Rela
* erelas
;
835 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
836 rel_size
, _("64-bit relocation data"));
840 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
842 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
843 sizeof (Elf_Internal_Rela
));
848 error (_("out of memory parsing relocs\n"));
852 for (i
= 0; i
< nrelas
; i
++)
854 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
855 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
856 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
858 /* The #ifdef BFD64 below is to prevent a compile time
859 warning. We know that if we do not have a 64 bit data
860 type that we will never execute this code anyway. */
862 if (elf_header
.e_machine
== EM_MIPS
863 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
865 /* In little-endian objects, r_info isn't really a
866 64-bit little-endian value: it has a 32-bit
867 little-endian symbol index followed by four
868 individual byte fields. Reorder INFO
870 bfd_vma inf
= relas
[i
].r_info
;
871 inf
= (((inf
& 0xffffffff) << 32)
872 | ((inf
>> 56) & 0xff)
873 | ((inf
>> 40) & 0xff00)
874 | ((inf
>> 24) & 0xff0000)
875 | ((inf
>> 8) & 0xff000000));
876 relas
[i
].r_info
= inf
;
889 slurp_rel_relocs (FILE * file
,
890 unsigned long rel_offset
,
891 unsigned long rel_size
,
892 Elf_Internal_Rela
** relsp
,
893 unsigned long * nrelsp
)
895 Elf_Internal_Rela
* rels
;
901 Elf32_External_Rel
* erels
;
903 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
904 rel_size
, _("32-bit relocation data"));
908 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
910 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
915 error (_("out of memory parsing relocs\n"));
919 for (i
= 0; i
< nrels
; i
++)
921 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
922 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
923 rels
[i
].r_addend
= 0;
930 Elf64_External_Rel
* erels
;
932 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
933 rel_size
, _("64-bit relocation data"));
937 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
939 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
944 error (_("out of memory parsing relocs\n"));
948 for (i
= 0; i
< nrels
; i
++)
950 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
951 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
952 rels
[i
].r_addend
= 0;
954 /* The #ifdef BFD64 below is to prevent a compile time
955 warning. We know that if we do not have a 64 bit data
956 type that we will never execute this code anyway. */
958 if (elf_header
.e_machine
== EM_MIPS
959 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
961 /* In little-endian objects, r_info isn't really a
962 64-bit little-endian value: it has a 32-bit
963 little-endian symbol index followed by four
964 individual byte fields. Reorder INFO
966 bfd_vma inf
= rels
[i
].r_info
;
967 inf
= (((inf
& 0xffffffff) << 32)
968 | ((inf
>> 56) & 0xff)
969 | ((inf
>> 40) & 0xff00)
970 | ((inf
>> 24) & 0xff0000)
971 | ((inf
>> 8) & 0xff000000));
972 rels
[i
].r_info
= inf
;
984 /* Returns the reloc type extracted from the reloc info field. */
987 get_reloc_type (bfd_vma reloc_info
)
990 return ELF32_R_TYPE (reloc_info
);
992 switch (elf_header
.e_machine
)
995 /* Note: We assume that reloc_info has already been adjusted for us. */
996 return ELF64_MIPS_R_TYPE (reloc_info
);
999 return ELF64_R_TYPE_ID (reloc_info
);
1002 return ELF64_R_TYPE (reloc_info
);
1006 /* Return the symbol index extracted from the reloc info field. */
1009 get_reloc_symindex (bfd_vma reloc_info
)
1011 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1014 static inline bfd_boolean
1015 uses_msp430x_relocs (void)
1018 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1019 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1020 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1021 /* TI compiler uses ELFOSABI_NONE. */
1022 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1025 /* Display the contents of the relocation data found at the specified
1029 dump_relocations (FILE * file
,
1030 unsigned long rel_offset
,
1031 unsigned long rel_size
,
1032 Elf_Internal_Sym
* symtab
,
1033 unsigned long nsyms
,
1035 unsigned long strtablen
,
1040 Elf_Internal_Rela
* rels
;
1042 if (is_rela
== UNKNOWN
)
1043 is_rela
= guess_is_rela (elf_header
.e_machine
);
1047 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1052 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1061 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1063 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1068 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1070 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1078 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1080 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1085 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1087 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1091 for (i
= 0; i
< rel_size
; i
++)
1096 bfd_vma symtab_index
;
1099 offset
= rels
[i
].r_offset
;
1100 inf
= rels
[i
].r_info
;
1102 type
= get_reloc_type (inf
);
1103 symtab_index
= get_reloc_symindex (inf
);
1107 printf ("%8.8lx %8.8lx ",
1108 (unsigned long) offset
& 0xffffffff,
1109 (unsigned long) inf
& 0xffffffff);
1113 #if BFD_HOST_64BIT_LONG
1115 ? "%16.16lx %16.16lx "
1116 : "%12.12lx %12.12lx ",
1118 #elif BFD_HOST_64BIT_LONG_LONG
1121 ? "%16.16llx %16.16llx "
1122 : "%12.12llx %12.12llx ",
1126 ? "%16.16I64x %16.16I64x "
1127 : "%12.12I64x %12.12I64x ",
1132 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1133 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1134 _bfd_int64_high (offset
),
1135 _bfd_int64_low (offset
),
1136 _bfd_int64_high (inf
),
1137 _bfd_int64_low (inf
));
1141 switch (elf_header
.e_machine
)
1148 rtype
= elf_aarch64_reloc_type (type
);
1152 case EM_CYGNUS_M32R
:
1153 rtype
= elf_m32r_reloc_type (type
);
1158 rtype
= elf_i386_reloc_type (type
);
1163 rtype
= elf_m68hc11_reloc_type (type
);
1167 rtype
= elf_m68k_reloc_type (type
);
1171 rtype
= elf_i960_reloc_type (type
);
1176 rtype
= elf_avr_reloc_type (type
);
1179 case EM_OLD_SPARCV9
:
1180 case EM_SPARC32PLUS
:
1183 rtype
= elf_sparc_reloc_type (type
);
1187 rtype
= elf_spu_reloc_type (type
);
1191 rtype
= v800_reloc_type (type
);
1194 case EM_CYGNUS_V850
:
1195 rtype
= v850_reloc_type (type
);
1199 case EM_CYGNUS_D10V
:
1200 rtype
= elf_d10v_reloc_type (type
);
1204 case EM_CYGNUS_D30V
:
1205 rtype
= elf_d30v_reloc_type (type
);
1209 rtype
= elf_dlx_reloc_type (type
);
1213 rtype
= elf_sh_reloc_type (type
);
1217 case EM_CYGNUS_MN10300
:
1218 rtype
= elf_mn10300_reloc_type (type
);
1222 case EM_CYGNUS_MN10200
:
1223 rtype
= elf_mn10200_reloc_type (type
);
1227 case EM_CYGNUS_FR30
:
1228 rtype
= elf_fr30_reloc_type (type
);
1232 rtype
= elf_frv_reloc_type (type
);
1236 rtype
= elf_mcore_reloc_type (type
);
1240 rtype
= elf_mmix_reloc_type (type
);
1244 rtype
= elf_moxie_reloc_type (type
);
1248 if (uses_msp430x_relocs ())
1250 rtype
= elf_msp430x_reloc_type (type
);
1254 rtype
= elf_msp430_reloc_type (type
);
1258 rtype
= elf_nds32_reloc_type (type
);
1262 rtype
= elf_ppc_reloc_type (type
);
1266 rtype
= elf_ppc64_reloc_type (type
);
1270 case EM_MIPS_RS3_LE
:
1271 rtype
= elf_mips_reloc_type (type
);
1275 rtype
= elf_alpha_reloc_type (type
);
1279 rtype
= elf_arm_reloc_type (type
);
1283 rtype
= elf_arc_reloc_type (type
);
1287 rtype
= elf_hppa_reloc_type (type
);
1293 rtype
= elf_h8_reloc_type (type
);
1297 rtype
= elf_or1k_reloc_type (type
);
1302 rtype
= elf_pj_reloc_type (type
);
1305 rtype
= elf_ia64_reloc_type (type
);
1309 rtype
= elf_cris_reloc_type (type
);
1313 rtype
= elf_i860_reloc_type (type
);
1319 rtype
= elf_x86_64_reloc_type (type
);
1323 rtype
= i370_reloc_type (type
);
1328 rtype
= elf_s390_reloc_type (type
);
1332 rtype
= elf_score_reloc_type (type
);
1336 rtype
= elf_xstormy16_reloc_type (type
);
1340 rtype
= elf_crx_reloc_type (type
);
1344 rtype
= elf_vax_reloc_type (type
);
1347 case EM_ADAPTEVA_EPIPHANY
:
1348 rtype
= elf_epiphany_reloc_type (type
);
1353 rtype
= elf_ip2k_reloc_type (type
);
1357 rtype
= elf_iq2000_reloc_type (type
);
1362 rtype
= elf_xtensa_reloc_type (type
);
1365 case EM_LATTICEMICO32
:
1366 rtype
= elf_lm32_reloc_type (type
);
1371 rtype
= elf_m32c_reloc_type (type
);
1375 rtype
= elf_mt_reloc_type (type
);
1379 rtype
= elf_bfin_reloc_type (type
);
1383 rtype
= elf_mep_reloc_type (type
);
1387 rtype
= elf_cr16_reloc_type (type
);
1391 case EM_MICROBLAZE_OLD
:
1392 rtype
= elf_microblaze_reloc_type (type
);
1396 rtype
= elf_rl78_reloc_type (type
);
1400 rtype
= elf_rx_reloc_type (type
);
1404 rtype
= elf_metag_reloc_type (type
);
1409 rtype
= elf_xc16x_reloc_type (type
);
1413 rtype
= elf_tic6x_reloc_type (type
);
1417 rtype
= elf_tilegx_reloc_type (type
);
1421 rtype
= elf_tilepro_reloc_type (type
);
1425 rtype
= elf_xgate_reloc_type (type
);
1428 case EM_ALTERA_NIOS2
:
1429 rtype
= elf_nios2_reloc_type (type
);
1434 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1436 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1438 if (elf_header
.e_machine
== EM_ALPHA
1440 && streq (rtype
, "R_ALPHA_LITUSE")
1443 switch (rels
[i
].r_addend
)
1445 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1446 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1447 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1448 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1449 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1450 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1451 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1452 default: rtype
= NULL
;
1455 printf (" (%s)", rtype
);
1459 printf (_("<unknown addend: %lx>"),
1460 (unsigned long) rels
[i
].r_addend
);
1463 else if (symtab_index
)
1465 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1466 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1469 Elf_Internal_Sym
* psym
;
1470 const char * version_string
;
1471 enum versioned_symbol_info sym_info
;
1472 unsigned short vna_other
;
1474 psym
= symtab
+ symtab_index
;
1477 = get_symbol_version_string (file
, is_dynsym
,
1486 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1490 unsigned int width
= is_32bit_elf
? 8 : 14;
1492 /* Relocations against GNU_IFUNC symbols do not use the value
1493 of the symbol as the address to relocate against. Instead
1494 they invoke the function named by the symbol and use its
1495 result as the address for relocation.
1497 To indicate this to the user, do not display the value of
1498 the symbol in the "Symbols's Value" field. Instead show
1499 its name followed by () as a hint that the symbol is
1503 || psym
->st_name
== 0
1504 || psym
->st_name
>= strtablen
)
1507 name
= strtab
+ psym
->st_name
;
1509 len
= print_symbol (width
, name
);
1511 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1513 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1517 print_vma (psym
->st_value
, LONG_HEX
);
1519 printf (is_32bit_elf
? " " : " ");
1522 if (psym
->st_name
== 0)
1524 const char * sec_name
= "<null>";
1527 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1529 if (psym
->st_shndx
< elf_header
.e_shnum
)
1530 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1531 else if (psym
->st_shndx
== SHN_ABS
)
1533 else if (psym
->st_shndx
== SHN_COMMON
)
1534 sec_name
= "COMMON";
1535 else if ((elf_header
.e_machine
== EM_MIPS
1536 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1537 || (elf_header
.e_machine
== EM_TI_C6000
1538 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1539 sec_name
= "SCOMMON";
1540 else if (elf_header
.e_machine
== EM_MIPS
1541 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1542 sec_name
= "SUNDEF";
1543 else if ((elf_header
.e_machine
== EM_X86_64
1544 || elf_header
.e_machine
== EM_L1OM
1545 || elf_header
.e_machine
== EM_K1OM
)
1546 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1547 sec_name
= "LARGE_COMMON";
1548 else if (elf_header
.e_machine
== EM_IA_64
1549 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1550 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1551 sec_name
= "ANSI_COM";
1552 else if (is_ia64_vms ()
1553 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1554 sec_name
= "VMS_SYMVEC";
1557 sprintf (name_buf
, "<section 0x%x>",
1558 (unsigned int) psym
->st_shndx
);
1559 sec_name
= name_buf
;
1562 print_symbol (22, sec_name
);
1564 else if (strtab
== NULL
)
1565 printf (_("<string table index: %3ld>"), psym
->st_name
);
1566 else if (psym
->st_name
>= strtablen
)
1567 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1570 print_symbol (22, strtab
+ psym
->st_name
);
1572 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1578 bfd_signed_vma off
= rels
[i
].r_addend
;
1581 printf (" - %" BFD_VMA_FMT
"x", - off
);
1583 printf (" + %" BFD_VMA_FMT
"x", off
);
1589 bfd_signed_vma off
= rels
[i
].r_addend
;
1591 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1593 printf ("-%" BFD_VMA_FMT
"x", - off
);
1595 printf ("%" BFD_VMA_FMT
"x", off
);
1598 if (elf_header
.e_machine
== EM_SPARCV9
1600 && streq (rtype
, "R_SPARC_OLO10"))
1601 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1606 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1608 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1609 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1610 const char * rtype2
= elf_mips_reloc_type (type2
);
1611 const char * rtype3
= elf_mips_reloc_type (type3
);
1613 printf (" Type2: ");
1616 printf (_("unrecognized: %-7lx"),
1617 (unsigned long) type2
& 0xffffffff);
1619 printf ("%-17.17s", rtype2
);
1621 printf ("\n Type3: ");
1624 printf (_("unrecognized: %-7lx"),
1625 (unsigned long) type3
& 0xffffffff);
1627 printf ("%-17.17s", rtype3
);
1638 get_mips_dynamic_type (unsigned long type
)
1642 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1643 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1644 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1645 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1646 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1647 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1648 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1649 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1650 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1651 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1652 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1653 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1654 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1655 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1656 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1657 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1658 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1659 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1660 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1661 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1662 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1663 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1664 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1665 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1666 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1667 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1668 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1669 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1670 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1671 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1672 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1673 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1674 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1675 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1676 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1677 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1678 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1679 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1680 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1681 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1682 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1683 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1684 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1685 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1686 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1693 get_sparc64_dynamic_type (unsigned long type
)
1697 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1704 get_ppc_dynamic_type (unsigned long type
)
1708 case DT_PPC_GOT
: return "PPC_GOT";
1709 case DT_PPC_OPT
: return "PPC_OPT";
1716 get_ppc64_dynamic_type (unsigned long type
)
1720 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1721 case DT_PPC64_OPD
: return "PPC64_OPD";
1722 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1723 case DT_PPC64_OPT
: return "PPC64_OPT";
1730 get_parisc_dynamic_type (unsigned long type
)
1734 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1735 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1736 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1737 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1738 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1739 case DT_HP_PREINIT
: return "HP_PREINIT";
1740 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1741 case DT_HP_NEEDED
: return "HP_NEEDED";
1742 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1743 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1744 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1745 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1746 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1747 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1748 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1749 case DT_HP_FILTERED
: return "HP_FILTERED";
1750 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1751 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1752 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1753 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1754 case DT_PLT
: return "PLT";
1755 case DT_PLT_SIZE
: return "PLT_SIZE";
1756 case DT_DLT
: return "DLT";
1757 case DT_DLT_SIZE
: return "DLT_SIZE";
1764 get_ia64_dynamic_type (unsigned long type
)
1768 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1769 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1770 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1771 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1772 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1773 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1774 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1775 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1776 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1777 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1778 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1779 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1780 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1781 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1782 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1783 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1784 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1785 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1786 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1787 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1788 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1789 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1790 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1791 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1792 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1793 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1794 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1795 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1796 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1797 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1798 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1805 get_alpha_dynamic_type (unsigned long type
)
1809 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1816 get_score_dynamic_type (unsigned long type
)
1820 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1821 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1822 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1823 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1824 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1825 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1832 get_tic6x_dynamic_type (unsigned long type
)
1836 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1837 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1838 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1839 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1840 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1841 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1848 get_nios2_dynamic_type (unsigned long type
)
1852 case DT_NIOS2_GP
: return "NIOS2_GP";
1859 get_dynamic_type (unsigned long type
)
1861 static char buff
[64];
1865 case DT_NULL
: return "NULL";
1866 case DT_NEEDED
: return "NEEDED";
1867 case DT_PLTRELSZ
: return "PLTRELSZ";
1868 case DT_PLTGOT
: return "PLTGOT";
1869 case DT_HASH
: return "HASH";
1870 case DT_STRTAB
: return "STRTAB";
1871 case DT_SYMTAB
: return "SYMTAB";
1872 case DT_RELA
: return "RELA";
1873 case DT_RELASZ
: return "RELASZ";
1874 case DT_RELAENT
: return "RELAENT";
1875 case DT_STRSZ
: return "STRSZ";
1876 case DT_SYMENT
: return "SYMENT";
1877 case DT_INIT
: return "INIT";
1878 case DT_FINI
: return "FINI";
1879 case DT_SONAME
: return "SONAME";
1880 case DT_RPATH
: return "RPATH";
1881 case DT_SYMBOLIC
: return "SYMBOLIC";
1882 case DT_REL
: return "REL";
1883 case DT_RELSZ
: return "RELSZ";
1884 case DT_RELENT
: return "RELENT";
1885 case DT_PLTREL
: return "PLTREL";
1886 case DT_DEBUG
: return "DEBUG";
1887 case DT_TEXTREL
: return "TEXTREL";
1888 case DT_JMPREL
: return "JMPREL";
1889 case DT_BIND_NOW
: return "BIND_NOW";
1890 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1891 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1892 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1893 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1894 case DT_RUNPATH
: return "RUNPATH";
1895 case DT_FLAGS
: return "FLAGS";
1897 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1898 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1900 case DT_CHECKSUM
: return "CHECKSUM";
1901 case DT_PLTPADSZ
: return "PLTPADSZ";
1902 case DT_MOVEENT
: return "MOVEENT";
1903 case DT_MOVESZ
: return "MOVESZ";
1904 case DT_FEATURE
: return "FEATURE";
1905 case DT_POSFLAG_1
: return "POSFLAG_1";
1906 case DT_SYMINSZ
: return "SYMINSZ";
1907 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1909 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1910 case DT_CONFIG
: return "CONFIG";
1911 case DT_DEPAUDIT
: return "DEPAUDIT";
1912 case DT_AUDIT
: return "AUDIT";
1913 case DT_PLTPAD
: return "PLTPAD";
1914 case DT_MOVETAB
: return "MOVETAB";
1915 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1917 case DT_VERSYM
: return "VERSYM";
1919 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1920 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1921 case DT_RELACOUNT
: return "RELACOUNT";
1922 case DT_RELCOUNT
: return "RELCOUNT";
1923 case DT_FLAGS_1
: return "FLAGS_1";
1924 case DT_VERDEF
: return "VERDEF";
1925 case DT_VERDEFNUM
: return "VERDEFNUM";
1926 case DT_VERNEED
: return "VERNEED";
1927 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1929 case DT_AUXILIARY
: return "AUXILIARY";
1930 case DT_USED
: return "USED";
1931 case DT_FILTER
: return "FILTER";
1933 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1934 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1935 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1936 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1937 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1938 case DT_GNU_HASH
: return "GNU_HASH";
1941 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1943 const char * result
;
1945 switch (elf_header
.e_machine
)
1948 case EM_MIPS_RS3_LE
:
1949 result
= get_mips_dynamic_type (type
);
1952 result
= get_sparc64_dynamic_type (type
);
1955 result
= get_ppc_dynamic_type (type
);
1958 result
= get_ppc64_dynamic_type (type
);
1961 result
= get_ia64_dynamic_type (type
);
1964 result
= get_alpha_dynamic_type (type
);
1967 result
= get_score_dynamic_type (type
);
1970 result
= get_tic6x_dynamic_type (type
);
1972 case EM_ALTERA_NIOS2
:
1973 result
= get_nios2_dynamic_type (type
);
1983 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1985 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1986 || (elf_header
.e_machine
== EM_PARISC
1987 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1989 const char * result
;
1991 switch (elf_header
.e_machine
)
1994 result
= get_parisc_dynamic_type (type
);
1997 result
= get_ia64_dynamic_type (type
);
2007 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2011 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2018 get_file_type (unsigned e_type
)
2020 static char buff
[32];
2024 case ET_NONE
: return _("NONE (None)");
2025 case ET_REL
: return _("REL (Relocatable file)");
2026 case ET_EXEC
: return _("EXEC (Executable file)");
2027 case ET_DYN
: return _("DYN (Shared object file)");
2028 case ET_CORE
: return _("CORE (Core file)");
2031 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2032 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2033 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2034 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2036 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2042 get_machine_name (unsigned e_machine
)
2044 static char buff
[64]; /* XXX */
2048 case EM_NONE
: return _("None");
2049 case EM_AARCH64
: return "AArch64";
2050 case EM_M32
: return "WE32100";
2051 case EM_SPARC
: return "Sparc";
2052 case EM_SPU
: return "SPU";
2053 case EM_386
: return "Intel 80386";
2054 case EM_68K
: return "MC68000";
2055 case EM_88K
: return "MC88000";
2056 case EM_486
: return "Intel 80486";
2057 case EM_860
: return "Intel 80860";
2058 case EM_MIPS
: return "MIPS R3000";
2059 case EM_S370
: return "IBM System/370";
2060 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2061 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2062 case EM_PARISC
: return "HPPA";
2063 case EM_PPC_OLD
: return "Power PC (old)";
2064 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2065 case EM_960
: return "Intel 90860";
2066 case EM_PPC
: return "PowerPC";
2067 case EM_PPC64
: return "PowerPC64";
2068 case EM_FR20
: return "Fujitsu FR20";
2069 case EM_RH32
: return "TRW RH32";
2070 case EM_MCORE
: return "MCORE";
2071 case EM_ARM
: return "ARM";
2072 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2073 case EM_SH
: return "Renesas / SuperH SH";
2074 case EM_SPARCV9
: return "Sparc v9";
2075 case EM_TRICORE
: return "Siemens Tricore";
2076 case EM_ARC
: return "ARC";
2077 case EM_H8_300
: return "Renesas H8/300";
2078 case EM_H8_300H
: return "Renesas H8/300H";
2079 case EM_H8S
: return "Renesas H8S";
2080 case EM_H8_500
: return "Renesas H8/500";
2081 case EM_IA_64
: return "Intel IA-64";
2082 case EM_MIPS_X
: return "Stanford MIPS-X";
2083 case EM_COLDFIRE
: return "Motorola Coldfire";
2084 case EM_ALPHA
: return "Alpha";
2085 case EM_CYGNUS_D10V
:
2086 case EM_D10V
: return "d10v";
2087 case EM_CYGNUS_D30V
:
2088 case EM_D30V
: return "d30v";
2089 case EM_CYGNUS_M32R
:
2090 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2091 case EM_CYGNUS_V850
:
2092 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2093 case EM_V850
: return "Renesas V850";
2094 case EM_CYGNUS_MN10300
:
2095 case EM_MN10300
: return "mn10300";
2096 case EM_CYGNUS_MN10200
:
2097 case EM_MN10200
: return "mn10200";
2098 case EM_MOXIE
: return "Moxie";
2099 case EM_CYGNUS_FR30
:
2100 case EM_FR30
: return "Fujitsu FR30";
2101 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2103 case EM_PJ
: return "picoJava";
2104 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2105 case EM_PCP
: return "Siemens PCP";
2106 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2107 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2108 case EM_STARCORE
: return "Motorola Star*Core processor";
2109 case EM_ME16
: return "Toyota ME16 processor";
2110 case EM_ST100
: return "STMicroelectronics ST100 processor";
2111 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2112 case EM_PDSP
: return "Sony DSP processor";
2113 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2114 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2115 case EM_FX66
: return "Siemens FX66 microcontroller";
2116 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2117 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2118 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2119 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2120 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2121 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2122 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2123 case EM_SVX
: return "Silicon Graphics SVx";
2124 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2125 case EM_VAX
: return "Digital VAX";
2127 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2128 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2129 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2130 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2131 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2132 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2133 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2134 case EM_PRISM
: return "Vitesse Prism";
2135 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2136 case EM_L1OM
: return "Intel L1OM";
2137 case EM_K1OM
: return "Intel K1OM";
2139 case EM_S390
: return "IBM S/390";
2140 case EM_SCORE
: return "SUNPLUS S+Core";
2141 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2142 case EM_OR1K
: return "OpenRISC 1000";
2143 case EM_ARC_A5
: return "ARC International ARCompact processor";
2144 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2145 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2146 case EM_DLX
: return "OpenDLX";
2148 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2149 case EM_IQ2000
: return "Vitesse IQ2000";
2151 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2152 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2153 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2154 case EM_NS32K
: return "National Semiconductor 32000 series";
2155 case EM_TPC
: return "Tenor Network TPC processor";
2156 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2157 case EM_MAX
: return "MAX Processor";
2158 case EM_CR
: return "National Semiconductor CompactRISC";
2159 case EM_F2MC16
: return "Fujitsu F2MC16";
2160 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2161 case EM_LATTICEMICO32
: return "Lattice Mico32";
2163 case EM_M32C
: return "Renesas M32c";
2164 case EM_MT
: return "Morpho Techologies MT processor";
2165 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2166 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2167 case EM_SEP
: return "Sharp embedded microprocessor";
2168 case EM_ARCA
: return "Arca RISC microprocessor";
2169 case EM_UNICORE
: return "Unicore";
2170 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2171 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2172 case EM_NIOS32
: return "Altera Nios";
2173 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2175 case EM_XC16X
: return "Infineon Technologies xc16x";
2176 case EM_M16C
: return "Renesas M16C series microprocessors";
2177 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2178 case EM_CE
: return "Freescale Communication Engine RISC core";
2179 case EM_TSK3000
: return "Altium TSK3000 core";
2180 case EM_RS08
: return "Freescale RS08 embedded processor";
2181 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2182 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2183 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2184 case EM_SE_C17
: return "Seiko Epson C17 family";
2185 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2186 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2187 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2188 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2189 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2190 case EM_R32C
: return "Renesas R32C series microprocessors";
2191 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2192 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2193 case EM_8051
: return "Intel 8051 and variants";
2194 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2195 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2196 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2197 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2198 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2199 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2200 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2201 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2204 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2205 case EM_RL78
: return "Renesas RL78";
2206 case EM_RX
: return "Renesas RX";
2207 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2208 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2209 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2210 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2211 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2212 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2213 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2214 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2215 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2216 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2217 case EM_CUDA
: return "NVIDIA CUDA architecture";
2218 case EM_XGATE
: return "Motorola XGATE embedded processor";
2220 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2226 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2231 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2232 e_flags
&= ~ EF_ARM_EABIMASK
;
2234 /* Handle "generic" ARM flags. */
2235 if (e_flags
& EF_ARM_RELEXEC
)
2237 strcat (buf
, ", relocatable executable");
2238 e_flags
&= ~ EF_ARM_RELEXEC
;
2241 if (e_flags
& EF_ARM_HASENTRY
)
2243 strcat (buf
, ", has entry point");
2244 e_flags
&= ~ EF_ARM_HASENTRY
;
2247 /* Now handle EABI specific flags. */
2251 strcat (buf
, ", <unrecognized EABI>");
2256 case EF_ARM_EABI_VER1
:
2257 strcat (buf
, ", Version1 EABI");
2262 /* Process flags one bit at a time. */
2263 flag
= e_flags
& - e_flags
;
2268 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2269 strcat (buf
, ", sorted symbol tables");
2279 case EF_ARM_EABI_VER2
:
2280 strcat (buf
, ", Version2 EABI");
2285 /* Process flags one bit at a time. */
2286 flag
= e_flags
& - e_flags
;
2291 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2292 strcat (buf
, ", sorted symbol tables");
2295 case EF_ARM_DYNSYMSUSESEGIDX
:
2296 strcat (buf
, ", dynamic symbols use segment index");
2299 case EF_ARM_MAPSYMSFIRST
:
2300 strcat (buf
, ", mapping symbols precede others");
2310 case EF_ARM_EABI_VER3
:
2311 strcat (buf
, ", Version3 EABI");
2314 case EF_ARM_EABI_VER4
:
2315 strcat (buf
, ", Version4 EABI");
2320 /* Process flags one bit at a time. */
2321 flag
= e_flags
& - e_flags
;
2327 strcat (buf
, ", BE8");
2331 strcat (buf
, ", LE8");
2342 case EF_ARM_EABI_VER5
:
2343 strcat (buf
, ", Version5 EABI");
2348 /* Process flags one bit at a time. */
2349 flag
= e_flags
& - e_flags
;
2355 strcat (buf
, ", BE8");
2359 strcat (buf
, ", LE8");
2362 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2363 strcat (buf
, ", soft-float ABI");
2366 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2367 strcat (buf
, ", hard-float ABI");
2377 case EF_ARM_EABI_UNKNOWN
:
2378 strcat (buf
, ", GNU EABI");
2383 /* Process flags one bit at a time. */
2384 flag
= e_flags
& - e_flags
;
2389 case EF_ARM_INTERWORK
:
2390 strcat (buf
, ", interworking enabled");
2393 case EF_ARM_APCS_26
:
2394 strcat (buf
, ", uses APCS/26");
2397 case EF_ARM_APCS_FLOAT
:
2398 strcat (buf
, ", uses APCS/float");
2402 strcat (buf
, ", position independent");
2406 strcat (buf
, ", 8 bit structure alignment");
2409 case EF_ARM_NEW_ABI
:
2410 strcat (buf
, ", uses new ABI");
2413 case EF_ARM_OLD_ABI
:
2414 strcat (buf
, ", uses old ABI");
2417 case EF_ARM_SOFT_FLOAT
:
2418 strcat (buf
, ", software FP");
2421 case EF_ARM_VFP_FLOAT
:
2422 strcat (buf
, ", VFP");
2425 case EF_ARM_MAVERICK_FLOAT
:
2426 strcat (buf
, ", Maverick FP");
2437 strcat (buf
,_(", <unknown>"));
2441 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2450 static const char *ABI_STRINGS
[] =
2452 "ABI v0", /* use r5 as return register; only used in N1213HC */
2453 "ABI v1", /* use r0 as return register */
2454 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2455 "ABI v2fp", /* for FPU */
2459 static const char *VER_STRINGS
[] =
2461 "Andes ELF V1.3 or older",
2465 static const char *ARCH_STRINGS
[] =
2474 abi
= EF_NDS_ABI
& e_flags
;
2475 arch
= EF_NDS_ARCH
& e_flags
;
2476 config
= EF_NDS_INST
& e_flags
;
2477 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2479 memset (buf
, 0, size
);
2486 case E_NDS_ABI_V2FP
:
2487 case E_NDS_ABI_AABI
:
2488 case E_NDS_ABI_V2FP_PLUS
:
2489 /* In case there are holes in the array. */
2490 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2494 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2500 case E_NDS32_ELF_VER_1_2
:
2501 case E_NDS32_ELF_VER_1_3
:
2502 case E_NDS32_ELF_VER_1_4
:
2503 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2507 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2511 if (E_NDS_ABI_V0
== abi
)
2513 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2514 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2515 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2516 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2522 case E_NDS_ARCH_STAR_V1_0
:
2523 case E_NDS_ARCH_STAR_V2_0
:
2524 case E_NDS_ARCH_STAR_V3_0
:
2525 case E_NDS_ARCH_STAR_V3_M
:
2526 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2530 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2531 /* ARCH version determines how the e_flags are interpreted.
2532 If it is unknown, we cannot proceed. */
2536 /* Newer ABI; Now handle architecture specific flags. */
2537 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2539 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2540 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2542 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2543 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2545 if (config
& E_NDS32_HAS_DIV_INST
)
2546 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2548 if (config
& E_NDS32_HAS_16BIT_INST
)
2549 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2553 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2555 if (version
<= E_NDS32_ELF_VER_1_3
)
2556 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2558 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2561 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2562 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2564 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2565 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2567 if (config
& E_NDS32_HAS_16BIT_INST
)
2569 if (version
<= E_NDS32_ELF_VER_1_3
)
2570 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2572 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2576 if (config
& E_NDS32_HAS_EXT_INST
)
2577 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2579 if (config
& E_NDS32_HAS_EXT2_INST
)
2580 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2582 if (config
& E_NDS32_HAS_FPU_INST
)
2585 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2588 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2591 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2594 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2597 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2602 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2604 case E_NDS32_FPU_REG_8SP_4DP
:
2605 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2607 case E_NDS32_FPU_REG_16SP_8DP
:
2608 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2610 case E_NDS32_FPU_REG_32SP_16DP
:
2611 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2613 case E_NDS32_FPU_REG_32SP_32DP
:
2614 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2619 if (config
& E_NDS32_HAS_AUDIO_INST
)
2620 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2622 if (config
& E_NDS32_HAS_STRING_INST
)
2623 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2625 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2626 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2628 if (config
& E_NDS32_HAS_VIDEO_INST
)
2630 if (version
<= E_NDS32_ELF_VER_1_3
)
2631 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2633 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2636 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2637 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2639 if (config
& E_NDS32_HAS_L2C_INST
)
2640 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2644 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2646 static char buf
[1024];
2658 decode_ARM_machine_flags (e_flags
, buf
);
2662 if (e_flags
& EF_BFIN_PIC
)
2663 strcat (buf
, ", PIC");
2665 if (e_flags
& EF_BFIN_FDPIC
)
2666 strcat (buf
, ", FDPIC");
2668 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2669 strcat (buf
, ", code in L1");
2671 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2672 strcat (buf
, ", data in L1");
2677 switch (e_flags
& EF_FRV_CPU_MASK
)
2679 case EF_FRV_CPU_GENERIC
:
2683 strcat (buf
, ", fr???");
2686 case EF_FRV_CPU_FR300
:
2687 strcat (buf
, ", fr300");
2690 case EF_FRV_CPU_FR400
:
2691 strcat (buf
, ", fr400");
2693 case EF_FRV_CPU_FR405
:
2694 strcat (buf
, ", fr405");
2697 case EF_FRV_CPU_FR450
:
2698 strcat (buf
, ", fr450");
2701 case EF_FRV_CPU_FR500
:
2702 strcat (buf
, ", fr500");
2704 case EF_FRV_CPU_FR550
:
2705 strcat (buf
, ", fr550");
2708 case EF_FRV_CPU_SIMPLE
:
2709 strcat (buf
, ", simple");
2711 case EF_FRV_CPU_TOMCAT
:
2712 strcat (buf
, ", tomcat");
2718 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2719 strcat (buf
, ", m68000");
2720 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2721 strcat (buf
, ", cpu32");
2722 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2723 strcat (buf
, ", fido_a");
2726 char const * isa
= _("unknown");
2727 char const * mac
= _("unknown mac");
2728 char const * additional
= NULL
;
2730 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2732 case EF_M68K_CF_ISA_A_NODIV
:
2734 additional
= ", nodiv";
2736 case EF_M68K_CF_ISA_A
:
2739 case EF_M68K_CF_ISA_A_PLUS
:
2742 case EF_M68K_CF_ISA_B_NOUSP
:
2744 additional
= ", nousp";
2746 case EF_M68K_CF_ISA_B
:
2749 case EF_M68K_CF_ISA_C
:
2752 case EF_M68K_CF_ISA_C_NODIV
:
2754 additional
= ", nodiv";
2757 strcat (buf
, ", cf, isa ");
2760 strcat (buf
, additional
);
2761 if (e_flags
& EF_M68K_CF_FLOAT
)
2762 strcat (buf
, ", float");
2763 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2768 case EF_M68K_CF_MAC
:
2771 case EF_M68K_CF_EMAC
:
2774 case EF_M68K_CF_EMAC_B
:
2787 if (e_flags
& EF_PPC_EMB
)
2788 strcat (buf
, ", emb");
2790 if (e_flags
& EF_PPC_RELOCATABLE
)
2791 strcat (buf
, _(", relocatable"));
2793 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2794 strcat (buf
, _(", relocatable-lib"));
2798 if (e_flags
& EF_PPC64_ABI
)
2800 char abi
[] = ", abiv0";
2802 abi
[6] += e_flags
& EF_PPC64_ABI
;
2808 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2809 strcat (buf
, ", RH850 ABI");
2811 if (e_flags
& EF_V800_850E3
)
2812 strcat (buf
, ", V3 architecture");
2814 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2815 strcat (buf
, ", FPU not used");
2817 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2818 strcat (buf
, ", regmode: COMMON");
2820 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2821 strcat (buf
, ", r4 not used");
2823 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2824 strcat (buf
, ", r30 not used");
2826 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2827 strcat (buf
, ", r5 not used");
2829 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2830 strcat (buf
, ", r2 not used");
2832 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2834 switch (e_flags
& - e_flags
)
2836 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2837 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2838 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2839 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2840 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2841 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2842 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2843 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2844 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2845 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2846 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2847 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2848 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2849 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2850 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2851 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2858 case EM_CYGNUS_V850
:
2859 switch (e_flags
& EF_V850_ARCH
)
2861 case E_V850E3V5_ARCH
:
2862 strcat (buf
, ", v850e3v5");
2864 case E_V850E2V3_ARCH
:
2865 strcat (buf
, ", v850e2v3");
2868 strcat (buf
, ", v850e2");
2871 strcat (buf
, ", v850e1");
2874 strcat (buf
, ", v850e");
2877 strcat (buf
, ", v850");
2880 strcat (buf
, _(", unknown v850 architecture variant"));
2886 case EM_CYGNUS_M32R
:
2887 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2888 strcat (buf
, ", m32r");
2892 case EM_MIPS_RS3_LE
:
2893 if (e_flags
& EF_MIPS_NOREORDER
)
2894 strcat (buf
, ", noreorder");
2896 if (e_flags
& EF_MIPS_PIC
)
2897 strcat (buf
, ", pic");
2899 if (e_flags
& EF_MIPS_CPIC
)
2900 strcat (buf
, ", cpic");
2902 if (e_flags
& EF_MIPS_UCODE
)
2903 strcat (buf
, ", ugen_reserved");
2905 if (e_flags
& EF_MIPS_ABI2
)
2906 strcat (buf
, ", abi2");
2908 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2909 strcat (buf
, ", odk first");
2911 if (e_flags
& EF_MIPS_32BITMODE
)
2912 strcat (buf
, ", 32bitmode");
2914 if (e_flags
& EF_MIPS_NAN2008
)
2915 strcat (buf
, ", nan2008");
2917 if (e_flags
& EF_MIPS_FP64
)
2918 strcat (buf
, ", fp64");
2920 switch ((e_flags
& EF_MIPS_MACH
))
2922 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2923 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2924 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2925 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2926 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2927 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2928 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2929 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2930 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2931 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2932 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2933 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2934 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2935 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2936 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2937 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2938 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2940 /* We simply ignore the field in this case to avoid confusion:
2941 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2944 default: strcat (buf
, _(", unknown CPU")); break;
2947 switch ((e_flags
& EF_MIPS_ABI
))
2949 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2950 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2951 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2952 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2954 /* We simply ignore the field in this case to avoid confusion:
2955 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2956 This means it is likely to be an o32 file, but not for
2959 default: strcat (buf
, _(", unknown ABI")); break;
2962 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2963 strcat (buf
, ", mdmx");
2965 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2966 strcat (buf
, ", mips16");
2968 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2969 strcat (buf
, ", micromips");
2971 switch ((e_flags
& EF_MIPS_ARCH
))
2973 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2974 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2975 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2976 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2977 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2978 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2979 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2980 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
2981 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2982 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2983 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
2984 default: strcat (buf
, _(", unknown ISA")); break;
2989 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2993 switch ((e_flags
& EF_SH_MACH_MASK
))
2995 case EF_SH1
: strcat (buf
, ", sh1"); break;
2996 case EF_SH2
: strcat (buf
, ", sh2"); break;
2997 case EF_SH3
: strcat (buf
, ", sh3"); break;
2998 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2999 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3000 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3001 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3002 case EF_SH4
: strcat (buf
, ", sh4"); break;
3003 case EF_SH5
: strcat (buf
, ", sh5"); break;
3004 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3005 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3006 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3007 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3008 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3009 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3010 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3011 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3012 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3013 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3014 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3015 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3016 default: strcat (buf
, _(", unknown ISA")); break;
3019 if (e_flags
& EF_SH_PIC
)
3020 strcat (buf
, ", pic");
3022 if (e_flags
& EF_SH_FDPIC
)
3023 strcat (buf
, ", fdpic");
3027 if (e_flags
& EF_OR1K_NODELAY
)
3028 strcat (buf
, ", no delay");
3032 if (e_flags
& EF_SPARC_32PLUS
)
3033 strcat (buf
, ", v8+");
3035 if (e_flags
& EF_SPARC_SUN_US1
)
3036 strcat (buf
, ", ultrasparcI");
3038 if (e_flags
& EF_SPARC_SUN_US3
)
3039 strcat (buf
, ", ultrasparcIII");
3041 if (e_flags
& EF_SPARC_HAL_R1
)
3042 strcat (buf
, ", halr1");
3044 if (e_flags
& EF_SPARC_LEDATA
)
3045 strcat (buf
, ", ledata");
3047 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3048 strcat (buf
, ", tso");
3050 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3051 strcat (buf
, ", pso");
3053 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3054 strcat (buf
, ", rmo");
3058 switch (e_flags
& EF_PARISC_ARCH
)
3060 case EFA_PARISC_1_0
:
3061 strcpy (buf
, ", PA-RISC 1.0");
3063 case EFA_PARISC_1_1
:
3064 strcpy (buf
, ", PA-RISC 1.1");
3066 case EFA_PARISC_2_0
:
3067 strcpy (buf
, ", PA-RISC 2.0");
3072 if (e_flags
& EF_PARISC_TRAPNIL
)
3073 strcat (buf
, ", trapnil");
3074 if (e_flags
& EF_PARISC_EXT
)
3075 strcat (buf
, ", ext");
3076 if (e_flags
& EF_PARISC_LSB
)
3077 strcat (buf
, ", lsb");
3078 if (e_flags
& EF_PARISC_WIDE
)
3079 strcat (buf
, ", wide");
3080 if (e_flags
& EF_PARISC_NO_KABP
)
3081 strcat (buf
, ", no kabp");
3082 if (e_flags
& EF_PARISC_LAZYSWAP
)
3083 strcat (buf
, ", lazyswap");
3088 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3089 strcat (buf
, ", new calling convention");
3091 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3092 strcat (buf
, ", gnu calling convention");
3096 if ((e_flags
& EF_IA_64_ABI64
))
3097 strcat (buf
, ", 64-bit");
3099 strcat (buf
, ", 32-bit");
3100 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3101 strcat (buf
, ", reduced fp model");
3102 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3103 strcat (buf
, ", no function descriptors, constant gp");
3104 else if ((e_flags
& EF_IA_64_CONS_GP
))
3105 strcat (buf
, ", constant gp");
3106 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3107 strcat (buf
, ", absolute");
3108 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3110 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3111 strcat (buf
, ", vms_linkages");
3112 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3114 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3116 case EF_IA_64_VMS_COMCOD_WARNING
:
3117 strcat (buf
, ", warning");
3119 case EF_IA_64_VMS_COMCOD_ERROR
:
3120 strcat (buf
, ", error");
3122 case EF_IA_64_VMS_COMCOD_ABORT
:
3123 strcat (buf
, ", abort");
3126 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3127 e_flags
& EF_IA_64_VMS_COMCOD
);
3128 strcat (buf
, ", <unknown>");
3134 if ((e_flags
& EF_VAX_NONPIC
))
3135 strcat (buf
, ", non-PIC");
3136 if ((e_flags
& EF_VAX_DFLOAT
))
3137 strcat (buf
, ", D-Float");
3138 if ((e_flags
& EF_VAX_GFLOAT
))
3139 strcat (buf
, ", G-Float");
3143 if (e_flags
& E_FLAG_RL78_G10
)
3144 strcat (buf
, ", G10");
3145 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3146 strcat (buf
, ", 64-bit doubles");
3150 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3151 strcat (buf
, ", 64-bit doubles");
3152 if (e_flags
& E_FLAG_RX_DSP
)
3153 strcat (buf
, ", dsp");
3154 if (e_flags
& E_FLAG_RX_PID
)
3155 strcat (buf
, ", pid");
3156 if (e_flags
& E_FLAG_RX_ABI
)
3157 strcat (buf
, ", RX ABI");
3161 if (e_flags
& EF_S390_HIGH_GPRS
)
3162 strcat (buf
, ", highgprs");
3166 if ((e_flags
& EF_C6000_REL
))
3167 strcat (buf
, ", relocatable module");
3171 strcat (buf
, _(": architecture variant: "));
3172 switch (e_flags
& EF_MSP430_MACH
)
3174 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3175 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3176 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3177 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3178 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3179 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3180 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3181 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3182 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3183 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3184 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3185 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3186 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3187 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3188 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3190 strcat (buf
, _(": unknown")); break;
3193 if (e_flags
& ~ EF_MSP430_MACH
)
3194 strcat (buf
, _(": unknown extra flag bits also present"));
3202 get_osabi_name (unsigned int osabi
)
3204 static char buff
[32];
3208 case ELFOSABI_NONE
: return "UNIX - System V";
3209 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3210 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3211 case ELFOSABI_GNU
: return "UNIX - GNU";
3212 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3213 case ELFOSABI_AIX
: return "UNIX - AIX";
3214 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3215 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3216 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3217 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3218 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3219 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3220 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3221 case ELFOSABI_AROS
: return "AROS";
3222 case ELFOSABI_FENIXOS
: return "FenixOS";
3225 switch (elf_header
.e_machine
)
3230 case ELFOSABI_ARM
: return "ARM";
3240 case ELFOSABI_STANDALONE
: return _("Standalone App");
3249 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3250 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3259 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3265 get_aarch64_segment_type (unsigned long type
)
3269 case PT_AARCH64_ARCHEXT
:
3270 return "AARCH64_ARCHEXT";
3279 get_arm_segment_type (unsigned long type
)
3293 get_mips_segment_type (unsigned long type
)
3297 case PT_MIPS_REGINFO
:
3299 case PT_MIPS_RTPROC
:
3301 case PT_MIPS_OPTIONS
:
3303 case PT_MIPS_ABIFLAGS
:
3313 get_parisc_segment_type (unsigned long type
)
3317 case PT_HP_TLS
: return "HP_TLS";
3318 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3319 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3320 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3321 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3322 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3323 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3324 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3325 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3326 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3327 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3328 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3329 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3330 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3331 case PT_HP_STACK
: return "HP_STACK";
3332 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3333 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3334 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3335 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3344 get_ia64_segment_type (unsigned long type
)
3348 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3349 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3350 case PT_HP_TLS
: return "HP_TLS";
3351 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3352 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3353 case PT_IA_64_HP_STACK
: return "HP_STACK";
3362 get_tic6x_segment_type (unsigned long type
)
3366 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3375 get_segment_type (unsigned long p_type
)
3377 static char buff
[32];
3381 case PT_NULL
: return "NULL";
3382 case PT_LOAD
: return "LOAD";
3383 case PT_DYNAMIC
: return "DYNAMIC";
3384 case PT_INTERP
: return "INTERP";
3385 case PT_NOTE
: return "NOTE";
3386 case PT_SHLIB
: return "SHLIB";
3387 case PT_PHDR
: return "PHDR";
3388 case PT_TLS
: return "TLS";
3390 case PT_GNU_EH_FRAME
:
3391 return "GNU_EH_FRAME";
3392 case PT_GNU_STACK
: return "GNU_STACK";
3393 case PT_GNU_RELRO
: return "GNU_RELRO";
3396 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3398 const char * result
;
3400 switch (elf_header
.e_machine
)
3403 result
= get_aarch64_segment_type (p_type
);
3406 result
= get_arm_segment_type (p_type
);
3409 case EM_MIPS_RS3_LE
:
3410 result
= get_mips_segment_type (p_type
);
3413 result
= get_parisc_segment_type (p_type
);
3416 result
= get_ia64_segment_type (p_type
);
3419 result
= get_tic6x_segment_type (p_type
);
3429 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3431 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3433 const char * result
;
3435 switch (elf_header
.e_machine
)
3438 result
= get_parisc_segment_type (p_type
);
3441 result
= get_ia64_segment_type (p_type
);
3451 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3454 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3461 get_mips_section_type_name (unsigned int sh_type
)
3465 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3466 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3467 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3468 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3469 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3470 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3471 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3472 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3473 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3474 case SHT_MIPS_RELD
: return "MIPS_RELD";
3475 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3476 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3477 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3478 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3479 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3480 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3481 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3482 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3483 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3484 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3485 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3486 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3487 case SHT_MIPS_LINE
: return "MIPS_LINE";
3488 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3489 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3490 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3491 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3492 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3493 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3494 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3495 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3496 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3497 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3498 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3499 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3500 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3501 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3502 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3503 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3504 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3512 get_parisc_section_type_name (unsigned int sh_type
)
3516 case SHT_PARISC_EXT
: return "PARISC_EXT";
3517 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3518 case SHT_PARISC_DOC
: return "PARISC_DOC";
3519 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3520 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3521 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3522 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3530 get_ia64_section_type_name (unsigned int sh_type
)
3532 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3533 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3534 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3538 case SHT_IA_64_EXT
: return "IA_64_EXT";
3539 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3540 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3541 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3542 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3543 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3544 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3545 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3546 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3547 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3555 get_x86_64_section_type_name (unsigned int sh_type
)
3559 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3567 get_aarch64_section_type_name (unsigned int sh_type
)
3571 case SHT_AARCH64_ATTRIBUTES
:
3572 return "AARCH64_ATTRIBUTES";
3580 get_arm_section_type_name (unsigned int sh_type
)
3584 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3585 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3586 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3587 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3588 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3596 get_tic6x_section_type_name (unsigned int sh_type
)
3600 case SHT_C6000_UNWIND
:
3601 return "C6000_UNWIND";
3602 case SHT_C6000_PREEMPTMAP
:
3603 return "C6000_PREEMPTMAP";
3604 case SHT_C6000_ATTRIBUTES
:
3605 return "C6000_ATTRIBUTES";
3610 case SHT_TI_HANDLER
:
3611 return "TI_HANDLER";
3612 case SHT_TI_INITINFO
:
3613 return "TI_INITINFO";
3614 case SHT_TI_PHATTRS
:
3615 return "TI_PHATTRS";
3623 get_msp430x_section_type_name (unsigned int sh_type
)
3627 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3628 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3629 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3630 default: return NULL
;
3635 get_section_type_name (unsigned int sh_type
)
3637 static char buff
[32];
3641 case SHT_NULL
: return "NULL";
3642 case SHT_PROGBITS
: return "PROGBITS";
3643 case SHT_SYMTAB
: return "SYMTAB";
3644 case SHT_STRTAB
: return "STRTAB";
3645 case SHT_RELA
: return "RELA";
3646 case SHT_HASH
: return "HASH";
3647 case SHT_DYNAMIC
: return "DYNAMIC";
3648 case SHT_NOTE
: return "NOTE";
3649 case SHT_NOBITS
: return "NOBITS";
3650 case SHT_REL
: return "REL";
3651 case SHT_SHLIB
: return "SHLIB";
3652 case SHT_DYNSYM
: return "DYNSYM";
3653 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3654 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3655 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3656 case SHT_GNU_HASH
: return "GNU_HASH";
3657 case SHT_GROUP
: return "GROUP";
3658 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3659 case SHT_GNU_verdef
: return "VERDEF";
3660 case SHT_GNU_verneed
: return "VERNEED";
3661 case SHT_GNU_versym
: return "VERSYM";
3662 case 0x6ffffff0: return "VERSYM";
3663 case 0x6ffffffc: return "VERDEF";
3664 case 0x7ffffffd: return "AUXILIARY";
3665 case 0x7fffffff: return "FILTER";
3666 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3669 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3671 const char * result
;
3673 switch (elf_header
.e_machine
)
3676 case EM_MIPS_RS3_LE
:
3677 result
= get_mips_section_type_name (sh_type
);
3680 result
= get_parisc_section_type_name (sh_type
);
3683 result
= get_ia64_section_type_name (sh_type
);
3688 result
= get_x86_64_section_type_name (sh_type
);
3691 result
= get_aarch64_section_type_name (sh_type
);
3694 result
= get_arm_section_type_name (sh_type
);
3697 result
= get_tic6x_section_type_name (sh_type
);
3700 result
= get_msp430x_section_type_name (sh_type
);
3710 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3712 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3714 const char * result
;
3716 switch (elf_header
.e_machine
)
3719 result
= get_ia64_section_type_name (sh_type
);
3729 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3731 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3732 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3734 /* This message is probably going to be displayed in a 15
3735 character wide field, so put the hex value first. */
3736 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3742 #define OPTION_DEBUG_DUMP 512
3743 #define OPTION_DYN_SYMS 513
3744 #define OPTION_DWARF_DEPTH 514
3745 #define OPTION_DWARF_START 515
3746 #define OPTION_DWARF_CHECK 516
3748 static struct option options
[] =
3750 {"all", no_argument
, 0, 'a'},
3751 {"file-header", no_argument
, 0, 'h'},
3752 {"program-headers", no_argument
, 0, 'l'},
3753 {"headers", no_argument
, 0, 'e'},
3754 {"histogram", no_argument
, 0, 'I'},
3755 {"segments", no_argument
, 0, 'l'},
3756 {"sections", no_argument
, 0, 'S'},
3757 {"section-headers", no_argument
, 0, 'S'},
3758 {"section-groups", no_argument
, 0, 'g'},
3759 {"section-details", no_argument
, 0, 't'},
3760 {"full-section-name",no_argument
, 0, 'N'},
3761 {"symbols", no_argument
, 0, 's'},
3762 {"syms", no_argument
, 0, 's'},
3763 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3764 {"relocs", no_argument
, 0, 'r'},
3765 {"notes", no_argument
, 0, 'n'},
3766 {"dynamic", no_argument
, 0, 'd'},
3767 {"arch-specific", no_argument
, 0, 'A'},
3768 {"version-info", no_argument
, 0, 'V'},
3769 {"use-dynamic", no_argument
, 0, 'D'},
3770 {"unwind", no_argument
, 0, 'u'},
3771 {"archive-index", no_argument
, 0, 'c'},
3772 {"hex-dump", required_argument
, 0, 'x'},
3773 {"relocated-dump", required_argument
, 0, 'R'},
3774 {"string-dump", required_argument
, 0, 'p'},
3775 #ifdef SUPPORT_DISASSEMBLY
3776 {"instruction-dump", required_argument
, 0, 'i'},
3778 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3780 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3781 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3782 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3784 {"version", no_argument
, 0, 'v'},
3785 {"wide", no_argument
, 0, 'W'},
3786 {"help", no_argument
, 0, 'H'},
3787 {0, no_argument
, 0, 0}
3791 usage (FILE * stream
)
3793 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3794 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3795 fprintf (stream
, _(" Options are:\n\
3796 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3797 -h --file-header Display the ELF file header\n\
3798 -l --program-headers Display the program headers\n\
3799 --segments An alias for --program-headers\n\
3800 -S --section-headers Display the sections' header\n\
3801 --sections An alias for --section-headers\n\
3802 -g --section-groups Display the section groups\n\
3803 -t --section-details Display the section details\n\
3804 -e --headers Equivalent to: -h -l -S\n\
3805 -s --syms Display the symbol table\n\
3806 --symbols An alias for --syms\n\
3807 --dyn-syms Display the dynamic symbol table\n\
3808 -n --notes Display the core notes (if present)\n\
3809 -r --relocs Display the relocations (if present)\n\
3810 -u --unwind Display the unwind info (if present)\n\
3811 -d --dynamic Display the dynamic section (if present)\n\
3812 -V --version-info Display the version sections (if present)\n\
3813 -A --arch-specific Display architecture specific information (if any)\n\
3814 -c --archive-index Display the symbol/file index in an archive\n\
3815 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3816 -x --hex-dump=<number|name>\n\
3817 Dump the contents of section <number|name> as bytes\n\
3818 -p --string-dump=<number|name>\n\
3819 Dump the contents of section <number|name> as strings\n\
3820 -R --relocated-dump=<number|name>\n\
3821 Dump the contents of section <number|name> as relocated bytes\n\
3822 -w[lLiaprmfFsoRt] or\n\
3823 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3824 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3825 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3827 Display the contents of DWARF2 debug sections\n"));
3828 fprintf (stream
, _("\
3829 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3830 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3832 #ifdef SUPPORT_DISASSEMBLY
3833 fprintf (stream
, _("\
3834 -i --instruction-dump=<number|name>\n\
3835 Disassemble the contents of section <number|name>\n"));
3837 fprintf (stream
, _("\
3838 -I --histogram Display histogram of bucket list lengths\n\
3839 -W --wide Allow output width to exceed 80 characters\n\
3840 @<file> Read options from <file>\n\
3841 -H --help Display this information\n\
3842 -v --version Display the version number of readelf\n"));
3844 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3845 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3847 exit (stream
== stdout
? 0 : 1);
3850 /* Record the fact that the user wants the contents of section number
3851 SECTION to be displayed using the method(s) encoded as flags bits
3852 in TYPE. Note, TYPE can be zero if we are creating the array for
3856 request_dump_bynumber (unsigned int section
, dump_type type
)
3858 if (section
>= num_dump_sects
)
3860 dump_type
* new_dump_sects
;
3862 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3863 sizeof (* dump_sects
));
3865 if (new_dump_sects
== NULL
)
3866 error (_("Out of memory allocating dump request table.\n"));
3869 /* Copy current flag settings. */
3870 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3874 dump_sects
= new_dump_sects
;
3875 num_dump_sects
= section
+ 1;
3880 dump_sects
[section
] |= type
;
3885 /* Request a dump by section name. */
3888 request_dump_byname (const char * section
, dump_type type
)
3890 struct dump_list_entry
* new_request
;
3892 new_request
= (struct dump_list_entry
*)
3893 malloc (sizeof (struct dump_list_entry
));
3895 error (_("Out of memory allocating dump request table.\n"));
3897 new_request
->name
= strdup (section
);
3898 if (!new_request
->name
)
3899 error (_("Out of memory allocating dump request table.\n"));
3901 new_request
->type
= type
;
3903 new_request
->next
= dump_sects_byname
;
3904 dump_sects_byname
= new_request
;
3908 request_dump (dump_type type
)
3914 section
= strtoul (optarg
, & cp
, 0);
3916 if (! *cp
&& section
>= 0)
3917 request_dump_bynumber (section
, type
);
3919 request_dump_byname (optarg
, type
);
3924 parse_args (int argc
, char ** argv
)
3931 while ((c
= getopt_long
3932 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3950 do_section_groups
++;
3958 do_section_groups
++;
3963 do_section_details
++;
4007 request_dump (HEX_DUMP
);
4010 request_dump (STRING_DUMP
);
4013 request_dump (RELOC_DUMP
);
4020 dwarf_select_sections_all ();
4025 dwarf_select_sections_by_letters (optarg
);
4028 case OPTION_DEBUG_DUMP
:
4035 dwarf_select_sections_by_names (optarg
);
4038 case OPTION_DWARF_DEPTH
:
4042 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4045 case OPTION_DWARF_START
:
4049 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4052 case OPTION_DWARF_CHECK
:
4055 case OPTION_DYN_SYMS
:
4058 #ifdef SUPPORT_DISASSEMBLY
4060 request_dump (DISASS_DUMP
);
4064 print_version (program_name
);
4073 /* xgettext:c-format */
4074 error (_("Invalid option '-%c'\n"), c
);
4081 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4082 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4083 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4084 && !do_section_groups
&& !do_archive_index
4089 warn (_("Nothing to do.\n"));
4095 get_elf_class (unsigned int elf_class
)
4097 static char buff
[32];
4101 case ELFCLASSNONE
: return _("none");
4102 case ELFCLASS32
: return "ELF32";
4103 case ELFCLASS64
: return "ELF64";
4105 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4111 get_data_encoding (unsigned int encoding
)
4113 static char buff
[32];
4117 case ELFDATANONE
: return _("none");
4118 case ELFDATA2LSB
: return _("2's complement, little endian");
4119 case ELFDATA2MSB
: return _("2's complement, big endian");
4121 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4126 /* Decode the data held in 'elf_header'. */
4129 process_file_header (void)
4131 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4132 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4133 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4134 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4137 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4141 init_dwarf_regnames (elf_header
.e_machine
);
4147 printf (_("ELF Header:\n"));
4148 printf (_(" Magic: "));
4149 for (i
= 0; i
< EI_NIDENT
; i
++)
4150 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4152 printf (_(" Class: %s\n"),
4153 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4154 printf (_(" Data: %s\n"),
4155 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4156 printf (_(" Version: %d %s\n"),
4157 elf_header
.e_ident
[EI_VERSION
],
4158 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4160 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4161 ? _("<unknown: %lx>")
4163 printf (_(" OS/ABI: %s\n"),
4164 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4165 printf (_(" ABI Version: %d\n"),
4166 elf_header
.e_ident
[EI_ABIVERSION
]);
4167 printf (_(" Type: %s\n"),
4168 get_file_type (elf_header
.e_type
));
4169 printf (_(" Machine: %s\n"),
4170 get_machine_name (elf_header
.e_machine
));
4171 printf (_(" Version: 0x%lx\n"),
4172 (unsigned long) elf_header
.e_version
);
4174 printf (_(" Entry point address: "));
4175 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4176 printf (_("\n Start of program headers: "));
4177 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4178 printf (_(" (bytes into file)\n Start of section headers: "));
4179 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4180 printf (_(" (bytes into file)\n"));
4182 printf (_(" Flags: 0x%lx%s\n"),
4183 (unsigned long) elf_header
.e_flags
,
4184 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4185 printf (_(" Size of this header: %ld (bytes)\n"),
4186 (long) elf_header
.e_ehsize
);
4187 printf (_(" Size of program headers: %ld (bytes)\n"),
4188 (long) elf_header
.e_phentsize
);
4189 printf (_(" Number of program headers: %ld"),
4190 (long) elf_header
.e_phnum
);
4191 if (section_headers
!= NULL
4192 && elf_header
.e_phnum
== PN_XNUM
4193 && section_headers
[0].sh_info
!= 0)
4194 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4195 putc ('\n', stdout
);
4196 printf (_(" Size of section headers: %ld (bytes)\n"),
4197 (long) elf_header
.e_shentsize
);
4198 printf (_(" Number of section headers: %ld"),
4199 (long) elf_header
.e_shnum
);
4200 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4201 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4202 putc ('\n', stdout
);
4203 printf (_(" Section header string table index: %ld"),
4204 (long) elf_header
.e_shstrndx
);
4205 if (section_headers
!= NULL
4206 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4207 printf (" (%u)", section_headers
[0].sh_link
);
4208 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4209 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4210 printf (_(" <corrupt: out of range>"));
4211 putc ('\n', stdout
);
4214 if (section_headers
!= NULL
)
4216 if (elf_header
.e_phnum
== PN_XNUM
4217 && section_headers
[0].sh_info
!= 0)
4218 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4219 if (elf_header
.e_shnum
== SHN_UNDEF
)
4220 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4221 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4222 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4223 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4224 elf_header
.e_shstrndx
= SHN_UNDEF
;
4225 free (section_headers
);
4226 section_headers
= NULL
;
4233 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4235 Elf32_External_Phdr
* phdrs
;
4236 Elf32_External_Phdr
* external
;
4237 Elf_Internal_Phdr
* internal
;
4239 unsigned int size
= elf_header
.e_phentsize
;
4240 unsigned int num
= elf_header
.e_phnum
;
4242 /* PR binutils/17531: Cope with unexpected section header sizes. */
4243 if (size
== 0 || num
== 0)
4245 if (size
< sizeof * phdrs
)
4247 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4250 if (size
> sizeof * phdrs
)
4251 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4253 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4254 size
, num
, _("program headers"));
4258 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4259 i
< elf_header
.e_phnum
;
4260 i
++, internal
++, external
++)
4262 internal
->p_type
= BYTE_GET (external
->p_type
);
4263 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4264 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4265 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4266 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4267 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4268 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4269 internal
->p_align
= BYTE_GET (external
->p_align
);
4277 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4279 Elf64_External_Phdr
* phdrs
;
4280 Elf64_External_Phdr
* external
;
4281 Elf_Internal_Phdr
* internal
;
4283 unsigned int size
= elf_header
.e_phentsize
;
4284 unsigned int num
= elf_header
.e_phnum
;
4286 /* PR binutils/17531: Cope with unexpected section header sizes. */
4287 if (size
== 0 || num
== 0)
4289 if (size
< sizeof * phdrs
)
4291 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4294 if (size
> sizeof * phdrs
)
4295 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4297 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4298 size
, num
, _("program headers"));
4302 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4303 i
< elf_header
.e_phnum
;
4304 i
++, internal
++, external
++)
4306 internal
->p_type
= BYTE_GET (external
->p_type
);
4307 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4308 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4309 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4310 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4311 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4312 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4313 internal
->p_align
= BYTE_GET (external
->p_align
);
4320 /* Returns 1 if the program headers were read into `program_headers'. */
4323 get_program_headers (FILE * file
)
4325 Elf_Internal_Phdr
* phdrs
;
4327 /* Check cache of prior read. */
4328 if (program_headers
!= NULL
)
4331 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4332 sizeof (Elf_Internal_Phdr
));
4336 error (_("Out of memory reading %u program headers\n"),
4337 elf_header
.e_phnum
);
4342 ? get_32bit_program_headers (file
, phdrs
)
4343 : get_64bit_program_headers (file
, phdrs
))
4345 program_headers
= phdrs
;
4353 /* Returns 1 if the program headers were loaded. */
4356 process_program_headers (FILE * file
)
4358 Elf_Internal_Phdr
* segment
;
4361 if (elf_header
.e_phnum
== 0)
4363 /* PR binutils/12467. */
4364 if (elf_header
.e_phoff
!= 0)
4365 warn (_("possibly corrupt ELF header - it has a non-zero program"
4366 " header offset, but no program headers"));
4367 else if (do_segments
)
4368 printf (_("\nThere are no program headers in this file.\n"));
4372 if (do_segments
&& !do_header
)
4374 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4375 printf (_("Entry point "));
4376 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4377 printf (_("\nThere are %d program headers, starting at offset "),
4378 elf_header
.e_phnum
);
4379 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4383 if (! get_program_headers (file
))
4388 if (elf_header
.e_phnum
> 1)
4389 printf (_("\nProgram Headers:\n"));
4391 printf (_("\nProgram Headers:\n"));
4395 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4398 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4402 (_(" Type Offset VirtAddr PhysAddr\n"));
4404 (_(" FileSiz MemSiz Flags Align\n"));
4411 for (i
= 0, segment
= program_headers
;
4412 i
< elf_header
.e_phnum
;
4417 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4421 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4422 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4423 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4424 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4425 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4427 (segment
->p_flags
& PF_R
? 'R' : ' '),
4428 (segment
->p_flags
& PF_W
? 'W' : ' '),
4429 (segment
->p_flags
& PF_X
? 'E' : ' '));
4430 printf ("%#lx", (unsigned long) segment
->p_align
);
4434 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4435 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4438 print_vma (segment
->p_offset
, FULL_HEX
);
4442 print_vma (segment
->p_vaddr
, FULL_HEX
);
4444 print_vma (segment
->p_paddr
, FULL_HEX
);
4447 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4448 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4451 print_vma (segment
->p_filesz
, FULL_HEX
);
4455 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4456 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4459 print_vma (segment
->p_memsz
, FULL_HEX
);
4463 (segment
->p_flags
& PF_R
? 'R' : ' '),
4464 (segment
->p_flags
& PF_W
? 'W' : ' '),
4465 (segment
->p_flags
& PF_X
? 'E' : ' '));
4467 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4468 printf ("%#lx", (unsigned long) segment
->p_align
);
4471 print_vma (segment
->p_align
, PREFIX_HEX
);
4476 print_vma (segment
->p_offset
, FULL_HEX
);
4478 print_vma (segment
->p_vaddr
, FULL_HEX
);
4480 print_vma (segment
->p_paddr
, FULL_HEX
);
4482 print_vma (segment
->p_filesz
, FULL_HEX
);
4484 print_vma (segment
->p_memsz
, FULL_HEX
);
4486 (segment
->p_flags
& PF_R
? 'R' : ' '),
4487 (segment
->p_flags
& PF_W
? 'W' : ' '),
4488 (segment
->p_flags
& PF_X
? 'E' : ' '));
4489 print_vma (segment
->p_align
, HEX
);
4494 putc ('\n', stdout
);
4496 switch (segment
->p_type
)
4500 error (_("more than one dynamic segment\n"));
4502 /* By default, assume that the .dynamic section is the first
4503 section in the DYNAMIC segment. */
4504 dynamic_addr
= segment
->p_offset
;
4505 dynamic_size
= segment
->p_filesz
;
4506 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4507 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4509 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4510 dynamic_addr
= dynamic_size
= 0;
4513 /* Try to locate the .dynamic section. If there is
4514 a section header table, we can easily locate it. */
4515 if (section_headers
!= NULL
)
4517 Elf_Internal_Shdr
* sec
;
4519 sec
= find_section (".dynamic");
4520 if (sec
== NULL
|| sec
->sh_size
== 0)
4522 /* A corresponding .dynamic section is expected, but on
4523 IA-64/OpenVMS it is OK for it to be missing. */
4524 if (!is_ia64_vms ())
4525 error (_("no .dynamic section in the dynamic segment\n"));
4529 if (sec
->sh_type
== SHT_NOBITS
)
4535 dynamic_addr
= sec
->sh_offset
;
4536 dynamic_size
= sec
->sh_size
;
4538 if (dynamic_addr
< segment
->p_offset
4539 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4540 warn (_("the .dynamic section is not contained"
4541 " within the dynamic segment\n"));
4542 else if (dynamic_addr
> segment
->p_offset
)
4543 warn (_("the .dynamic section is not the first section"
4544 " in the dynamic segment.\n"));
4549 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4551 error (_("Unable to find program interpreter name\n"));
4555 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4557 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4558 error (_("Internal error: failed to create format string to display program interpreter\n"));
4560 program_interpreter
[0] = 0;
4561 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4562 error (_("Unable to read program interpreter name\n"));
4565 printf (_(" [Requesting program interpreter: %s]\n"),
4566 program_interpreter
);
4572 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4574 printf (_("\n Section to Segment mapping:\n"));
4575 printf (_(" Segment Sections...\n"));
4577 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4580 Elf_Internal_Shdr
* section
;
4582 segment
= program_headers
+ i
;
4583 section
= section_headers
+ 1;
4585 printf (" %2.2d ", i
);
4587 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4589 if (!ELF_TBSS_SPECIAL (section
, segment
)
4590 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4591 printf ("%s ", printable_section_name (section
));
4602 /* Find the file offset corresponding to VMA by using the program headers. */
4605 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4607 Elf_Internal_Phdr
* seg
;
4609 if (! get_program_headers (file
))
4611 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4615 for (seg
= program_headers
;
4616 seg
< program_headers
+ elf_header
.e_phnum
;
4619 if (seg
->p_type
!= PT_LOAD
)
4622 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4623 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4624 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4627 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4628 (unsigned long) vma
);
4633 /* Allocate memory and load the sections headers into the global pointer
4634 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4635 generate any error messages if the load fails. */
4638 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4640 Elf32_External_Shdr
* shdrs
;
4641 Elf_Internal_Shdr
* internal
;
4643 unsigned int size
= elf_header
.e_shentsize
;
4644 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4646 /* PR binutils/17531: Cope with unexpected section header sizes. */
4647 if (size
== 0 || num
== 0)
4649 if (size
< sizeof * shdrs
)
4652 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4655 if (!probe
&& size
> sizeof * shdrs
)
4656 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4658 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4660 probe
? NULL
: _("section headers"));
4664 if (section_headers
!= NULL
)
4665 free (section_headers
);
4666 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4667 sizeof (Elf_Internal_Shdr
));
4668 if (section_headers
== NULL
)
4671 error (_("Out of memory reading %u section headers\n"), num
);
4675 for (i
= 0, internal
= section_headers
;
4679 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4680 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4681 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4682 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4683 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4684 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4685 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4686 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4687 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4688 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4696 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4698 Elf64_External_Shdr
* shdrs
;
4699 Elf_Internal_Shdr
* internal
;
4701 unsigned int size
= elf_header
.e_shentsize
;
4702 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4704 /* PR binutils/17531: Cope with unexpected section header sizes. */
4705 if (size
== 0 || num
== 0)
4707 if (size
< sizeof * shdrs
)
4710 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4713 if (! probe
&& size
> sizeof * shdrs
)
4714 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4716 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4718 probe
? NULL
: _("section headers"));
4722 if (section_headers
!= NULL
)
4723 free (section_headers
);
4724 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4725 sizeof (Elf_Internal_Shdr
));
4726 if (section_headers
== NULL
)
4729 error (_("Out of memory reading %u section headers\n"), num
);
4733 for (i
= 0, internal
= section_headers
;
4737 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4738 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4739 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4740 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4741 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4742 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4743 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4744 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4745 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4746 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4753 static Elf_Internal_Sym
*
4754 get_32bit_elf_symbols (FILE * file
,
4755 Elf_Internal_Shdr
* section
,
4756 unsigned long * num_syms_return
)
4758 unsigned long number
= 0;
4759 Elf32_External_Sym
* esyms
= NULL
;
4760 Elf_External_Sym_Shndx
* shndx
= NULL
;
4761 Elf_Internal_Sym
* isyms
= NULL
;
4762 Elf_Internal_Sym
* psym
;
4765 if (section
->sh_size
== 0)
4767 if (num_syms_return
!= NULL
)
4768 * num_syms_return
= 0;
4772 /* Run some sanity checks first. */
4773 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4775 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4776 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4780 if (section
->sh_size
> current_file_size
)
4782 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4783 printable_section_name (section
), (unsigned long) section
->sh_size
);
4787 number
= section
->sh_size
/ section
->sh_entsize
;
4789 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4791 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4792 (unsigned long) section
->sh_size
,
4793 printable_section_name (section
),
4794 (unsigned long) section
->sh_entsize
);
4798 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4799 section
->sh_size
, _("symbols"));
4804 if (symtab_shndx_hdr
!= NULL
4805 && (symtab_shndx_hdr
->sh_link
4806 == (unsigned long) (section
- section_headers
)))
4808 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4809 symtab_shndx_hdr
->sh_offset
,
4810 1, symtab_shndx_hdr
->sh_size
,
4811 _("symbol table section indicies"));
4814 /* PR17531: file: heap-buffer-overflow */
4815 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4817 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4818 printable_section_name (symtab_shndx_hdr
),
4819 (unsigned long) symtab_shndx_hdr
->sh_size
,
4820 (unsigned long) section
->sh_size
);
4825 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4829 error (_("Out of memory reading %lu symbols\n"),
4830 (unsigned long) number
);
4834 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4836 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4837 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4838 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4839 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4840 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4842 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4843 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4844 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4845 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4846 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4855 if (num_syms_return
!= NULL
)
4856 * num_syms_return
= isyms
== NULL
? 0 : number
;
4861 static Elf_Internal_Sym
*
4862 get_64bit_elf_symbols (FILE * file
,
4863 Elf_Internal_Shdr
* section
,
4864 unsigned long * num_syms_return
)
4866 unsigned long number
= 0;
4867 Elf64_External_Sym
* esyms
= NULL
;
4868 Elf_External_Sym_Shndx
* shndx
= NULL
;
4869 Elf_Internal_Sym
* isyms
= NULL
;
4870 Elf_Internal_Sym
* psym
;
4873 if (section
->sh_size
== 0)
4875 if (num_syms_return
!= NULL
)
4876 * num_syms_return
= 0;
4880 /* Run some sanity checks first. */
4881 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4883 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4884 printable_section_name (section
),
4885 (unsigned long) section
->sh_entsize
);
4889 if (section
->sh_size
> current_file_size
)
4891 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4892 printable_section_name (section
),
4893 (unsigned long) section
->sh_size
);
4897 number
= section
->sh_size
/ section
->sh_entsize
;
4899 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4901 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4902 (unsigned long) section
->sh_size
,
4903 printable_section_name (section
),
4904 (unsigned long) section
->sh_entsize
);
4908 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4909 section
->sh_size
, _("symbols"));
4913 if (symtab_shndx_hdr
!= NULL
4914 && (symtab_shndx_hdr
->sh_link
4915 == (unsigned long) (section
- section_headers
)))
4917 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4918 symtab_shndx_hdr
->sh_offset
,
4919 1, symtab_shndx_hdr
->sh_size
,
4920 _("symbol table section indicies"));
4923 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4925 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4926 printable_section_name (symtab_shndx_hdr
),
4927 (unsigned long) symtab_shndx_hdr
->sh_size
,
4928 (unsigned long) section
->sh_size
);
4933 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4937 error (_("Out of memory reading %lu symbols\n"),
4938 (unsigned long) number
);
4942 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4944 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4945 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4946 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4947 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4949 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4951 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4952 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4953 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4955 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4956 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4965 if (num_syms_return
!= NULL
)
4966 * num_syms_return
= isyms
== NULL
? 0 : number
;
4972 get_elf_section_flags (bfd_vma sh_flags
)
4974 static char buff
[1024];
4976 int field_size
= is_32bit_elf
? 8 : 16;
4978 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4979 bfd_vma os_flags
= 0;
4980 bfd_vma proc_flags
= 0;
4981 bfd_vma unknown_flags
= 0;
4989 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4990 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4991 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4992 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4993 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4994 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4995 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4996 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4997 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4998 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4999 /* IA-64 specific. */
5000 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5001 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5002 /* IA-64 OpenVMS specific. */
5003 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5004 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5005 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5006 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5007 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5008 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5010 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5011 /* SPARC specific. */
5012 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5015 if (do_section_details
)
5017 sprintf (buff
, "[%*.*lx]: ",
5018 field_size
, field_size
, (unsigned long) sh_flags
);
5019 p
+= field_size
+ 4;
5026 flag
= sh_flags
& - sh_flags
;
5029 if (do_section_details
)
5033 case SHF_WRITE
: sindex
= 0; break;
5034 case SHF_ALLOC
: sindex
= 1; break;
5035 case SHF_EXECINSTR
: sindex
= 2; break;
5036 case SHF_MERGE
: sindex
= 3; break;
5037 case SHF_STRINGS
: sindex
= 4; break;
5038 case SHF_INFO_LINK
: sindex
= 5; break;
5039 case SHF_LINK_ORDER
: sindex
= 6; break;
5040 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5041 case SHF_GROUP
: sindex
= 8; break;
5042 case SHF_TLS
: sindex
= 9; break;
5043 case SHF_EXCLUDE
: sindex
= 18; break;
5047 switch (elf_header
.e_machine
)
5050 if (flag
== SHF_IA_64_SHORT
)
5052 else if (flag
== SHF_IA_64_NORECOV
)
5055 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5058 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5059 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5060 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5061 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5062 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5063 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5074 case EM_OLD_SPARCV9
:
5075 case EM_SPARC32PLUS
:
5078 if (flag
== SHF_ORDERED
)
5088 if (p
!= buff
+ field_size
+ 4)
5090 if (size
< (10 + 2))
5092 warn (_("Internal error: not enough buffer room for section flag info"));
5093 return _("<unknown>");
5100 size
-= flags
[sindex
].len
;
5101 p
= stpcpy (p
, flags
[sindex
].str
);
5103 else if (flag
& SHF_MASKOS
)
5105 else if (flag
& SHF_MASKPROC
)
5108 unknown_flags
|= flag
;
5114 case SHF_WRITE
: *p
= 'W'; break;
5115 case SHF_ALLOC
: *p
= 'A'; break;
5116 case SHF_EXECINSTR
: *p
= 'X'; break;
5117 case SHF_MERGE
: *p
= 'M'; break;
5118 case SHF_STRINGS
: *p
= 'S'; break;
5119 case SHF_INFO_LINK
: *p
= 'I'; break;
5120 case SHF_LINK_ORDER
: *p
= 'L'; break;
5121 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5122 case SHF_GROUP
: *p
= 'G'; break;
5123 case SHF_TLS
: *p
= 'T'; break;
5124 case SHF_EXCLUDE
: *p
= 'E'; break;
5127 if ((elf_header
.e_machine
== EM_X86_64
5128 || elf_header
.e_machine
== EM_L1OM
5129 || elf_header
.e_machine
== EM_K1OM
)
5130 && flag
== SHF_X86_64_LARGE
)
5132 else if (flag
& SHF_MASKOS
)
5135 sh_flags
&= ~ SHF_MASKOS
;
5137 else if (flag
& SHF_MASKPROC
)
5140 sh_flags
&= ~ SHF_MASKPROC
;
5150 if (do_section_details
)
5154 size
-= 5 + field_size
;
5155 if (p
!= buff
+ field_size
+ 4)
5159 warn (_("Internal error: not enough buffer room for section flag info"));
5160 return _("<unknown>");
5166 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5167 (unsigned long) os_flags
);
5168 p
+= 5 + field_size
;
5172 size
-= 7 + field_size
;
5173 if (p
!= buff
+ field_size
+ 4)
5177 warn (_("Internal error: not enough buffer room for section flag info"));
5178 return _("<unknown>");
5184 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5185 (unsigned long) proc_flags
);
5186 p
+= 7 + field_size
;
5190 size
-= 10 + field_size
;
5191 if (p
!= buff
+ field_size
+ 4)
5195 warn (_("Internal error: not enough buffer room for section flag info"));
5196 return _("<unknown>");
5202 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5203 (unsigned long) unknown_flags
);
5204 p
+= 10 + field_size
;
5213 process_section_headers (FILE * file
)
5215 Elf_Internal_Shdr
* section
;
5218 section_headers
= NULL
;
5220 if (elf_header
.e_shnum
== 0)
5222 /* PR binutils/12467. */
5223 if (elf_header
.e_shoff
!= 0)
5224 warn (_("possibly corrupt ELF file header - it has a non-zero"
5225 " section header offset, but no section headers\n"));
5226 else if (do_sections
)
5227 printf (_("\nThere are no sections in this file.\n"));
5232 if (do_sections
&& !do_header
)
5233 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5234 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5238 if (! get_32bit_section_headers (file
, FALSE
))
5241 else if (! get_64bit_section_headers (file
, FALSE
))
5244 /* Read in the string table, so that we have names to display. */
5245 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5246 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5248 section
= section_headers
+ elf_header
.e_shstrndx
;
5250 if (section
->sh_size
!= 0)
5252 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5253 1, section
->sh_size
,
5256 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5260 /* Scan the sections for the dynamic symbol table
5261 and dynamic string table and debug sections. */
5262 dynamic_symbols
= NULL
;
5263 dynamic_strings
= NULL
;
5264 dynamic_syminfo
= NULL
;
5265 symtab_shndx_hdr
= NULL
;
5267 eh_addr_size
= is_32bit_elf
? 4 : 8;
5268 switch (elf_header
.e_machine
)
5271 case EM_MIPS_RS3_LE
:
5272 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5273 FDE addresses. However, the ABI also has a semi-official ILP32
5274 variant for which the normal FDE address size rules apply.
5276 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5277 section, where XX is the size of longs in bits. Unfortunately,
5278 earlier compilers provided no way of distinguishing ILP32 objects
5279 from LP64 objects, so if there's any doubt, we should assume that
5280 the official LP64 form is being used. */
5281 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5282 && find_section (".gcc_compiled_long32") == NULL
)
5288 switch (elf_header
.e_flags
& EF_H8_MACH
)
5290 case E_H8_MACH_H8300
:
5291 case E_H8_MACH_H8300HN
:
5292 case E_H8_MACH_H8300SN
:
5293 case E_H8_MACH_H8300SXN
:
5296 case E_H8_MACH_H8300H
:
5297 case E_H8_MACH_H8300S
:
5298 case E_H8_MACH_H8300SX
:
5306 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5308 case EF_M32C_CPU_M16C
:
5315 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5318 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5319 if (section->sh_entsize != expected_entsize) \
5322 sprintf_vma (buf, section->sh_entsize); \
5323 /* Note: coded this way so that there is a single string for \
5325 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5326 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5327 (unsigned) expected_entsize); \
5328 section->sh_entsize = expected_entsize; \
5333 #define CHECK_ENTSIZE(section, i, type) \
5334 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5335 sizeof (Elf64_External_##type))
5337 for (i
= 0, section
= section_headers
;
5338 i
< elf_header
.e_shnum
;
5341 char * name
= SECTION_NAME (section
);
5343 if (section
->sh_type
== SHT_DYNSYM
)
5345 if (dynamic_symbols
!= NULL
)
5347 error (_("File contains multiple dynamic symbol tables\n"));
5351 CHECK_ENTSIZE (section
, i
, Sym
);
5352 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5354 else if (section
->sh_type
== SHT_STRTAB
5355 && streq (name
, ".dynstr"))
5357 if (dynamic_strings
!= NULL
)
5359 error (_("File contains multiple dynamic string tables\n"));
5363 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5364 1, section
->sh_size
,
5365 _("dynamic strings"));
5366 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5368 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5370 if (symtab_shndx_hdr
!= NULL
)
5372 error (_("File contains multiple symtab shndx tables\n"));
5375 symtab_shndx_hdr
= section
;
5377 else if (section
->sh_type
== SHT_SYMTAB
)
5378 CHECK_ENTSIZE (section
, i
, Sym
);
5379 else if (section
->sh_type
== SHT_GROUP
)
5380 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5381 else if (section
->sh_type
== SHT_REL
)
5382 CHECK_ENTSIZE (section
, i
, Rel
);
5383 else if (section
->sh_type
== SHT_RELA
)
5384 CHECK_ENTSIZE (section
, i
, Rela
);
5385 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5386 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5387 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5388 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5389 || do_debug_addr
|| do_debug_cu_index
)
5390 && (const_strneq (name
, ".debug_")
5391 || const_strneq (name
, ".zdebug_")))
5394 name
+= sizeof (".zdebug_") - 1;
5396 name
+= sizeof (".debug_") - 1;
5399 || (do_debug_info
&& const_strneq (name
, "info"))
5400 || (do_debug_info
&& const_strneq (name
, "types"))
5401 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5402 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5403 || (do_debug_lines
&& const_strneq (name
, "line."))
5404 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5405 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5406 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5407 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5408 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5409 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5410 || (do_debug_frames
&& const_strneq (name
, "frame"))
5411 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5412 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5413 || (do_debug_str
&& const_strneq (name
, "str"))
5414 || (do_debug_loc
&& const_strneq (name
, "loc"))
5415 || (do_debug_addr
&& const_strneq (name
, "addr"))
5416 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5417 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5419 request_dump_bynumber (i
, DEBUG_DUMP
);
5421 /* Linkonce section to be combined with .debug_info at link time. */
5422 else if ((do_debugging
|| do_debug_info
)
5423 && const_strneq (name
, ".gnu.linkonce.wi."))
5424 request_dump_bynumber (i
, DEBUG_DUMP
);
5425 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5426 request_dump_bynumber (i
, DEBUG_DUMP
);
5427 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5428 request_dump_bynumber (i
, DEBUG_DUMP
);
5429 /* Trace sections for Itanium VMS. */
5430 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5431 || do_trace_aranges
)
5432 && const_strneq (name
, ".trace_"))
5434 name
+= sizeof (".trace_") - 1;
5437 || (do_trace_info
&& streq (name
, "info"))
5438 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5439 || (do_trace_aranges
&& streq (name
, "aranges"))
5441 request_dump_bynumber (i
, DEBUG_DUMP
);
5448 if (elf_header
.e_shnum
> 1)
5449 printf (_("\nSection Headers:\n"));
5451 printf (_("\nSection Header:\n"));
5455 if (do_section_details
)
5457 printf (_(" [Nr] Name\n"));
5458 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5462 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5466 if (do_section_details
)
5468 printf (_(" [Nr] Name\n"));
5469 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5473 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5477 if (do_section_details
)
5479 printf (_(" [Nr] Name\n"));
5480 printf (_(" Type Address Offset Link\n"));
5481 printf (_(" Size EntSize Info Align\n"));
5485 printf (_(" [Nr] Name Type Address Offset\n"));
5486 printf (_(" Size EntSize Flags Link Info Align\n"));
5490 if (do_section_details
)
5491 printf (_(" Flags\n"));
5493 for (i
= 0, section
= section_headers
;
5494 i
< elf_header
.e_shnum
;
5497 printf (" [%2u] ", i
);
5498 if (do_section_details
)
5499 printf ("%s\n ", printable_section_name (section
));
5501 print_symbol (-17, SECTION_NAME (section
));
5503 printf (do_wide
? " %-15s " : " %-15.15s ",
5504 get_section_type_name (section
->sh_type
));
5508 const char * link_too_big
= NULL
;
5510 print_vma (section
->sh_addr
, LONG_HEX
);
5512 printf ( " %6.6lx %6.6lx %2.2lx",
5513 (unsigned long) section
->sh_offset
,
5514 (unsigned long) section
->sh_size
,
5515 (unsigned long) section
->sh_entsize
);
5517 if (do_section_details
)
5518 fputs (" ", stdout
);
5520 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5522 if (section
->sh_link
>= elf_header
.e_shnum
)
5525 /* The sh_link value is out of range. Normally this indicates
5526 an error but it can have special values in Solaris binaries. */
5527 switch (elf_header
.e_machine
)
5534 case EM_OLD_SPARCV9
:
5535 case EM_SPARC32PLUS
:
5538 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5539 link_too_big
= "BEFORE";
5540 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5541 link_too_big
= "AFTER";
5548 if (do_section_details
)
5550 if (link_too_big
!= NULL
&& * link_too_big
)
5551 printf ("<%s> ", link_too_big
);
5553 printf ("%2u ", section
->sh_link
);
5554 printf ("%3u %2lu\n", section
->sh_info
,
5555 (unsigned long) section
->sh_addralign
);
5558 printf ("%2u %3u %2lu\n",
5561 (unsigned long) section
->sh_addralign
);
5563 if (link_too_big
&& ! * link_too_big
)
5564 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5565 i
, section
->sh_link
);
5569 print_vma (section
->sh_addr
, LONG_HEX
);
5571 if ((long) section
->sh_offset
== section
->sh_offset
)
5572 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5576 print_vma (section
->sh_offset
, LONG_HEX
);
5579 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5580 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5584 print_vma (section
->sh_size
, LONG_HEX
);
5587 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5588 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5592 print_vma (section
->sh_entsize
, LONG_HEX
);
5595 if (do_section_details
)
5596 fputs (" ", stdout
);
5598 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5600 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5602 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5603 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5606 print_vma (section
->sh_addralign
, DEC
);
5610 else if (do_section_details
)
5612 printf (" %-15.15s ",
5613 get_section_type_name (section
->sh_type
));
5614 print_vma (section
->sh_addr
, LONG_HEX
);
5615 if ((long) section
->sh_offset
== section
->sh_offset
)
5616 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5620 print_vma (section
->sh_offset
, LONG_HEX
);
5622 printf (" %u\n ", section
->sh_link
);
5623 print_vma (section
->sh_size
, LONG_HEX
);
5625 print_vma (section
->sh_entsize
, LONG_HEX
);
5627 printf (" %-16u %lu\n",
5629 (unsigned long) section
->sh_addralign
);
5634 print_vma (section
->sh_addr
, LONG_HEX
);
5635 if ((long) section
->sh_offset
== section
->sh_offset
)
5636 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5640 print_vma (section
->sh_offset
, LONG_HEX
);
5643 print_vma (section
->sh_size
, LONG_HEX
);
5645 print_vma (section
->sh_entsize
, LONG_HEX
);
5647 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5649 printf (" %2u %3u %lu\n",
5652 (unsigned long) section
->sh_addralign
);
5655 if (do_section_details
)
5656 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5659 if (!do_section_details
)
5661 if (elf_header
.e_machine
== EM_X86_64
5662 || elf_header
.e_machine
== EM_L1OM
5663 || elf_header
.e_machine
== EM_K1OM
)
5664 printf (_("Key to Flags:\n\
5665 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5666 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5667 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5669 printf (_("Key to Flags:\n\
5670 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5671 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5672 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5679 get_group_flags (unsigned int flags
)
5681 static char buff
[32];
5691 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5698 process_section_groups (FILE * file
)
5700 Elf_Internal_Shdr
* section
;
5702 struct group
* group
;
5703 Elf_Internal_Shdr
* symtab_sec
;
5704 Elf_Internal_Shdr
* strtab_sec
;
5705 Elf_Internal_Sym
* symtab
;
5706 unsigned long num_syms
;
5710 /* Don't process section groups unless needed. */
5711 if (!do_unwind
&& !do_section_groups
)
5714 if (elf_header
.e_shnum
== 0)
5716 if (do_section_groups
)
5717 printf (_("\nThere are no sections to group in this file.\n"));
5722 if (section_headers
== NULL
)
5724 error (_("Section headers are not available!\n"));
5725 /* PR 13622: This can happen with a corrupt ELF header. */
5729 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5730 sizeof (struct group
*));
5732 if (section_headers_groups
== NULL
)
5734 error (_("Out of memory reading %u section group headers\n"),
5735 elf_header
.e_shnum
);
5739 /* Scan the sections for the group section. */
5741 for (i
= 0, section
= section_headers
;
5742 i
< elf_header
.e_shnum
;
5744 if (section
->sh_type
== SHT_GROUP
)
5747 if (group_count
== 0)
5749 if (do_section_groups
)
5750 printf (_("\nThere are no section groups in this file.\n"));
5755 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5757 if (section_groups
== NULL
)
5759 error (_("Out of memory reading %lu groups\n"),
5760 (unsigned long) group_count
);
5770 for (i
= 0, section
= section_headers
, group
= section_groups
;
5771 i
< elf_header
.e_shnum
;
5774 if (section
->sh_type
== SHT_GROUP
)
5776 const char * name
= printable_section_name (section
);
5777 const char * group_name
;
5778 unsigned char * start
;
5779 unsigned char * indices
;
5780 unsigned int entry
, j
, size
;
5781 Elf_Internal_Shdr
* sec
;
5782 Elf_Internal_Sym
* sym
;
5784 /* Get the symbol table. */
5785 if (section
->sh_link
>= elf_header
.e_shnum
5786 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5789 error (_("Bad sh_link in group section `%s'\n"), name
);
5793 if (symtab_sec
!= sec
)
5798 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5803 error (_("Corrupt header in group section `%s'\n"), name
);
5807 if (section
->sh_info
>= num_syms
)
5809 error (_("Bad sh_info in group section `%s'\n"), name
);
5813 sym
= symtab
+ section
->sh_info
;
5815 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5817 if (sym
->st_shndx
== 0
5818 || sym
->st_shndx
>= elf_header
.e_shnum
)
5820 error (_("Bad sh_info in group section `%s'\n"), name
);
5824 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5833 /* Get the string table. */
5834 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5843 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5849 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5850 1, strtab_sec
->sh_size
,
5852 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5854 group_name
= sym
->st_name
< strtab_size
5855 ? strtab
+ sym
->st_name
: _("<corrupt>");
5858 /* PR 17531: file: loop. */
5859 if (section
->sh_entsize
> section
->sh_size
)
5861 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5862 printable_section_name (section
),
5863 (unsigned long) section
->sh_entsize
,
5864 (unsigned long) section
->sh_size
);
5868 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5869 1, section
->sh_size
,
5875 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5876 entry
= byte_get (indices
, 4);
5879 if (do_section_groups
)
5881 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5882 get_group_flags (entry
), i
, name
, group_name
, size
);
5884 printf (_(" [Index] Name\n"));
5887 group
->group_index
= i
;
5889 for (j
= 0; j
< size
; j
++)
5891 struct group_list
* g
;
5893 entry
= byte_get (indices
, 4);
5896 if (entry
>= elf_header
.e_shnum
)
5898 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5899 entry
, i
, elf_header
.e_shnum
- 1);
5903 if (section_headers_groups
[entry
] != NULL
)
5907 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5909 section_headers_groups
[entry
]->group_index
);
5914 /* Intel C/C++ compiler may put section 0 in a
5915 section group. We just warn it the first time
5916 and ignore it afterwards. */
5917 static int warned
= 0;
5920 error (_("section 0 in group section [%5u]\n"),
5921 section_headers_groups
[entry
]->group_index
);
5927 section_headers_groups
[entry
] = group
;
5929 if (do_section_groups
)
5931 sec
= section_headers
+ entry
;
5932 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
5935 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5936 g
->section_index
= entry
;
5937 g
->next
= group
->root
;
5955 /* Data used to display dynamic fixups. */
5957 struct ia64_vms_dynfixup
5959 bfd_vma needed_ident
; /* Library ident number. */
5960 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5961 bfd_vma fixup_needed
; /* Index of the library. */
5962 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5963 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5966 /* Data used to display dynamic relocations. */
5968 struct ia64_vms_dynimgrela
5970 bfd_vma img_rela_cnt
; /* Number of relocations. */
5971 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5974 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5978 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5979 const char *strtab
, unsigned int strtab_sz
)
5981 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5983 const char *lib_name
;
5985 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5986 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5987 _("dynamic section image fixups"));
5991 if (fixup
->needed
< strtab_sz
)
5992 lib_name
= strtab
+ fixup
->needed
;
5995 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5996 (unsigned long) fixup
->needed
);
5999 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6000 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6002 (_("Seg Offset Type SymVec DataType\n"));
6004 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6009 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6010 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6011 type
= BYTE_GET (imfs
[i
].type
);
6012 rtype
= elf_ia64_reloc_type (type
);
6014 printf (" 0x%08x ", type
);
6016 printf (" %-32s ", rtype
);
6017 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6018 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6024 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6027 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6029 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6032 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6033 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6034 _("dynamic section image relocations"));
6038 printf (_("\nImage relocs\n"));
6040 (_("Seg Offset Type Addend Seg Sym Off\n"));
6042 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6047 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6048 printf ("%08" BFD_VMA_FMT
"x ",
6049 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6050 type
= BYTE_GET (imrs
[i
].type
);
6051 rtype
= elf_ia64_reloc_type (type
);
6053 printf ("0x%08x ", type
);
6055 printf ("%-31s ", rtype
);
6056 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6057 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6058 printf ("%08" BFD_VMA_FMT
"x\n",
6059 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6065 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6068 process_ia64_vms_dynamic_relocs (FILE *file
)
6070 struct ia64_vms_dynfixup fixup
;
6071 struct ia64_vms_dynimgrela imgrela
;
6072 Elf_Internal_Dyn
*entry
;
6074 bfd_vma strtab_off
= 0;
6075 bfd_vma strtab_sz
= 0;
6076 char *strtab
= NULL
;
6078 memset (&fixup
, 0, sizeof (fixup
));
6079 memset (&imgrela
, 0, sizeof (imgrela
));
6081 /* Note: the order of the entries is specified by the OpenVMS specs. */
6082 for (entry
= dynamic_section
;
6083 entry
< dynamic_section
+ dynamic_nent
;
6086 switch (entry
->d_tag
)
6088 case DT_IA_64_VMS_STRTAB_OFFSET
:
6089 strtab_off
= entry
->d_un
.d_val
;
6092 strtab_sz
= entry
->d_un
.d_val
;
6094 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6095 1, strtab_sz
, _("dynamic string section"));
6098 case DT_IA_64_VMS_NEEDED_IDENT
:
6099 fixup
.needed_ident
= entry
->d_un
.d_val
;
6102 fixup
.needed
= entry
->d_un
.d_val
;
6104 case DT_IA_64_VMS_FIXUP_NEEDED
:
6105 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6107 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6108 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6110 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6111 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6113 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6116 case DT_IA_64_VMS_IMG_RELA_CNT
:
6117 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6119 case DT_IA_64_VMS_IMG_RELA_OFF
:
6120 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6122 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6142 } dynamic_relocations
[] =
6144 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6145 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6146 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6149 /* Process the reloc section. */
6152 process_relocs (FILE * file
)
6154 unsigned long rel_size
;
6155 unsigned long rel_offset
;
6161 if (do_using_dynamic
)
6165 int has_dynamic_reloc
;
6168 has_dynamic_reloc
= 0;
6170 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6172 is_rela
= dynamic_relocations
[i
].rela
;
6173 name
= dynamic_relocations
[i
].name
;
6174 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6175 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6177 has_dynamic_reloc
|= rel_size
;
6179 if (is_rela
== UNKNOWN
)
6181 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6182 switch (dynamic_info
[DT_PLTREL
])
6196 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6197 name
, rel_offset
, rel_size
);
6199 dump_relocations (file
,
6200 offset_from_vma (file
, rel_offset
, rel_size
),
6202 dynamic_symbols
, num_dynamic_syms
,
6203 dynamic_strings
, dynamic_strings_length
,
6209 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6211 if (! has_dynamic_reloc
)
6212 printf (_("\nThere are no dynamic relocations in this file.\n"));
6216 Elf_Internal_Shdr
* section
;
6220 for (i
= 0, section
= section_headers
;
6221 i
< elf_header
.e_shnum
;
6224 if ( section
->sh_type
!= SHT_RELA
6225 && section
->sh_type
!= SHT_REL
)
6228 rel_offset
= section
->sh_offset
;
6229 rel_size
= section
->sh_size
;
6233 Elf_Internal_Shdr
* strsec
;
6236 printf (_("\nRelocation section "));
6238 if (string_table
== NULL
)
6239 printf ("%d", section
->sh_name
);
6241 printf ("'%s'", printable_section_name (section
));
6243 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6244 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6246 is_rela
= section
->sh_type
== SHT_RELA
;
6248 if (section
->sh_link
!= 0
6249 && section
->sh_link
< elf_header
.e_shnum
)
6251 Elf_Internal_Shdr
* symsec
;
6252 Elf_Internal_Sym
* symtab
;
6253 unsigned long nsyms
;
6254 unsigned long strtablen
= 0;
6255 char * strtab
= NULL
;
6257 symsec
= section_headers
+ section
->sh_link
;
6258 if (symsec
->sh_type
!= SHT_SYMTAB
6259 && symsec
->sh_type
!= SHT_DYNSYM
)
6262 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6267 if (symsec
->sh_link
!= 0
6268 && symsec
->sh_link
< elf_header
.e_shnum
)
6270 strsec
= section_headers
+ symsec
->sh_link
;
6272 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6275 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6278 dump_relocations (file
, rel_offset
, rel_size
,
6279 symtab
, nsyms
, strtab
, strtablen
,
6281 symsec
->sh_type
== SHT_DYNSYM
);
6287 dump_relocations (file
, rel_offset
, rel_size
,
6288 NULL
, 0, NULL
, 0, is_rela
, 0);
6295 printf (_("\nThere are no relocations in this file.\n"));
6301 /* Process the unwind section. */
6303 #include "unwind-ia64.h"
6305 /* An absolute address consists of a section and an offset. If the
6306 section is NULL, the offset itself is the address, otherwise, the
6307 address equals to LOAD_ADDRESS(section) + offset. */
6311 unsigned short section
;
6315 #define ABSADDR(a) \
6317 ? section_headers [(a).section].sh_addr + (a).offset \
6320 struct ia64_unw_table_entry
6322 struct absaddr start
;
6324 struct absaddr info
;
6327 struct ia64_unw_aux_info
6330 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6331 unsigned long table_len
; /* Length of unwind table. */
6332 unsigned char * info
; /* Unwind info. */
6333 unsigned long info_size
; /* Size of unwind info. */
6334 bfd_vma info_addr
; /* starting address of unwind info. */
6335 bfd_vma seg_base
; /* Starting address of segment. */
6336 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6337 unsigned long nsyms
; /* Number of symbols. */
6338 char * strtab
; /* The string table. */
6339 unsigned long strtab_size
; /* Size of string table. */
6343 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6344 unsigned long nsyms
,
6345 const char * strtab
,
6346 unsigned long strtab_size
,
6347 struct absaddr addr
,
6348 const char ** symname
,
6351 bfd_vma dist
= 0x100000;
6352 Elf_Internal_Sym
* sym
;
6353 Elf_Internal_Sym
* best
= NULL
;
6356 REMOVE_ARCH_BITS (addr
.offset
);
6358 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6360 bfd_vma value
= sym
->st_value
;
6362 REMOVE_ARCH_BITS (value
);
6364 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6365 && sym
->st_name
!= 0
6366 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6367 && addr
.offset
>= value
6368 && addr
.offset
- value
< dist
)
6371 dist
= addr
.offset
- value
;
6379 *symname
= (best
->st_name
>= strtab_size
6380 ? _("<corrupt>") : strtab
+ best
->st_name
);
6386 *offset
= addr
.offset
;
6390 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6392 struct ia64_unw_table_entry
* tp
;
6395 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6399 const unsigned char * dp
;
6400 const unsigned char * head
;
6401 const char * procname
;
6403 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6404 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6406 fputs ("\n<", stdout
);
6410 fputs (procname
, stdout
);
6413 printf ("+%lx", (unsigned long) offset
);
6416 fputs (">: [", stdout
);
6417 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6418 fputc ('-', stdout
);
6419 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6420 printf ("], info at +0x%lx\n",
6421 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6423 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6424 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6426 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6427 (unsigned) UNW_VER (stamp
),
6428 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6429 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6430 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6431 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6433 if (UNW_VER (stamp
) != 1)
6435 printf (_("\tUnknown version.\n"));
6440 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6441 dp
= unw_decode (dp
, in_body
, & in_body
);
6446 slurp_ia64_unwind_table (FILE * file
,
6447 struct ia64_unw_aux_info
* aux
,
6448 Elf_Internal_Shdr
* sec
)
6450 unsigned long size
, nrelas
, i
;
6451 Elf_Internal_Phdr
* seg
;
6452 struct ia64_unw_table_entry
* tep
;
6453 Elf_Internal_Shdr
* relsec
;
6454 Elf_Internal_Rela
* rela
;
6455 Elf_Internal_Rela
* rp
;
6456 unsigned char * table
;
6458 Elf_Internal_Sym
* sym
;
6459 const char * relname
;
6461 /* First, find the starting address of the segment that includes
6464 if (elf_header
.e_phnum
)
6466 if (! get_program_headers (file
))
6469 for (seg
= program_headers
;
6470 seg
< program_headers
+ elf_header
.e_phnum
;
6473 if (seg
->p_type
!= PT_LOAD
)
6476 if (sec
->sh_addr
>= seg
->p_vaddr
6477 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6479 aux
->seg_base
= seg
->p_vaddr
;
6485 /* Second, build the unwind table from the contents of the unwind section: */
6486 size
= sec
->sh_size
;
6487 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6492 aux
->table
= (struct ia64_unw_table_entry
*)
6493 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6495 for (tp
= table
; tp
< table
+ size
; ++tep
)
6497 tep
->start
.section
= SHN_UNDEF
;
6498 tep
->end
.section
= SHN_UNDEF
;
6499 tep
->info
.section
= SHN_UNDEF
;
6500 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6501 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6502 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6503 tep
->start
.offset
+= aux
->seg_base
;
6504 tep
->end
.offset
+= aux
->seg_base
;
6505 tep
->info
.offset
+= aux
->seg_base
;
6509 /* Third, apply any relocations to the unwind table: */
6510 for (relsec
= section_headers
;
6511 relsec
< section_headers
+ elf_header
.e_shnum
;
6514 if (relsec
->sh_type
!= SHT_RELA
6515 || relsec
->sh_info
>= elf_header
.e_shnum
6516 || section_headers
+ relsec
->sh_info
!= sec
)
6519 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6523 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6525 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6526 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6528 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6530 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6534 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6536 switch (rp
->r_offset
/eh_addr_size
% 3)
6539 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6540 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6543 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6544 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6547 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6548 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6558 aux
->table_len
= size
/ (3 * eh_addr_size
);
6563 ia64_process_unwind (FILE * file
)
6565 Elf_Internal_Shdr
* sec
;
6566 Elf_Internal_Shdr
* unwsec
= NULL
;
6567 Elf_Internal_Shdr
* strsec
;
6568 unsigned long i
, unwcount
= 0, unwstart
= 0;
6569 struct ia64_unw_aux_info aux
;
6571 memset (& aux
, 0, sizeof (aux
));
6573 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6575 if (sec
->sh_type
== SHT_SYMTAB
6576 && sec
->sh_link
< elf_header
.e_shnum
)
6578 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6580 strsec
= section_headers
+ sec
->sh_link
;
6581 if (aux
.strtab
!= NULL
)
6583 error (_("Multiple auxillary string tables encountered\n"));
6586 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6589 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6591 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6596 printf (_("\nThere are no unwind sections in this file.\n"));
6598 while (unwcount
-- > 0)
6603 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6604 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6605 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6610 /* We have already counted the number of SHT_IA64_UNWIND
6611 sections so the loop above should never fail. */
6612 assert (unwsec
!= NULL
);
6615 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6617 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6619 /* We need to find which section group it is in. */
6620 struct group_list
* g
;
6622 if (section_headers_groups
== NULL
6623 || section_headers_groups
[i
] == NULL
)
6624 i
= elf_header
.e_shnum
;
6627 g
= section_headers_groups
[i
]->root
;
6629 for (; g
!= NULL
; g
= g
->next
)
6631 sec
= section_headers
+ g
->section_index
;
6633 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6638 i
= elf_header
.e_shnum
;
6641 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6643 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6644 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6645 suffix
= SECTION_NAME (unwsec
) + len
;
6646 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6648 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6649 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6654 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6655 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6656 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6657 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6659 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6660 suffix
= SECTION_NAME (unwsec
) + len
;
6661 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6663 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6664 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6668 if (i
== elf_header
.e_shnum
)
6670 printf (_("\nCould not find unwind info section for "));
6672 if (string_table
== NULL
)
6673 printf ("%d", unwsec
->sh_name
);
6675 printf ("'%s'", printable_section_name (unwsec
));
6679 aux
.info_addr
= sec
->sh_addr
;
6680 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6683 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6685 printf (_("\nUnwind section "));
6687 if (string_table
== NULL
)
6688 printf ("%d", unwsec
->sh_name
);
6690 printf ("'%s'", printable_section_name (unwsec
));
6692 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6693 (unsigned long) unwsec
->sh_offset
,
6694 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6696 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6698 if (aux
.table_len
> 0)
6699 dump_ia64_unwind (& aux
);
6702 free ((char *) aux
.table
);
6704 free ((char *) aux
.info
);
6713 free ((char *) aux
.strtab
);
6716 struct hppa_unw_table_entry
6718 struct absaddr start
;
6720 unsigned int Cannot_unwind
:1; /* 0 */
6721 unsigned int Millicode
:1; /* 1 */
6722 unsigned int Millicode_save_sr0
:1; /* 2 */
6723 unsigned int Region_description
:2; /* 3..4 */
6724 unsigned int reserved1
:1; /* 5 */
6725 unsigned int Entry_SR
:1; /* 6 */
6726 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6727 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6728 unsigned int Args_stored
:1; /* 16 */
6729 unsigned int Variable_Frame
:1; /* 17 */
6730 unsigned int Separate_Package_Body
:1; /* 18 */
6731 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6732 unsigned int Stack_Overflow_Check
:1; /* 20 */
6733 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6734 unsigned int Ada_Region
:1; /* 22 */
6735 unsigned int cxx_info
:1; /* 23 */
6736 unsigned int cxx_try_catch
:1; /* 24 */
6737 unsigned int sched_entry_seq
:1; /* 25 */
6738 unsigned int reserved2
:1; /* 26 */
6739 unsigned int Save_SP
:1; /* 27 */
6740 unsigned int Save_RP
:1; /* 28 */
6741 unsigned int Save_MRP_in_frame
:1; /* 29 */
6742 unsigned int extn_ptr_defined
:1; /* 30 */
6743 unsigned int Cleanup_defined
:1; /* 31 */
6745 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6746 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6747 unsigned int Large_frame
:1; /* 2 */
6748 unsigned int Pseudo_SP_Set
:1; /* 3 */
6749 unsigned int reserved4
:1; /* 4 */
6750 unsigned int Total_frame_size
:27; /* 5..31 */
6753 struct hppa_unw_aux_info
6755 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6756 unsigned long table_len
; /* Length of unwind table. */
6757 bfd_vma seg_base
; /* Starting address of segment. */
6758 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6759 unsigned long nsyms
; /* Number of symbols. */
6760 char * strtab
; /* The string table. */
6761 unsigned long strtab_size
; /* Size of string table. */
6765 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6767 struct hppa_unw_table_entry
* tp
;
6769 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6772 const char * procname
;
6774 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6775 aux
->strtab_size
, tp
->start
, &procname
,
6778 fputs ("\n<", stdout
);
6782 fputs (procname
, stdout
);
6785 printf ("+%lx", (unsigned long) offset
);
6788 fputs (">: [", stdout
);
6789 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6790 fputc ('-', stdout
);
6791 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6794 #define PF(_m) if (tp->_m) printf (#_m " ");
6795 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6798 PF(Millicode_save_sr0
);
6799 /* PV(Region_description); */
6805 PF(Separate_Package_Body
);
6806 PF(Frame_Extension_Millicode
);
6807 PF(Stack_Overflow_Check
);
6808 PF(Two_Instruction_SP_Increment
);
6812 PF(sched_entry_seq
);
6815 PF(Save_MRP_in_frame
);
6816 PF(extn_ptr_defined
);
6817 PF(Cleanup_defined
);
6818 PF(MPE_XL_interrupt_marker
);
6819 PF(HP_UX_interrupt_marker
);
6822 PV(Total_frame_size
);
6831 slurp_hppa_unwind_table (FILE * file
,
6832 struct hppa_unw_aux_info
* aux
,
6833 Elf_Internal_Shdr
* sec
)
6835 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6836 Elf_Internal_Phdr
* seg
;
6837 struct hppa_unw_table_entry
* tep
;
6838 Elf_Internal_Shdr
* relsec
;
6839 Elf_Internal_Rela
* rela
;
6840 Elf_Internal_Rela
* rp
;
6841 unsigned char * table
;
6843 Elf_Internal_Sym
* sym
;
6844 const char * relname
;
6846 /* First, find the starting address of the segment that includes
6849 if (elf_header
.e_phnum
)
6851 if (! get_program_headers (file
))
6854 for (seg
= program_headers
;
6855 seg
< program_headers
+ elf_header
.e_phnum
;
6858 if (seg
->p_type
!= PT_LOAD
)
6861 if (sec
->sh_addr
>= seg
->p_vaddr
6862 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6864 aux
->seg_base
= seg
->p_vaddr
;
6870 /* Second, build the unwind table from the contents of the unwind
6872 size
= sec
->sh_size
;
6873 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6879 nentries
= size
/ unw_ent_size
;
6880 size
= unw_ent_size
* nentries
;
6882 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6883 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6885 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6887 unsigned int tmp1
, tmp2
;
6889 tep
->start
.section
= SHN_UNDEF
;
6890 tep
->end
.section
= SHN_UNDEF
;
6892 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6893 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6894 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6895 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6897 tep
->start
.offset
+= aux
->seg_base
;
6898 tep
->end
.offset
+= aux
->seg_base
;
6900 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6901 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6902 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6903 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6904 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6905 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6906 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6907 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6908 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6909 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6910 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6911 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6912 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6913 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6914 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6915 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6916 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6917 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6918 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6919 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6920 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6921 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6922 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6923 tep
->Cleanup_defined
= tmp1
& 0x1;
6925 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6926 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6927 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6928 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6929 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6930 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6934 /* Third, apply any relocations to the unwind table. */
6935 for (relsec
= section_headers
;
6936 relsec
< section_headers
+ elf_header
.e_shnum
;
6939 if (relsec
->sh_type
!= SHT_RELA
6940 || relsec
->sh_info
>= elf_header
.e_shnum
6941 || section_headers
+ relsec
->sh_info
!= sec
)
6944 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6948 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6950 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6951 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6953 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6954 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6956 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6960 i
= rp
->r_offset
/ unw_ent_size
;
6962 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6965 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6966 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6969 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6970 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6980 aux
->table_len
= nentries
;
6986 hppa_process_unwind (FILE * file
)
6988 struct hppa_unw_aux_info aux
;
6989 Elf_Internal_Shdr
* unwsec
= NULL
;
6990 Elf_Internal_Shdr
* strsec
;
6991 Elf_Internal_Shdr
* sec
;
6994 if (string_table
== NULL
)
6997 memset (& aux
, 0, sizeof (aux
));
6999 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7001 if (sec
->sh_type
== SHT_SYMTAB
7002 && sec
->sh_link
< elf_header
.e_shnum
)
7004 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7006 strsec
= section_headers
+ sec
->sh_link
;
7007 if (aux
.strtab
!= NULL
)
7009 error (_("Multiple auxillary string tables encountered\n"));
7012 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7015 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7017 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7022 printf (_("\nThere are no unwind sections in this file.\n"));
7024 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7026 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7028 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7029 printable_section_name (sec
),
7030 (unsigned long) sec
->sh_offset
,
7031 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7033 slurp_hppa_unwind_table (file
, &aux
, sec
);
7034 if (aux
.table_len
> 0)
7035 dump_hppa_unwind (&aux
);
7038 free ((char *) aux
.table
);
7046 free ((char *) aux
.strtab
);
7051 unsigned char * data
; /* The unwind data. */
7052 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7053 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7054 unsigned long nrelas
; /* The number of relocations. */
7055 unsigned int rel_type
; /* REL or RELA ? */
7056 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7059 struct arm_unw_aux_info
7061 FILE * file
; /* The file containing the unwind sections. */
7062 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7063 unsigned long nsyms
; /* Number of symbols. */
7064 char * strtab
; /* The file's string table. */
7065 unsigned long strtab_size
; /* Size of string table. */
7069 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7070 bfd_vma fn
, struct absaddr addr
)
7072 const char *procname
;
7075 if (addr
.section
== SHN_UNDEF
)
7078 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
7079 aux
->strtab_size
, addr
, &procname
,
7082 print_vma (fn
, PREFIX_HEX
);
7086 fputs (" <", stdout
);
7087 fputs (procname
, stdout
);
7090 printf ("+0x%lx", (unsigned long) sym_offset
);
7091 fputc ('>', stdout
);
7098 arm_free_section (struct arm_section
*arm_sec
)
7100 if (arm_sec
->data
!= NULL
)
7101 free (arm_sec
->data
);
7103 if (arm_sec
->rela
!= NULL
)
7104 free (arm_sec
->rela
);
7107 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7108 cached section and install SEC instead.
7109 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7110 and return its valued in * WORDP, relocating if necessary.
7111 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7112 relocation's offset in ADDR.
7113 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7114 into the string table of the symbol associated with the reloc. If no
7115 reloc was applied store -1 there.
7116 5) Return TRUE upon success, FALSE otherwise. */
7119 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7120 struct arm_section
* arm_sec
,
7121 Elf_Internal_Shdr
* sec
,
7122 bfd_vma word_offset
,
7123 unsigned int * wordp
,
7124 struct absaddr
* addr
,
7127 Elf_Internal_Rela
*rp
;
7128 Elf_Internal_Sym
*sym
;
7129 const char * relname
;
7131 bfd_boolean wrapped
;
7133 if (sec
== NULL
|| arm_sec
== NULL
)
7136 addr
->section
= SHN_UNDEF
;
7139 if (sym_name
!= NULL
)
7140 *sym_name
= (bfd_vma
) -1;
7142 /* If necessary, update the section cache. */
7143 if (sec
!= arm_sec
->sec
)
7145 Elf_Internal_Shdr
*relsec
;
7147 arm_free_section (arm_sec
);
7150 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7151 sec
->sh_size
, _("unwind data"));
7152 arm_sec
->rela
= NULL
;
7153 arm_sec
->nrelas
= 0;
7155 for (relsec
= section_headers
;
7156 relsec
< section_headers
+ elf_header
.e_shnum
;
7159 if (relsec
->sh_info
>= elf_header
.e_shnum
7160 || section_headers
+ relsec
->sh_info
!= sec
7161 /* PR 15745: Check the section type as well. */
7162 || (relsec
->sh_type
!= SHT_REL
7163 && relsec
->sh_type
!= SHT_RELA
))
7166 arm_sec
->rel_type
= relsec
->sh_type
;
7167 if (relsec
->sh_type
== SHT_REL
)
7169 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7171 & arm_sec
->rela
, & arm_sec
->nrelas
))
7174 else /* relsec->sh_type == SHT_RELA */
7176 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7178 & arm_sec
->rela
, & arm_sec
->nrelas
))
7184 arm_sec
->next_rela
= arm_sec
->rela
;
7187 /* If there is no unwind data we can do nothing. */
7188 if (arm_sec
->data
== NULL
)
7191 /* If the offset is invalid then fail. */
7192 if (word_offset
> sec
->sh_size
- 4)
7195 /* Get the word at the required offset. */
7196 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7198 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7199 if (arm_sec
->rela
== NULL
)
7205 /* Look through the relocs to find the one that applies to the provided offset. */
7207 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7209 bfd_vma prelval
, offset
;
7211 if (rp
->r_offset
> word_offset
&& !wrapped
)
7216 if (rp
->r_offset
> word_offset
)
7219 if (rp
->r_offset
& 3)
7221 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7222 (unsigned long) rp
->r_offset
);
7226 if (rp
->r_offset
< word_offset
)
7229 /* PR 17531: file: 027-161405-0.004 */
7230 if (aux
->symtab
== NULL
)
7233 if (arm_sec
->rel_type
== SHT_REL
)
7235 offset
= word
& 0x7fffffff;
7236 if (offset
& 0x40000000)
7237 offset
|= ~ (bfd_vma
) 0x7fffffff;
7239 else if (arm_sec
->rel_type
== SHT_RELA
)
7240 offset
= rp
->r_addend
;
7243 error (_("Unknown section relocation type %d encountered\n"),
7248 /* PR 17531 file: 027-1241568-0.004. */
7249 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7251 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7252 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7256 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7257 offset
+= sym
->st_value
;
7258 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7260 /* Check that we are processing the expected reloc type. */
7261 if (elf_header
.e_machine
== EM_ARM
)
7263 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7264 if (relname
== NULL
)
7266 warn (_("Skipping unknown ARM relocation type: %d\n"),
7267 (int) ELF32_R_TYPE (rp
->r_info
));
7271 if (streq (relname
, "R_ARM_NONE"))
7274 if (! streq (relname
, "R_ARM_PREL31"))
7276 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7280 else if (elf_header
.e_machine
== EM_TI_C6000
)
7282 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7283 if (relname
== NULL
)
7285 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7286 (int) ELF32_R_TYPE (rp
->r_info
));
7290 if (streq (relname
, "R_C6000_NONE"))
7293 if (! streq (relname
, "R_C6000_PREL31"))
7295 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7303 /* This function currently only supports ARM and TI unwinders. */
7304 warn (_("Only TI and ARM unwinders are currently supported\n"));
7308 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7309 addr
->section
= sym
->st_shndx
;
7310 addr
->offset
= offset
;
7313 * sym_name
= sym
->st_name
;
7318 arm_sec
->next_rela
= rp
;
7323 static const char *tic6x_unwind_regnames
[16] =
7325 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7326 "A14", "A13", "A12", "A11", "A10",
7327 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7331 decode_tic6x_unwind_regmask (unsigned int mask
)
7335 for (i
= 12; mask
; mask
>>= 1, i
--)
7339 fputs (tic6x_unwind_regnames
[i
], stdout
);
7341 fputs (", ", stdout
);
7347 if (remaining == 0 && more_words) \
7350 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7351 data_offset, & word, & addr, NULL)) \
7357 #define GET_OP(OP) \
7362 (OP) = word >> 24; \
7367 printf (_("[Truncated opcode]\n")); \
7370 printf ("0x%02x ", OP)
7373 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7374 unsigned int word
, unsigned int remaining
,
7375 unsigned int more_words
,
7376 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7377 struct arm_section
*data_arm_sec
)
7379 struct absaddr addr
;
7381 /* Decode the unwinding instructions. */
7384 unsigned int op
, op2
;
7393 printf (" 0x%02x ", op
);
7395 if ((op
& 0xc0) == 0x00)
7397 int offset
= ((op
& 0x3f) << 2) + 4;
7399 printf (" vsp = vsp + %d", offset
);
7401 else if ((op
& 0xc0) == 0x40)
7403 int offset
= ((op
& 0x3f) << 2) + 4;
7405 printf (" vsp = vsp - %d", offset
);
7407 else if ((op
& 0xf0) == 0x80)
7410 if (op
== 0x80 && op2
== 0)
7411 printf (_("Refuse to unwind"));
7414 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7419 for (i
= 0; i
< 12; i
++)
7420 if (mask
& (1 << i
))
7426 printf ("r%d", 4 + i
);
7431 else if ((op
& 0xf0) == 0x90)
7433 if (op
== 0x9d || op
== 0x9f)
7434 printf (_(" [Reserved]"));
7436 printf (" vsp = r%d", op
& 0x0f);
7438 else if ((op
& 0xf0) == 0xa0)
7440 int end
= 4 + (op
& 0x07);
7445 for (i
= 4; i
<= end
; i
++)
7461 else if (op
== 0xb0)
7462 printf (_(" finish"));
7463 else if (op
== 0xb1)
7466 if (op2
== 0 || (op2
& 0xf0) != 0)
7467 printf (_("[Spare]"));
7470 unsigned int mask
= op2
& 0x0f;
7475 for (i
= 0; i
< 12; i
++)
7476 if (mask
& (1 << i
))
7487 else if (op
== 0xb2)
7489 unsigned char buf
[9];
7490 unsigned int i
, len
;
7491 unsigned long offset
;
7493 for (i
= 0; i
< sizeof (buf
); i
++)
7496 if ((buf
[i
] & 0x80) == 0)
7499 if (i
== sizeof (buf
))
7500 printf (_("corrupt change to vsp"));
7503 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7504 assert (len
== i
+ 1);
7505 offset
= offset
* 4 + 0x204;
7506 printf ("vsp = vsp + %ld", offset
);
7509 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7511 unsigned int first
, last
;
7518 printf ("pop {D%d", first
);
7520 printf ("-D%d", first
+ last
);
7523 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7525 unsigned int count
= op
& 0x07;
7529 printf ("-D%d", 8 + count
);
7532 else if (op
>= 0xc0 && op
<= 0xc5)
7534 unsigned int count
= op
& 0x07;
7536 printf (" pop {wR10");
7538 printf ("-wR%d", 10 + count
);
7541 else if (op
== 0xc6)
7543 unsigned int first
, last
;
7548 printf ("pop {wR%d", first
);
7550 printf ("-wR%d", first
+ last
);
7553 else if (op
== 0xc7)
7556 if (op2
== 0 || (op2
& 0xf0) != 0)
7557 printf (_("[Spare]"));
7560 unsigned int mask
= op2
& 0x0f;
7565 for (i
= 0; i
< 4; i
++)
7566 if (mask
& (1 << i
))
7572 printf ("wCGR%d", i
);
7578 printf (_(" [unsupported opcode]"));
7584 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7585 unsigned int word
, unsigned int remaining
,
7586 unsigned int more_words
,
7587 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7588 struct arm_section
*data_arm_sec
)
7590 struct absaddr addr
;
7592 /* Decode the unwinding instructions. */
7595 unsigned int op
, op2
;
7604 printf (" 0x%02x ", op
);
7606 if ((op
& 0xc0) == 0x00)
7608 int offset
= ((op
& 0x3f) << 3) + 8;
7609 printf (" sp = sp + %d", offset
);
7611 else if ((op
& 0xc0) == 0x80)
7614 if (op
== 0x80 && op2
== 0)
7615 printf (_("Refuse to unwind"));
7618 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7620 printf ("pop compact {");
7624 decode_tic6x_unwind_regmask (mask
);
7628 else if ((op
& 0xf0) == 0xc0)
7636 unsigned int offset
;
7640 /* Scan entire instruction first so that GET_OP output is not
7641 interleaved with disassembly. */
7643 for (i
= 0; nregs
< (op
& 0xf); i
++)
7649 regpos
[nregs
].offset
= i
* 2;
7650 regpos
[nregs
].reg
= reg
;
7657 regpos
[nregs
].offset
= i
* 2 + 1;
7658 regpos
[nregs
].reg
= reg
;
7663 printf (_("pop frame {"));
7665 for (i
= i
* 2; i
> 0; i
--)
7667 if (regpos
[reg
].offset
== i
- 1)
7669 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7676 fputs (name
, stdout
);
7683 else if (op
== 0xd0)
7684 printf (" MOV FP, SP");
7685 else if (op
== 0xd1)
7686 printf (" __c6xabi_pop_rts");
7687 else if (op
== 0xd2)
7689 unsigned char buf
[9];
7690 unsigned int i
, len
;
7691 unsigned long offset
;
7693 for (i
= 0; i
< sizeof (buf
); i
++)
7696 if ((buf
[i
] & 0x80) == 0)
7699 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7700 if (i
== sizeof (buf
))
7702 printf ("<corrupt sp adjust>\n");
7703 warn (_("Corrupt stack pointer adjustment detected\n"));
7707 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7708 assert (len
== i
+ 1);
7709 offset
= offset
* 8 + 0x408;
7710 printf (_("sp = sp + %ld"), offset
);
7712 else if ((op
& 0xf0) == 0xe0)
7714 if ((op
& 0x0f) == 7)
7717 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7721 printf (_(" [unsupported opcode]"));
7728 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7732 offset
= word
& 0x7fffffff;
7733 if (offset
& 0x40000000)
7734 offset
|= ~ (bfd_vma
) 0x7fffffff;
7736 if (elf_header
.e_machine
== EM_TI_C6000
)
7739 return offset
+ where
;
7743 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7745 unsigned int remaining
,
7746 bfd_vma data_offset
,
7747 Elf_Internal_Shdr
* data_sec
,
7748 struct arm_section
* data_arm_sec
)
7751 unsigned int more_words
= 0;
7752 struct absaddr addr
;
7753 bfd_vma sym_name
= (bfd_vma
) -1;
7757 /* Fetch the first word.
7758 Note - when decoding an object file the address extracted
7759 here will always be 0. So we also pass in the sym_name
7760 parameter so that we can find the symbol associated with
7761 the personality routine. */
7762 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7763 & word
, & addr
, & sym_name
))
7769 if ((word
& 0x80000000) == 0)
7771 /* Expand prel31 for personality routine. */
7773 const char *procname
;
7775 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7776 printf (_(" Personality routine: "));
7778 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7779 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7781 procname
= aux
->strtab
+ sym_name
;
7782 print_vma (fn
, PREFIX_HEX
);
7785 fputs (" <", stdout
);
7786 fputs (procname
, stdout
);
7787 fputc ('>', stdout
);
7791 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7792 fputc ('\n', stdout
);
7794 /* The GCC personality routines use the standard compact
7795 encoding, starting with one byte giving the number of
7797 if (procname
!= NULL
7798 && (const_strneq (procname
, "__gcc_personality_v0")
7799 || const_strneq (procname
, "__gxx_personality_v0")
7800 || const_strneq (procname
, "__gcj_personality_v0")
7801 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7808 printf (_(" [Truncated data]\n"));
7811 more_words
= word
>> 24;
7821 /* ARM EHABI Section 6.3:
7823 An exception-handling table entry for the compact model looks like:
7827 1 0 index Data for personalityRoutine[index] */
7829 if (elf_header
.e_machine
== EM_ARM
7830 && (word
& 0x70000000))
7831 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7833 per_index
= (word
>> 24) & 0x7f;
7834 printf (_(" Compact model index: %d\n"), per_index
);
7841 else if (per_index
< 3)
7843 more_words
= (word
>> 16) & 0xff;
7849 switch (elf_header
.e_machine
)
7854 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7855 data_offset
, data_sec
, data_arm_sec
);
7859 warn (_("Unknown ARM compact model index encountered\n"));
7860 printf (_(" [reserved]\n"));
7867 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7868 data_offset
, data_sec
, data_arm_sec
);
7870 else if (per_index
< 5)
7872 if (((word
>> 17) & 0x7f) == 0x7f)
7873 printf (_(" Restore stack from frame pointer\n"));
7875 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7876 printf (_(" Registers restored: "));
7878 printf (" (compact) ");
7879 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7881 printf (_(" Return register: %s\n"),
7882 tic6x_unwind_regnames
[word
& 0xf]);
7885 printf (_(" [reserved (%d)]\n"), per_index
);
7889 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7890 elf_header
.e_machine
);
7893 /* Decode the descriptors. Not implemented. */
7897 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7899 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7900 unsigned int i
, exidx_len
;
7902 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7903 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7904 exidx_len
= exidx_sec
->sh_size
/ 8;
7906 for (i
= 0; i
< exidx_len
; i
++)
7908 unsigned int exidx_fn
, exidx_entry
;
7909 struct absaddr fn_addr
, entry_addr
;
7912 fputc ('\n', stdout
);
7914 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7915 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7916 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7917 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7919 arm_free_section (& exidx_arm_sec
);
7920 arm_free_section (& extab_arm_sec
);
7924 /* ARM EHABI, Section 5:
7925 An index table entry consists of 2 words.
7926 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7927 if (exidx_fn
& 0x80000000)
7928 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7930 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7932 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7933 fputs (": ", stdout
);
7935 if (exidx_entry
== 1)
7937 print_vma (exidx_entry
, PREFIX_HEX
);
7938 fputs (" [cantunwind]\n", stdout
);
7940 else if (exidx_entry
& 0x80000000)
7942 print_vma (exidx_entry
, PREFIX_HEX
);
7943 fputc ('\n', stdout
);
7944 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7948 bfd_vma table
, table_offset
= 0;
7949 Elf_Internal_Shdr
*table_sec
;
7951 fputs ("@", stdout
);
7952 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7953 print_vma (table
, PREFIX_HEX
);
7956 /* Locate the matching .ARM.extab. */
7957 if (entry_addr
.section
!= SHN_UNDEF
7958 && entry_addr
.section
< elf_header
.e_shnum
)
7960 table_sec
= section_headers
+ entry_addr
.section
;
7961 table_offset
= entry_addr
.offset
;
7965 table_sec
= find_section_by_address (table
);
7966 if (table_sec
!= NULL
)
7967 table_offset
= table
- table_sec
->sh_addr
;
7969 if (table_sec
== NULL
)
7971 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7972 (unsigned long) table
);
7975 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7982 arm_free_section (&exidx_arm_sec
);
7983 arm_free_section (&extab_arm_sec
);
7986 /* Used for both ARM and C6X unwinding tables. */
7989 arm_process_unwind (FILE *file
)
7991 struct arm_unw_aux_info aux
;
7992 Elf_Internal_Shdr
*unwsec
= NULL
;
7993 Elf_Internal_Shdr
*strsec
;
7994 Elf_Internal_Shdr
*sec
;
7996 unsigned int sec_type
;
7998 switch (elf_header
.e_machine
)
8001 sec_type
= SHT_ARM_EXIDX
;
8005 sec_type
= SHT_C6000_UNWIND
;
8009 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8010 elf_header
.e_machine
);
8014 if (string_table
== NULL
)
8017 memset (& aux
, 0, sizeof (aux
));
8020 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8022 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8024 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8026 strsec
= section_headers
+ sec
->sh_link
;
8028 /* PR binutils/17531 file: 011-12666-0.004. */
8029 if (aux
.strtab
!= NULL
)
8031 error (_("Multiple string tables found in file.\n"));
8034 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8035 1, strsec
->sh_size
, _("string table"));
8036 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8038 else if (sec
->sh_type
== sec_type
)
8043 printf (_("\nThere are no unwind sections in this file.\n"));
8045 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8047 if (sec
->sh_type
== sec_type
)
8049 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8050 printable_section_name (sec
),
8051 (unsigned long) sec
->sh_offset
,
8052 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8054 dump_arm_unwind (&aux
, sec
);
8061 free ((char *) aux
.strtab
);
8065 process_unwind (FILE * file
)
8067 struct unwind_handler
8070 void (* handler
)(FILE *);
8073 { EM_ARM
, arm_process_unwind
},
8074 { EM_IA_64
, ia64_process_unwind
},
8075 { EM_PARISC
, hppa_process_unwind
},
8076 { EM_TI_C6000
, arm_process_unwind
},
8084 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8085 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8087 handlers
[i
].handler (file
);
8091 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8092 get_machine_name (elf_header
.e_machine
));
8096 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8098 switch (entry
->d_tag
)
8101 if (entry
->d_un
.d_val
== 0)
8105 static const char * opts
[] =
8107 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8108 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8109 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8110 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8116 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8117 if (entry
->d_un
.d_val
& (1 << cnt
))
8119 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8125 case DT_MIPS_IVERSION
:
8126 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8127 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8131 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8132 /* Note: coded this way so that there is a single string for translation. */
8133 printf (_("<corrupt: %s>"), buf
);
8137 case DT_MIPS_TIME_STAMP
:
8142 time_t atime
= entry
->d_un
.d_val
;
8143 tmp
= gmtime (&atime
);
8144 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8145 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8146 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8147 printf (_("Time Stamp: %s"), timebuf
);
8151 case DT_MIPS_RLD_VERSION
:
8152 case DT_MIPS_LOCAL_GOTNO
:
8153 case DT_MIPS_CONFLICTNO
:
8154 case DT_MIPS_LIBLISTNO
:
8155 case DT_MIPS_SYMTABNO
:
8156 case DT_MIPS_UNREFEXTNO
:
8157 case DT_MIPS_HIPAGENO
:
8158 case DT_MIPS_DELTA_CLASS_NO
:
8159 case DT_MIPS_DELTA_INSTANCE_NO
:
8160 case DT_MIPS_DELTA_RELOC_NO
:
8161 case DT_MIPS_DELTA_SYM_NO
:
8162 case DT_MIPS_DELTA_CLASSSYM_NO
:
8163 case DT_MIPS_COMPACT_SIZE
:
8164 print_vma (entry
->d_un
.d_ptr
, DEC
);
8168 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8174 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8176 switch (entry
->d_tag
)
8178 case DT_HP_DLD_FLAGS
:
8187 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8188 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8189 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8190 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8191 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8192 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8193 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8194 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8195 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8196 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8197 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8198 { DT_HP_GST
, "HP_GST" },
8199 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8200 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8201 { DT_HP_NODELETE
, "HP_NODELETE" },
8202 { DT_HP_GROUP
, "HP_GROUP" },
8203 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8207 bfd_vma val
= entry
->d_un
.d_val
;
8209 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8210 if (val
& flags
[cnt
].bit
)
8214 fputs (flags
[cnt
].str
, stdout
);
8216 val
^= flags
[cnt
].bit
;
8219 if (val
!= 0 || first
)
8223 print_vma (val
, HEX
);
8229 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8237 /* VMS vs Unix time offset and factor. */
8239 #define VMS_EPOCH_OFFSET 35067168000000000LL
8240 #define VMS_GRANULARITY_FACTOR 10000000
8242 /* Display a VMS time in a human readable format. */
8245 print_vms_time (bfd_int64_t vmstime
)
8250 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8251 tm
= gmtime (&unxtime
);
8252 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8253 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8254 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8259 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8261 switch (entry
->d_tag
)
8263 case DT_IA_64_PLT_RESERVE
:
8264 /* First 3 slots reserved. */
8265 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8267 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8270 case DT_IA_64_VMS_LINKTIME
:
8272 print_vms_time (entry
->d_un
.d_val
);
8276 case DT_IA_64_VMS_LNKFLAGS
:
8277 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8278 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8279 printf (" CALL_DEBUG");
8280 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8281 printf (" NOP0BUFS");
8282 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8283 printf (" P0IMAGE");
8284 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8285 printf (" MKTHREADS");
8286 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8287 printf (" UPCALLS");
8288 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8290 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8291 printf (" INITIALIZE");
8292 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8294 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8295 printf (" EXE_INIT");
8296 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8297 printf (" TBK_IN_IMG");
8298 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8299 printf (" DBG_IN_IMG");
8300 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8301 printf (" TBK_IN_DSF");
8302 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8303 printf (" DBG_IN_DSF");
8304 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8305 printf (" SIGNATURES");
8306 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8307 printf (" REL_SEG_OFF");
8311 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8318 get_32bit_dynamic_section (FILE * file
)
8320 Elf32_External_Dyn
* edyn
;
8321 Elf32_External_Dyn
* ext
;
8322 Elf_Internal_Dyn
* entry
;
8324 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8325 dynamic_size
, _("dynamic section"));
8329 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8330 might not have the luxury of section headers. Look for the DT_NULL
8331 terminator to determine the number of entries. */
8332 for (ext
= edyn
, dynamic_nent
= 0;
8333 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8337 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8341 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8343 if (dynamic_section
== NULL
)
8345 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8346 (unsigned long) dynamic_nent
);
8351 for (ext
= edyn
, entry
= dynamic_section
;
8352 entry
< dynamic_section
+ dynamic_nent
;
8355 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8356 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8365 get_64bit_dynamic_section (FILE * file
)
8367 Elf64_External_Dyn
* edyn
;
8368 Elf64_External_Dyn
* ext
;
8369 Elf_Internal_Dyn
* entry
;
8371 /* Read in the data. */
8372 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8373 dynamic_size
, _("dynamic section"));
8377 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8378 might not have the luxury of section headers. Look for the DT_NULL
8379 terminator to determine the number of entries. */
8380 for (ext
= edyn
, dynamic_nent
= 0;
8381 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8382 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8386 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8390 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8392 if (dynamic_section
== NULL
)
8394 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8395 (unsigned long) dynamic_nent
);
8400 /* Convert from external to internal formats. */
8401 for (ext
= edyn
, entry
= dynamic_section
;
8402 entry
< dynamic_section
+ dynamic_nent
;
8405 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8406 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8415 print_dynamic_flags (bfd_vma flags
)
8423 flag
= flags
& - flags
;
8433 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8434 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8435 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8436 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8437 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8438 default: fputs (_("unknown"), stdout
); break;
8444 /* Parse and display the contents of the dynamic section. */
8447 process_dynamic_section (FILE * file
)
8449 Elf_Internal_Dyn
* entry
;
8451 if (dynamic_size
== 0)
8454 printf (_("\nThere is no dynamic section in this file.\n"));
8461 if (! get_32bit_dynamic_section (file
))
8464 else if (! get_64bit_dynamic_section (file
))
8467 /* Find the appropriate symbol table. */
8468 if (dynamic_symbols
== NULL
)
8470 for (entry
= dynamic_section
;
8471 entry
< dynamic_section
+ dynamic_nent
;
8474 Elf_Internal_Shdr section
;
8476 if (entry
->d_tag
!= DT_SYMTAB
)
8479 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8481 /* Since we do not know how big the symbol table is,
8482 we default to reading in the entire file (!) and
8483 processing that. This is overkill, I know, but it
8485 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8487 if (archive_file_offset
!= 0)
8488 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8491 if (fseek (file
, 0, SEEK_END
))
8492 error (_("Unable to seek to end of file!\n"));
8494 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8498 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8500 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8501 section
.sh_name
= string_table_length
;
8503 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8504 if (num_dynamic_syms
< 1)
8506 error (_("Unable to determine the number of symbols to load\n"));
8512 /* Similarly find a string table. */
8513 if (dynamic_strings
== NULL
)
8515 for (entry
= dynamic_section
;
8516 entry
< dynamic_section
+ dynamic_nent
;
8519 unsigned long offset
;
8522 if (entry
->d_tag
!= DT_STRTAB
)
8525 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8527 /* Since we do not know how big the string table is,
8528 we default to reading in the entire file (!) and
8529 processing that. This is overkill, I know, but it
8532 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8534 if (archive_file_offset
!= 0)
8535 str_tab_len
= archive_file_size
- offset
;
8538 if (fseek (file
, 0, SEEK_END
))
8539 error (_("Unable to seek to end of file\n"));
8540 str_tab_len
= ftell (file
) - offset
;
8543 if (str_tab_len
< 1)
8546 (_("Unable to determine the length of the dynamic string table\n"));
8550 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8552 _("dynamic string table"));
8553 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8558 /* And find the syminfo section if available. */
8559 if (dynamic_syminfo
== NULL
)
8561 unsigned long syminsz
= 0;
8563 for (entry
= dynamic_section
;
8564 entry
< dynamic_section
+ dynamic_nent
;
8567 if (entry
->d_tag
== DT_SYMINENT
)
8569 /* Note: these braces are necessary to avoid a syntax
8570 error from the SunOS4 C compiler. */
8571 /* PR binutils/17531: A corrupt file can trigger this test.
8572 So do not use an assert, instead generate an error message. */
8573 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8574 error (_("Bad value (%d) for SYMINENT entry\n"),
8575 (int) entry
->d_un
.d_val
);
8577 else if (entry
->d_tag
== DT_SYMINSZ
)
8578 syminsz
= entry
->d_un
.d_val
;
8579 else if (entry
->d_tag
== DT_SYMINFO
)
8580 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8584 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8586 Elf_External_Syminfo
* extsyminfo
;
8587 Elf_External_Syminfo
* extsym
;
8588 Elf_Internal_Syminfo
* syminfo
;
8590 /* There is a syminfo section. Read the data. */
8591 extsyminfo
= (Elf_External_Syminfo
*)
8592 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8593 _("symbol information"));
8597 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8598 if (dynamic_syminfo
== NULL
)
8600 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8601 (unsigned long) syminsz
);
8605 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8606 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8607 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8608 ++syminfo
, ++extsym
)
8610 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8611 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8618 if (do_dynamic
&& dynamic_addr
)
8619 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8620 dynamic_addr
, (unsigned long) dynamic_nent
);
8622 printf (_(" Tag Type Name/Value\n"));
8624 for (entry
= dynamic_section
;
8625 entry
< dynamic_section
+ dynamic_nent
;
8633 print_vma (entry
->d_tag
, FULL_HEX
);
8634 dtype
= get_dynamic_type (entry
->d_tag
);
8635 printf (" (%s)%*s", dtype
,
8636 ((is_32bit_elf
? 27 : 19)
8637 - (int) strlen (dtype
)),
8641 switch (entry
->d_tag
)
8645 print_dynamic_flags (entry
->d_un
.d_val
);
8655 switch (entry
->d_tag
)
8658 printf (_("Auxiliary library"));
8662 printf (_("Filter library"));
8666 printf (_("Configuration file"));
8670 printf (_("Dependency audit library"));
8674 printf (_("Audit library"));
8678 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8679 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8683 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8692 printf (_("Flags:"));
8694 if (entry
->d_un
.d_val
== 0)
8695 printf (_(" None\n"));
8698 unsigned long int val
= entry
->d_un
.d_val
;
8700 if (val
& DTF_1_PARINIT
)
8702 printf (" PARINIT");
8703 val
^= DTF_1_PARINIT
;
8705 if (val
& DTF_1_CONFEXP
)
8707 printf (" CONFEXP");
8708 val
^= DTF_1_CONFEXP
;
8711 printf (" %lx", val
);
8720 printf (_("Flags:"));
8722 if (entry
->d_un
.d_val
== 0)
8723 printf (_(" None\n"));
8726 unsigned long int val
= entry
->d_un
.d_val
;
8728 if (val
& DF_P1_LAZYLOAD
)
8730 printf (" LAZYLOAD");
8731 val
^= DF_P1_LAZYLOAD
;
8733 if (val
& DF_P1_GROUPPERM
)
8735 printf (" GROUPPERM");
8736 val
^= DF_P1_GROUPPERM
;
8739 printf (" %lx", val
);
8748 printf (_("Flags:"));
8749 if (entry
->d_un
.d_val
== 0)
8750 printf (_(" None\n"));
8753 unsigned long int val
= entry
->d_un
.d_val
;
8760 if (val
& DF_1_GLOBAL
)
8765 if (val
& DF_1_GROUP
)
8770 if (val
& DF_1_NODELETE
)
8772 printf (" NODELETE");
8773 val
^= DF_1_NODELETE
;
8775 if (val
& DF_1_LOADFLTR
)
8777 printf (" LOADFLTR");
8778 val
^= DF_1_LOADFLTR
;
8780 if (val
& DF_1_INITFIRST
)
8782 printf (" INITFIRST");
8783 val
^= DF_1_INITFIRST
;
8785 if (val
& DF_1_NOOPEN
)
8790 if (val
& DF_1_ORIGIN
)
8795 if (val
& DF_1_DIRECT
)
8800 if (val
& DF_1_TRANS
)
8805 if (val
& DF_1_INTERPOSE
)
8807 printf (" INTERPOSE");
8808 val
^= DF_1_INTERPOSE
;
8810 if (val
& DF_1_NODEFLIB
)
8812 printf (" NODEFLIB");
8813 val
^= DF_1_NODEFLIB
;
8815 if (val
& DF_1_NODUMP
)
8820 if (val
& DF_1_CONFALT
)
8822 printf (" CONFALT");
8823 val
^= DF_1_CONFALT
;
8825 if (val
& DF_1_ENDFILTEE
)
8827 printf (" ENDFILTEE");
8828 val
^= DF_1_ENDFILTEE
;
8830 if (val
& DF_1_DISPRELDNE
)
8832 printf (" DISPRELDNE");
8833 val
^= DF_1_DISPRELDNE
;
8835 if (val
& DF_1_DISPRELPND
)
8837 printf (" DISPRELPND");
8838 val
^= DF_1_DISPRELPND
;
8840 if (val
& DF_1_NODIRECT
)
8842 printf (" NODIRECT");
8843 val
^= DF_1_NODIRECT
;
8845 if (val
& DF_1_IGNMULDEF
)
8847 printf (" IGNMULDEF");
8848 val
^= DF_1_IGNMULDEF
;
8850 if (val
& DF_1_NOKSYMS
)
8852 printf (" NOKSYMS");
8853 val
^= DF_1_NOKSYMS
;
8855 if (val
& DF_1_NOHDR
)
8860 if (val
& DF_1_EDITED
)
8865 if (val
& DF_1_NORELOC
)
8867 printf (" NORELOC");
8868 val
^= DF_1_NORELOC
;
8870 if (val
& DF_1_SYMINTPOSE
)
8872 printf (" SYMINTPOSE");
8873 val
^= DF_1_SYMINTPOSE
;
8875 if (val
& DF_1_GLOBAUDIT
)
8877 printf (" GLOBAUDIT");
8878 val
^= DF_1_GLOBAUDIT
;
8880 if (val
& DF_1_SINGLETON
)
8882 printf (" SINGLETON");
8883 val
^= DF_1_SINGLETON
;
8886 printf (" %lx", val
);
8893 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8895 puts (get_dynamic_type (entry
->d_un
.d_val
));
8915 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8921 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8922 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8928 switch (entry
->d_tag
)
8931 printf (_("Shared library: [%s]"), name
);
8933 if (streq (name
, program_interpreter
))
8934 printf (_(" program interpreter"));
8938 printf (_("Library soname: [%s]"), name
);
8942 printf (_("Library rpath: [%s]"), name
);
8946 printf (_("Library runpath: [%s]"), name
);
8950 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8955 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8968 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8972 case DT_INIT_ARRAYSZ
:
8973 case DT_FINI_ARRAYSZ
:
8974 case DT_GNU_CONFLICTSZ
:
8975 case DT_GNU_LIBLISTSZ
:
8978 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8979 printf (_(" (bytes)\n"));
8989 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9002 if (entry
->d_tag
== DT_USED
9003 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9005 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9009 printf (_("Not needed object: [%s]\n"), name
);
9014 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9020 /* The value of this entry is ignored. */
9025 case DT_GNU_PRELINKED
:
9029 time_t atime
= entry
->d_un
.d_val
;
9031 tmp
= gmtime (&atime
);
9032 /* PR 17533 file: 041-1244816-0.004. */
9034 printf (_("<corrupt time val: %lx"),
9035 (unsigned long) atime
);
9037 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9038 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9039 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9045 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9048 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9054 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9055 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9060 switch (elf_header
.e_machine
)
9063 case EM_MIPS_RS3_LE
:
9064 dynamic_section_mips_val (entry
);
9067 dynamic_section_parisc_val (entry
);
9070 dynamic_section_ia64_val (entry
);
9073 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9085 get_ver_flags (unsigned int flags
)
9087 static char buff
[32];
9094 if (flags
& VER_FLG_BASE
)
9095 strcat (buff
, "BASE ");
9097 if (flags
& VER_FLG_WEAK
)
9099 if (flags
& VER_FLG_BASE
)
9100 strcat (buff
, "| ");
9102 strcat (buff
, "WEAK ");
9105 if (flags
& VER_FLG_INFO
)
9107 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9108 strcat (buff
, "| ");
9110 strcat (buff
, "INFO ");
9113 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9114 strcat (buff
, _("| <unknown>"));
9119 /* Display the contents of the version sections. */
9122 process_version_sections (FILE * file
)
9124 Elf_Internal_Shdr
* section
;
9131 for (i
= 0, section
= section_headers
;
9132 i
< elf_header
.e_shnum
;
9135 switch (section
->sh_type
)
9137 case SHT_GNU_verdef
:
9139 Elf_External_Verdef
* edefs
;
9146 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9147 printable_section_name (section
),
9150 printf (_(" Addr: 0x"));
9151 printf_vma (section
->sh_addr
);
9152 printf (_(" Offset: %#08lx Link: %u (%s)"),
9153 (unsigned long) section
->sh_offset
, section
->sh_link
,
9154 printable_section_name_from_index (section
->sh_link
));
9156 edefs
= (Elf_External_Verdef
*)
9157 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9158 _("version definition section"));
9161 endbuf
= (char *) edefs
+ section
->sh_size
;
9163 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9166 Elf_External_Verdef
* edef
;
9167 Elf_Internal_Verdef ent
;
9168 Elf_External_Verdaux
* eaux
;
9169 Elf_Internal_Verdaux aux
;
9173 /* Check for very large indicies. */
9174 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9177 vstart
= ((char *) edefs
) + idx
;
9178 if (vstart
+ sizeof (*edef
) > endbuf
)
9181 edef
= (Elf_External_Verdef
*) vstart
;
9183 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9184 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9185 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9186 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9187 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9188 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9189 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9191 printf (_(" %#06x: Rev: %d Flags: %s"),
9192 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9194 printf (_(" Index: %d Cnt: %d "),
9195 ent
.vd_ndx
, ent
.vd_cnt
);
9197 /* Check for overflow. */
9198 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9201 vstart
+= ent
.vd_aux
;
9203 eaux
= (Elf_External_Verdaux
*) vstart
;
9205 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9206 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9208 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9209 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9211 printf (_("Name index: %ld\n"), aux
.vda_name
);
9213 isum
= idx
+ ent
.vd_aux
;
9215 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9217 /* Check for overflow. */
9218 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9221 isum
+= aux
.vda_next
;
9222 vstart
+= aux
.vda_next
;
9224 eaux
= (Elf_External_Verdaux
*) vstart
;
9225 if (vstart
+ sizeof (*eaux
) > endbuf
)
9228 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9229 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9231 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9232 printf (_(" %#06x: Parent %d: %s\n"),
9233 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9235 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9236 isum
, j
, aux
.vda_name
);
9240 printf (_(" Version def aux past end of section\n"));
9242 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9243 if (idx
+ ent
.vd_next
<= idx
)
9249 if (cnt
< section
->sh_info
)
9250 printf (_(" Version definition past end of section\n"));
9256 case SHT_GNU_verneed
:
9258 Elf_External_Verneed
* eneed
;
9265 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9266 printable_section_name (section
), section
->sh_info
);
9268 printf (_(" Addr: 0x"));
9269 printf_vma (section
->sh_addr
);
9270 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9271 (unsigned long) section
->sh_offset
, section
->sh_link
,
9272 printable_section_name_from_index (section
->sh_link
));
9274 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9275 section
->sh_offset
, 1,
9277 _("Version Needs section"));
9280 endbuf
= (char *) eneed
+ section
->sh_size
;
9282 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9284 Elf_External_Verneed
* entry
;
9285 Elf_Internal_Verneed ent
;
9290 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9293 vstart
= ((char *) eneed
) + idx
;
9294 if (vstart
+ sizeof (*entry
) > endbuf
)
9297 entry
= (Elf_External_Verneed
*) vstart
;
9299 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9300 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9301 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9302 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9303 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9305 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9307 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9308 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9310 printf (_(" File: %lx"), ent
.vn_file
);
9312 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9314 /* Check for overflow. */
9315 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9318 vstart
+= ent
.vn_aux
;
9320 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9322 Elf_External_Vernaux
* eaux
;
9323 Elf_Internal_Vernaux aux
;
9325 if (vstart
+ sizeof (*eaux
) > endbuf
)
9327 eaux
= (Elf_External_Vernaux
*) vstart
;
9329 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9330 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9331 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9332 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9333 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9335 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9336 printf (_(" %#06x: Name: %s"),
9337 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9339 printf (_(" %#06x: Name index: %lx"),
9340 isum
, aux
.vna_name
);
9342 printf (_(" Flags: %s Version: %d\n"),
9343 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9345 /* Check for overflow. */
9346 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9349 isum
+= aux
.vna_next
;
9350 vstart
+= aux
.vna_next
;
9354 warn (_("Missing Version Needs auxillary information\n"));
9356 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9358 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9359 cnt
= section
->sh_info
;
9365 if (cnt
< section
->sh_info
)
9366 warn (_("Missing Version Needs information\n"));
9372 case SHT_GNU_versym
:
9374 Elf_Internal_Shdr
* link_section
;
9377 unsigned char * edata
;
9378 unsigned short * data
;
9380 Elf_Internal_Sym
* symbols
;
9381 Elf_Internal_Shdr
* string_sec
;
9382 unsigned long num_syms
;
9385 if (section
->sh_link
>= elf_header
.e_shnum
)
9388 link_section
= section_headers
+ section
->sh_link
;
9389 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9391 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9396 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9397 if (symbols
== NULL
)
9400 string_sec
= section_headers
+ link_section
->sh_link
;
9402 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9403 string_sec
->sh_size
,
9404 _("version string table"));
9411 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9412 printable_section_name (section
), (unsigned long) total
);
9414 printf (_(" Addr: "));
9415 printf_vma (section
->sh_addr
);
9416 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9417 (unsigned long) section
->sh_offset
, section
->sh_link
,
9418 printable_section_name (link_section
));
9420 off
= offset_from_vma (file
,
9421 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9422 total
* sizeof (short));
9423 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9425 _("version symbol data"));
9433 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9435 for (cnt
= total
; cnt
--;)
9436 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9441 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9444 int check_def
, check_need
;
9447 printf (" %03x:", cnt
);
9449 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9450 switch (data
[cnt
+ j
])
9453 fputs (_(" 0 (*local*) "), stdout
);
9457 fputs (_(" 1 (*global*) "), stdout
);
9461 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9462 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9464 /* If this index value is greater than the size of the symbols
9465 array, break to avoid an out-of-bounds read. */
9466 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9468 warn (_("invalid index into symbol array\n"));
9474 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9475 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9478 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9485 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9487 Elf_Internal_Verneed ivn
;
9488 unsigned long offset
;
9490 offset
= offset_from_vma
9491 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9492 sizeof (Elf_External_Verneed
));
9496 Elf_Internal_Vernaux ivna
;
9497 Elf_External_Verneed evn
;
9498 Elf_External_Vernaux evna
;
9499 unsigned long a_off
;
9501 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9502 _("version need")) == NULL
)
9505 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9506 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9508 a_off
= offset
+ ivn
.vn_aux
;
9512 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9513 1, _("version need aux (2)")) == NULL
)
9520 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9521 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9524 a_off
+= ivna
.vna_next
;
9526 while (ivna
.vna_other
!= data
[cnt
+ j
]
9527 && ivna
.vna_next
!= 0);
9529 if (ivna
.vna_other
== data
[cnt
+ j
])
9531 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9533 if (ivna
.vna_name
>= string_sec
->sh_size
)
9534 name
= _("*invalid*");
9536 name
= strtab
+ ivna
.vna_name
;
9537 nn
+= printf ("(%s%-*s",
9539 12 - (int) strlen (name
),
9545 offset
+= ivn
.vn_next
;
9547 while (ivn
.vn_next
);
9550 if (check_def
&& data
[cnt
+ j
] != 0x8001
9551 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9553 Elf_Internal_Verdef ivd
;
9554 Elf_External_Verdef evd
;
9555 unsigned long offset
;
9557 offset
= offset_from_vma
9558 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9563 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9564 _("version def")) == NULL
)
9567 /* PR 17531: file: 046-1082287-0.004. */
9568 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9573 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9574 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9577 offset
+= ivd
.vd_next
;
9579 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9580 && ivd
.vd_next
!= 0);
9582 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9584 Elf_External_Verdaux evda
;
9585 Elf_Internal_Verdaux ivda
;
9587 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9589 if (get_data (&evda
, file
,
9590 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9592 _("version def aux")) == NULL
)
9595 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9597 if (ivda
.vda_name
>= string_sec
->sh_size
)
9598 name
= _("*invalid*");
9600 name
= strtab
+ ivda
.vda_name
;
9601 nn
+= printf ("(%s%-*s",
9603 12 - (int) strlen (name
),
9609 printf ("%*c", 18 - nn
, ' ');
9627 printf (_("\nNo version information found in this file.\n"));
9633 get_symbol_binding (unsigned int binding
)
9635 static char buff
[32];
9639 case STB_LOCAL
: return "LOCAL";
9640 case STB_GLOBAL
: return "GLOBAL";
9641 case STB_WEAK
: return "WEAK";
9643 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9644 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9646 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9648 if (binding
== STB_GNU_UNIQUE
9649 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9650 /* GNU is still using the default value 0. */
9651 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9653 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9656 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9662 get_symbol_type (unsigned int type
)
9664 static char buff
[32];
9668 case STT_NOTYPE
: return "NOTYPE";
9669 case STT_OBJECT
: return "OBJECT";
9670 case STT_FUNC
: return "FUNC";
9671 case STT_SECTION
: return "SECTION";
9672 case STT_FILE
: return "FILE";
9673 case STT_COMMON
: return "COMMON";
9674 case STT_TLS
: return "TLS";
9675 case STT_RELC
: return "RELC";
9676 case STT_SRELC
: return "SRELC";
9678 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9680 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9681 return "THUMB_FUNC";
9683 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9686 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9687 return "PARISC_MILLI";
9689 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9691 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9693 if (elf_header
.e_machine
== EM_PARISC
)
9695 if (type
== STT_HP_OPAQUE
)
9697 if (type
== STT_HP_STUB
)
9701 if (type
== STT_GNU_IFUNC
9702 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9703 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9704 /* GNU is still using the default value 0. */
9705 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9708 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9711 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9717 get_symbol_visibility (unsigned int visibility
)
9721 case STV_DEFAULT
: return "DEFAULT";
9722 case STV_INTERNAL
: return "INTERNAL";
9723 case STV_HIDDEN
: return "HIDDEN";
9724 case STV_PROTECTED
: return "PROTECTED";
9726 error (_("Unrecognized visibility value: %u"), visibility
);
9727 return _("<unknown>");
9732 get_mips_symbol_other (unsigned int other
)
9744 case STO_MICROMIPS
| STO_MIPS_PIC
:
9745 return "MICROMIPS, MIPS PIC";
9754 get_ia64_symbol_other (unsigned int other
)
9758 static char res
[32];
9762 /* Function types is for images and .STB files only. */
9763 switch (elf_header
.e_type
)
9767 switch (VMS_ST_FUNC_TYPE (other
))
9769 case VMS_SFT_CODE_ADDR
:
9770 strcat (res
, " CA");
9772 case VMS_SFT_SYMV_IDX
:
9773 strcat (res
, " VEC");
9776 strcat (res
, " FD");
9778 case VMS_SFT_RESERVE
:
9779 strcat (res
, " RSV");
9782 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9783 VMS_ST_FUNC_TYPE (other
));
9784 strcat (res
, " <unknown>");
9791 switch (VMS_ST_LINKAGE (other
))
9793 case VMS_STL_IGNORE
:
9794 strcat (res
, " IGN");
9796 case VMS_STL_RESERVE
:
9797 strcat (res
, " RSV");
9800 strcat (res
, " STD");
9803 strcat (res
, " LNK");
9806 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9807 VMS_ST_LINKAGE (other
));
9808 strcat (res
, " <unknown>");
9821 get_ppc64_symbol_other (unsigned int other
)
9823 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9825 static char buf
[32];
9826 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9827 PPC64_LOCAL_ENTRY_OFFSET (other
));
9834 get_symbol_other (unsigned int other
)
9836 const char * result
= NULL
;
9837 static char buff
[32];
9842 switch (elf_header
.e_machine
)
9845 result
= get_mips_symbol_other (other
);
9848 result
= get_ia64_symbol_other (other
);
9851 result
= get_ppc64_symbol_other (other
);
9860 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9865 get_symbol_index_type (unsigned int type
)
9867 static char buff
[32];
9871 case SHN_UNDEF
: return "UND";
9872 case SHN_ABS
: return "ABS";
9873 case SHN_COMMON
: return "COM";
9875 if (type
== SHN_IA_64_ANSI_COMMON
9876 && elf_header
.e_machine
== EM_IA_64
9877 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9879 else if ((elf_header
.e_machine
== EM_X86_64
9880 || elf_header
.e_machine
== EM_L1OM
9881 || elf_header
.e_machine
== EM_K1OM
)
9882 && type
== SHN_X86_64_LCOMMON
)
9884 else if ((type
== SHN_MIPS_SCOMMON
9885 && elf_header
.e_machine
== EM_MIPS
)
9886 || (type
== SHN_TIC6X_SCOMMON
9887 && elf_header
.e_machine
== EM_TI_C6000
))
9889 else if (type
== SHN_MIPS_SUNDEFINED
9890 && elf_header
.e_machine
== EM_MIPS
)
9892 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9893 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9894 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9895 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9896 else if (type
>= SHN_LORESERVE
)
9897 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9898 else if (type
>= elf_header
.e_shnum
)
9899 sprintf (buff
, _("bad section index[%3d]"), type
);
9901 sprintf (buff
, "%3d", type
);
9909 get_dynamic_data (FILE * file
, size_t number
, unsigned int ent_size
)
9911 unsigned char * e_data
;
9914 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9915 attempting to allocate memory when the read is bound to fail. */
9916 if (ent_size
* number
> current_file_size
)
9918 error (_("Invalid number of dynamic entries: %lu\n"),
9919 (unsigned long) number
);
9923 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9926 error (_("Out of memory reading %lu dynamic entries\n"),
9927 (unsigned long) number
);
9931 if (fread (e_data
, ent_size
, number
, file
) != number
)
9933 error (_("Unable to read in %lu bytes of dynamic data\n"),
9934 (unsigned long) (number
* ent_size
));
9939 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9942 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9943 (unsigned long) number
);
9949 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9957 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9959 Elf_Internal_Sym
* psym
;
9962 n
= print_vma (si
, DEC_5
);
9964 fputs (&" "[n
], stdout
);
9965 printf (" %3lu: ", hn
);
9967 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
9969 printf (_("<No info available for dynamic symbol number %lu>\n"),
9970 (unsigned long) si
);
9974 psym
= dynamic_symbols
+ si
;
9975 print_vma (psym
->st_value
, LONG_HEX
);
9977 print_vma (psym
->st_size
, DEC_5
);
9979 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9980 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9981 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9982 /* Check to see if any other bits in the st_other field are set.
9983 Note - displaying this information disrupts the layout of the
9984 table being generated, but for the moment this case is very
9986 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9987 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9988 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9989 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9990 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9992 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9997 get_symbol_version_string (FILE *file
, int is_dynsym
,
9999 unsigned long int strtab_size
,
10000 unsigned int si
, Elf_Internal_Sym
*psym
,
10001 enum versioned_symbol_info
*sym_info
,
10002 unsigned short *vna_other
)
10004 const char *version_string
= NULL
;
10007 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10009 unsigned char data
[2];
10010 unsigned short vers_data
;
10011 unsigned long offset
;
10015 offset
= offset_from_vma
10016 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10017 sizeof data
+ si
* sizeof (vers_data
));
10019 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10020 sizeof (data
), 1, _("version data")) == NULL
)
10023 vers_data
= byte_get (data
, 2);
10025 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
10026 && section_headers
[psym
->st_shndx
].sh_type
10029 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10031 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10033 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10034 && (is_nobits
|| ! check_def
))
10036 Elf_External_Verneed evn
;
10037 Elf_Internal_Verneed ivn
;
10038 Elf_Internal_Vernaux ivna
;
10040 /* We must test both. */
10041 offset
= offset_from_vma
10042 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10047 unsigned long vna_off
;
10049 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10050 _("version need")) == NULL
)
10053 ivna
.vna_other
= 0;
10058 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10059 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10061 vna_off
= offset
+ ivn
.vn_aux
;
10065 Elf_External_Vernaux evna
;
10067 if (get_data (&evna
, file
, vna_off
,
10069 _("version need aux (3)")) == NULL
)
10072 ivna
.vna_other
= 0;
10077 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10078 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10079 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10082 vna_off
+= ivna
.vna_next
;
10084 while (ivna
.vna_other
!= vers_data
10085 && ivna
.vna_next
!= 0);
10087 if (ivna
.vna_other
== vers_data
)
10090 offset
+= ivn
.vn_next
;
10092 while (ivn
.vn_next
!= 0);
10094 if (ivna
.vna_other
== vers_data
)
10096 *sym_info
= symbol_undefined
;
10097 *vna_other
= ivna
.vna_other
;
10098 version_string
= (ivna
.vna_name
< strtab_size
10099 ? strtab
+ ivna
.vna_name
10103 else if (! is_nobits
)
10104 error (_("bad dynamic symbol\n"));
10111 if (vers_data
!= 0x8001
10112 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10114 Elf_Internal_Verdef ivd
;
10115 Elf_Internal_Verdaux ivda
;
10116 Elf_External_Verdaux evda
;
10119 off
= offset_from_vma
10121 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10122 sizeof (Elf_External_Verdef
));
10126 Elf_External_Verdef evd
;
10128 if (get_data (&evd
, file
, off
, sizeof (evd
),
10129 1, _("version def")) == NULL
)
10137 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10138 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10139 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10142 off
+= ivd
.vd_next
;
10144 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10145 && ivd
.vd_next
!= 0);
10147 off
-= ivd
.vd_next
;
10150 if (get_data (&evda
, file
, off
, sizeof (evda
),
10151 1, _("version def aux")) == NULL
)
10152 return version_string
;
10154 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10156 if (psym
->st_name
!= ivda
.vda_name
)
10158 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10159 ? symbol_hidden
: symbol_public
);
10160 version_string
= (ivda
.vda_name
< strtab_size
10161 ? strtab
+ ivda
.vda_name
10168 return version_string
;
10171 /* Dump the symbol table. */
10173 process_symbol_table (FILE * file
)
10175 Elf_Internal_Shdr
* section
;
10176 bfd_size_type nbuckets
= 0;
10177 bfd_size_type nchains
= 0;
10178 bfd_vma
* buckets
= NULL
;
10179 bfd_vma
* chains
= NULL
;
10180 bfd_vma ngnubuckets
= 0;
10181 bfd_vma
* gnubuckets
= NULL
;
10182 bfd_vma
* gnuchains
= NULL
;
10183 bfd_vma gnusymidx
= 0;
10184 bfd_size_type ngnuchains
= 0;
10186 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10189 if (dynamic_info
[DT_HASH
]
10191 || (do_using_dynamic
10193 && dynamic_strings
!= NULL
)))
10195 unsigned char nb
[8];
10196 unsigned char nc
[8];
10197 unsigned int hash_ent_size
= 4;
10199 if ((elf_header
.e_machine
== EM_ALPHA
10200 || elf_header
.e_machine
== EM_S390
10201 || elf_header
.e_machine
== EM_S390_OLD
)
10202 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10206 (archive_file_offset
10207 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10208 sizeof nb
+ sizeof nc
)),
10211 error (_("Unable to seek to start of dynamic information\n"));
10215 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10217 error (_("Failed to read in number of buckets\n"));
10221 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10223 error (_("Failed to read in number of chains\n"));
10227 nbuckets
= byte_get (nb
, hash_ent_size
);
10228 nchains
= byte_get (nc
, hash_ent_size
);
10230 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10231 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10234 if (buckets
== NULL
|| chains
== NULL
)
10236 if (do_using_dynamic
)
10247 if (dynamic_info_DT_GNU_HASH
10249 || (do_using_dynamic
10251 && dynamic_strings
!= NULL
)))
10253 unsigned char nb
[16];
10254 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10255 bfd_vma buckets_vma
;
10258 (archive_file_offset
10259 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10263 error (_("Unable to seek to start of dynamic information\n"));
10267 if (fread (nb
, 16, 1, file
) != 1)
10269 error (_("Failed to read in number of buckets\n"));
10273 ngnubuckets
= byte_get (nb
, 4);
10274 gnusymidx
= byte_get (nb
+ 4, 4);
10275 bitmaskwords
= byte_get (nb
+ 8, 4);
10276 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10278 buckets_vma
+= bitmaskwords
* 4;
10280 buckets_vma
+= bitmaskwords
* 8;
10283 (archive_file_offset
10284 + offset_from_vma (file
, buckets_vma
, 4)),
10287 error (_("Unable to seek to start of dynamic information\n"));
10291 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10293 if (gnubuckets
== NULL
)
10296 for (i
= 0; i
< ngnubuckets
; i
++)
10297 if (gnubuckets
[i
] != 0)
10299 if (gnubuckets
[i
] < gnusymidx
)
10302 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10303 maxchain
= gnubuckets
[i
];
10306 if (maxchain
== 0xffffffff)
10309 maxchain
-= gnusymidx
;
10312 (archive_file_offset
10313 + offset_from_vma (file
, buckets_vma
10314 + 4 * (ngnubuckets
+ maxchain
), 4)),
10317 error (_("Unable to seek to start of dynamic information\n"));
10323 if (fread (nb
, 4, 1, file
) != 1)
10325 error (_("Failed to determine last chain length\n"));
10329 if (maxchain
+ 1 == 0)
10334 while ((byte_get (nb
, 4) & 1) == 0);
10337 (archive_file_offset
10338 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10341 error (_("Unable to seek to start of dynamic information\n"));
10345 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10346 ngnuchains
= maxchain
;
10349 if (gnuchains
== NULL
)
10354 if (do_using_dynamic
)
10359 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10361 && do_using_dynamic
10362 && dynamic_strings
!= NULL
10363 && dynamic_symbols
!= NULL
)
10367 if (dynamic_info
[DT_HASH
])
10371 printf (_("\nSymbol table for image:\n"));
10373 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10375 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10377 for (hn
= 0; hn
< nbuckets
; hn
++)
10382 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10383 print_dynamic_symbol (si
, hn
);
10387 if (dynamic_info_DT_GNU_HASH
)
10389 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10391 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10393 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10395 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10396 if (gnubuckets
[hn
] != 0)
10398 bfd_vma si
= gnubuckets
[hn
];
10399 bfd_vma off
= si
- gnusymidx
;
10403 print_dynamic_symbol (si
, hn
);
10406 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10410 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10411 && section_headers
!= NULL
)
10415 for (i
= 0, section
= section_headers
;
10416 i
< elf_header
.e_shnum
;
10420 char * strtab
= NULL
;
10421 unsigned long int strtab_size
= 0;
10422 Elf_Internal_Sym
* symtab
;
10423 Elf_Internal_Sym
* psym
;
10424 unsigned long num_syms
;
10426 if ((section
->sh_type
!= SHT_SYMTAB
10427 && section
->sh_type
!= SHT_DYNSYM
)
10429 && section
->sh_type
== SHT_SYMTAB
))
10432 if (section
->sh_entsize
== 0)
10434 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10435 printable_section_name (section
));
10439 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10440 printable_section_name (section
),
10441 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10444 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10446 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10448 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10449 if (symtab
== NULL
)
10452 if (section
->sh_link
== elf_header
.e_shstrndx
)
10454 strtab
= string_table
;
10455 strtab_size
= string_table_length
;
10457 else if (section
->sh_link
< elf_header
.e_shnum
)
10459 Elf_Internal_Shdr
* string_sec
;
10461 string_sec
= section_headers
+ section
->sh_link
;
10463 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10464 1, string_sec
->sh_size
,
10465 _("string table"));
10466 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10469 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10471 const char *version_string
;
10472 enum versioned_symbol_info sym_info
;
10473 unsigned short vna_other
;
10475 printf ("%6d: ", si
);
10476 print_vma (psym
->st_value
, LONG_HEX
);
10478 print_vma (psym
->st_size
, DEC_5
);
10479 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10480 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10481 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10482 /* Check to see if any other bits in the st_other field are set.
10483 Note - displaying this information disrupts the layout of the
10484 table being generated, but for the moment this case is very rare. */
10485 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10486 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10487 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10488 print_symbol (25, psym
->st_name
< strtab_size
10489 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10492 = get_symbol_version_string (file
,
10493 section
->sh_type
== SHT_DYNSYM
,
10494 strtab
, strtab_size
, si
,
10495 psym
, &sym_info
, &vna_other
);
10496 if (version_string
)
10498 if (sym_info
== symbol_undefined
)
10499 printf ("@%s (%d)", version_string
, vna_other
);
10501 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10509 if (strtab
!= string_table
)
10515 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10517 if (do_histogram
&& buckets
!= NULL
)
10519 unsigned long * lengths
;
10520 unsigned long * counts
;
10523 unsigned long maxlength
= 0;
10524 unsigned long nzero_counts
= 0;
10525 unsigned long nsyms
= 0;
10527 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10528 (unsigned long) nbuckets
);
10530 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10531 if (lengths
== NULL
)
10533 error (_("Out of memory allocating space for histogram buckets\n"));
10537 printf (_(" Length Number %% of total Coverage\n"));
10538 for (hn
= 0; hn
< nbuckets
; ++hn
)
10540 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10543 if (maxlength
< ++lengths
[hn
])
10546 /* PR binutils/17531: A corrupt binary could contain broken
10547 histogram data. Do not go into an infinite loop trying
10549 if (chains
[si
] == si
)
10551 error (_("histogram chain links to itself\n"));
10557 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10558 if (counts
== NULL
)
10561 error (_("Out of memory allocating space for histogram counts\n"));
10565 for (hn
= 0; hn
< nbuckets
; ++hn
)
10566 ++counts
[lengths
[hn
]];
10571 printf (" 0 %-10lu (%5.1f%%)\n",
10572 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10573 for (i
= 1; i
<= maxlength
; ++i
)
10575 nzero_counts
+= counts
[i
] * i
;
10576 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10577 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10578 (nzero_counts
* 100.0) / nsyms
);
10586 if (buckets
!= NULL
)
10592 if (do_histogram
&& gnubuckets
!= NULL
)
10594 unsigned long * lengths
;
10595 unsigned long * counts
;
10597 unsigned long maxlength
= 0;
10598 unsigned long nzero_counts
= 0;
10599 unsigned long nsyms
= 0;
10601 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10602 (unsigned long) ngnubuckets
);
10604 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10605 if (lengths
== NULL
)
10607 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10611 printf (_(" Length Number %% of total Coverage\n"));
10613 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10614 if (gnubuckets
[hn
] != 0)
10616 bfd_vma off
, length
= 1;
10618 for (off
= gnubuckets
[hn
] - gnusymidx
;
10619 /* PR 17531 file: 010-77222-0.004. */
10620 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10623 lengths
[hn
] = length
;
10624 if (length
> maxlength
)
10625 maxlength
= length
;
10629 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10630 if (counts
== NULL
)
10633 error (_("Out of memory allocating space for gnu histogram counts\n"));
10637 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10638 ++counts
[lengths
[hn
]];
10640 if (ngnubuckets
> 0)
10643 printf (" 0 %-10lu (%5.1f%%)\n",
10644 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10645 for (j
= 1; j
<= maxlength
; ++j
)
10647 nzero_counts
+= counts
[j
] * j
;
10648 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10649 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10650 (nzero_counts
* 100.0) / nsyms
);
10664 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10668 if (dynamic_syminfo
== NULL
10670 /* No syminfo, this is ok. */
10673 /* There better should be a dynamic symbol section. */
10674 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10678 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10679 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10681 printf (_(" Num: Name BoundTo Flags\n"));
10682 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10684 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10686 printf ("%4d: ", i
);
10687 if (i
>= num_dynamic_syms
)
10688 printf (_("<corrupt index>"));
10689 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10690 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10692 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10695 switch (dynamic_syminfo
[i
].si_boundto
)
10697 case SYMINFO_BT_SELF
:
10698 fputs ("SELF ", stdout
);
10700 case SYMINFO_BT_PARENT
:
10701 fputs ("PARENT ", stdout
);
10704 if (dynamic_syminfo
[i
].si_boundto
> 0
10705 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10706 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10708 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10712 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10716 if (flags
& SYMINFO_FLG_DIRECT
)
10717 printf (" DIRECT");
10718 if (flags
& SYMINFO_FLG_PASSTHRU
)
10719 printf (" PASSTHRU");
10720 if (flags
& SYMINFO_FLG_COPY
)
10722 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10723 printf (" LAZYLOAD");
10731 /* Check to see if the given reloc needs to be handled in a target specific
10732 manner. If so then process the reloc and return TRUE otherwise return
10736 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10737 unsigned char * start
,
10738 Elf_Internal_Sym
* symtab
)
10740 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10742 switch (elf_header
.e_machine
)
10745 case EM_MSP430_OLD
:
10747 static Elf_Internal_Sym
* saved_sym
= NULL
;
10749 switch (reloc_type
)
10751 case 10: /* R_MSP430_SYM_DIFF */
10752 if (uses_msp430x_relocs ())
10754 case 21: /* R_MSP430X_SYM_DIFF */
10755 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10758 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10759 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10760 goto handle_sym_diff
;
10762 case 5: /* R_MSP430_16_BYTE */
10763 case 9: /* R_MSP430_8 */
10764 if (uses_msp430x_relocs ())
10766 goto handle_sym_diff
;
10768 case 2: /* R_MSP430_ABS16 */
10769 case 15: /* R_MSP430X_ABS16 */
10770 if (! uses_msp430x_relocs ())
10772 goto handle_sym_diff
;
10775 if (saved_sym
!= NULL
)
10779 value
= reloc
->r_addend
10780 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10781 - saved_sym
->st_value
);
10783 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10791 if (saved_sym
!= NULL
)
10792 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10799 case EM_CYGNUS_MN10300
:
10801 static Elf_Internal_Sym
* saved_sym
= NULL
;
10803 switch (reloc_type
)
10805 case 34: /* R_MN10300_ALIGN */
10807 case 33: /* R_MN10300_SYM_DIFF */
10808 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10810 case 1: /* R_MN10300_32 */
10811 case 2: /* R_MN10300_16 */
10812 if (saved_sym
!= NULL
)
10816 value
= reloc
->r_addend
10817 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10818 - saved_sym
->st_value
);
10820 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10827 if (saved_sym
!= NULL
)
10828 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10838 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10839 DWARF debug sections. This is a target specific test. Note - we do not
10840 go through the whole including-target-headers-multiple-times route, (as
10841 we have already done with <elf/h8.h>) because this would become very
10842 messy and even then this function would have to contain target specific
10843 information (the names of the relocs instead of their numeric values).
10844 FIXME: This is not the correct way to solve this problem. The proper way
10845 is to have target specific reloc sizing and typing functions created by
10846 the reloc-macros.h header, in the same way that it already creates the
10847 reloc naming functions. */
10850 is_32bit_abs_reloc (unsigned int reloc_type
)
10852 switch (elf_header
.e_machine
)
10856 return reloc_type
== 1; /* R_386_32. */
10858 return reloc_type
== 1; /* R_68K_32. */
10860 return reloc_type
== 1; /* R_860_32. */
10862 return reloc_type
== 2; /* R_960_32. */
10864 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10866 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10868 return reloc_type
== 1; /* R_ARC_32. */
10870 return reloc_type
== 2; /* R_ARM_ABS32 */
10873 return reloc_type
== 1;
10874 case EM_ADAPTEVA_EPIPHANY
:
10875 return reloc_type
== 3;
10877 return reloc_type
== 0x12; /* R_byte4_data. */
10879 return reloc_type
== 3; /* R_CRIS_32. */
10881 return reloc_type
== 3; /* R_CR16_NUM32. */
10883 return reloc_type
== 15; /* R_CRX_NUM32. */
10884 case EM_CYGNUS_FRV
:
10885 return reloc_type
== 1;
10886 case EM_CYGNUS_D10V
:
10888 return reloc_type
== 6; /* R_D10V_32. */
10889 case EM_CYGNUS_D30V
:
10891 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10893 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10894 case EM_CYGNUS_FR30
:
10896 return reloc_type
== 3; /* R_FR30_32. */
10900 return reloc_type
== 1; /* R_H8_DIR32. */
10902 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10905 return reloc_type
== 2; /* R_IP2K_32. */
10907 return reloc_type
== 2; /* R_IQ2000_32. */
10908 case EM_LATTICEMICO32
:
10909 return reloc_type
== 3; /* R_LM32_32. */
10912 return reloc_type
== 3; /* R_M32C_32. */
10914 return reloc_type
== 34; /* R_M32R_32_RELA. */
10916 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10917 case EM_CYGNUS_MEP
:
10918 return reloc_type
== 4; /* R_MEP_32. */
10920 return reloc_type
== 2; /* R_METAG_ADDR32. */
10921 case EM_MICROBLAZE
:
10922 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10924 return reloc_type
== 2; /* R_MIPS_32. */
10926 return reloc_type
== 4; /* R_MMIX_32. */
10927 case EM_CYGNUS_MN10200
:
10929 return reloc_type
== 1; /* R_MN10200_32. */
10930 case EM_CYGNUS_MN10300
:
10932 return reloc_type
== 1; /* R_MN10300_32. */
10934 return reloc_type
== 1; /* R_MOXIE_32. */
10935 case EM_MSP430_OLD
:
10937 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10939 return reloc_type
== 2; /* R_MT_32. */
10941 return reloc_type
== 20; /* R_NDS32_RELA. */
10942 case EM_ALTERA_NIOS2
:
10943 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10945 return reloc_type
== 1; /* R_NIOS_32. */
10947 return reloc_type
== 1; /* R_OR1K_32. */
10949 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10950 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10953 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10955 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10957 return reloc_type
== 1; /* R_PPC_ADDR32. */
10959 return reloc_type
== 1; /* R_RL78_DIR32. */
10961 return reloc_type
== 1; /* R_RX_DIR32. */
10963 return reloc_type
== 1; /* R_I370_ADDR31. */
10966 return reloc_type
== 4; /* R_S390_32. */
10968 return reloc_type
== 8; /* R_SCORE_ABS32. */
10970 return reloc_type
== 1; /* R_SH_DIR32. */
10971 case EM_SPARC32PLUS
:
10974 return reloc_type
== 3 /* R_SPARC_32. */
10975 || reloc_type
== 23; /* R_SPARC_UA32. */
10977 return reloc_type
== 6; /* R_SPU_ADDR32 */
10979 return reloc_type
== 1; /* R_C6000_ABS32. */
10981 return reloc_type
== 2; /* R_TILEGX_32. */
10983 return reloc_type
== 1; /* R_TILEPRO_32. */
10984 case EM_CYGNUS_V850
:
10986 return reloc_type
== 6; /* R_V850_ABS32. */
10988 return reloc_type
== 0x33; /* R_V810_WORD. */
10990 return reloc_type
== 1; /* R_VAX_32. */
10994 return reloc_type
== 10; /* R_X86_64_32. */
10997 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10999 return reloc_type
== 4; /* R_XGATE_32. */
11001 return reloc_type
== 1; /* R_XSTROMY16_32. */
11002 case EM_XTENSA_OLD
:
11004 return reloc_type
== 1; /* R_XTENSA_32. */
11007 static unsigned int prev_warn
= 0;
11009 /* Avoid repeating the same warning multiple times. */
11010 if (prev_warn
!= elf_header
.e_machine
)
11011 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11012 elf_header
.e_machine
);
11013 prev_warn
= elf_header
.e_machine
;
11019 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11020 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11023 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11025 switch (elf_header
.e_machine
)
11029 return reloc_type
== 2; /* R_386_PC32. */
11031 return reloc_type
== 4; /* R_68K_PC32. */
11033 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11034 case EM_ADAPTEVA_EPIPHANY
:
11035 return reloc_type
== 6;
11037 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11039 return reloc_type
== 3; /* R_ARM_REL32 */
11040 case EM_MICROBLAZE
:
11041 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11043 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11045 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11047 return reloc_type
== 26; /* R_PPC_REL32. */
11049 return reloc_type
== 26; /* R_PPC64_REL32. */
11052 return reloc_type
== 5; /* R_390_PC32. */
11054 return reloc_type
== 2; /* R_SH_REL32. */
11055 case EM_SPARC32PLUS
:
11058 return reloc_type
== 6; /* R_SPARC_DISP32. */
11060 return reloc_type
== 13; /* R_SPU_REL32. */
11062 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11064 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11068 return reloc_type
== 2; /* R_X86_64_PC32. */
11069 case EM_XTENSA_OLD
:
11071 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11073 /* Do not abort or issue an error message here. Not all targets use
11074 pc-relative 32-bit relocs in their DWARF debug information and we
11075 have already tested for target coverage in is_32bit_abs_reloc. A
11076 more helpful warning message will be generated by apply_relocations
11077 anyway, so just return. */
11082 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11083 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11086 is_64bit_abs_reloc (unsigned int reloc_type
)
11088 switch (elf_header
.e_machine
)
11091 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11093 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11095 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11097 return reloc_type
== 80; /* R_PARISC_DIR64. */
11099 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11100 case EM_SPARC32PLUS
:
11103 return reloc_type
== 54; /* R_SPARC_UA64. */
11107 return reloc_type
== 1; /* R_X86_64_64. */
11110 return reloc_type
== 22; /* R_S390_64. */
11112 return reloc_type
== 1; /* R_TILEGX_64. */
11114 return reloc_type
== 18; /* R_MIPS_64. */
11120 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11121 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11124 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11126 switch (elf_header
.e_machine
)
11129 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11131 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11133 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11135 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11137 return reloc_type
== 44; /* R_PPC64_REL64. */
11138 case EM_SPARC32PLUS
:
11141 return reloc_type
== 46; /* R_SPARC_DISP64. */
11145 return reloc_type
== 24; /* R_X86_64_PC64. */
11148 return reloc_type
== 23; /* R_S390_PC64. */
11150 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11156 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11157 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11160 is_24bit_abs_reloc (unsigned int reloc_type
)
11162 switch (elf_header
.e_machine
)
11164 case EM_CYGNUS_MN10200
:
11166 return reloc_type
== 4; /* R_MN10200_24. */
11172 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11173 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11176 is_16bit_abs_reloc (unsigned int reloc_type
)
11178 switch (elf_header
.e_machine
)
11182 return reloc_type
== 4; /* R_AVR_16. */
11183 case EM_ADAPTEVA_EPIPHANY
:
11184 return reloc_type
== 5;
11185 case EM_CYGNUS_D10V
:
11187 return reloc_type
== 3; /* R_D10V_16. */
11191 return reloc_type
== R_H8_DIR16
;
11194 return reloc_type
== 1; /* R_IP2K_16. */
11197 return reloc_type
== 1; /* R_M32C_16 */
11199 if (uses_msp430x_relocs ())
11200 return reloc_type
== 2; /* R_MSP430_ABS16. */
11201 case EM_MSP430_OLD
:
11202 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11204 return reloc_type
== 19; /* R_NDS32_RELA. */
11205 case EM_ALTERA_NIOS2
:
11206 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11208 return reloc_type
== 9; /* R_NIOS_16. */
11210 return reloc_type
== 2; /* R_OR1K_16. */
11212 return reloc_type
== 2; /* R_C6000_ABS16. */
11215 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11216 case EM_CYGNUS_MN10200
:
11218 return reloc_type
== 2; /* R_MN10200_16. */
11219 case EM_CYGNUS_MN10300
:
11221 return reloc_type
== 2; /* R_MN10300_16. */
11223 return reloc_type
== 3; /* R_XGATE_16. */
11229 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11230 relocation entries (possibly formerly used for SHT_GROUP sections). */
11233 is_none_reloc (unsigned int reloc_type
)
11235 switch (elf_header
.e_machine
)
11237 case EM_68K
: /* R_68K_NONE. */
11238 case EM_386
: /* R_386_NONE. */
11239 case EM_SPARC32PLUS
:
11241 case EM_SPARC
: /* R_SPARC_NONE. */
11242 case EM_MIPS
: /* R_MIPS_NONE. */
11243 case EM_PARISC
: /* R_PARISC_NONE. */
11244 case EM_ALPHA
: /* R_ALPHA_NONE. */
11245 case EM_ADAPTEVA_EPIPHANY
:
11246 case EM_PPC
: /* R_PPC_NONE. */
11247 case EM_PPC64
: /* R_PPC64_NONE. */
11248 case EM_ARM
: /* R_ARM_NONE. */
11249 case EM_IA_64
: /* R_IA64_NONE. */
11250 case EM_SH
: /* R_SH_NONE. */
11252 case EM_S390
: /* R_390_NONE. */
11253 case EM_CRIS
: /* R_CRIS_NONE. */
11254 case EM_X86_64
: /* R_X86_64_NONE. */
11255 case EM_L1OM
: /* R_X86_64_NONE. */
11256 case EM_K1OM
: /* R_X86_64_NONE. */
11257 case EM_MN10300
: /* R_MN10300_NONE. */
11258 case EM_MOXIE
: /* R_MOXIE_NONE. */
11259 case EM_M32R
: /* R_M32R_NONE. */
11260 case EM_TI_C6000
:/* R_C6000_NONE. */
11261 case EM_TILEGX
: /* R_TILEGX_NONE. */
11262 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11264 case EM_C166
: /* R_XC16X_NONE. */
11265 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11266 case EM_NIOS32
: /* R_NIOS_NONE. */
11267 case EM_OR1K
: /* R_OR1K_NONE. */
11268 return reloc_type
== 0;
11270 return reloc_type
== 0 || reloc_type
== 256;
11272 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11273 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11274 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11275 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11276 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11277 case EM_XTENSA_OLD
:
11279 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11280 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11281 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11282 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11284 return reloc_type
== 3; /* R_METAG_NONE. */
11289 /* Apply relocations to a section.
11290 Note: So far support has been added only for those relocations
11291 which can be found in debug sections.
11292 FIXME: Add support for more relocations ? */
11295 apply_relocations (void * file
,
11296 Elf_Internal_Shdr
* section
,
11297 unsigned char * start
)
11299 Elf_Internal_Shdr
* relsec
;
11300 unsigned char * end
= start
+ section
->sh_size
;
11302 if (elf_header
.e_type
!= ET_REL
)
11305 /* Find the reloc section associated with the section. */
11306 for (relsec
= section_headers
;
11307 relsec
< section_headers
+ elf_header
.e_shnum
;
11310 bfd_boolean is_rela
;
11311 unsigned long num_relocs
;
11312 Elf_Internal_Rela
* relocs
;
11313 Elf_Internal_Rela
* rp
;
11314 Elf_Internal_Shdr
* symsec
;
11315 Elf_Internal_Sym
* symtab
;
11316 unsigned long num_syms
;
11317 Elf_Internal_Sym
* sym
;
11319 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11320 || relsec
->sh_info
>= elf_header
.e_shnum
11321 || section_headers
+ relsec
->sh_info
!= section
11322 || relsec
->sh_size
== 0
11323 || relsec
->sh_link
>= elf_header
.e_shnum
)
11326 is_rela
= relsec
->sh_type
== SHT_RELA
;
11330 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11331 relsec
->sh_size
, & relocs
, & num_relocs
))
11336 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11337 relsec
->sh_size
, & relocs
, & num_relocs
))
11341 /* SH uses RELA but uses in place value instead of the addend field. */
11342 if (elf_header
.e_machine
== EM_SH
)
11345 symsec
= section_headers
+ relsec
->sh_link
;
11346 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11348 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11351 unsigned int reloc_type
;
11352 unsigned int reloc_size
;
11353 unsigned char * rloc
;
11354 unsigned long sym_index
;
11356 reloc_type
= get_reloc_type (rp
->r_info
);
11358 if (target_specific_reloc_handling (rp
, start
, symtab
))
11360 else if (is_none_reloc (reloc_type
))
11362 else if (is_32bit_abs_reloc (reloc_type
)
11363 || is_32bit_pcrel_reloc (reloc_type
))
11365 else if (is_64bit_abs_reloc (reloc_type
)
11366 || is_64bit_pcrel_reloc (reloc_type
))
11368 else if (is_24bit_abs_reloc (reloc_type
))
11370 else if (is_16bit_abs_reloc (reloc_type
))
11374 static unsigned int prev_reloc
= 0;
11375 if (reloc_type
!= prev_reloc
)
11376 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11377 reloc_type
, printable_section_name (section
));
11378 prev_reloc
= reloc_type
;
11382 rloc
= start
+ rp
->r_offset
;
11383 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11385 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11386 (unsigned long) rp
->r_offset
,
11387 printable_section_name (section
));
11391 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11392 if (sym_index
>= num_syms
)
11394 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11395 sym_index
, printable_section_name (section
));
11398 sym
= symtab
+ sym_index
;
11400 /* If the reloc has a symbol associated with it,
11401 make sure that it is of an appropriate type.
11403 Relocations against symbols without type can happen.
11404 Gcc -feliminate-dwarf2-dups may generate symbols
11405 without type for debug info.
11407 Icc generates relocations against function symbols
11408 instead of local labels.
11410 Relocations against object symbols can happen, eg when
11411 referencing a global array. For an example of this see
11412 the _clz.o binary in libgcc.a. */
11414 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11416 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11417 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11418 (long int)(rp
- relocs
),
11419 printable_section_name (relsec
));
11425 addend
+= rp
->r_addend
;
11426 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11427 partial_inplace. */
11429 || (elf_header
.e_machine
== EM_XTENSA
11430 && reloc_type
== 1)
11431 || ((elf_header
.e_machine
== EM_PJ
11432 || elf_header
.e_machine
== EM_PJ_OLD
)
11433 && reloc_type
== 1)
11434 || ((elf_header
.e_machine
== EM_D30V
11435 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11436 && reloc_type
== 12))
11437 addend
+= byte_get (rloc
, reloc_size
);
11439 if (is_32bit_pcrel_reloc (reloc_type
)
11440 || is_64bit_pcrel_reloc (reloc_type
))
11442 /* On HPPA, all pc-relative relocations are biased by 8. */
11443 if (elf_header
.e_machine
== EM_PARISC
)
11445 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11449 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11458 #ifdef SUPPORT_DISASSEMBLY
11460 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11462 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11464 /* FIXME: XXX -- to be done --- XXX */
11470 /* Reads in the contents of SECTION from FILE, returning a pointer
11471 to a malloc'ed buffer or NULL if something went wrong. */
11474 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11476 bfd_size_type num_bytes
;
11478 num_bytes
= section
->sh_size
;
11480 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11482 printf (_("\nSection '%s' has no data to dump.\n"),
11483 printable_section_name (section
));
11487 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11488 _("section contents"));
11493 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11495 Elf_Internal_Shdr
* relsec
;
11496 bfd_size_type num_bytes
;
11500 bfd_boolean some_strings_shown
;
11502 start
= get_section_contents (section
, file
);
11506 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11508 /* If the section being dumped has relocations against it the user might
11509 be expecting these relocations to have been applied. Check for this
11510 case and issue a warning message in order to avoid confusion.
11511 FIXME: Maybe we ought to have an option that dumps a section with
11512 relocs applied ? */
11513 for (relsec
= section_headers
;
11514 relsec
< section_headers
+ elf_header
.e_shnum
;
11517 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11518 || relsec
->sh_info
>= elf_header
.e_shnum
11519 || section_headers
+ relsec
->sh_info
!= section
11520 || relsec
->sh_size
== 0
11521 || relsec
->sh_link
>= elf_header
.e_shnum
)
11524 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11528 num_bytes
= section
->sh_size
;
11530 end
= start
+ num_bytes
;
11531 some_strings_shown
= FALSE
;
11535 while (!ISPRINT (* data
))
11536 if (++ data
>= end
)
11541 size_t maxlen
= end
- data
;
11544 /* PR 11128: Use two separate invocations in order to work
11545 around bugs in the Solaris 8 implementation of printf. */
11546 printf (" [%6tx] ", data
- start
);
11548 printf (" [%6Ix] ", (size_t) (data
- start
));
11552 print_symbol ((int) maxlen
, data
);
11554 data
+= strnlen (data
, maxlen
);
11558 printf (_("<corrupt>\n"));
11561 some_strings_shown
= TRUE
;
11565 if (! some_strings_shown
)
11566 printf (_(" No strings found in this section."));
11574 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11576 bfd_boolean relocate
)
11578 Elf_Internal_Shdr
* relsec
;
11579 bfd_size_type bytes
;
11581 unsigned char * data
;
11582 unsigned char * start
;
11584 start
= (unsigned char *) get_section_contents (section
, file
);
11588 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11592 apply_relocations (file
, section
, start
);
11596 /* If the section being dumped has relocations against it the user might
11597 be expecting these relocations to have been applied. Check for this
11598 case and issue a warning message in order to avoid confusion.
11599 FIXME: Maybe we ought to have an option that dumps a section with
11600 relocs applied ? */
11601 for (relsec
= section_headers
;
11602 relsec
< section_headers
+ elf_header
.e_shnum
;
11605 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11606 || relsec
->sh_info
>= elf_header
.e_shnum
11607 || section_headers
+ relsec
->sh_info
!= section
11608 || relsec
->sh_size
== 0
11609 || relsec
->sh_link
>= elf_header
.e_shnum
)
11612 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11617 addr
= section
->sh_addr
;
11618 bytes
= section
->sh_size
;
11627 lbytes
= (bytes
> 16 ? 16 : bytes
);
11629 printf (" 0x%8.8lx ", (unsigned long) addr
);
11631 for (j
= 0; j
< 16; j
++)
11634 printf ("%2.2x", data
[j
]);
11642 for (j
= 0; j
< lbytes
; j
++)
11645 if (k
>= ' ' && k
< 0x7f)
11663 /* Uncompresses a section that was compressed using zlib, in place. */
11666 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11667 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11669 #ifndef HAVE_ZLIB_H
11672 dwarf_size_type compressed_size
= *size
;
11673 unsigned char * compressed_buffer
= *buffer
;
11674 dwarf_size_type uncompressed_size
;
11675 unsigned char * uncompressed_buffer
;
11678 dwarf_size_type header_size
= 12;
11680 /* Read the zlib header. In this case, it should be "ZLIB" followed
11681 by the uncompressed section size, 8 bytes in big-endian order. */
11682 if (compressed_size
< header_size
11683 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11686 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11687 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11688 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11689 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11690 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11691 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11692 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11693 uncompressed_size
+= compressed_buffer
[11];
11695 /* It is possible the section consists of several compressed
11696 buffers concatenated together, so we uncompress in a loop. */
11697 strm
.zalloc
= NULL
;
11699 strm
.opaque
= NULL
;
11700 strm
.avail_in
= compressed_size
- header_size
;
11701 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11702 strm
.avail_out
= uncompressed_size
;
11703 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11705 rc
= inflateInit (& strm
);
11706 while (strm
.avail_in
> 0)
11710 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11711 + (uncompressed_size
- strm
.avail_out
));
11712 rc
= inflate (&strm
, Z_FINISH
);
11713 if (rc
!= Z_STREAM_END
)
11715 rc
= inflateReset (& strm
);
11717 rc
= inflateEnd (& strm
);
11719 || strm
.avail_out
!= 0)
11722 free (compressed_buffer
);
11723 *buffer
= uncompressed_buffer
;
11724 *size
= uncompressed_size
;
11728 free (uncompressed_buffer
);
11729 /* Indicate decompression failure. */
11732 #endif /* HAVE_ZLIB_H */
11736 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11737 Elf_Internal_Shdr
* sec
, void * file
)
11739 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11742 /* If it is already loaded, do nothing. */
11743 if (section
->start
!= NULL
)
11746 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11747 section
->address
= sec
->sh_addr
;
11748 section
->user_data
= NULL
;
11749 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11751 sec
->sh_size
, buf
);
11752 if (section
->start
== NULL
)
11756 section
->size
= sec
->sh_size
;
11757 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11758 sec
->sh_size
= section
->size
;
11761 if (section
->start
== NULL
)
11764 if (debug_displays
[debug
].relocate
)
11765 apply_relocations ((FILE *) file
, sec
, section
->start
);
11770 /* If this is not NULL, load_debug_section will only look for sections
11771 within the list of sections given here. */
11772 unsigned int *section_subset
= NULL
;
11775 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11777 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11778 Elf_Internal_Shdr
* sec
;
11780 /* Locate the debug section. */
11781 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11783 section
->name
= section
->uncompressed_name
;
11786 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11788 section
->name
= section
->compressed_name
;
11793 /* If we're loading from a subset of sections, and we've loaded
11794 a section matching this name before, it's likely that it's a
11796 if (section_subset
!= NULL
)
11797 free_debug_section (debug
);
11799 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11803 free_debug_section (enum dwarf_section_display_enum debug
)
11805 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11807 if (section
->start
== NULL
)
11810 free ((char *) section
->start
);
11811 section
->start
= NULL
;
11812 section
->address
= 0;
11817 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11819 char * name
= SECTION_NAME (section
);
11820 const char * print_name
= printable_section_name (section
);
11821 bfd_size_type length
;
11825 length
= section
->sh_size
;
11828 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
11831 if (section
->sh_type
== SHT_NOBITS
)
11833 /* There is no point in dumping the contents of a debugging section
11834 which has the NOBITS type - the bits in the file will be random.
11835 This can happen when a file containing a .eh_frame section is
11836 stripped with the --only-keep-debug command line option. */
11837 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11842 if (const_strneq (name
, ".gnu.linkonce.wi."))
11843 name
= ".debug_info";
11845 /* See if we know how to display the contents of this section. */
11846 for (i
= 0; i
< max
; i
++)
11847 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11848 || (i
== line
&& const_strneq (name
, ".debug_line."))
11849 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11851 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11852 int secondary
= (section
!= find_section (name
));
11855 free_debug_section ((enum dwarf_section_display_enum
) i
);
11857 if (i
== line
&& const_strneq (name
, ".debug_line."))
11859 else if (streq (sec
->uncompressed_name
, name
))
11860 sec
->name
= sec
->uncompressed_name
;
11862 sec
->name
= sec
->compressed_name
;
11863 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11866 /* If this debug section is part of a CU/TU set in a .dwp file,
11867 restrict load_debug_section to the sections in that set. */
11868 section_subset
= find_cu_tu_set (file
, shndx
);
11870 result
&= debug_displays
[i
].display (sec
, file
);
11872 section_subset
= NULL
;
11874 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11875 free_debug_section ((enum dwarf_section_display_enum
) i
);
11883 printf (_("Unrecognized debug section: %s\n"), print_name
);
11890 /* Set DUMP_SECTS for all sections where dumps were requested
11891 based on section name. */
11894 initialise_dumps_byname (void)
11896 struct dump_list_entry
* cur
;
11898 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11903 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11904 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11906 request_dump_bynumber (i
, cur
->type
);
11911 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11917 process_section_contents (FILE * file
)
11919 Elf_Internal_Shdr
* section
;
11925 initialise_dumps_byname ();
11927 for (i
= 0, section
= section_headers
;
11928 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11931 #ifdef SUPPORT_DISASSEMBLY
11932 if (dump_sects
[i
] & DISASS_DUMP
)
11933 disassemble_section (section
, file
);
11935 if (dump_sects
[i
] & HEX_DUMP
)
11936 dump_section_as_bytes (section
, file
, FALSE
);
11938 if (dump_sects
[i
] & RELOC_DUMP
)
11939 dump_section_as_bytes (section
, file
, TRUE
);
11941 if (dump_sects
[i
] & STRING_DUMP
)
11942 dump_section_as_strings (section
, file
);
11944 if (dump_sects
[i
] & DEBUG_DUMP
)
11945 display_debug_section (i
, section
, file
);
11948 /* Check to see if the user requested a
11949 dump of a section that does not exist. */
11950 while (i
++ < num_dump_sects
)
11952 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11956 process_mips_fpe_exception (int mask
)
11961 if (mask
& OEX_FPU_INEX
)
11962 fputs ("INEX", stdout
), first
= 0;
11963 if (mask
& OEX_FPU_UFLO
)
11964 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11965 if (mask
& OEX_FPU_OFLO
)
11966 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11967 if (mask
& OEX_FPU_DIV0
)
11968 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11969 if (mask
& OEX_FPU_INVAL
)
11970 printf ("%sINVAL", first
? "" : "|");
11973 fputs ("0", stdout
);
11976 /* Display's the value of TAG at location P. If TAG is
11977 greater than 0 it is assumed to be an unknown tag, and
11978 a message is printed to this effect. Otherwise it is
11979 assumed that a message has already been printed.
11981 If the bottom bit of TAG is set it assumed to have a
11982 string value, otherwise it is assumed to have an integer
11985 Returns an updated P pointing to the first unread byte
11986 beyond the end of TAG's value.
11988 Reads at or beyond END will not be made. */
11990 static unsigned char *
11991 display_tag_value (int tag
,
11993 const unsigned char * const end
)
11998 printf (" Tag_unknown_%d: ", tag
);
12002 warn (_("<corrupt tag>\n"));
12006 /* PR 17531 file: 027-19978-0.004. */
12007 size_t maxlen
= (end
- p
) - 1;
12012 print_symbol ((int) maxlen
, (const char *) p
);
12013 p
+= strnlen ((char *) p
, maxlen
) + 1;
12017 printf (_("<corrupt string tag>"));
12018 p
= (unsigned char *) end
;
12026 val
= read_uleb128 (p
, &len
, end
);
12028 printf ("%ld (0x%lx)\n", val
, val
);
12035 /* ARM EABI attributes section. */
12040 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12042 const char ** table
;
12043 } arm_attr_public_tag
;
12045 static const char * arm_attr_tag_CPU_arch
[] =
12046 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12047 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12048 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12049 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12050 {"No", "Thumb-1", "Thumb-2"};
12051 static const char * arm_attr_tag_FP_arch
[] =
12052 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12053 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12054 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12055 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12056 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12057 static const char * arm_attr_tag_PCS_config
[] =
12058 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12059 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12060 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12061 {"V6", "SB", "TLS", "Unused"};
12062 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12063 {"Absolute", "PC-relative", "SB-relative", "None"};
12064 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12065 {"Absolute", "PC-relative", "None"};
12066 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12067 {"None", "direct", "GOT-indirect"};
12068 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12069 {"None", "??? 1", "2", "??? 3", "4"};
12070 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12071 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12072 {"Unused", "Needed", "Sign only"};
12073 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12074 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12075 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12076 {"Unused", "Finite", "RTABI", "IEEE 754"};
12077 static const char * arm_attr_tag_ABI_enum_size
[] =
12078 {"Unused", "small", "int", "forced to int"};
12079 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12080 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12081 static const char * arm_attr_tag_ABI_VFP_args
[] =
12082 {"AAPCS", "VFP registers", "custom"};
12083 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12084 {"AAPCS", "WMMX registers", "custom"};
12085 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12086 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12087 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12088 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12089 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12090 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12091 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12092 static const char * arm_attr_tag_FP_HP_extension
[] =
12093 {"Not Allowed", "Allowed"};
12094 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12095 {"None", "IEEE 754", "Alternative Format"};
12096 static const char * arm_attr_tag_MPextension_use
[] =
12097 {"Not Allowed", "Allowed"};
12098 static const char * arm_attr_tag_DIV_use
[] =
12099 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12100 "Allowed in v7-A with integer division extension"};
12101 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12102 static const char * arm_attr_tag_Virtualization_use
[] =
12103 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12104 "TrustZone and Virtualization Extensions"};
12105 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12106 {"Not Allowed", "Allowed"};
12108 #define LOOKUP(id, name) \
12109 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12110 static arm_attr_public_tag arm_attr_public_tags
[] =
12112 {4, "CPU_raw_name", 1, NULL
},
12113 {5, "CPU_name", 1, NULL
},
12114 LOOKUP(6, CPU_arch
),
12115 {7, "CPU_arch_profile", 0, NULL
},
12116 LOOKUP(8, ARM_ISA_use
),
12117 LOOKUP(9, THUMB_ISA_use
),
12118 LOOKUP(10, FP_arch
),
12119 LOOKUP(11, WMMX_arch
),
12120 LOOKUP(12, Advanced_SIMD_arch
),
12121 LOOKUP(13, PCS_config
),
12122 LOOKUP(14, ABI_PCS_R9_use
),
12123 LOOKUP(15, ABI_PCS_RW_data
),
12124 LOOKUP(16, ABI_PCS_RO_data
),
12125 LOOKUP(17, ABI_PCS_GOT_use
),
12126 LOOKUP(18, ABI_PCS_wchar_t
),
12127 LOOKUP(19, ABI_FP_rounding
),
12128 LOOKUP(20, ABI_FP_denormal
),
12129 LOOKUP(21, ABI_FP_exceptions
),
12130 LOOKUP(22, ABI_FP_user_exceptions
),
12131 LOOKUP(23, ABI_FP_number_model
),
12132 {24, "ABI_align_needed", 0, NULL
},
12133 {25, "ABI_align_preserved", 0, NULL
},
12134 LOOKUP(26, ABI_enum_size
),
12135 LOOKUP(27, ABI_HardFP_use
),
12136 LOOKUP(28, ABI_VFP_args
),
12137 LOOKUP(29, ABI_WMMX_args
),
12138 LOOKUP(30, ABI_optimization_goals
),
12139 LOOKUP(31, ABI_FP_optimization_goals
),
12140 {32, "compatibility", 0, NULL
},
12141 LOOKUP(34, CPU_unaligned_access
),
12142 LOOKUP(36, FP_HP_extension
),
12143 LOOKUP(38, ABI_FP_16bit_format
),
12144 LOOKUP(42, MPextension_use
),
12145 LOOKUP(44, DIV_use
),
12146 {64, "nodefaults", 0, NULL
},
12147 {65, "also_compatible_with", 0, NULL
},
12148 LOOKUP(66, T2EE_use
),
12149 {67, "conformance", 1, NULL
},
12150 LOOKUP(68, Virtualization_use
),
12151 LOOKUP(70, MPextension_use_legacy
)
12155 static unsigned char *
12156 display_arm_attribute (unsigned char * p
,
12157 const unsigned char * const end
)
12162 arm_attr_public_tag
* attr
;
12166 tag
= read_uleb128 (p
, &len
, end
);
12169 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12171 if (arm_attr_public_tags
[i
].tag
== tag
)
12173 attr
= &arm_attr_public_tags
[i
];
12180 printf (" Tag_%s: ", attr
->name
);
12181 switch (attr
->type
)
12186 case 7: /* Tag_CPU_arch_profile. */
12187 val
= read_uleb128 (p
, &len
, end
);
12191 case 0: printf (_("None\n")); break;
12192 case 'A': printf (_("Application\n")); break;
12193 case 'R': printf (_("Realtime\n")); break;
12194 case 'M': printf (_("Microcontroller\n")); break;
12195 case 'S': printf (_("Application or Realtime\n")); break;
12196 default: printf ("??? (%d)\n", val
); break;
12200 case 24: /* Tag_align_needed. */
12201 val
= read_uleb128 (p
, &len
, end
);
12205 case 0: printf (_("None\n")); break;
12206 case 1: printf (_("8-byte\n")); break;
12207 case 2: printf (_("4-byte\n")); break;
12208 case 3: printf ("??? 3\n"); break;
12211 printf (_("8-byte and up to %d-byte extended\n"),
12214 printf ("??? (%d)\n", val
);
12219 case 25: /* Tag_align_preserved. */
12220 val
= read_uleb128 (p
, &len
, end
);
12224 case 0: printf (_("None\n")); break;
12225 case 1: printf (_("8-byte, except leaf SP\n")); break;
12226 case 2: printf (_("8-byte\n")); break;
12227 case 3: printf ("??? 3\n"); break;
12230 printf (_("8-byte and up to %d-byte extended\n"),
12233 printf ("??? (%d)\n", val
);
12238 case 32: /* Tag_compatibility. */
12240 val
= read_uleb128 (p
, &len
, end
);
12242 printf (_("flag = %d, vendor = "), val
);
12245 size_t maxlen
= (end
- p
) - 1;
12247 print_symbol ((int) maxlen
, (const char *) p
);
12248 p
+= strnlen ((char *) p
, maxlen
) + 1;
12252 printf (_("<corrupt>"));
12253 p
= (unsigned char *) end
;
12259 case 64: /* Tag_nodefaults. */
12260 /* PR 17531: file: 001-505008-0.01. */
12263 printf (_("True\n"));
12266 case 65: /* Tag_also_compatible_with. */
12267 val
= read_uleb128 (p
, &len
, end
);
12269 if (val
== 6 /* Tag_CPU_arch. */)
12271 val
= read_uleb128 (p
, &len
, end
);
12273 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12274 printf ("??? (%d)\n", val
);
12276 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12280 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12285 printf (_("<unknown: %d>\n"), tag
);
12291 return display_tag_value (-1, p
, end
);
12293 return display_tag_value (0, p
, end
);
12296 assert (attr
->type
& 0x80);
12297 val
= read_uleb128 (p
, &len
, end
);
12299 type
= attr
->type
& 0x7f;
12301 printf ("??? (%d)\n", val
);
12303 printf ("%s\n", attr
->table
[val
]);
12308 return display_tag_value (tag
, p
, end
);
12311 static unsigned char *
12312 display_gnu_attribute (unsigned char * p
,
12313 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12314 const unsigned char * const end
)
12320 tag
= read_uleb128 (p
, &len
, end
);
12323 /* Tag_compatibility is the only generic GNU attribute defined at
12327 val
= read_uleb128 (p
, &len
, end
);
12330 printf (_("flag = %d, vendor = "), val
);
12333 printf (_("<corrupt>\n"));
12334 warn (_("corrupt vendor attribute\n"));
12340 size_t maxlen
= (end
- p
) - 1;
12342 print_symbol ((int) maxlen
, (const char *) p
);
12343 p
+= strnlen ((char *) p
, maxlen
) + 1;
12347 printf (_("<corrupt>"));
12348 p
= (unsigned char *) end
;
12355 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12356 return display_proc_gnu_attribute (p
, tag
, end
);
12358 return display_tag_value (tag
, p
, end
);
12361 static unsigned char *
12362 display_power_gnu_attribute (unsigned char * p
,
12364 const unsigned char * const end
)
12369 if (tag
== Tag_GNU_Power_ABI_FP
)
12371 val
= read_uleb128 (p
, &len
, end
);
12373 printf (" Tag_GNU_Power_ABI_FP: ");
12378 printf (_("Hard or soft float\n"));
12381 printf (_("Hard float\n"));
12384 printf (_("Soft float\n"));
12387 printf (_("Single-precision hard float\n"));
12390 printf ("??? (%d)\n", val
);
12396 if (tag
== Tag_GNU_Power_ABI_Vector
)
12398 val
= read_uleb128 (p
, &len
, end
);
12400 printf (" Tag_GNU_Power_ABI_Vector: ");
12404 printf (_("Any\n"));
12407 printf (_("Generic\n"));
12410 printf ("AltiVec\n");
12416 printf ("??? (%d)\n", val
);
12422 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12426 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12430 val
= read_uleb128 (p
, &len
, end
);
12432 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12436 printf (_("Any\n"));
12439 printf ("r3/r4\n");
12442 printf (_("Memory\n"));
12445 printf ("??? (%d)\n", val
);
12451 return display_tag_value (tag
& 1, p
, end
);
12455 display_sparc_hwcaps (int mask
)
12461 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12462 fputs ("mul32", stdout
), first
= 0;
12463 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12464 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12465 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12466 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12467 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12468 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12469 if (mask
& ELF_SPARC_HWCAP_POPC
)
12470 printf ("%spopc", first
? "" : "|"), first
= 0;
12471 if (mask
& ELF_SPARC_HWCAP_VIS
)
12472 printf ("%svis", first
? "" : "|"), first
= 0;
12473 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12474 printf ("%svis2", first
? "" : "|"), first
= 0;
12475 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12476 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12477 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12478 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12479 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12480 printf ("%svis3", first
? "" : "|"), first
= 0;
12481 if (mask
& ELF_SPARC_HWCAP_HPC
)
12482 printf ("%shpc", first
? "" : "|"), first
= 0;
12483 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12484 printf ("%srandom", first
? "" : "|"), first
= 0;
12485 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12486 printf ("%strans", first
? "" : "|"), first
= 0;
12487 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12488 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12489 if (mask
& ELF_SPARC_HWCAP_IMA
)
12490 printf ("%sima", first
? "" : "|"), first
= 0;
12491 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12492 printf ("%scspare", first
? "" : "|"), first
= 0;
12495 fputc ('0', stdout
);
12496 fputc ('\n', stdout
);
12500 display_sparc_hwcaps2 (int mask
)
12506 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12507 fputs ("fjathplus", stdout
), first
= 0;
12508 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12509 printf ("%svis3b", first
? "" : "|"), first
= 0;
12510 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12511 printf ("%sadp", first
? "" : "|"), first
= 0;
12512 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12513 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12514 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12515 printf ("%smwait", first
? "" : "|"), first
= 0;
12516 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12517 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12518 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12519 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12520 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12521 printf ("%snsec", first
? "" : "|"), first
= 0;
12522 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12523 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12524 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12525 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12526 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12527 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12530 fputc ('0', stdout
);
12531 fputc ('\n', stdout
);
12534 static unsigned char *
12535 display_sparc_gnu_attribute (unsigned char * p
,
12537 const unsigned char * const end
)
12542 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12544 val
= read_uleb128 (p
, &len
, end
);
12546 printf (" Tag_GNU_Sparc_HWCAPS: ");
12547 display_sparc_hwcaps (val
);
12550 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12552 val
= read_uleb128 (p
, &len
, end
);
12554 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12555 display_sparc_hwcaps2 (val
);
12559 return display_tag_value (tag
, p
, end
);
12563 print_mips_fp_abi_value (int val
)
12567 case Val_GNU_MIPS_ABI_FP_ANY
:
12568 printf (_("Hard or soft float\n"));
12570 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12571 printf (_("Hard float (double precision)\n"));
12573 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12574 printf (_("Hard float (single precision)\n"));
12576 case Val_GNU_MIPS_ABI_FP_SOFT
:
12577 printf (_("Soft float\n"));
12579 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12580 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12582 case Val_GNU_MIPS_ABI_FP_XX
:
12583 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12585 case Val_GNU_MIPS_ABI_FP_64
:
12586 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12588 case Val_GNU_MIPS_ABI_FP_64A
:
12589 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12592 printf ("??? (%d)\n", val
);
12597 static unsigned char *
12598 display_mips_gnu_attribute (unsigned char * p
,
12600 const unsigned char * const end
)
12602 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12607 val
= read_uleb128 (p
, &len
, end
);
12609 printf (" Tag_GNU_MIPS_ABI_FP: ");
12611 print_mips_fp_abi_value (val
);
12616 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12621 val
= read_uleb128 (p
, &len
, end
);
12623 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12627 case Val_GNU_MIPS_ABI_MSA_ANY
:
12628 printf (_("Any MSA or not\n"));
12630 case Val_GNU_MIPS_ABI_MSA_128
:
12631 printf (_("128-bit MSA\n"));
12634 printf ("??? (%d)\n", val
);
12640 return display_tag_value (tag
& 1, p
, end
);
12643 static unsigned char *
12644 display_tic6x_attribute (unsigned char * p
,
12645 const unsigned char * const end
)
12651 tag
= read_uleb128 (p
, &len
, end
);
12657 val
= read_uleb128 (p
, &len
, end
);
12659 printf (" Tag_ISA: ");
12663 case C6XABI_Tag_ISA_none
:
12664 printf (_("None\n"));
12666 case C6XABI_Tag_ISA_C62X
:
12669 case C6XABI_Tag_ISA_C67X
:
12672 case C6XABI_Tag_ISA_C67XP
:
12673 printf ("C67x+\n");
12675 case C6XABI_Tag_ISA_C64X
:
12678 case C6XABI_Tag_ISA_C64XP
:
12679 printf ("C64x+\n");
12681 case C6XABI_Tag_ISA_C674X
:
12682 printf ("C674x\n");
12685 printf ("??? (%d)\n", val
);
12690 case Tag_ABI_wchar_t
:
12691 val
= read_uleb128 (p
, &len
, end
);
12693 printf (" Tag_ABI_wchar_t: ");
12697 printf (_("Not used\n"));
12700 printf (_("2 bytes\n"));
12703 printf (_("4 bytes\n"));
12706 printf ("??? (%d)\n", val
);
12711 case Tag_ABI_stack_align_needed
:
12712 val
= read_uleb128 (p
, &len
, end
);
12714 printf (" Tag_ABI_stack_align_needed: ");
12718 printf (_("8-byte\n"));
12721 printf (_("16-byte\n"));
12724 printf ("??? (%d)\n", val
);
12729 case Tag_ABI_stack_align_preserved
:
12730 val
= read_uleb128 (p
, &len
, end
);
12732 printf (" Tag_ABI_stack_align_preserved: ");
12736 printf (_("8-byte\n"));
12739 printf (_("16-byte\n"));
12742 printf ("??? (%d)\n", val
);
12748 val
= read_uleb128 (p
, &len
, end
);
12750 printf (" Tag_ABI_DSBT: ");
12754 printf (_("DSBT addressing not used\n"));
12757 printf (_("DSBT addressing used\n"));
12760 printf ("??? (%d)\n", val
);
12766 val
= read_uleb128 (p
, &len
, end
);
12768 printf (" Tag_ABI_PID: ");
12772 printf (_("Data addressing position-dependent\n"));
12775 printf (_("Data addressing position-independent, GOT near DP\n"));
12778 printf (_("Data addressing position-independent, GOT far from DP\n"));
12781 printf ("??? (%d)\n", val
);
12787 val
= read_uleb128 (p
, &len
, end
);
12789 printf (" Tag_ABI_PIC: ");
12793 printf (_("Code addressing position-dependent\n"));
12796 printf (_("Code addressing position-independent\n"));
12799 printf ("??? (%d)\n", val
);
12804 case Tag_ABI_array_object_alignment
:
12805 val
= read_uleb128 (p
, &len
, end
);
12807 printf (" Tag_ABI_array_object_alignment: ");
12811 printf (_("8-byte\n"));
12814 printf (_("4-byte\n"));
12817 printf (_("16-byte\n"));
12820 printf ("??? (%d)\n", val
);
12825 case Tag_ABI_array_object_align_expected
:
12826 val
= read_uleb128 (p
, &len
, end
);
12828 printf (" Tag_ABI_array_object_align_expected: ");
12832 printf (_("8-byte\n"));
12835 printf (_("4-byte\n"));
12838 printf (_("16-byte\n"));
12841 printf ("??? (%d)\n", val
);
12846 case Tag_ABI_compatibility
:
12848 val
= read_uleb128 (p
, &len
, end
);
12850 printf (" Tag_ABI_compatibility: ");
12851 printf (_("flag = %d, vendor = "), val
);
12854 size_t maxlen
= (end
- p
) - 1;
12856 print_symbol ((int) maxlen
, (const char *) p
);
12857 p
+= strnlen ((char *) p
, maxlen
) + 1;
12861 printf (_("<corrupt>"));
12862 p
= (unsigned char *) end
;
12868 case Tag_ABI_conformance
:
12870 printf (" Tag_ABI_conformance: \"");
12873 size_t maxlen
= (end
- p
) - 1;
12875 print_symbol ((int) maxlen
, (const char *) p
);
12876 p
+= strnlen ((char *) p
, maxlen
) + 1;
12880 printf (_("<corrupt>"));
12881 p
= (unsigned char *) end
;
12888 return display_tag_value (tag
, p
, end
);
12892 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12894 unsigned long addr
= 0;
12895 size_t bytes
= end
- p
;
12902 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12904 printf (" 0x%8.8lx ", addr
);
12906 for (j
= 0; j
< 16; j
++)
12909 printf ("%2.2x", p
[j
]);
12917 for (j
= 0; j
< lbytes
; j
++)
12920 if (k
>= ' ' && k
< 0x7f)
12936 static unsigned char *
12937 display_msp430x_attribute (unsigned char * p
,
12938 const unsigned char * const end
)
12944 tag
= read_uleb128 (p
, & len
, end
);
12949 case OFBA_MSPABI_Tag_ISA
:
12950 val
= read_uleb128 (p
, &len
, end
);
12952 printf (" Tag_ISA: ");
12955 case 0: printf (_("None\n")); break;
12956 case 1: printf (_("MSP430\n")); break;
12957 case 2: printf (_("MSP430X\n")); break;
12958 default: printf ("??? (%d)\n", val
); break;
12962 case OFBA_MSPABI_Tag_Code_Model
:
12963 val
= read_uleb128 (p
, &len
, end
);
12965 printf (" Tag_Code_Model: ");
12968 case 0: printf (_("None\n")); break;
12969 case 1: printf (_("Small\n")); break;
12970 case 2: printf (_("Large\n")); break;
12971 default: printf ("??? (%d)\n", val
); break;
12975 case OFBA_MSPABI_Tag_Data_Model
:
12976 val
= read_uleb128 (p
, &len
, end
);
12978 printf (" Tag_Data_Model: ");
12981 case 0: printf (_("None\n")); break;
12982 case 1: printf (_("Small\n")); break;
12983 case 2: printf (_("Large\n")); break;
12984 case 3: printf (_("Restricted Large\n")); break;
12985 default: printf ("??? (%d)\n", val
); break;
12990 printf (_(" <unknown tag %d>: "), tag
);
12997 size_t maxlen
= (end
- p
) - 1;
12999 print_symbol ((int) maxlen
, (const char *) p
);
13000 p
+= strnlen ((char *) p
, maxlen
) + 1;
13004 printf (_("<corrupt>"));
13005 p
= (unsigned char *) end
;
13011 val
= read_uleb128 (p
, &len
, end
);
13013 printf ("%d (0x%x)\n", val
, val
);
13023 process_attributes (FILE * file
,
13024 const char * public_name
,
13025 unsigned int proc_type
,
13026 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13027 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13029 Elf_Internal_Shdr
* sect
;
13032 /* Find the section header so that we get the size. */
13033 for (i
= 0, sect
= section_headers
;
13034 i
< elf_header
.e_shnum
;
13037 unsigned char * contents
;
13040 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13043 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13044 sect
->sh_size
, _("attributes"));
13045 if (contents
== NULL
)
13051 bfd_vma section_len
;
13053 section_len
= sect
->sh_size
- 1;
13056 while (section_len
> 0)
13059 unsigned int namelen
;
13060 bfd_boolean public_section
;
13061 bfd_boolean gnu_section
;
13063 if (section_len
<= 4)
13065 error (_("Tag section ends prematurely\n"));
13068 attr_len
= byte_get (p
, 4);
13071 if (attr_len
> section_len
)
13073 error (_("Bad attribute length (%u > %u)\n"),
13074 (unsigned) attr_len
, (unsigned) section_len
);
13075 attr_len
= section_len
;
13077 /* PR 17531: file: 001-101425-0.004 */
13078 else if (attr_len
< 5)
13080 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13084 section_len
-= attr_len
;
13087 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13088 if (namelen
== 0 || namelen
>= attr_len
)
13090 error (_("Corrupt attribute section name\n"));
13094 printf (_("Attribute Section: "));
13095 print_symbol (INT_MAX
, (const char *) p
);
13098 if (public_name
&& streq ((char *) p
, public_name
))
13099 public_section
= TRUE
;
13101 public_section
= FALSE
;
13103 if (streq ((char *) p
, "gnu"))
13104 gnu_section
= TRUE
;
13106 gnu_section
= FALSE
;
13109 attr_len
-= namelen
;
13111 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13116 unsigned char * end
;
13118 /* PR binutils/17531: Safe handling of corrupt files. */
13121 error (_("Unused bytes at end of section\n"));
13127 size
= byte_get (p
, 4);
13128 if (size
> attr_len
)
13130 error (_("Bad subsection length (%u > %u)\n"),
13131 (unsigned) size
, (unsigned) attr_len
);
13134 /* PR binutils/17531: Safe handling of corrupt files. */
13137 error (_("Bad subsection length (%u < 6)\n"),
13144 end
= p
+ size
- 1;
13145 assert (end
<= contents
+ sect
->sh_size
);
13151 printf (_("File Attributes\n"));
13154 printf (_("Section Attributes:"));
13157 printf (_("Symbol Attributes:"));
13163 val
= read_uleb128 (p
, &j
, end
);
13167 printf (" %d", val
);
13172 printf (_("Unknown tag: %d\n"), tag
);
13173 public_section
= FALSE
;
13177 if (public_section
&& display_pub_attribute
!= NULL
)
13180 p
= display_pub_attribute (p
, end
);
13183 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13186 p
= display_gnu_attribute (p
,
13187 display_proc_gnu_attribute
,
13193 printf (_(" Unknown attribute:\n"));
13194 display_raw_attribute (p
, end
);
13203 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13211 process_arm_specific (FILE * file
)
13213 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13214 display_arm_attribute
, NULL
);
13218 process_power_specific (FILE * file
)
13220 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13221 display_power_gnu_attribute
);
13225 process_sparc_specific (FILE * file
)
13227 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13228 display_sparc_gnu_attribute
);
13232 process_tic6x_specific (FILE * file
)
13234 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13235 display_tic6x_attribute
, NULL
);
13239 process_msp430x_specific (FILE * file
)
13241 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13242 display_msp430x_attribute
, NULL
);
13245 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13246 Print the Address, Access and Initial fields of an entry at VMA ADDR
13247 and return the VMA of the next entry. */
13250 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13253 print_vma (addr
, LONG_HEX
);
13255 if (addr
< pltgot
+ 0xfff0)
13256 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13258 printf ("%10s", "");
13261 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13266 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13267 print_vma (entry
, LONG_HEX
);
13269 return addr
+ (is_32bit_elf
? 4 : 8);
13272 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13273 PLTGOT. Print the Address and Initial fields of an entry at VMA
13274 ADDR and return the VMA of the next entry. */
13277 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13280 print_vma (addr
, LONG_HEX
);
13283 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13288 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13289 print_vma (entry
, LONG_HEX
);
13291 return addr
+ (is_32bit_elf
? 4 : 8);
13295 print_mips_ases (unsigned int mask
)
13297 if (mask
& AFL_ASE_DSP
)
13298 fputs ("\n\tDSP ASE", stdout
);
13299 if (mask
& AFL_ASE_DSPR2
)
13300 fputs ("\n\tDSP R2 ASE", stdout
);
13301 if (mask
& AFL_ASE_EVA
)
13302 fputs ("\n\tEnhanced VA Scheme", stdout
);
13303 if (mask
& AFL_ASE_MCU
)
13304 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13305 if (mask
& AFL_ASE_MDMX
)
13306 fputs ("\n\tMDMX ASE", stdout
);
13307 if (mask
& AFL_ASE_MIPS3D
)
13308 fputs ("\n\tMIPS-3D ASE", stdout
);
13309 if (mask
& AFL_ASE_MT
)
13310 fputs ("\n\tMT ASE", stdout
);
13311 if (mask
& AFL_ASE_SMARTMIPS
)
13312 fputs ("\n\tSmartMIPS ASE", stdout
);
13313 if (mask
& AFL_ASE_VIRT
)
13314 fputs ("\n\tVZ ASE", stdout
);
13315 if (mask
& AFL_ASE_MSA
)
13316 fputs ("\n\tMSA ASE", stdout
);
13317 if (mask
& AFL_ASE_MIPS16
)
13318 fputs ("\n\tMIPS16 ASE", stdout
);
13319 if (mask
& AFL_ASE_MICROMIPS
)
13320 fputs ("\n\tMICROMIPS ASE", stdout
);
13321 if (mask
& AFL_ASE_XPA
)
13322 fputs ("\n\tXPA ASE", stdout
);
13324 fprintf (stdout
, "\n\t%s", _("None"));
13325 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13326 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13330 print_mips_isa_ext (unsigned int isa_ext
)
13335 fputs (_("None"), stdout
);
13338 fputs ("RMI XLR", stdout
);
13340 case AFL_EXT_OCTEON3
:
13341 fputs ("Cavium Networks Octeon3", stdout
);
13343 case AFL_EXT_OCTEON2
:
13344 fputs ("Cavium Networks Octeon2", stdout
);
13346 case AFL_EXT_OCTEONP
:
13347 fputs ("Cavium Networks OcteonP", stdout
);
13349 case AFL_EXT_LOONGSON_3A
:
13350 fputs ("Loongson 3A", stdout
);
13352 case AFL_EXT_OCTEON
:
13353 fputs ("Cavium Networks Octeon", stdout
);
13356 fputs ("Toshiba R5900", stdout
);
13359 fputs ("MIPS R4650", stdout
);
13362 fputs ("LSI R4010", stdout
);
13365 fputs ("NEC VR4100", stdout
);
13368 fputs ("Toshiba R3900", stdout
);
13370 case AFL_EXT_10000
:
13371 fputs ("MIPS R10000", stdout
);
13374 fputs ("Broadcom SB-1", stdout
);
13377 fputs ("NEC VR4111/VR4181", stdout
);
13380 fputs ("NEC VR4120", stdout
);
13383 fputs ("NEC VR5400", stdout
);
13386 fputs ("NEC VR5500", stdout
);
13388 case AFL_EXT_LOONGSON_2E
:
13389 fputs ("ST Microelectronics Loongson 2E", stdout
);
13391 case AFL_EXT_LOONGSON_2F
:
13392 fputs ("ST Microelectronics Loongson 2F", stdout
);
13395 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13400 get_mips_reg_size (int reg_size
)
13402 return (reg_size
== AFL_REG_NONE
) ? 0
13403 : (reg_size
== AFL_REG_32
) ? 32
13404 : (reg_size
== AFL_REG_64
) ? 64
13405 : (reg_size
== AFL_REG_128
) ? 128
13410 process_mips_specific (FILE * file
)
13412 Elf_Internal_Dyn
* entry
;
13413 Elf_Internal_Shdr
*sect
= NULL
;
13414 size_t liblist_offset
= 0;
13415 size_t liblistno
= 0;
13416 size_t conflictsno
= 0;
13417 size_t options_offset
= 0;
13418 size_t conflicts_offset
= 0;
13419 size_t pltrelsz
= 0;
13421 bfd_vma pltgot
= 0;
13422 bfd_vma mips_pltgot
= 0;
13423 bfd_vma jmprel
= 0;
13424 bfd_vma local_gotno
= 0;
13425 bfd_vma gotsym
= 0;
13426 bfd_vma symtabno
= 0;
13428 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13429 display_mips_gnu_attribute
);
13431 sect
= find_section (".MIPS.abiflags");
13435 Elf_External_ABIFlags_v0
*abiflags_ext
;
13436 Elf_Internal_ABIFlags_v0 abiflags_in
;
13438 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13439 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13442 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13443 sect
->sh_size
, _("MIPS ABI Flags section"));
13446 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13447 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13448 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13449 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13450 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13451 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13452 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13453 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13454 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13455 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13456 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13458 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13459 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13460 if (abiflags_in
.isa_rev
> 1)
13461 printf ("r%d", abiflags_in
.isa_rev
);
13462 printf ("\nGPR size: %d",
13463 get_mips_reg_size (abiflags_in
.gpr_size
));
13464 printf ("\nCPR1 size: %d",
13465 get_mips_reg_size (abiflags_in
.cpr1_size
));
13466 printf ("\nCPR2 size: %d",
13467 get_mips_reg_size (abiflags_in
.cpr2_size
));
13468 fputs ("\nFP ABI: ", stdout
);
13469 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13470 fputs ("ISA Extension: ", stdout
);
13471 print_mips_isa_ext (abiflags_in
.isa_ext
);
13472 fputs ("\nASEs:", stdout
);
13473 print_mips_ases (abiflags_in
.ases
);
13474 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13475 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13476 fputc ('\n', stdout
);
13477 free (abiflags_ext
);
13482 /* We have a lot of special sections. Thanks SGI! */
13483 if (dynamic_section
== NULL
)
13484 /* No information available. */
13487 for (entry
= dynamic_section
;
13488 /* PR 17531 file: 012-50589-0.004. */
13489 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13491 switch (entry
->d_tag
)
13493 case DT_MIPS_LIBLIST
:
13495 = offset_from_vma (file
, entry
->d_un
.d_val
,
13496 liblistno
* sizeof (Elf32_External_Lib
));
13498 case DT_MIPS_LIBLISTNO
:
13499 liblistno
= entry
->d_un
.d_val
;
13501 case DT_MIPS_OPTIONS
:
13502 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13504 case DT_MIPS_CONFLICT
:
13506 = offset_from_vma (file
, entry
->d_un
.d_val
,
13507 conflictsno
* sizeof (Elf32_External_Conflict
));
13509 case DT_MIPS_CONFLICTNO
:
13510 conflictsno
= entry
->d_un
.d_val
;
13513 pltgot
= entry
->d_un
.d_ptr
;
13515 case DT_MIPS_LOCAL_GOTNO
:
13516 local_gotno
= entry
->d_un
.d_val
;
13518 case DT_MIPS_GOTSYM
:
13519 gotsym
= entry
->d_un
.d_val
;
13521 case DT_MIPS_SYMTABNO
:
13522 symtabno
= entry
->d_un
.d_val
;
13524 case DT_MIPS_PLTGOT
:
13525 mips_pltgot
= entry
->d_un
.d_ptr
;
13528 pltrel
= entry
->d_un
.d_val
;
13531 pltrelsz
= entry
->d_un
.d_val
;
13534 jmprel
= entry
->d_un
.d_ptr
;
13540 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13542 Elf32_External_Lib
* elib
;
13545 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13547 sizeof (Elf32_External_Lib
),
13548 _("liblist section data"));
13551 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13552 (unsigned long) liblistno
);
13553 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13556 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13563 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13564 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13565 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13566 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13567 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13569 tmp
= gmtime (&atime
);
13570 snprintf (timebuf
, sizeof (timebuf
),
13571 "%04u-%02u-%02uT%02u:%02u:%02u",
13572 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13573 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13575 printf ("%3lu: ", (unsigned long) cnt
);
13576 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13577 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13579 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13580 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13581 liblist
.l_version
);
13583 if (liblist
.l_flags
== 0)
13587 static const struct
13594 { " EXACT_MATCH", LL_EXACT_MATCH
},
13595 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13596 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13597 { " EXPORTS", LL_EXPORTS
},
13598 { " DELAY_LOAD", LL_DELAY_LOAD
},
13599 { " DELTA", LL_DELTA
}
13601 int flags
= liblist
.l_flags
;
13604 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13605 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13607 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13608 flags
^= l_flags_vals
[fcnt
].bit
;
13611 printf (" %#x", (unsigned int) flags
);
13621 if (options_offset
!= 0)
13623 Elf_External_Options
* eopt
;
13624 Elf_Internal_Options
* iopt
;
13625 Elf_Internal_Options
* option
;
13628 sect
= section_headers
;
13630 /* Find the section header so that we get the size. */
13631 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13632 /* PR 17533 file: 012-277276-0.004. */
13635 error (_("No MIPS_OPTIONS header found\n"));
13639 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13640 sect
->sh_size
, _("options"));
13643 iopt
= (Elf_Internal_Options
*)
13644 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13647 error (_("Out of memory allocatinf space for MIPS options\n"));
13654 while (offset
< sect
->sh_size
)
13656 Elf_External_Options
* eoption
;
13658 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13660 option
->kind
= BYTE_GET (eoption
->kind
);
13661 option
->size
= BYTE_GET (eoption
->size
);
13662 option
->section
= BYTE_GET (eoption
->section
);
13663 option
->info
= BYTE_GET (eoption
->info
);
13665 offset
+= option
->size
;
13671 printf (_("\nSection '%s' contains %d entries:\n"),
13672 printable_section_name (sect
), cnt
);
13680 switch (option
->kind
)
13683 /* This shouldn't happen. */
13684 printf (" NULL %d %lx", option
->section
, option
->info
);
13687 printf (" REGINFO ");
13688 if (elf_header
.e_machine
== EM_MIPS
)
13691 Elf32_External_RegInfo
* ereg
;
13692 Elf32_RegInfo reginfo
;
13694 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13695 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13696 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13697 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13698 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13699 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13700 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13702 printf ("GPR %08lx GP 0x%lx\n",
13703 reginfo
.ri_gprmask
,
13704 (unsigned long) reginfo
.ri_gp_value
);
13705 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13706 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13707 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13712 Elf64_External_RegInfo
* ereg
;
13713 Elf64_Internal_RegInfo reginfo
;
13715 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13716 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13717 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13718 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13719 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13720 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13721 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13723 printf ("GPR %08lx GP 0x",
13724 reginfo
.ri_gprmask
);
13725 printf_vma (reginfo
.ri_gp_value
);
13728 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13729 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13730 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13734 case ODK_EXCEPTIONS
:
13735 fputs (" EXCEPTIONS fpe_min(", stdout
);
13736 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13737 fputs (") fpe_max(", stdout
);
13738 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13739 fputs (")", stdout
);
13741 if (option
->info
& OEX_PAGE0
)
13742 fputs (" PAGE0", stdout
);
13743 if (option
->info
& OEX_SMM
)
13744 fputs (" SMM", stdout
);
13745 if (option
->info
& OEX_FPDBUG
)
13746 fputs (" FPDBUG", stdout
);
13747 if (option
->info
& OEX_DISMISS
)
13748 fputs (" DISMISS", stdout
);
13751 fputs (" PAD ", stdout
);
13752 if (option
->info
& OPAD_PREFIX
)
13753 fputs (" PREFIX", stdout
);
13754 if (option
->info
& OPAD_POSTFIX
)
13755 fputs (" POSTFIX", stdout
);
13756 if (option
->info
& OPAD_SYMBOL
)
13757 fputs (" SYMBOL", stdout
);
13760 fputs (" HWPATCH ", stdout
);
13761 if (option
->info
& OHW_R4KEOP
)
13762 fputs (" R4KEOP", stdout
);
13763 if (option
->info
& OHW_R8KPFETCH
)
13764 fputs (" R8KPFETCH", stdout
);
13765 if (option
->info
& OHW_R5KEOP
)
13766 fputs (" R5KEOP", stdout
);
13767 if (option
->info
& OHW_R5KCVTL
)
13768 fputs (" R5KCVTL", stdout
);
13771 fputs (" FILL ", stdout
);
13772 /* XXX Print content of info word? */
13775 fputs (" TAGS ", stdout
);
13776 /* XXX Print content of info word? */
13779 fputs (" HWAND ", stdout
);
13780 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13781 fputs (" R4KEOP_CHECKED", stdout
);
13782 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13783 fputs (" R4KEOP_CLEAN", stdout
);
13786 fputs (" HWOR ", stdout
);
13787 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13788 fputs (" R4KEOP_CHECKED", stdout
);
13789 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13790 fputs (" R4KEOP_CLEAN", stdout
);
13793 printf (" GP_GROUP %#06lx self-contained %#06lx",
13794 option
->info
& OGP_GROUP
,
13795 (option
->info
& OGP_SELF
) >> 16);
13798 printf (" IDENT %#06lx self-contained %#06lx",
13799 option
->info
& OGP_GROUP
,
13800 (option
->info
& OGP_SELF
) >> 16);
13803 /* This shouldn't happen. */
13804 printf (" %3d ??? %d %lx",
13805 option
->kind
, option
->section
, option
->info
);
13809 len
= sizeof (* eopt
);
13810 while (len
< option
->size
)
13811 if (((char *) option
)[len
] >= ' '
13812 && ((char *) option
)[len
] < 0x7f)
13813 printf ("%c", ((char *) option
)[len
++]);
13815 printf ("\\%03o", ((char *) option
)[len
++]);
13817 fputs ("\n", stdout
);
13825 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13827 Elf32_Conflict
* iconf
;
13830 if (dynamic_symbols
== NULL
)
13832 error (_("conflict list found without a dynamic symbol table\n"));
13836 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13839 error (_("Out of memory allocating space for dynamic conflicts\n"));
13845 Elf32_External_Conflict
* econf32
;
13847 econf32
= (Elf32_External_Conflict
*)
13848 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13849 sizeof (* econf32
), _("conflict"));
13853 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13854 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13860 Elf64_External_Conflict
* econf64
;
13862 econf64
= (Elf64_External_Conflict
*)
13863 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13864 sizeof (* econf64
), _("conflict"));
13868 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13869 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13874 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13875 (unsigned long) conflictsno
);
13876 puts (_(" Num: Index Value Name"));
13878 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13880 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13882 if (iconf
[cnt
] >= num_dynamic_syms
)
13883 printf (_("<corrupt symbol index>"));
13886 Elf_Internal_Sym
* psym
;
13888 psym
= & dynamic_symbols
[iconf
[cnt
]];
13889 print_vma (psym
->st_value
, FULL_HEX
);
13891 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13892 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13894 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13902 if (pltgot
!= 0 && local_gotno
!= 0)
13904 bfd_vma ent
, local_end
, global_end
;
13906 unsigned char * data
;
13910 addr_size
= (is_32bit_elf
? 4 : 8);
13911 local_end
= pltgot
+ local_gotno
* addr_size
;
13913 /* PR binutils/17533 file: 012-111227-0.004 */
13914 if (symtabno
< gotsym
)
13916 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13917 (long) gotsym
, (long) symtabno
);
13921 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13922 assert (global_end
>= local_end
);
13923 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13924 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13925 global_end
- pltgot
, 1,
13926 _("Global Offset Table data"));
13930 printf (_("\nPrimary GOT:\n"));
13931 printf (_(" Canonical gp value: "));
13932 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13935 printf (_(" Reserved entries:\n"));
13936 printf (_(" %*s %10s %*s Purpose\n"),
13937 addr_size
* 2, _("Address"), _("Access"),
13938 addr_size
* 2, _("Initial"));
13939 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13940 printf (_(" Lazy resolver\n"));
13942 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13943 >> (addr_size
* 8 - 1)) != 0)
13945 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13946 printf (_(" Module pointer (GNU extension)\n"));
13950 if (ent
< local_end
)
13952 printf (_(" Local entries:\n"));
13953 printf (" %*s %10s %*s\n",
13954 addr_size
* 2, _("Address"), _("Access"),
13955 addr_size
* 2, _("Initial"));
13956 while (ent
< local_end
)
13958 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13964 if (gotsym
< symtabno
)
13968 printf (_(" Global entries:\n"));
13969 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13970 addr_size
* 2, _("Address"),
13972 addr_size
* 2, _("Initial"),
13973 addr_size
* 2, _("Sym.Val."),
13975 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13976 _("Ndx"), _("Name"));
13978 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13980 for (i
= gotsym
; i
< symtabno
; i
++)
13982 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13985 if (dynamic_symbols
== NULL
)
13986 printf (_("<no dynamic symbols>"));
13987 else if (i
< num_dynamic_syms
)
13989 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
13991 print_vma (psym
->st_value
, LONG_HEX
);
13992 printf (" %-7s %3s ",
13993 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13994 get_symbol_index_type (psym
->st_shndx
));
13996 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13997 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13999 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14002 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14003 (unsigned long) i
);
14014 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14017 size_t offset
, rel_offset
;
14018 unsigned long count
, i
;
14019 unsigned char * data
;
14020 int addr_size
, sym_width
;
14021 Elf_Internal_Rela
* rels
;
14023 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14024 if (pltrel
== DT_RELA
)
14026 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14031 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14036 addr_size
= (is_32bit_elf
? 4 : 8);
14037 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14039 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14040 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14041 1, _("Procedure Linkage Table data"));
14045 printf ("\nPLT GOT:\n\n");
14046 printf (_(" Reserved entries:\n"));
14047 printf (_(" %*s %*s Purpose\n"),
14048 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14049 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14050 printf (_(" PLT lazy resolver\n"));
14051 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14052 printf (_(" Module pointer\n"));
14055 printf (_(" Entries:\n"));
14056 printf (" %*s %*s %*s %-7s %3s %s\n",
14057 addr_size
* 2, _("Address"),
14058 addr_size
* 2, _("Initial"),
14059 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14060 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14061 for (i
= 0; i
< count
; i
++)
14063 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14065 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14068 if (idx
>= num_dynamic_syms
)
14069 printf (_("<corrupt symbol index: %lu>"), idx
);
14072 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14074 print_vma (psym
->st_value
, LONG_HEX
);
14075 printf (" %-7s %3s ",
14076 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14077 get_symbol_index_type (psym
->st_shndx
));
14078 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14079 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14081 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14096 process_nds32_specific (FILE * file
)
14098 Elf_Internal_Shdr
*sect
= NULL
;
14100 sect
= find_section (".nds32_e_flags");
14103 unsigned int *flag
;
14105 printf ("\nNDS32 elf flags section:\n");
14106 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14107 sect
->sh_size
, _("NDS32 elf flags section"));
14109 switch ((*flag
) & 0x3)
14112 printf ("(VEC_SIZE):\tNo entry.\n");
14115 printf ("(VEC_SIZE):\t4 bytes\n");
14118 printf ("(VEC_SIZE):\t16 bytes\n");
14121 printf ("(VEC_SIZE):\treserved\n");
14130 process_gnu_liblist (FILE * file
)
14132 Elf_Internal_Shdr
* section
;
14133 Elf_Internal_Shdr
* string_sec
;
14134 Elf32_External_Lib
* elib
;
14136 size_t strtab_size
;
14143 for (i
= 0, section
= section_headers
;
14144 i
< elf_header
.e_shnum
;
14147 switch (section
->sh_type
)
14149 case SHT_GNU_LIBLIST
:
14150 if (section
->sh_link
>= elf_header
.e_shnum
)
14153 elib
= (Elf32_External_Lib
*)
14154 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14155 _("liblist section data"));
14159 string_sec
= section_headers
+ section
->sh_link
;
14161 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14162 string_sec
->sh_size
,
14163 _("liblist string table"));
14165 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14171 strtab_size
= string_sec
->sh_size
;
14173 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14174 printable_section_name (section
),
14175 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14177 puts (_(" Library Time Stamp Checksum Version Flags"));
14179 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14187 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14188 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14189 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14190 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14191 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14193 tmp
= gmtime (&atime
);
14194 snprintf (timebuf
, sizeof (timebuf
),
14195 "%04u-%02u-%02uT%02u:%02u:%02u",
14196 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14197 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14199 printf ("%3lu: ", (unsigned long) cnt
);
14201 printf ("%-20s", liblist
.l_name
< strtab_size
14202 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14204 printf ("%-20.20s", liblist
.l_name
< strtab_size
14205 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14206 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14207 liblist
.l_version
, liblist
.l_flags
);
14218 static const char *
14219 get_note_type (unsigned e_type
)
14221 static char buff
[64];
14223 if (elf_header
.e_type
== ET_CORE
)
14227 return _("NT_AUXV (auxiliary vector)");
14229 return _("NT_PRSTATUS (prstatus structure)");
14231 return _("NT_FPREGSET (floating point registers)");
14233 return _("NT_PRPSINFO (prpsinfo structure)");
14234 case NT_TASKSTRUCT
:
14235 return _("NT_TASKSTRUCT (task structure)");
14237 return _("NT_PRXFPREG (user_xfpregs structure)");
14239 return _("NT_PPC_VMX (ppc Altivec registers)");
14241 return _("NT_PPC_VSX (ppc VSX registers)");
14243 return _("NT_386_TLS (x86 TLS information)");
14244 case NT_386_IOPERM
:
14245 return _("NT_386_IOPERM (x86 I/O permissions)");
14246 case NT_X86_XSTATE
:
14247 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14248 case NT_S390_HIGH_GPRS
:
14249 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14250 case NT_S390_TIMER
:
14251 return _("NT_S390_TIMER (s390 timer register)");
14252 case NT_S390_TODCMP
:
14253 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14254 case NT_S390_TODPREG
:
14255 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14257 return _("NT_S390_CTRS (s390 control registers)");
14258 case NT_S390_PREFIX
:
14259 return _("NT_S390_PREFIX (s390 prefix register)");
14260 case NT_S390_LAST_BREAK
:
14261 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14262 case NT_S390_SYSTEM_CALL
:
14263 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14265 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14267 return _("NT_ARM_VFP (arm VFP registers)");
14269 return _("NT_ARM_TLS (AArch TLS registers)");
14270 case NT_ARM_HW_BREAK
:
14271 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14272 case NT_ARM_HW_WATCH
:
14273 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14275 return _("NT_PSTATUS (pstatus structure)");
14277 return _("NT_FPREGS (floating point registers)");
14279 return _("NT_PSINFO (psinfo structure)");
14281 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14283 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14284 case NT_WIN32PSTATUS
:
14285 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14287 return _("NT_SIGINFO (siginfo_t data)");
14289 return _("NT_FILE (mapped files)");
14297 return _("NT_VERSION (version)");
14299 return _("NT_ARCH (architecture)");
14304 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14309 print_core_note (Elf_Internal_Note
*pnote
)
14311 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14312 bfd_vma count
, page_size
;
14313 unsigned char *descdata
, *filenames
, *descend
;
14315 if (pnote
->type
!= NT_FILE
)
14321 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14322 /* Still "successful". */
14327 if (pnote
->descsz
< 2 * addr_size
)
14329 printf (_(" Malformed note - too short for header\n"));
14333 descdata
= (unsigned char *) pnote
->descdata
;
14334 descend
= descdata
+ pnote
->descsz
;
14336 if (descdata
[pnote
->descsz
- 1] != '\0')
14338 printf (_(" Malformed note - does not end with \\0\n"));
14342 count
= byte_get (descdata
, addr_size
);
14343 descdata
+= addr_size
;
14345 page_size
= byte_get (descdata
, addr_size
);
14346 descdata
+= addr_size
;
14348 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14350 printf (_(" Malformed note - too short for supplied file count\n"));
14354 printf (_(" Page size: "));
14355 print_vma (page_size
, DEC
);
14358 printf (_(" %*s%*s%*s\n"),
14359 (int) (2 + 2 * addr_size
), _("Start"),
14360 (int) (4 + 2 * addr_size
), _("End"),
14361 (int) (4 + 2 * addr_size
), _("Page Offset"));
14362 filenames
= descdata
+ count
* 3 * addr_size
;
14363 while (--count
> 0)
14365 bfd_vma start
, end
, file_ofs
;
14367 if (filenames
== descend
)
14369 printf (_(" Malformed note - filenames end too early\n"));
14373 start
= byte_get (descdata
, addr_size
);
14374 descdata
+= addr_size
;
14375 end
= byte_get (descdata
, addr_size
);
14376 descdata
+= addr_size
;
14377 file_ofs
= byte_get (descdata
, addr_size
);
14378 descdata
+= addr_size
;
14381 print_vma (start
, FULL_HEX
);
14383 print_vma (end
, FULL_HEX
);
14385 print_vma (file_ofs
, FULL_HEX
);
14386 printf ("\n %s\n", filenames
);
14388 filenames
+= 1 + strlen ((char *) filenames
);
14394 static const char *
14395 get_gnu_elf_note_type (unsigned e_type
)
14397 static char buff
[64];
14401 case NT_GNU_ABI_TAG
:
14402 return _("NT_GNU_ABI_TAG (ABI version tag)");
14404 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14405 case NT_GNU_BUILD_ID
:
14406 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14407 case NT_GNU_GOLD_VERSION
:
14408 return _("NT_GNU_GOLD_VERSION (gold version)");
14413 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14418 print_gnu_note (Elf_Internal_Note
*pnote
)
14420 switch (pnote
->type
)
14422 case NT_GNU_BUILD_ID
:
14426 printf (_(" Build ID: "));
14427 for (i
= 0; i
< pnote
->descsz
; ++i
)
14428 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14433 case NT_GNU_ABI_TAG
:
14435 unsigned long os
, major
, minor
, subminor
;
14436 const char *osname
;
14438 /* PR 17531: file: 030-599401-0.004. */
14439 if (pnote
->descsz
< 16)
14441 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14445 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14446 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14447 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14448 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14452 case GNU_ABI_TAG_LINUX
:
14455 case GNU_ABI_TAG_HURD
:
14458 case GNU_ABI_TAG_SOLARIS
:
14459 osname
= "Solaris";
14461 case GNU_ABI_TAG_FREEBSD
:
14462 osname
= "FreeBSD";
14464 case GNU_ABI_TAG_NETBSD
:
14468 osname
= "Unknown";
14472 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14473 major
, minor
, subminor
);
14477 case NT_GNU_GOLD_VERSION
:
14481 printf (_(" Version: "));
14482 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14483 printf ("%c", pnote
->descdata
[i
]);
14492 static const char *
14493 get_netbsd_elfcore_note_type (unsigned e_type
)
14495 static char buff
[64];
14497 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14499 /* NetBSD core "procinfo" structure. */
14500 return _("NetBSD procinfo structure");
14503 /* As of Jan 2002 there are no other machine-independent notes
14504 defined for NetBSD core files. If the note type is less
14505 than the start of the machine-dependent note types, we don't
14508 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14510 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14514 switch (elf_header
.e_machine
)
14516 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14517 and PT_GETFPREGS == mach+2. */
14522 case EM_SPARC32PLUS
:
14526 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14527 return _("PT_GETREGS (reg structure)");
14528 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14529 return _("PT_GETFPREGS (fpreg structure)");
14535 /* On all other arch's, PT_GETREGS == mach+1 and
14536 PT_GETFPREGS == mach+3. */
14540 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14541 return _("PT_GETREGS (reg structure)");
14542 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14543 return _("PT_GETFPREGS (fpreg structure)");
14549 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14550 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14554 static const char *
14555 get_stapsdt_note_type (unsigned e_type
)
14557 static char buff
[64];
14562 return _("NT_STAPSDT (SystemTap probe descriptors)");
14568 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14573 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14575 int addr_size
= is_32bit_elf
? 4 : 8;
14576 char *data
= pnote
->descdata
;
14577 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14578 bfd_vma pc
, base_addr
, semaphore
;
14579 char *provider
, *probe
, *arg_fmt
;
14581 pc
= byte_get ((unsigned char *) data
, addr_size
);
14583 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14585 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14589 data
+= strlen (data
) + 1;
14591 data
+= strlen (data
) + 1;
14593 data
+= strlen (data
) + 1;
14595 printf (_(" Provider: %s\n"), provider
);
14596 printf (_(" Name: %s\n"), probe
);
14597 printf (_(" Location: "));
14598 print_vma (pc
, FULL_HEX
);
14599 printf (_(", Base: "));
14600 print_vma (base_addr
, FULL_HEX
);
14601 printf (_(", Semaphore: "));
14602 print_vma (semaphore
, FULL_HEX
);
14604 printf (_(" Arguments: %s\n"), arg_fmt
);
14606 return data
== data_end
;
14609 static const char *
14610 get_ia64_vms_note_type (unsigned e_type
)
14612 static char buff
[64];
14617 return _("NT_VMS_MHD (module header)");
14619 return _("NT_VMS_LNM (language name)");
14621 return _("NT_VMS_SRC (source files)");
14623 return "NT_VMS_TITLE";
14625 return _("NT_VMS_EIDC (consistency check)");
14626 case NT_VMS_FPMODE
:
14627 return _("NT_VMS_FPMODE (FP mode)");
14628 case NT_VMS_LINKTIME
:
14629 return "NT_VMS_LINKTIME";
14630 case NT_VMS_IMGNAM
:
14631 return _("NT_VMS_IMGNAM (image name)");
14633 return _("NT_VMS_IMGID (image id)");
14634 case NT_VMS_LINKID
:
14635 return _("NT_VMS_LINKID (link id)");
14636 case NT_VMS_IMGBID
:
14637 return _("NT_VMS_IMGBID (build id)");
14638 case NT_VMS_GSTNAM
:
14639 return _("NT_VMS_GSTNAM (sym table name)");
14640 case NT_VMS_ORIG_DYN
:
14641 return "NT_VMS_ORIG_DYN";
14642 case NT_VMS_PATCHTIME
:
14643 return "NT_VMS_PATCHTIME";
14645 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14651 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14653 switch (pnote
->type
)
14656 if (pnote
->descsz
> 36)
14658 size_t l
= strlen (pnote
->descdata
+ 34);
14659 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14660 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14661 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14662 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14665 printf (_(" Invalid size\n"));
14668 printf (_(" Language: %s\n"), pnote
->descdata
);
14671 case NT_VMS_FPMODE
:
14672 printf (_(" Floating Point mode: "));
14673 printf ("0x%016" BFD_VMA_FMT
"x\n",
14674 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14676 case NT_VMS_LINKTIME
:
14677 printf (_(" Link time: "));
14679 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14682 case NT_VMS_PATCHTIME
:
14683 printf (_(" Patch time: "));
14685 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14688 case NT_VMS_ORIG_DYN
:
14689 printf (_(" Major id: %u, minor id: %u\n"),
14690 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14691 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14692 printf (_(" Last modified : "));
14694 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14695 printf (_("\n Link flags : "));
14696 printf ("0x%016" BFD_VMA_FMT
"x\n",
14697 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14698 printf (_(" Header flags: 0x%08x\n"),
14699 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14700 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14703 case NT_VMS_IMGNAM
:
14704 printf (_(" Image name: %s\n"), pnote
->descdata
);
14706 case NT_VMS_GSTNAM
:
14707 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14710 printf (_(" Image id: %s\n"), pnote
->descdata
);
14712 case NT_VMS_LINKID
:
14713 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14721 /* Note that by the ELF standard, the name field is already null byte
14722 terminated, and namesz includes the terminating null byte.
14723 I.E. the value of namesz for the name "FSF" is 4.
14725 If the value of namesz is zero, there is no name present. */
14727 process_note (Elf_Internal_Note
* pnote
)
14729 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14732 if (pnote
->namesz
== 0)
14733 /* If there is no note name, then use the default set of
14734 note type strings. */
14735 nt
= get_note_type (pnote
->type
);
14737 else if (const_strneq (pnote
->namedata
, "GNU"))
14738 /* GNU-specific object file notes. */
14739 nt
= get_gnu_elf_note_type (pnote
->type
);
14741 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14742 /* NetBSD-specific core file notes. */
14743 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14745 else if (strneq (pnote
->namedata
, "SPU/", 4))
14747 /* SPU-specific core file notes. */
14748 nt
= pnote
->namedata
+ 4;
14752 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14753 /* VMS/ia64-specific file notes. */
14754 nt
= get_ia64_vms_note_type (pnote
->type
);
14756 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14757 nt
= get_stapsdt_note_type (pnote
->type
);
14760 /* Don't recognize this note name; just use the default set of
14761 note type strings. */
14762 nt
= get_note_type (pnote
->type
);
14764 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14766 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14767 return print_ia64_vms_note (pnote
);
14768 else if (const_strneq (pnote
->namedata
, "GNU"))
14769 return print_gnu_note (pnote
);
14770 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14771 return print_stapsdt_note (pnote
);
14772 else if (const_strneq (pnote
->namedata
, "CORE"))
14773 return print_core_note (pnote
);
14780 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14782 Elf_External_Note
* pnotes
;
14783 Elf_External_Note
* external
;
14789 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14791 if (pnotes
== NULL
)
14796 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14797 (unsigned long) offset
, (unsigned long) length
);
14798 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14800 while ((char *) external
< (char *) pnotes
+ length
)
14802 Elf_Internal_Note inote
;
14805 char * temp
= NULL
;
14806 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14808 if (!is_ia64_vms ())
14810 /* PR binutils/15191
14811 Make sure that there is enough data to read. */
14812 min_notesz
= offsetof (Elf_External_Note
, name
);
14813 if (data_remaining
< min_notesz
)
14815 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14816 (int) data_remaining
);
14819 inote
.type
= BYTE_GET (external
->type
);
14820 inote
.namesz
= BYTE_GET (external
->namesz
);
14821 inote
.namedata
= external
->name
;
14822 inote
.descsz
= BYTE_GET (external
->descsz
);
14823 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14824 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14825 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14829 Elf64_External_VMS_Note
*vms_external
;
14831 /* PR binutils/15191
14832 Make sure that there is enough data to read. */
14833 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14834 if (data_remaining
< min_notesz
)
14836 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14837 (int) data_remaining
);
14841 vms_external
= (Elf64_External_VMS_Note
*) external
;
14842 inote
.type
= BYTE_GET (vms_external
->type
);
14843 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14844 inote
.namedata
= vms_external
->name
;
14845 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14846 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14847 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14848 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14851 if (inote
.descdata
< (char *) external
+ min_notesz
14852 || next
< (char *) external
+ min_notesz
14853 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14854 || inote
.namedata
+ inote
.namesz
< inote
.namedata
14855 || inote
.descdata
+ inote
.descsz
< inote
.descdata
14856 || data_remaining
< (size_t)(next
- (char *) external
))
14858 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14859 (unsigned long) ((char *) external
- (char *) pnotes
));
14860 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14861 inote
.type
, inote
.namesz
, inote
.descsz
);
14865 external
= (Elf_External_Note
*) next
;
14867 /* Verify that name is null terminated. It appears that at least
14868 one version of Linux (RedHat 6.0) generates corefiles that don't
14869 comply with the ELF spec by failing to include the null byte in
14871 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14873 temp
= (char *) malloc (inote
.namesz
+ 1);
14876 error (_("Out of memory allocating space for inote name\n"));
14881 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14882 temp
[inote
.namesz
] = 0;
14884 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14885 inote
.namedata
= temp
;
14888 res
&= process_note (& inote
);
14903 process_corefile_note_segments (FILE * file
)
14905 Elf_Internal_Phdr
* segment
;
14909 if (! get_program_headers (file
))
14912 for (i
= 0, segment
= program_headers
;
14913 i
< elf_header
.e_phnum
;
14916 if (segment
->p_type
== PT_NOTE
)
14917 res
&= process_corefile_note_segment (file
,
14918 (bfd_vma
) segment
->p_offset
,
14919 (bfd_vma
) segment
->p_filesz
);
14926 process_note_sections (FILE * file
)
14928 Elf_Internal_Shdr
* section
;
14933 for (i
= 0, section
= section_headers
;
14934 i
< elf_header
.e_shnum
&& section
!= NULL
;
14936 if (section
->sh_type
== SHT_NOTE
)
14938 res
&= process_corefile_note_segment (file
,
14939 (bfd_vma
) section
->sh_offset
,
14940 (bfd_vma
) section
->sh_size
);
14945 /* Try processing NOTE segments instead. */
14946 return process_corefile_note_segments (file
);
14952 process_notes (FILE * file
)
14954 /* If we have not been asked to display the notes then do nothing. */
14958 if (elf_header
.e_type
!= ET_CORE
)
14959 return process_note_sections (file
);
14961 /* No program headers means no NOTE segment. */
14962 if (elf_header
.e_phnum
> 0)
14963 return process_corefile_note_segments (file
);
14965 printf (_("No note segments present in the core file.\n"));
14970 process_arch_specific (FILE * file
)
14975 switch (elf_header
.e_machine
)
14978 return process_arm_specific (file
);
14980 case EM_MIPS_RS3_LE
:
14981 return process_mips_specific (file
);
14984 return process_nds32_specific (file
);
14987 return process_power_specific (file
);
14990 case EM_SPARC32PLUS
:
14992 return process_sparc_specific (file
);
14995 return process_tic6x_specific (file
);
14998 return process_msp430x_specific (file
);
15006 get_file_header (FILE * file
)
15008 /* Read in the identity array. */
15009 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15012 /* Determine how to read the rest of the header. */
15013 switch (elf_header
.e_ident
[EI_DATA
])
15015 default: /* fall through */
15016 case ELFDATANONE
: /* fall through */
15018 byte_get
= byte_get_little_endian
;
15019 byte_put
= byte_put_little_endian
;
15022 byte_get
= byte_get_big_endian
;
15023 byte_put
= byte_put_big_endian
;
15027 /* For now we only support 32 bit and 64 bit ELF files. */
15028 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15030 /* Read in the rest of the header. */
15033 Elf32_External_Ehdr ehdr32
;
15035 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15038 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15039 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15040 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15041 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15042 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15043 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15044 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15045 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15046 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15047 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15048 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15049 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15050 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15054 Elf64_External_Ehdr ehdr64
;
15056 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15057 we will not be able to cope with the 64bit data found in
15058 64 ELF files. Detect this now and abort before we start
15059 overwriting things. */
15060 if (sizeof (bfd_vma
) < 8)
15062 error (_("This instance of readelf has been built without support for a\n\
15063 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15067 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15070 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15071 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15072 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15073 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15074 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15075 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15076 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15077 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15078 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15079 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15080 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15081 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15082 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15085 if (elf_header
.e_shoff
)
15087 /* There may be some extensions in the first section header. Don't
15088 bomb if we can't read it. */
15090 get_32bit_section_headers (file
, TRUE
);
15092 get_64bit_section_headers (file
, TRUE
);
15098 /* Process one ELF object file according to the command line options.
15099 This file may actually be stored in an archive. The file is
15100 positioned at the start of the ELF object. */
15103 process_object (char * file_name
, FILE * file
)
15107 if (! get_file_header (file
))
15109 error (_("%s: Failed to read file header\n"), file_name
);
15113 /* Initialise per file variables. */
15114 for (i
= ARRAY_SIZE (version_info
); i
--;)
15115 version_info
[i
] = 0;
15117 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15118 dynamic_info
[i
] = 0;
15119 dynamic_info_DT_GNU_HASH
= 0;
15121 /* Process the file. */
15123 printf (_("\nFile: %s\n"), file_name
);
15125 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15126 Note we do this even if cmdline_dump_sects is empty because we
15127 must make sure that the dump_sets array is zeroed out before each
15128 object file is processed. */
15129 if (num_dump_sects
> num_cmdline_dump_sects
)
15130 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15132 if (num_cmdline_dump_sects
> 0)
15134 if (num_dump_sects
== 0)
15135 /* A sneaky way of allocating the dump_sects array. */
15136 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15138 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15139 memcpy (dump_sects
, cmdline_dump_sects
,
15140 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15143 if (! process_file_header ())
15146 if (! process_section_headers (file
))
15148 /* Without loaded section headers we cannot process lots of
15150 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15152 if (! do_using_dynamic
)
15153 do_syms
= do_dyn_syms
= do_reloc
= 0;
15156 if (! process_section_groups (file
))
15158 /* Without loaded section groups we cannot process unwind. */
15162 if (process_program_headers (file
))
15163 process_dynamic_section (file
);
15165 process_relocs (file
);
15167 process_unwind (file
);
15169 process_symbol_table (file
);
15171 process_syminfo (file
);
15173 process_version_sections (file
);
15175 process_section_contents (file
);
15177 process_notes (file
);
15179 process_gnu_liblist (file
);
15181 process_arch_specific (file
);
15183 if (program_headers
)
15185 free (program_headers
);
15186 program_headers
= NULL
;
15189 if (section_headers
)
15191 free (section_headers
);
15192 section_headers
= NULL
;
15197 free (string_table
);
15198 string_table
= NULL
;
15199 string_table_length
= 0;
15202 if (dynamic_strings
)
15204 free (dynamic_strings
);
15205 dynamic_strings
= NULL
;
15206 dynamic_strings_length
= 0;
15209 if (dynamic_symbols
)
15211 free (dynamic_symbols
);
15212 dynamic_symbols
= NULL
;
15213 num_dynamic_syms
= 0;
15216 if (dynamic_syminfo
)
15218 free (dynamic_syminfo
);
15219 dynamic_syminfo
= NULL
;
15222 if (dynamic_section
)
15224 free (dynamic_section
);
15225 dynamic_section
= NULL
;
15228 if (section_headers_groups
)
15230 free (section_headers_groups
);
15231 section_headers_groups
= NULL
;
15234 if (section_groups
)
15236 struct group_list
* g
;
15237 struct group_list
* next
;
15239 for (i
= 0; i
< group_count
; i
++)
15241 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15248 free (section_groups
);
15249 section_groups
= NULL
;
15252 free_debug_memory ();
15257 /* Process an ELF archive.
15258 On entry the file is positioned just after the ARMAG string. */
15261 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15263 struct archive_info arch
;
15264 struct archive_info nested_arch
;
15270 /* The ARCH structure is used to hold information about this archive. */
15271 arch
.file_name
= NULL
;
15273 arch
.index_array
= NULL
;
15274 arch
.sym_table
= NULL
;
15275 arch
.longnames
= NULL
;
15277 /* The NESTED_ARCH structure is used as a single-item cache of information
15278 about a nested archive (when members of a thin archive reside within
15279 another regular archive file). */
15280 nested_arch
.file_name
= NULL
;
15281 nested_arch
.file
= NULL
;
15282 nested_arch
.index_array
= NULL
;
15283 nested_arch
.sym_table
= NULL
;
15284 nested_arch
.longnames
= NULL
;
15286 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15292 if (do_archive_index
)
15294 if (arch
.sym_table
== NULL
)
15295 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15298 unsigned long i
, l
;
15299 unsigned long current_pos
;
15301 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15302 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15303 current_pos
= ftell (file
);
15305 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15307 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15309 char * member_name
;
15311 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15313 if (member_name
!= NULL
)
15315 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15317 if (qualified_name
!= NULL
)
15319 printf (_("Contents of binary %s at offset "), qualified_name
);
15320 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15322 free (qualified_name
);
15327 if (l
>= arch
.sym_size
)
15329 error (_("%s: end of the symbol table reached before the end of the index\n"),
15333 /* PR 17531: file: 0b6630b2. */
15334 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15335 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15338 if (arch
.uses_64bit_indicies
)
15343 if (l
< arch
.sym_size
)
15344 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15345 file_name
, arch
.sym_size
- l
);
15347 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15349 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15355 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15356 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15357 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15358 && !do_section_groups
&& !do_dyn_syms
)
15360 ret
= 0; /* Archive index only. */
15371 char * qualified_name
;
15373 /* Read the next archive header. */
15374 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15376 error (_("%s: failed to seek to next archive header\n"), file_name
);
15379 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15380 if (got
!= sizeof arch
.arhdr
)
15384 error (_("%s: failed to read archive header\n"), file_name
);
15388 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15390 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15395 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15397 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15398 if (archive_file_size
& 01)
15399 ++archive_file_size
;
15401 name
= get_archive_member_name (&arch
, &nested_arch
);
15404 error (_("%s: bad archive file name\n"), file_name
);
15408 namelen
= strlen (name
);
15410 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15411 if (qualified_name
== NULL
)
15413 error (_("%s: bad archive file name\n"), file_name
);
15418 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15420 /* This is a proxy for an external member of a thin archive. */
15421 FILE * member_file
;
15422 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15423 if (member_file_name
== NULL
)
15429 member_file
= fopen (member_file_name
, "rb");
15430 if (member_file
== NULL
)
15432 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15433 free (member_file_name
);
15438 archive_file_offset
= arch
.nested_member_origin
;
15440 ret
|= process_object (qualified_name
, member_file
);
15442 fclose (member_file
);
15443 free (member_file_name
);
15445 else if (is_thin_archive
)
15447 /* PR 15140: Allow for corrupt thin archives. */
15448 if (nested_arch
.file
== NULL
)
15450 error (_("%s: contains corrupt thin archive: %s\n"),
15456 /* This is a proxy for a member of a nested archive. */
15457 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15459 /* The nested archive file will have been opened and setup by
15460 get_archive_member_name. */
15461 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15463 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15468 ret
|= process_object (qualified_name
, nested_arch
.file
);
15472 archive_file_offset
= arch
.next_arhdr_offset
;
15473 arch
.next_arhdr_offset
+= archive_file_size
;
15475 ret
|= process_object (qualified_name
, file
);
15478 if (dump_sects
!= NULL
)
15482 num_dump_sects
= 0;
15485 free (qualified_name
);
15489 if (nested_arch
.file
!= NULL
)
15490 fclose (nested_arch
.file
);
15491 release_archive (&nested_arch
);
15492 release_archive (&arch
);
15498 process_file (char * file_name
)
15501 struct stat statbuf
;
15502 char armag
[SARMAG
];
15505 if (stat (file_name
, &statbuf
) < 0)
15507 if (errno
== ENOENT
)
15508 error (_("'%s': No such file\n"), file_name
);
15510 error (_("Could not locate '%s'. System error message: %s\n"),
15511 file_name
, strerror (errno
));
15515 if (! S_ISREG (statbuf
.st_mode
))
15517 error (_("'%s' is not an ordinary file\n"), file_name
);
15521 file
= fopen (file_name
, "rb");
15524 error (_("Input file '%s' is not readable.\n"), file_name
);
15528 if (fread (armag
, SARMAG
, 1, file
) != 1)
15530 error (_("%s: Failed to read file's magic number\n"), file_name
);
15535 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15537 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15538 ret
= process_archive (file_name
, file
, FALSE
);
15539 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15540 ret
= process_archive (file_name
, file
, TRUE
);
15543 if (do_archive_index
)
15544 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15548 archive_file_size
= archive_file_offset
= 0;
15549 ret
= process_object (file_name
, file
);
15554 current_file_size
= 0;
15558 #ifdef SUPPORT_DISASSEMBLY
15559 /* Needed by the i386 disassembler. For extra credit, someone could
15560 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15564 print_address (unsigned int addr
, FILE * outfile
)
15566 fprintf (outfile
,"0x%8.8x", addr
);
15569 /* Needed by the i386 disassembler. */
15571 db_task_printsym (unsigned int addr
)
15573 print_address (addr
, stderr
);
15578 main (int argc
, char ** argv
)
15582 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15583 setlocale (LC_MESSAGES
, "");
15585 #if defined (HAVE_SETLOCALE)
15586 setlocale (LC_CTYPE
, "");
15588 bindtextdomain (PACKAGE
, LOCALEDIR
);
15589 textdomain (PACKAGE
);
15591 expandargv (&argc
, &argv
);
15593 parse_args (argc
, argv
);
15595 if (num_dump_sects
> 0)
15597 /* Make a copy of the dump_sects array. */
15598 cmdline_dump_sects
= (dump_type
*)
15599 malloc (num_dump_sects
* sizeof (* dump_sects
));
15600 if (cmdline_dump_sects
== NULL
)
15601 error (_("Out of memory allocating dump request table.\n"));
15604 memcpy (cmdline_dump_sects
, dump_sects
,
15605 num_dump_sects
* sizeof (* dump_sects
));
15606 num_cmdline_dump_sects
= num_dump_sects
;
15610 if (optind
< (argc
- 1))
15614 while (optind
< argc
)
15615 err
|= process_file (argv
[optind
++]);
15617 if (dump_sects
!= NULL
)
15619 if (cmdline_dump_sects
!= NULL
)
15620 free (cmdline_dump_sects
);