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 long archive_file_offset
;
169 static unsigned long archive_file_size
;
170 static unsigned long dynamic_addr
;
171 static bfd_size_type dynamic_size
;
172 static unsigned int dynamic_nent
;
173 static char * dynamic_strings
;
174 static unsigned long dynamic_strings_length
;
175 static char * string_table
;
176 static unsigned long string_table_length
;
177 static unsigned long num_dynamic_syms
;
178 static Elf_Internal_Sym
* dynamic_symbols
;
179 static Elf_Internal_Syminfo
* dynamic_syminfo
;
180 static unsigned long dynamic_syminfo_offset
;
181 static unsigned int dynamic_syminfo_nent
;
182 static char program_interpreter
[PATH_MAX
];
183 static bfd_vma dynamic_info
[DT_ENCODING
];
184 static bfd_vma dynamic_info_DT_GNU_HASH
;
185 static bfd_vma version_info
[16];
186 static Elf_Internal_Ehdr elf_header
;
187 static Elf_Internal_Shdr
* section_headers
;
188 static Elf_Internal_Phdr
* program_headers
;
189 static Elf_Internal_Dyn
* dynamic_section
;
190 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
191 static int show_name
;
192 static int do_dynamic
;
194 static int do_dyn_syms
;
196 static int do_sections
;
197 static int do_section_groups
;
198 static int do_section_details
;
199 static int do_segments
;
200 static int do_unwind
;
201 static int do_using_dynamic
;
202 static int do_header
;
204 static int do_version
;
205 static int do_histogram
;
206 static int do_debugging
;
209 static int do_archive_index
;
210 static int is_32bit_elf
;
214 struct group_list
* next
;
215 unsigned int section_index
;
220 struct group_list
* root
;
221 unsigned int group_index
;
224 static size_t group_count
;
225 static struct group
* section_groups
;
226 static struct group
** section_headers_groups
;
229 /* Flag bits indicating particular types of dump. */
230 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
231 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
234 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
236 typedef unsigned char dump_type
;
238 /* A linked list of the section names for which dumps were requested. */
239 struct dump_list_entry
243 struct dump_list_entry
* next
;
245 static struct dump_list_entry
* dump_sects_byname
;
247 /* A dynamic array of flags indicating for which sections a dump
248 has been requested via command line switches. */
249 static dump_type
* cmdline_dump_sects
= NULL
;
250 static unsigned int num_cmdline_dump_sects
= 0;
252 /* A dynamic array of flags indicating for which sections a dump of
253 some kind has been requested. It is reset on a per-object file
254 basis and then initialised from the cmdline_dump_sects array,
255 the results of interpreting the -w switch, and the
256 dump_sects_byname list. */
257 static dump_type
* dump_sects
= NULL
;
258 static unsigned int num_dump_sects
= 0;
261 /* How to print a vma value. */
262 typedef enum print_mode
276 #define SECTION_NAME(X) \
277 ((X) == NULL ? _("<none>") \
278 : string_table == NULL ? _("<no-name>") \
279 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
280 : string_table + (X)->sh_name))
282 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
284 #define GET_ELF_SYMBOLS(file, section, sym_count) \
285 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
286 : get_64bit_elf_symbols (file, section, sym_count))
288 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
289 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
290 already been called and verified that the string exists. */
291 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
293 #define REMOVE_ARCH_BITS(ADDR) \
296 if (elf_header.e_machine == EM_ARM) \
301 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
302 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
303 using malloc and fill that. In either case return the pointer to the start of
304 the retrieved data or NULL if something went wrong. If something does go wrong
305 emit an error message using REASON as part of the context. */
308 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
313 if (size
== 0 || nmemb
== 0)
316 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
318 error (_("Unable to seek to 0x%lx for %s\n"),
319 (unsigned long) archive_file_offset
+ offset
, reason
);
326 /* Check for overflow. */
327 if (nmemb
< (~(size_t) 0 - 1) / size
)
328 /* + 1 so that we can '\0' terminate invalid string table sections. */
329 mvar
= malloc (size
* nmemb
+ 1);
333 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
334 (unsigned long)(size
* nmemb
), reason
);
338 ((char *) mvar
)[size
* nmemb
] = '\0';
341 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
343 error (_("Unable to read in 0x%lx bytes of %s\n"),
344 (unsigned long)(size
* nmemb
), reason
);
353 /* Print a VMA value. */
356 print_vma (bfd_vma vma
, print_mode mode
)
369 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
376 return printf ("%5" BFD_VMA_FMT
"d", vma
);
384 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
387 return printf ("%" BFD_VMA_FMT
"d", vma
);
390 return printf ("%" BFD_VMA_FMT
"u", vma
);
395 /* Display a symbol on stdout. Handles the display of control characters and
396 multibye characters (assuming the host environment supports them).
398 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
400 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
401 padding as necessary.
403 Returns the number of emitted characters. */
406 print_symbol (int width
, const char *symbol
)
408 bfd_boolean extra_padding
= FALSE
;
410 #ifdef HAVE_MBSTATE_T
417 /* Keep the width positive. This also helps. */
419 extra_padding
= TRUE
;
423 /* Set the remaining width to a very large value.
424 This simplifies the code below. */
425 width_remaining
= INT_MAX
;
427 width_remaining
= width
;
429 #ifdef HAVE_MBSTATE_T
430 /* Initialise the multibyte conversion state. */
431 memset (& state
, 0, sizeof (state
));
434 while (width_remaining
)
437 const char c
= *symbol
++;
442 /* Do not print control characters directly as they can affect terminal
443 settings. Such characters usually appear in the names generated
444 by the assembler for local labels. */
447 if (width_remaining
< 2)
450 printf ("^%c", c
+ 0x40);
451 width_remaining
-= 2;
454 else if (ISPRINT (c
))
462 #ifdef HAVE_MBSTATE_T
465 /* Let printf do the hard work of displaying multibyte characters. */
466 printf ("%.1s", symbol
- 1);
470 #ifdef HAVE_MBSTATE_T
471 /* Try to find out how many bytes made up the character that was
472 just printed. Advance the symbol pointer past the bytes that
474 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
478 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
483 if (extra_padding
&& num_printed
< width
)
485 /* Fill in the remaining spaces. */
486 printf ("%-*s", width
- num_printed
, " ");
493 /* Return a pointer to section NAME, or NULL if no such section exists. */
495 static Elf_Internal_Shdr
*
496 find_section (const char * name
)
500 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
501 if (streq (SECTION_NAME (section_headers
+ i
), name
))
502 return section_headers
+ i
;
507 /* Return a pointer to a section containing ADDR, or NULL if no such
510 static Elf_Internal_Shdr
*
511 find_section_by_address (bfd_vma addr
)
515 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
517 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
518 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
525 /* Return a pointer to section NAME, or NULL if no such section exists,
526 restricted to the list of sections given in SET. */
528 static Elf_Internal_Shdr
*
529 find_section_in_set (const char * name
, unsigned int * set
)
535 while ((i
= *set
++) > 0)
536 if (streq (SECTION_NAME (section_headers
+ i
), name
))
537 return section_headers
+ i
;
540 return find_section (name
);
543 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
546 static inline unsigned long
547 read_uleb128 (unsigned char *data
,
548 unsigned int *length_return
,
549 const unsigned char * const end
)
551 return read_leb128 (data
, length_return
, FALSE
, end
);
554 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
555 This OS has so many departures from the ELF standard that we test it at
561 return elf_header
.e_machine
== EM_IA_64
562 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
565 /* Guess the relocation size commonly used by the specific machines. */
568 guess_is_rela (unsigned int e_machine
)
572 /* Targets that use REL relocations. */
587 /* Targets that use RELA relocations. */
591 case EM_ADAPTEVA_EPIPHANY
:
593 case EM_ALTERA_NIOS2
:
612 case EM_LATTICEMICO32
:
621 case EM_CYGNUS_MN10200
:
623 case EM_CYGNUS_MN10300
:
656 case EM_MICROBLAZE_OLD
:
677 warn (_("Don't know about relocations on this machine architecture\n"));
683 slurp_rela_relocs (FILE * file
,
684 unsigned long rel_offset
,
685 unsigned long rel_size
,
686 Elf_Internal_Rela
** relasp
,
687 unsigned long * nrelasp
)
689 Elf_Internal_Rela
* relas
;
690 unsigned long nrelas
;
695 Elf32_External_Rela
* erelas
;
697 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
698 rel_size
, _("32-bit relocation data"));
702 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
704 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
705 sizeof (Elf_Internal_Rela
));
710 error (_("out of memory parsing relocs\n"));
714 for (i
= 0; i
< nrelas
; i
++)
716 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
717 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
718 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
725 Elf64_External_Rela
* erelas
;
727 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
728 rel_size
, _("64-bit relocation data"));
732 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
734 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
735 sizeof (Elf_Internal_Rela
));
740 error (_("out of memory parsing relocs\n"));
744 for (i
= 0; i
< nrelas
; i
++)
746 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
747 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
748 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
750 /* The #ifdef BFD64 below is to prevent a compile time
751 warning. We know that if we do not have a 64 bit data
752 type that we will never execute this code anyway. */
754 if (elf_header
.e_machine
== EM_MIPS
755 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
757 /* In little-endian objects, r_info isn't really a
758 64-bit little-endian value: it has a 32-bit
759 little-endian symbol index followed by four
760 individual byte fields. Reorder INFO
762 bfd_vma inf
= relas
[i
].r_info
;
763 inf
= (((inf
& 0xffffffff) << 32)
764 | ((inf
>> 56) & 0xff)
765 | ((inf
>> 40) & 0xff00)
766 | ((inf
>> 24) & 0xff0000)
767 | ((inf
>> 8) & 0xff000000));
768 relas
[i
].r_info
= inf
;
781 slurp_rel_relocs (FILE * file
,
782 unsigned long rel_offset
,
783 unsigned long rel_size
,
784 Elf_Internal_Rela
** relsp
,
785 unsigned long * nrelsp
)
787 Elf_Internal_Rela
* rels
;
793 Elf32_External_Rel
* erels
;
795 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
796 rel_size
, _("32-bit relocation data"));
800 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
802 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
807 error (_("out of memory parsing relocs\n"));
811 for (i
= 0; i
< nrels
; i
++)
813 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
814 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
815 rels
[i
].r_addend
= 0;
822 Elf64_External_Rel
* erels
;
824 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
825 rel_size
, _("64-bit relocation data"));
829 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
831 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
836 error (_("out of memory parsing relocs\n"));
840 for (i
= 0; i
< nrels
; i
++)
842 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
843 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
844 rels
[i
].r_addend
= 0;
846 /* The #ifdef BFD64 below is to prevent a compile time
847 warning. We know that if we do not have a 64 bit data
848 type that we will never execute this code anyway. */
850 if (elf_header
.e_machine
== EM_MIPS
851 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
853 /* In little-endian objects, r_info isn't really a
854 64-bit little-endian value: it has a 32-bit
855 little-endian symbol index followed by four
856 individual byte fields. Reorder INFO
858 bfd_vma inf
= rels
[i
].r_info
;
859 inf
= (((inf
& 0xffffffff) << 32)
860 | ((inf
>> 56) & 0xff)
861 | ((inf
>> 40) & 0xff00)
862 | ((inf
>> 24) & 0xff0000)
863 | ((inf
>> 8) & 0xff000000));
864 rels
[i
].r_info
= inf
;
876 /* Returns the reloc type extracted from the reloc info field. */
879 get_reloc_type (bfd_vma reloc_info
)
882 return ELF32_R_TYPE (reloc_info
);
884 switch (elf_header
.e_machine
)
887 /* Note: We assume that reloc_info has already been adjusted for us. */
888 return ELF64_MIPS_R_TYPE (reloc_info
);
891 return ELF64_R_TYPE_ID (reloc_info
);
894 return ELF64_R_TYPE (reloc_info
);
898 /* Return the symbol index extracted from the reloc info field. */
901 get_reloc_symindex (bfd_vma reloc_info
)
903 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
906 static inline bfd_boolean
907 uses_msp430x_relocs (void)
910 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
911 /* GCC uses osabi == ELFOSBI_STANDALONE. */
912 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
913 /* TI compiler uses ELFOSABI_NONE. */
914 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
917 /* Display the contents of the relocation data found at the specified
921 dump_relocations (FILE * file
,
922 unsigned long rel_offset
,
923 unsigned long rel_size
,
924 Elf_Internal_Sym
* symtab
,
927 unsigned long strtablen
,
931 Elf_Internal_Rela
* rels
;
933 if (is_rela
== UNKNOWN
)
934 is_rela
= guess_is_rela (elf_header
.e_machine
);
938 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
943 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
952 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
954 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
959 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
961 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
969 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
971 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
976 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
978 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
982 for (i
= 0; i
< rel_size
; i
++)
987 bfd_vma symtab_index
;
990 offset
= rels
[i
].r_offset
;
991 inf
= rels
[i
].r_info
;
993 type
= get_reloc_type (inf
);
994 symtab_index
= get_reloc_symindex (inf
);
998 printf ("%8.8lx %8.8lx ",
999 (unsigned long) offset
& 0xffffffff,
1000 (unsigned long) inf
& 0xffffffff);
1004 #if BFD_HOST_64BIT_LONG
1006 ? "%16.16lx %16.16lx "
1007 : "%12.12lx %12.12lx ",
1009 #elif BFD_HOST_64BIT_LONG_LONG
1012 ? "%16.16llx %16.16llx "
1013 : "%12.12llx %12.12llx ",
1017 ? "%16.16I64x %16.16I64x "
1018 : "%12.12I64x %12.12I64x ",
1023 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1024 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1025 _bfd_int64_high (offset
),
1026 _bfd_int64_low (offset
),
1027 _bfd_int64_high (inf
),
1028 _bfd_int64_low (inf
));
1032 switch (elf_header
.e_machine
)
1039 rtype
= elf_aarch64_reloc_type (type
);
1043 case EM_CYGNUS_M32R
:
1044 rtype
= elf_m32r_reloc_type (type
);
1049 rtype
= elf_i386_reloc_type (type
);
1054 rtype
= elf_m68hc11_reloc_type (type
);
1058 rtype
= elf_m68k_reloc_type (type
);
1062 rtype
= elf_i960_reloc_type (type
);
1067 rtype
= elf_avr_reloc_type (type
);
1070 case EM_OLD_SPARCV9
:
1071 case EM_SPARC32PLUS
:
1074 rtype
= elf_sparc_reloc_type (type
);
1078 rtype
= elf_spu_reloc_type (type
);
1082 rtype
= v800_reloc_type (type
);
1085 case EM_CYGNUS_V850
:
1086 rtype
= v850_reloc_type (type
);
1090 case EM_CYGNUS_D10V
:
1091 rtype
= elf_d10v_reloc_type (type
);
1095 case EM_CYGNUS_D30V
:
1096 rtype
= elf_d30v_reloc_type (type
);
1100 rtype
= elf_dlx_reloc_type (type
);
1104 rtype
= elf_sh_reloc_type (type
);
1108 case EM_CYGNUS_MN10300
:
1109 rtype
= elf_mn10300_reloc_type (type
);
1113 case EM_CYGNUS_MN10200
:
1114 rtype
= elf_mn10200_reloc_type (type
);
1118 case EM_CYGNUS_FR30
:
1119 rtype
= elf_fr30_reloc_type (type
);
1123 rtype
= elf_frv_reloc_type (type
);
1127 rtype
= elf_mcore_reloc_type (type
);
1131 rtype
= elf_mmix_reloc_type (type
);
1135 rtype
= elf_moxie_reloc_type (type
);
1139 if (uses_msp430x_relocs ())
1141 rtype
= elf_msp430x_reloc_type (type
);
1145 rtype
= elf_msp430_reloc_type (type
);
1149 rtype
= elf_nds32_reloc_type (type
);
1153 rtype
= elf_ppc_reloc_type (type
);
1157 rtype
= elf_ppc64_reloc_type (type
);
1161 case EM_MIPS_RS3_LE
:
1162 rtype
= elf_mips_reloc_type (type
);
1166 rtype
= elf_alpha_reloc_type (type
);
1170 rtype
= elf_arm_reloc_type (type
);
1174 rtype
= elf_arc_reloc_type (type
);
1178 rtype
= elf_hppa_reloc_type (type
);
1184 rtype
= elf_h8_reloc_type (type
);
1188 rtype
= elf_or1k_reloc_type (type
);
1193 rtype
= elf_pj_reloc_type (type
);
1196 rtype
= elf_ia64_reloc_type (type
);
1200 rtype
= elf_cris_reloc_type (type
);
1204 rtype
= elf_i860_reloc_type (type
);
1210 rtype
= elf_x86_64_reloc_type (type
);
1214 rtype
= i370_reloc_type (type
);
1219 rtype
= elf_s390_reloc_type (type
);
1223 rtype
= elf_score_reloc_type (type
);
1227 rtype
= elf_xstormy16_reloc_type (type
);
1231 rtype
= elf_crx_reloc_type (type
);
1235 rtype
= elf_vax_reloc_type (type
);
1238 case EM_ADAPTEVA_EPIPHANY
:
1239 rtype
= elf_epiphany_reloc_type (type
);
1244 rtype
= elf_ip2k_reloc_type (type
);
1248 rtype
= elf_iq2000_reloc_type (type
);
1253 rtype
= elf_xtensa_reloc_type (type
);
1256 case EM_LATTICEMICO32
:
1257 rtype
= elf_lm32_reloc_type (type
);
1262 rtype
= elf_m32c_reloc_type (type
);
1266 rtype
= elf_mt_reloc_type (type
);
1270 rtype
= elf_bfin_reloc_type (type
);
1274 rtype
= elf_mep_reloc_type (type
);
1278 rtype
= elf_cr16_reloc_type (type
);
1282 case EM_MICROBLAZE_OLD
:
1283 rtype
= elf_microblaze_reloc_type (type
);
1287 rtype
= elf_rl78_reloc_type (type
);
1291 rtype
= elf_rx_reloc_type (type
);
1295 rtype
= elf_metag_reloc_type (type
);
1300 rtype
= elf_xc16x_reloc_type (type
);
1304 rtype
= elf_tic6x_reloc_type (type
);
1308 rtype
= elf_tilegx_reloc_type (type
);
1312 rtype
= elf_tilepro_reloc_type (type
);
1316 rtype
= elf_xgate_reloc_type (type
);
1319 case EM_ALTERA_NIOS2
:
1320 rtype
= elf_nios2_reloc_type (type
);
1325 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1327 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1329 if (elf_header
.e_machine
== EM_ALPHA
1331 && streq (rtype
, "R_ALPHA_LITUSE")
1334 switch (rels
[i
].r_addend
)
1336 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1337 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1338 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1339 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1340 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1341 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1342 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1343 default: rtype
= NULL
;
1346 printf (" (%s)", rtype
);
1350 printf (_("<unknown addend: %lx>"),
1351 (unsigned long) rels
[i
].r_addend
);
1354 else if (symtab_index
)
1356 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1357 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1360 Elf_Internal_Sym
* psym
;
1362 psym
= symtab
+ symtab_index
;
1366 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1370 unsigned int width
= is_32bit_elf
? 8 : 14;
1372 /* Relocations against GNU_IFUNC symbols do not use the value
1373 of the symbol as the address to relocate against. Instead
1374 they invoke the function named by the symbol and use its
1375 result as the address for relocation.
1377 To indicate this to the user, do not display the value of
1378 the symbol in the "Symbols's Value" field. Instead show
1379 its name followed by () as a hint that the symbol is
1383 || psym
->st_name
== 0
1384 || psym
->st_name
>= strtablen
)
1387 name
= strtab
+ psym
->st_name
;
1389 len
= print_symbol (width
, name
);
1390 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1394 print_vma (psym
->st_value
, LONG_HEX
);
1396 printf (is_32bit_elf
? " " : " ");
1399 if (psym
->st_name
== 0)
1401 const char * sec_name
= "<null>";
1404 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1406 if (psym
->st_shndx
< elf_header
.e_shnum
)
1408 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1409 else if (psym
->st_shndx
== SHN_ABS
)
1411 else if (psym
->st_shndx
== SHN_COMMON
)
1412 sec_name
= "COMMON";
1413 else if ((elf_header
.e_machine
== EM_MIPS
1414 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1415 || (elf_header
.e_machine
== EM_TI_C6000
1416 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1417 sec_name
= "SCOMMON";
1418 else if (elf_header
.e_machine
== EM_MIPS
1419 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1420 sec_name
= "SUNDEF";
1421 else if ((elf_header
.e_machine
== EM_X86_64
1422 || elf_header
.e_machine
== EM_L1OM
1423 || elf_header
.e_machine
== EM_K1OM
)
1424 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1425 sec_name
= "LARGE_COMMON";
1426 else if (elf_header
.e_machine
== EM_IA_64
1427 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1428 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1429 sec_name
= "ANSI_COM";
1430 else if (is_ia64_vms ()
1431 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1432 sec_name
= "VMS_SYMVEC";
1435 sprintf (name_buf
, "<section 0x%x>",
1436 (unsigned int) psym
->st_shndx
);
1437 sec_name
= name_buf
;
1440 print_symbol (22, sec_name
);
1442 else if (strtab
== NULL
)
1443 printf (_("<string table index: %3ld>"), psym
->st_name
);
1444 else if (psym
->st_name
>= strtablen
)
1445 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1447 print_symbol (22, strtab
+ psym
->st_name
);
1451 bfd_signed_vma off
= rels
[i
].r_addend
;
1454 printf (" - %" BFD_VMA_FMT
"x", - off
);
1456 printf (" + %" BFD_VMA_FMT
"x", off
);
1462 bfd_signed_vma off
= rels
[i
].r_addend
;
1464 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1466 printf ("-%" BFD_VMA_FMT
"x", - off
);
1468 printf ("%" BFD_VMA_FMT
"x", off
);
1471 if (elf_header
.e_machine
== EM_SPARCV9
1473 && streq (rtype
, "R_SPARC_OLO10"))
1474 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1479 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1481 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1482 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1483 const char * rtype2
= elf_mips_reloc_type (type2
);
1484 const char * rtype3
= elf_mips_reloc_type (type3
);
1486 printf (" Type2: ");
1489 printf (_("unrecognized: %-7lx"),
1490 (unsigned long) type2
& 0xffffffff);
1492 printf ("%-17.17s", rtype2
);
1494 printf ("\n Type3: ");
1497 printf (_("unrecognized: %-7lx"),
1498 (unsigned long) type3
& 0xffffffff);
1500 printf ("%-17.17s", rtype3
);
1511 get_mips_dynamic_type (unsigned long type
)
1515 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1516 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1517 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1518 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1519 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1520 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1521 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1522 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1523 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1524 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1525 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1526 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1527 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1528 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1529 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1530 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1531 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1532 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1533 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1534 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1535 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1536 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1537 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1538 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1539 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1540 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1541 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1542 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1543 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1544 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1545 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1546 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1547 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1548 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1549 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1550 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1551 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1552 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1553 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1554 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1555 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1556 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1557 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1558 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1559 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1566 get_sparc64_dynamic_type (unsigned long type
)
1570 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1577 get_ppc_dynamic_type (unsigned long type
)
1581 case DT_PPC_GOT
: return "PPC_GOT";
1582 case DT_PPC_OPT
: return "PPC_OPT";
1589 get_ppc64_dynamic_type (unsigned long type
)
1593 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1594 case DT_PPC64_OPD
: return "PPC64_OPD";
1595 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1596 case DT_PPC64_OPT
: return "PPC64_OPT";
1603 get_parisc_dynamic_type (unsigned long type
)
1607 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1608 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1609 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1610 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1611 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1612 case DT_HP_PREINIT
: return "HP_PREINIT";
1613 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1614 case DT_HP_NEEDED
: return "HP_NEEDED";
1615 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1616 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1617 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1618 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1619 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1620 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1621 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1622 case DT_HP_FILTERED
: return "HP_FILTERED";
1623 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1624 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1625 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1626 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1627 case DT_PLT
: return "PLT";
1628 case DT_PLT_SIZE
: return "PLT_SIZE";
1629 case DT_DLT
: return "DLT";
1630 case DT_DLT_SIZE
: return "DLT_SIZE";
1637 get_ia64_dynamic_type (unsigned long type
)
1641 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1642 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1643 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1644 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1645 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1646 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1647 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1648 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1649 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1650 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1651 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1652 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1653 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1654 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1655 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1656 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1657 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1658 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1659 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1660 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1661 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1662 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1663 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1664 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1665 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1666 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1667 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1668 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1669 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1670 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1671 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1678 get_alpha_dynamic_type (unsigned long type
)
1682 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1689 get_score_dynamic_type (unsigned long type
)
1693 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1694 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1695 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1696 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1697 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1698 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1705 get_tic6x_dynamic_type (unsigned long type
)
1709 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1710 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1711 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1712 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1713 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1714 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1721 get_nios2_dynamic_type (unsigned long type
)
1725 case DT_NIOS2_GP
: return "NIOS2_GP";
1732 get_dynamic_type (unsigned long type
)
1734 static char buff
[64];
1738 case DT_NULL
: return "NULL";
1739 case DT_NEEDED
: return "NEEDED";
1740 case DT_PLTRELSZ
: return "PLTRELSZ";
1741 case DT_PLTGOT
: return "PLTGOT";
1742 case DT_HASH
: return "HASH";
1743 case DT_STRTAB
: return "STRTAB";
1744 case DT_SYMTAB
: return "SYMTAB";
1745 case DT_RELA
: return "RELA";
1746 case DT_RELASZ
: return "RELASZ";
1747 case DT_RELAENT
: return "RELAENT";
1748 case DT_STRSZ
: return "STRSZ";
1749 case DT_SYMENT
: return "SYMENT";
1750 case DT_INIT
: return "INIT";
1751 case DT_FINI
: return "FINI";
1752 case DT_SONAME
: return "SONAME";
1753 case DT_RPATH
: return "RPATH";
1754 case DT_SYMBOLIC
: return "SYMBOLIC";
1755 case DT_REL
: return "REL";
1756 case DT_RELSZ
: return "RELSZ";
1757 case DT_RELENT
: return "RELENT";
1758 case DT_PLTREL
: return "PLTREL";
1759 case DT_DEBUG
: return "DEBUG";
1760 case DT_TEXTREL
: return "TEXTREL";
1761 case DT_JMPREL
: return "JMPREL";
1762 case DT_BIND_NOW
: return "BIND_NOW";
1763 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1764 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1765 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1766 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1767 case DT_RUNPATH
: return "RUNPATH";
1768 case DT_FLAGS
: return "FLAGS";
1770 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1771 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1773 case DT_CHECKSUM
: return "CHECKSUM";
1774 case DT_PLTPADSZ
: return "PLTPADSZ";
1775 case DT_MOVEENT
: return "MOVEENT";
1776 case DT_MOVESZ
: return "MOVESZ";
1777 case DT_FEATURE
: return "FEATURE";
1778 case DT_POSFLAG_1
: return "POSFLAG_1";
1779 case DT_SYMINSZ
: return "SYMINSZ";
1780 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1782 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1783 case DT_CONFIG
: return "CONFIG";
1784 case DT_DEPAUDIT
: return "DEPAUDIT";
1785 case DT_AUDIT
: return "AUDIT";
1786 case DT_PLTPAD
: return "PLTPAD";
1787 case DT_MOVETAB
: return "MOVETAB";
1788 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1790 case DT_VERSYM
: return "VERSYM";
1792 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1793 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1794 case DT_RELACOUNT
: return "RELACOUNT";
1795 case DT_RELCOUNT
: return "RELCOUNT";
1796 case DT_FLAGS_1
: return "FLAGS_1";
1797 case DT_VERDEF
: return "VERDEF";
1798 case DT_VERDEFNUM
: return "VERDEFNUM";
1799 case DT_VERNEED
: return "VERNEED";
1800 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1802 case DT_AUXILIARY
: return "AUXILIARY";
1803 case DT_USED
: return "USED";
1804 case DT_FILTER
: return "FILTER";
1806 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1807 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1808 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1809 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1810 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1811 case DT_GNU_HASH
: return "GNU_HASH";
1814 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1816 const char * result
;
1818 switch (elf_header
.e_machine
)
1821 case EM_MIPS_RS3_LE
:
1822 result
= get_mips_dynamic_type (type
);
1825 result
= get_sparc64_dynamic_type (type
);
1828 result
= get_ppc_dynamic_type (type
);
1831 result
= get_ppc64_dynamic_type (type
);
1834 result
= get_ia64_dynamic_type (type
);
1837 result
= get_alpha_dynamic_type (type
);
1840 result
= get_score_dynamic_type (type
);
1843 result
= get_tic6x_dynamic_type (type
);
1845 case EM_ALTERA_NIOS2
:
1846 result
= get_nios2_dynamic_type (type
);
1856 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1858 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1859 || (elf_header
.e_machine
== EM_PARISC
1860 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1862 const char * result
;
1864 switch (elf_header
.e_machine
)
1867 result
= get_parisc_dynamic_type (type
);
1870 result
= get_ia64_dynamic_type (type
);
1880 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1884 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1891 get_file_type (unsigned e_type
)
1893 static char buff
[32];
1897 case ET_NONE
: return _("NONE (None)");
1898 case ET_REL
: return _("REL (Relocatable file)");
1899 case ET_EXEC
: return _("EXEC (Executable file)");
1900 case ET_DYN
: return _("DYN (Shared object file)");
1901 case ET_CORE
: return _("CORE (Core file)");
1904 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1905 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1906 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1907 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1909 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1915 get_machine_name (unsigned e_machine
)
1917 static char buff
[64]; /* XXX */
1921 case EM_NONE
: return _("None");
1922 case EM_AARCH64
: return "AArch64";
1923 case EM_M32
: return "WE32100";
1924 case EM_SPARC
: return "Sparc";
1925 case EM_SPU
: return "SPU";
1926 case EM_386
: return "Intel 80386";
1927 case EM_68K
: return "MC68000";
1928 case EM_88K
: return "MC88000";
1929 case EM_486
: return "Intel 80486";
1930 case EM_860
: return "Intel 80860";
1931 case EM_MIPS
: return "MIPS R3000";
1932 case EM_S370
: return "IBM System/370";
1933 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1934 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1935 case EM_PARISC
: return "HPPA";
1936 case EM_PPC_OLD
: return "Power PC (old)";
1937 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1938 case EM_960
: return "Intel 90860";
1939 case EM_PPC
: return "PowerPC";
1940 case EM_PPC64
: return "PowerPC64";
1941 case EM_FR20
: return "Fujitsu FR20";
1942 case EM_RH32
: return "TRW RH32";
1943 case EM_MCORE
: return "MCORE";
1944 case EM_ARM
: return "ARM";
1945 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1946 case EM_SH
: return "Renesas / SuperH SH";
1947 case EM_SPARCV9
: return "Sparc v9";
1948 case EM_TRICORE
: return "Siemens Tricore";
1949 case EM_ARC
: return "ARC";
1950 case EM_H8_300
: return "Renesas H8/300";
1951 case EM_H8_300H
: return "Renesas H8/300H";
1952 case EM_H8S
: return "Renesas H8S";
1953 case EM_H8_500
: return "Renesas H8/500";
1954 case EM_IA_64
: return "Intel IA-64";
1955 case EM_MIPS_X
: return "Stanford MIPS-X";
1956 case EM_COLDFIRE
: return "Motorola Coldfire";
1957 case EM_ALPHA
: return "Alpha";
1958 case EM_CYGNUS_D10V
:
1959 case EM_D10V
: return "d10v";
1960 case EM_CYGNUS_D30V
:
1961 case EM_D30V
: return "d30v";
1962 case EM_CYGNUS_M32R
:
1963 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1964 case EM_CYGNUS_V850
:
1965 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1966 case EM_V850
: return "Renesas V850";
1967 case EM_CYGNUS_MN10300
:
1968 case EM_MN10300
: return "mn10300";
1969 case EM_CYGNUS_MN10200
:
1970 case EM_MN10200
: return "mn10200";
1971 case EM_MOXIE
: return "Moxie";
1972 case EM_CYGNUS_FR30
:
1973 case EM_FR30
: return "Fujitsu FR30";
1974 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1976 case EM_PJ
: return "picoJava";
1977 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1978 case EM_PCP
: return "Siemens PCP";
1979 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1980 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1981 case EM_STARCORE
: return "Motorola Star*Core processor";
1982 case EM_ME16
: return "Toyota ME16 processor";
1983 case EM_ST100
: return "STMicroelectronics ST100 processor";
1984 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1985 case EM_PDSP
: return "Sony DSP processor";
1986 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1987 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1988 case EM_FX66
: return "Siemens FX66 microcontroller";
1989 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1990 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1991 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1992 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1993 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1994 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1995 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1996 case EM_SVX
: return "Silicon Graphics SVx";
1997 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1998 case EM_VAX
: return "Digital VAX";
2000 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2001 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2002 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2003 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2004 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2005 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2006 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2007 case EM_PRISM
: return "Vitesse Prism";
2008 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2009 case EM_L1OM
: return "Intel L1OM";
2010 case EM_K1OM
: return "Intel K1OM";
2012 case EM_S390
: return "IBM S/390";
2013 case EM_SCORE
: return "SUNPLUS S+Core";
2014 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2015 case EM_OR1K
: return "OpenRISC 1000";
2016 case EM_ARC_A5
: return "ARC International ARCompact processor";
2017 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2018 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2019 case EM_DLX
: return "OpenDLX";
2021 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2022 case EM_IQ2000
: return "Vitesse IQ2000";
2024 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2025 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2026 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2027 case EM_NS32K
: return "National Semiconductor 32000 series";
2028 case EM_TPC
: return "Tenor Network TPC processor";
2029 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2030 case EM_MAX
: return "MAX Processor";
2031 case EM_CR
: return "National Semiconductor CompactRISC";
2032 case EM_F2MC16
: return "Fujitsu F2MC16";
2033 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2034 case EM_LATTICEMICO32
: return "Lattice Mico32";
2036 case EM_M32C
: return "Renesas M32c";
2037 case EM_MT
: return "Morpho Techologies MT processor";
2038 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2039 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2040 case EM_SEP
: return "Sharp embedded microprocessor";
2041 case EM_ARCA
: return "Arca RISC microprocessor";
2042 case EM_UNICORE
: return "Unicore";
2043 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2044 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2045 case EM_NIOS32
: return "Altera Nios";
2046 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2048 case EM_XC16X
: return "Infineon Technologies xc16x";
2049 case EM_M16C
: return "Renesas M16C series microprocessors";
2050 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2051 case EM_CE
: return "Freescale Communication Engine RISC core";
2052 case EM_TSK3000
: return "Altium TSK3000 core";
2053 case EM_RS08
: return "Freescale RS08 embedded processor";
2054 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2055 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2056 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2057 case EM_SE_C17
: return "Seiko Epson C17 family";
2058 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2059 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2060 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2061 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2062 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2063 case EM_R32C
: return "Renesas R32C series microprocessors";
2064 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2065 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2066 case EM_8051
: return "Intel 8051 and variants";
2067 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2068 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2069 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2070 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2071 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2072 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2073 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2074 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2077 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2078 case EM_RL78
: return "Renesas RL78";
2079 case EM_RX
: return "Renesas RX";
2080 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2081 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2082 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2083 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2084 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2085 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2086 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2087 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2088 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2089 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2090 case EM_CUDA
: return "NVIDIA CUDA architecture";
2091 case EM_XGATE
: return "Motorola XGATE embedded processor";
2093 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2099 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2104 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2105 e_flags
&= ~ EF_ARM_EABIMASK
;
2107 /* Handle "generic" ARM flags. */
2108 if (e_flags
& EF_ARM_RELEXEC
)
2110 strcat (buf
, ", relocatable executable");
2111 e_flags
&= ~ EF_ARM_RELEXEC
;
2114 if (e_flags
& EF_ARM_HASENTRY
)
2116 strcat (buf
, ", has entry point");
2117 e_flags
&= ~ EF_ARM_HASENTRY
;
2120 /* Now handle EABI specific flags. */
2124 strcat (buf
, ", <unrecognized EABI>");
2129 case EF_ARM_EABI_VER1
:
2130 strcat (buf
, ", Version1 EABI");
2135 /* Process flags one bit at a time. */
2136 flag
= e_flags
& - e_flags
;
2141 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2142 strcat (buf
, ", sorted symbol tables");
2152 case EF_ARM_EABI_VER2
:
2153 strcat (buf
, ", Version2 EABI");
2158 /* Process flags one bit at a time. */
2159 flag
= e_flags
& - e_flags
;
2164 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2165 strcat (buf
, ", sorted symbol tables");
2168 case EF_ARM_DYNSYMSUSESEGIDX
:
2169 strcat (buf
, ", dynamic symbols use segment index");
2172 case EF_ARM_MAPSYMSFIRST
:
2173 strcat (buf
, ", mapping symbols precede others");
2183 case EF_ARM_EABI_VER3
:
2184 strcat (buf
, ", Version3 EABI");
2187 case EF_ARM_EABI_VER4
:
2188 strcat (buf
, ", Version4 EABI");
2193 /* Process flags one bit at a time. */
2194 flag
= e_flags
& - e_flags
;
2200 strcat (buf
, ", BE8");
2204 strcat (buf
, ", LE8");
2215 case EF_ARM_EABI_VER5
:
2216 strcat (buf
, ", Version5 EABI");
2221 /* Process flags one bit at a time. */
2222 flag
= e_flags
& - e_flags
;
2228 strcat (buf
, ", BE8");
2232 strcat (buf
, ", LE8");
2235 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2236 strcat (buf
, ", soft-float ABI");
2239 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2240 strcat (buf
, ", hard-float ABI");
2250 case EF_ARM_EABI_UNKNOWN
:
2251 strcat (buf
, ", GNU EABI");
2256 /* Process flags one bit at a time. */
2257 flag
= e_flags
& - e_flags
;
2262 case EF_ARM_INTERWORK
:
2263 strcat (buf
, ", interworking enabled");
2266 case EF_ARM_APCS_26
:
2267 strcat (buf
, ", uses APCS/26");
2270 case EF_ARM_APCS_FLOAT
:
2271 strcat (buf
, ", uses APCS/float");
2275 strcat (buf
, ", position independent");
2279 strcat (buf
, ", 8 bit structure alignment");
2282 case EF_ARM_NEW_ABI
:
2283 strcat (buf
, ", uses new ABI");
2286 case EF_ARM_OLD_ABI
:
2287 strcat (buf
, ", uses old ABI");
2290 case EF_ARM_SOFT_FLOAT
:
2291 strcat (buf
, ", software FP");
2294 case EF_ARM_VFP_FLOAT
:
2295 strcat (buf
, ", VFP");
2298 case EF_ARM_MAVERICK_FLOAT
:
2299 strcat (buf
, ", Maverick FP");
2310 strcat (buf
,_(", <unknown>"));
2314 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2323 static const char *ABI_STRINGS
[] =
2325 "ABI v0", /* use r5 as return register; only used in N1213HC */
2326 "ABI v1", /* use r0 as return register */
2327 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2328 "ABI v2fp", /* for FPU */
2331 static const char *VER_STRINGS
[] =
2333 "Andes ELF V1.3 or older",
2337 static const char *ARCH_STRINGS
[] =
2346 abi
= EF_NDS_ABI
& e_flags
;
2347 arch
= EF_NDS_ARCH
& e_flags
;
2348 config
= EF_NDS_INST
& e_flags
;
2349 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2351 memset (buf
, 0, size
);
2358 case E_NDS_ABI_V2FP
:
2359 case E_NDS_ABI_AABI
:
2360 /* In case there are holes in the array. */
2361 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2365 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2371 case E_NDS32_ELF_VER_1_2
:
2372 case E_NDS32_ELF_VER_1_3
:
2373 case E_NDS32_ELF_VER_1_4
:
2374 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2378 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2382 if (E_NDS_ABI_V0
== abi
)
2384 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2385 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2386 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2387 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2393 case E_NDS_ARCH_STAR_V1_0
:
2394 case E_NDS_ARCH_STAR_V2_0
:
2395 case E_NDS_ARCH_STAR_V3_0
:
2396 case E_NDS_ARCH_STAR_V3_M
:
2397 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2401 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2402 /* ARCH version determines how the e_flags are interpreted.
2403 If it is unknown, we cannot proceed. */
2407 /* Newer ABI; Now handle architecture specific flags. */
2408 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2410 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2411 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2413 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2414 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2416 if (config
& E_NDS32_HAS_DIV_INST
)
2417 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2419 if (config
& E_NDS32_HAS_16BIT_INST
)
2420 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2424 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2426 if (version
<= E_NDS32_ELF_VER_1_3
)
2427 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2429 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2432 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2433 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2435 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2436 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2438 if (config
& E_NDS32_HAS_16BIT_INST
)
2440 if (version
<= E_NDS32_ELF_VER_1_3
)
2441 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2443 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2447 if (config
& E_NDS32_HAS_EXT_INST
)
2448 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2450 if (config
& E_NDS32_HAS_EXT2_INST
)
2451 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2453 if (config
& E_NDS32_HAS_FPU_INST
)
2456 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2459 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2462 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2465 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2468 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2473 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2475 case E_NDS32_FPU_REG_8SP_4DP
:
2476 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2478 case E_NDS32_FPU_REG_16SP_8DP
:
2479 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2481 case E_NDS32_FPU_REG_32SP_16DP
:
2482 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2484 case E_NDS32_FPU_REG_32SP_32DP
:
2485 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2490 if (config
& E_NDS32_HAS_AUDIO_INST
)
2491 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2493 if (config
& E_NDS32_HAS_STRING_INST
)
2494 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2496 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2497 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2499 if (config
& E_NDS32_HAS_VIDEO_INST
)
2501 if (version
<= E_NDS32_ELF_VER_1_3
)
2502 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2504 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2507 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2508 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2510 if (config
& E_NDS32_HAS_L2C_INST
)
2511 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2515 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2517 static char buf
[1024];
2529 decode_ARM_machine_flags (e_flags
, buf
);
2533 if (e_flags
& EF_BFIN_PIC
)
2534 strcat (buf
, ", PIC");
2536 if (e_flags
& EF_BFIN_FDPIC
)
2537 strcat (buf
, ", FDPIC");
2539 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2540 strcat (buf
, ", code in L1");
2542 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2543 strcat (buf
, ", data in L1");
2548 switch (e_flags
& EF_FRV_CPU_MASK
)
2550 case EF_FRV_CPU_GENERIC
:
2554 strcat (buf
, ", fr???");
2557 case EF_FRV_CPU_FR300
:
2558 strcat (buf
, ", fr300");
2561 case EF_FRV_CPU_FR400
:
2562 strcat (buf
, ", fr400");
2564 case EF_FRV_CPU_FR405
:
2565 strcat (buf
, ", fr405");
2568 case EF_FRV_CPU_FR450
:
2569 strcat (buf
, ", fr450");
2572 case EF_FRV_CPU_FR500
:
2573 strcat (buf
, ", fr500");
2575 case EF_FRV_CPU_FR550
:
2576 strcat (buf
, ", fr550");
2579 case EF_FRV_CPU_SIMPLE
:
2580 strcat (buf
, ", simple");
2582 case EF_FRV_CPU_TOMCAT
:
2583 strcat (buf
, ", tomcat");
2589 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2590 strcat (buf
, ", m68000");
2591 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2592 strcat (buf
, ", cpu32");
2593 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2594 strcat (buf
, ", fido_a");
2597 char const * isa
= _("unknown");
2598 char const * mac
= _("unknown mac");
2599 char const * additional
= NULL
;
2601 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2603 case EF_M68K_CF_ISA_A_NODIV
:
2605 additional
= ", nodiv";
2607 case EF_M68K_CF_ISA_A
:
2610 case EF_M68K_CF_ISA_A_PLUS
:
2613 case EF_M68K_CF_ISA_B_NOUSP
:
2615 additional
= ", nousp";
2617 case EF_M68K_CF_ISA_B
:
2620 case EF_M68K_CF_ISA_C
:
2623 case EF_M68K_CF_ISA_C_NODIV
:
2625 additional
= ", nodiv";
2628 strcat (buf
, ", cf, isa ");
2631 strcat (buf
, additional
);
2632 if (e_flags
& EF_M68K_CF_FLOAT
)
2633 strcat (buf
, ", float");
2634 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2639 case EF_M68K_CF_MAC
:
2642 case EF_M68K_CF_EMAC
:
2645 case EF_M68K_CF_EMAC_B
:
2658 if (e_flags
& EF_PPC_EMB
)
2659 strcat (buf
, ", emb");
2661 if (e_flags
& EF_PPC_RELOCATABLE
)
2662 strcat (buf
, _(", relocatable"));
2664 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2665 strcat (buf
, _(", relocatable-lib"));
2669 if (e_flags
& EF_PPC64_ABI
)
2671 char abi
[] = ", abiv0";
2673 abi
[6] += e_flags
& EF_PPC64_ABI
;
2679 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2680 strcat (buf
, ", RH850 ABI");
2682 if (e_flags
& EF_V800_850E3
)
2683 strcat (buf
, ", V3 architecture");
2685 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2686 strcat (buf
, ", FPU not used");
2688 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2689 strcat (buf
, ", regmode: COMMON");
2691 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2692 strcat (buf
, ", r4 not used");
2694 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2695 strcat (buf
, ", r30 not used");
2697 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2698 strcat (buf
, ", r5 not used");
2700 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2701 strcat (buf
, ", r2 not used");
2703 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2705 switch (e_flags
& - e_flags
)
2707 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2708 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2709 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2710 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2711 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2712 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2713 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2714 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2715 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2716 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2717 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2718 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2719 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2720 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2721 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2722 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2729 case EM_CYGNUS_V850
:
2730 switch (e_flags
& EF_V850_ARCH
)
2732 case E_V850E3V5_ARCH
:
2733 strcat (buf
, ", v850e3v5");
2735 case E_V850E2V3_ARCH
:
2736 strcat (buf
, ", v850e2v3");
2739 strcat (buf
, ", v850e2");
2742 strcat (buf
, ", v850e1");
2745 strcat (buf
, ", v850e");
2748 strcat (buf
, ", v850");
2751 strcat (buf
, _(", unknown v850 architecture variant"));
2757 case EM_CYGNUS_M32R
:
2758 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2759 strcat (buf
, ", m32r");
2763 case EM_MIPS_RS3_LE
:
2764 if (e_flags
& EF_MIPS_NOREORDER
)
2765 strcat (buf
, ", noreorder");
2767 if (e_flags
& EF_MIPS_PIC
)
2768 strcat (buf
, ", pic");
2770 if (e_flags
& EF_MIPS_CPIC
)
2771 strcat (buf
, ", cpic");
2773 if (e_flags
& EF_MIPS_UCODE
)
2774 strcat (buf
, ", ugen_reserved");
2776 if (e_flags
& EF_MIPS_ABI2
)
2777 strcat (buf
, ", abi2");
2779 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2780 strcat (buf
, ", odk first");
2782 if (e_flags
& EF_MIPS_32BITMODE
)
2783 strcat (buf
, ", 32bitmode");
2785 if (e_flags
& EF_MIPS_NAN2008
)
2786 strcat (buf
, ", nan2008");
2788 if (e_flags
& EF_MIPS_FP64
)
2789 strcat (buf
, ", fp64");
2791 switch ((e_flags
& EF_MIPS_MACH
))
2793 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2794 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2795 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2796 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2797 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2798 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2799 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2800 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2801 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2802 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2803 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2804 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2805 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2806 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2807 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2808 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2809 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2811 /* We simply ignore the field in this case to avoid confusion:
2812 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2815 default: strcat (buf
, _(", unknown CPU")); break;
2818 switch ((e_flags
& EF_MIPS_ABI
))
2820 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2821 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2822 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2823 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2825 /* We simply ignore the field in this case to avoid confusion:
2826 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2827 This means it is likely to be an o32 file, but not for
2830 default: strcat (buf
, _(", unknown ABI")); break;
2833 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2834 strcat (buf
, ", mdmx");
2836 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2837 strcat (buf
, ", mips16");
2839 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2840 strcat (buf
, ", micromips");
2842 switch ((e_flags
& EF_MIPS_ARCH
))
2844 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2845 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2846 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2847 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2848 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2849 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2850 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2851 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2852 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2853 default: strcat (buf
, _(", unknown ISA")); break;
2858 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2862 switch ((e_flags
& EF_SH_MACH_MASK
))
2864 case EF_SH1
: strcat (buf
, ", sh1"); break;
2865 case EF_SH2
: strcat (buf
, ", sh2"); break;
2866 case EF_SH3
: strcat (buf
, ", sh3"); break;
2867 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2868 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2869 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2870 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2871 case EF_SH4
: strcat (buf
, ", sh4"); break;
2872 case EF_SH5
: strcat (buf
, ", sh5"); break;
2873 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2874 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2875 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2876 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2877 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2878 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2879 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2880 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2881 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2882 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2883 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2884 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2885 default: strcat (buf
, _(", unknown ISA")); break;
2888 if (e_flags
& EF_SH_PIC
)
2889 strcat (buf
, ", pic");
2891 if (e_flags
& EF_SH_FDPIC
)
2892 strcat (buf
, ", fdpic");
2896 if (e_flags
& EF_OR1K_NODELAY
)
2897 strcat (buf
, ", no delay");
2901 if (e_flags
& EF_SPARC_32PLUS
)
2902 strcat (buf
, ", v8+");
2904 if (e_flags
& EF_SPARC_SUN_US1
)
2905 strcat (buf
, ", ultrasparcI");
2907 if (e_flags
& EF_SPARC_SUN_US3
)
2908 strcat (buf
, ", ultrasparcIII");
2910 if (e_flags
& EF_SPARC_HAL_R1
)
2911 strcat (buf
, ", halr1");
2913 if (e_flags
& EF_SPARC_LEDATA
)
2914 strcat (buf
, ", ledata");
2916 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2917 strcat (buf
, ", tso");
2919 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2920 strcat (buf
, ", pso");
2922 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2923 strcat (buf
, ", rmo");
2927 switch (e_flags
& EF_PARISC_ARCH
)
2929 case EFA_PARISC_1_0
:
2930 strcpy (buf
, ", PA-RISC 1.0");
2932 case EFA_PARISC_1_1
:
2933 strcpy (buf
, ", PA-RISC 1.1");
2935 case EFA_PARISC_2_0
:
2936 strcpy (buf
, ", PA-RISC 2.0");
2941 if (e_flags
& EF_PARISC_TRAPNIL
)
2942 strcat (buf
, ", trapnil");
2943 if (e_flags
& EF_PARISC_EXT
)
2944 strcat (buf
, ", ext");
2945 if (e_flags
& EF_PARISC_LSB
)
2946 strcat (buf
, ", lsb");
2947 if (e_flags
& EF_PARISC_WIDE
)
2948 strcat (buf
, ", wide");
2949 if (e_flags
& EF_PARISC_NO_KABP
)
2950 strcat (buf
, ", no kabp");
2951 if (e_flags
& EF_PARISC_LAZYSWAP
)
2952 strcat (buf
, ", lazyswap");
2957 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2958 strcat (buf
, ", new calling convention");
2960 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2961 strcat (buf
, ", gnu calling convention");
2965 if ((e_flags
& EF_IA_64_ABI64
))
2966 strcat (buf
, ", 64-bit");
2968 strcat (buf
, ", 32-bit");
2969 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2970 strcat (buf
, ", reduced fp model");
2971 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2972 strcat (buf
, ", no function descriptors, constant gp");
2973 else if ((e_flags
& EF_IA_64_CONS_GP
))
2974 strcat (buf
, ", constant gp");
2975 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2976 strcat (buf
, ", absolute");
2977 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2979 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2980 strcat (buf
, ", vms_linkages");
2981 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2983 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2985 case EF_IA_64_VMS_COMCOD_WARNING
:
2986 strcat (buf
, ", warning");
2988 case EF_IA_64_VMS_COMCOD_ERROR
:
2989 strcat (buf
, ", error");
2991 case EF_IA_64_VMS_COMCOD_ABORT
:
2992 strcat (buf
, ", abort");
3001 if ((e_flags
& EF_VAX_NONPIC
))
3002 strcat (buf
, ", non-PIC");
3003 if ((e_flags
& EF_VAX_DFLOAT
))
3004 strcat (buf
, ", D-Float");
3005 if ((e_flags
& EF_VAX_GFLOAT
))
3006 strcat (buf
, ", G-Float");
3010 if (e_flags
& E_FLAG_RL78_G10
)
3011 strcat (buf
, ", G10");
3015 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3016 strcat (buf
, ", 64-bit doubles");
3017 if (e_flags
& E_FLAG_RX_DSP
)
3018 strcat (buf
, ", dsp");
3019 if (e_flags
& E_FLAG_RX_PID
)
3020 strcat (buf
, ", pid");
3021 if (e_flags
& E_FLAG_RX_ABI
)
3022 strcat (buf
, ", RX ABI");
3026 if (e_flags
& EF_S390_HIGH_GPRS
)
3027 strcat (buf
, ", highgprs");
3031 if ((e_flags
& EF_C6000_REL
))
3032 strcat (buf
, ", relocatable module");
3036 strcat (buf
, _(": architecture variant: "));
3037 switch (e_flags
& EF_MSP430_MACH
)
3039 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3040 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3041 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3042 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3043 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3044 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3045 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3046 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3047 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3048 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3049 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3050 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3051 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3052 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3053 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3055 strcat (buf
, _(": unknown")); break;
3058 if (e_flags
& ~ EF_MSP430_MACH
)
3059 strcat (buf
, _(": unknown extra flag bits also present"));
3067 get_osabi_name (unsigned int osabi
)
3069 static char buff
[32];
3073 case ELFOSABI_NONE
: return "UNIX - System V";
3074 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3075 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3076 case ELFOSABI_GNU
: return "UNIX - GNU";
3077 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3078 case ELFOSABI_AIX
: return "UNIX - AIX";
3079 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3080 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3081 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3082 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3083 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3084 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3085 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3086 case ELFOSABI_AROS
: return "AROS";
3087 case ELFOSABI_FENIXOS
: return "FenixOS";
3090 switch (elf_header
.e_machine
)
3095 case ELFOSABI_ARM
: return "ARM";
3105 case ELFOSABI_STANDALONE
: return _("Standalone App");
3114 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3115 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3124 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3130 get_aarch64_segment_type (unsigned long type
)
3134 case PT_AARCH64_ARCHEXT
:
3135 return "AARCH64_ARCHEXT";
3144 get_arm_segment_type (unsigned long type
)
3158 get_mips_segment_type (unsigned long type
)
3162 case PT_MIPS_REGINFO
:
3164 case PT_MIPS_RTPROC
:
3166 case PT_MIPS_OPTIONS
:
3176 get_parisc_segment_type (unsigned long type
)
3180 case PT_HP_TLS
: return "HP_TLS";
3181 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3182 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3183 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3184 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3185 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3186 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3187 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3188 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3189 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3190 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3191 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3192 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3193 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3194 case PT_HP_STACK
: return "HP_STACK";
3195 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3196 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3197 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3198 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3207 get_ia64_segment_type (unsigned long type
)
3211 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3212 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3213 case PT_HP_TLS
: return "HP_TLS";
3214 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3215 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3216 case PT_IA_64_HP_STACK
: return "HP_STACK";
3225 get_tic6x_segment_type (unsigned long type
)
3229 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3238 get_segment_type (unsigned long p_type
)
3240 static char buff
[32];
3244 case PT_NULL
: return "NULL";
3245 case PT_LOAD
: return "LOAD";
3246 case PT_DYNAMIC
: return "DYNAMIC";
3247 case PT_INTERP
: return "INTERP";
3248 case PT_NOTE
: return "NOTE";
3249 case PT_SHLIB
: return "SHLIB";
3250 case PT_PHDR
: return "PHDR";
3251 case PT_TLS
: return "TLS";
3253 case PT_GNU_EH_FRAME
:
3254 return "GNU_EH_FRAME";
3255 case PT_GNU_STACK
: return "GNU_STACK";
3256 case PT_GNU_RELRO
: return "GNU_RELRO";
3259 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3261 const char * result
;
3263 switch (elf_header
.e_machine
)
3266 result
= get_aarch64_segment_type (p_type
);
3269 result
= get_arm_segment_type (p_type
);
3272 case EM_MIPS_RS3_LE
:
3273 result
= get_mips_segment_type (p_type
);
3276 result
= get_parisc_segment_type (p_type
);
3279 result
= get_ia64_segment_type (p_type
);
3282 result
= get_tic6x_segment_type (p_type
);
3292 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3294 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3296 const char * result
;
3298 switch (elf_header
.e_machine
)
3301 result
= get_parisc_segment_type (p_type
);
3304 result
= get_ia64_segment_type (p_type
);
3314 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3317 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3324 get_mips_section_type_name (unsigned int sh_type
)
3328 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3329 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3330 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3331 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3332 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3333 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3334 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3335 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3336 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3337 case SHT_MIPS_RELD
: return "MIPS_RELD";
3338 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3339 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3340 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3341 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3342 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3343 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3344 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3345 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3346 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3347 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3348 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3349 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3350 case SHT_MIPS_LINE
: return "MIPS_LINE";
3351 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3352 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3353 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3354 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3355 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3356 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3357 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3358 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3359 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3360 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3361 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3362 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3363 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3364 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3365 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3366 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3374 get_parisc_section_type_name (unsigned int sh_type
)
3378 case SHT_PARISC_EXT
: return "PARISC_EXT";
3379 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3380 case SHT_PARISC_DOC
: return "PARISC_DOC";
3381 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3382 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3383 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3384 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3392 get_ia64_section_type_name (unsigned int sh_type
)
3394 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3395 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3396 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3400 case SHT_IA_64_EXT
: return "IA_64_EXT";
3401 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3402 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3403 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3404 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3405 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3406 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3407 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3408 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3409 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3417 get_x86_64_section_type_name (unsigned int sh_type
)
3421 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3429 get_aarch64_section_type_name (unsigned int sh_type
)
3433 case SHT_AARCH64_ATTRIBUTES
:
3434 return "AARCH64_ATTRIBUTES";
3442 get_arm_section_type_name (unsigned int sh_type
)
3446 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3447 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3448 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3449 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3450 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3458 get_tic6x_section_type_name (unsigned int sh_type
)
3462 case SHT_C6000_UNWIND
:
3463 return "C6000_UNWIND";
3464 case SHT_C6000_PREEMPTMAP
:
3465 return "C6000_PREEMPTMAP";
3466 case SHT_C6000_ATTRIBUTES
:
3467 return "C6000_ATTRIBUTES";
3472 case SHT_TI_HANDLER
:
3473 return "TI_HANDLER";
3474 case SHT_TI_INITINFO
:
3475 return "TI_INITINFO";
3476 case SHT_TI_PHATTRS
:
3477 return "TI_PHATTRS";
3485 get_msp430x_section_type_name (unsigned int sh_type
)
3489 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3490 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3491 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3492 default: return NULL
;
3497 get_section_type_name (unsigned int sh_type
)
3499 static char buff
[32];
3503 case SHT_NULL
: return "NULL";
3504 case SHT_PROGBITS
: return "PROGBITS";
3505 case SHT_SYMTAB
: return "SYMTAB";
3506 case SHT_STRTAB
: return "STRTAB";
3507 case SHT_RELA
: return "RELA";
3508 case SHT_HASH
: return "HASH";
3509 case SHT_DYNAMIC
: return "DYNAMIC";
3510 case SHT_NOTE
: return "NOTE";
3511 case SHT_NOBITS
: return "NOBITS";
3512 case SHT_REL
: return "REL";
3513 case SHT_SHLIB
: return "SHLIB";
3514 case SHT_DYNSYM
: return "DYNSYM";
3515 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3516 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3517 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3518 case SHT_GNU_HASH
: return "GNU_HASH";
3519 case SHT_GROUP
: return "GROUP";
3520 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3521 case SHT_GNU_verdef
: return "VERDEF";
3522 case SHT_GNU_verneed
: return "VERNEED";
3523 case SHT_GNU_versym
: return "VERSYM";
3524 case 0x6ffffff0: return "VERSYM";
3525 case 0x6ffffffc: return "VERDEF";
3526 case 0x7ffffffd: return "AUXILIARY";
3527 case 0x7fffffff: return "FILTER";
3528 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3531 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3533 const char * result
;
3535 switch (elf_header
.e_machine
)
3538 case EM_MIPS_RS3_LE
:
3539 result
= get_mips_section_type_name (sh_type
);
3542 result
= get_parisc_section_type_name (sh_type
);
3545 result
= get_ia64_section_type_name (sh_type
);
3550 result
= get_x86_64_section_type_name (sh_type
);
3553 result
= get_aarch64_section_type_name (sh_type
);
3556 result
= get_arm_section_type_name (sh_type
);
3559 result
= get_tic6x_section_type_name (sh_type
);
3562 result
= get_msp430x_section_type_name (sh_type
);
3572 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3574 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3576 const char * result
;
3578 switch (elf_header
.e_machine
)
3581 result
= get_ia64_section_type_name (sh_type
);
3591 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3593 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3594 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3596 /* This message is probably going to be displayed in a 15
3597 character wide field, so put the hex value first. */
3598 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3604 #define OPTION_DEBUG_DUMP 512
3605 #define OPTION_DYN_SYMS 513
3606 #define OPTION_DWARF_DEPTH 514
3607 #define OPTION_DWARF_START 515
3608 #define OPTION_DWARF_CHECK 516
3610 static struct option options
[] =
3612 {"all", no_argument
, 0, 'a'},
3613 {"file-header", no_argument
, 0, 'h'},
3614 {"program-headers", no_argument
, 0, 'l'},
3615 {"headers", no_argument
, 0, 'e'},
3616 {"histogram", no_argument
, 0, 'I'},
3617 {"segments", no_argument
, 0, 'l'},
3618 {"sections", no_argument
, 0, 'S'},
3619 {"section-headers", no_argument
, 0, 'S'},
3620 {"section-groups", no_argument
, 0, 'g'},
3621 {"section-details", no_argument
, 0, 't'},
3622 {"full-section-name",no_argument
, 0, 'N'},
3623 {"symbols", no_argument
, 0, 's'},
3624 {"syms", no_argument
, 0, 's'},
3625 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3626 {"relocs", no_argument
, 0, 'r'},
3627 {"notes", no_argument
, 0, 'n'},
3628 {"dynamic", no_argument
, 0, 'd'},
3629 {"arch-specific", no_argument
, 0, 'A'},
3630 {"version-info", no_argument
, 0, 'V'},
3631 {"use-dynamic", no_argument
, 0, 'D'},
3632 {"unwind", no_argument
, 0, 'u'},
3633 {"archive-index", no_argument
, 0, 'c'},
3634 {"hex-dump", required_argument
, 0, 'x'},
3635 {"relocated-dump", required_argument
, 0, 'R'},
3636 {"string-dump", required_argument
, 0, 'p'},
3637 #ifdef SUPPORT_DISASSEMBLY
3638 {"instruction-dump", required_argument
, 0, 'i'},
3640 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3642 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3643 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3644 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3646 {"version", no_argument
, 0, 'v'},
3647 {"wide", no_argument
, 0, 'W'},
3648 {"help", no_argument
, 0, 'H'},
3649 {0, no_argument
, 0, 0}
3653 usage (FILE * stream
)
3655 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3656 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3657 fprintf (stream
, _(" Options are:\n\
3658 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3659 -h --file-header Display the ELF file header\n\
3660 -l --program-headers Display the program headers\n\
3661 --segments An alias for --program-headers\n\
3662 -S --section-headers Display the sections' header\n\
3663 --sections An alias for --section-headers\n\
3664 -g --section-groups Display the section groups\n\
3665 -t --section-details Display the section details\n\
3666 -e --headers Equivalent to: -h -l -S\n\
3667 -s --syms Display the symbol table\n\
3668 --symbols An alias for --syms\n\
3669 --dyn-syms Display the dynamic symbol table\n\
3670 -n --notes Display the core notes (if present)\n\
3671 -r --relocs Display the relocations (if present)\n\
3672 -u --unwind Display the unwind info (if present)\n\
3673 -d --dynamic Display the dynamic section (if present)\n\
3674 -V --version-info Display the version sections (if present)\n\
3675 -A --arch-specific Display architecture specific information (if any)\n\
3676 -c --archive-index Display the symbol/file index in an archive\n\
3677 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3678 -x --hex-dump=<number|name>\n\
3679 Dump the contents of section <number|name> as bytes\n\
3680 -p --string-dump=<number|name>\n\
3681 Dump the contents of section <number|name> as strings\n\
3682 -R --relocated-dump=<number|name>\n\
3683 Dump the contents of section <number|name> as relocated bytes\n\
3684 -w[lLiaprmfFsoRt] or\n\
3685 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3686 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3687 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3689 Display the contents of DWARF2 debug sections\n"));
3690 fprintf (stream
, _("\
3691 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3692 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3694 #ifdef SUPPORT_DISASSEMBLY
3695 fprintf (stream
, _("\
3696 -i --instruction-dump=<number|name>\n\
3697 Disassemble the contents of section <number|name>\n"));
3699 fprintf (stream
, _("\
3700 -I --histogram Display histogram of bucket list lengths\n\
3701 -W --wide Allow output width to exceed 80 characters\n\
3702 @<file> Read options from <file>\n\
3703 -H --help Display this information\n\
3704 -v --version Display the version number of readelf\n"));
3706 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3707 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3709 exit (stream
== stdout
? 0 : 1);
3712 /* Record the fact that the user wants the contents of section number
3713 SECTION to be displayed using the method(s) encoded as flags bits
3714 in TYPE. Note, TYPE can be zero if we are creating the array for
3718 request_dump_bynumber (unsigned int section
, dump_type type
)
3720 if (section
>= num_dump_sects
)
3722 dump_type
* new_dump_sects
;
3724 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3725 sizeof (* dump_sects
));
3727 if (new_dump_sects
== NULL
)
3728 error (_("Out of memory allocating dump request table.\n"));
3731 /* Copy current flag settings. */
3732 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3736 dump_sects
= new_dump_sects
;
3737 num_dump_sects
= section
+ 1;
3742 dump_sects
[section
] |= type
;
3747 /* Request a dump by section name. */
3750 request_dump_byname (const char * section
, dump_type type
)
3752 struct dump_list_entry
* new_request
;
3754 new_request
= (struct dump_list_entry
*)
3755 malloc (sizeof (struct dump_list_entry
));
3757 error (_("Out of memory allocating dump request table.\n"));
3759 new_request
->name
= strdup (section
);
3760 if (!new_request
->name
)
3761 error (_("Out of memory allocating dump request table.\n"));
3763 new_request
->type
= type
;
3765 new_request
->next
= dump_sects_byname
;
3766 dump_sects_byname
= new_request
;
3770 request_dump (dump_type type
)
3776 section
= strtoul (optarg
, & cp
, 0);
3778 if (! *cp
&& section
>= 0)
3779 request_dump_bynumber (section
, type
);
3781 request_dump_byname (optarg
, type
);
3786 parse_args (int argc
, char ** argv
)
3793 while ((c
= getopt_long
3794 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3812 do_section_groups
++;
3820 do_section_groups
++;
3825 do_section_details
++;
3869 request_dump (HEX_DUMP
);
3872 request_dump (STRING_DUMP
);
3875 request_dump (RELOC_DUMP
);
3882 dwarf_select_sections_all ();
3887 dwarf_select_sections_by_letters (optarg
);
3890 case OPTION_DEBUG_DUMP
:
3897 dwarf_select_sections_by_names (optarg
);
3900 case OPTION_DWARF_DEPTH
:
3904 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3907 case OPTION_DWARF_START
:
3911 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3914 case OPTION_DWARF_CHECK
:
3917 case OPTION_DYN_SYMS
:
3920 #ifdef SUPPORT_DISASSEMBLY
3922 request_dump (DISASS_DUMP
);
3926 print_version (program_name
);
3935 /* xgettext:c-format */
3936 error (_("Invalid option '-%c'\n"), c
);
3943 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3944 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3945 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3946 && !do_section_groups
&& !do_archive_index
3951 warn (_("Nothing to do.\n"));
3957 get_elf_class (unsigned int elf_class
)
3959 static char buff
[32];
3963 case ELFCLASSNONE
: return _("none");
3964 case ELFCLASS32
: return "ELF32";
3965 case ELFCLASS64
: return "ELF64";
3967 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3973 get_data_encoding (unsigned int encoding
)
3975 static char buff
[32];
3979 case ELFDATANONE
: return _("none");
3980 case ELFDATA2LSB
: return _("2's complement, little endian");
3981 case ELFDATA2MSB
: return _("2's complement, big endian");
3983 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3988 /* Decode the data held in 'elf_header'. */
3991 process_file_header (void)
3993 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3994 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3995 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3996 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3999 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4003 init_dwarf_regnames (elf_header
.e_machine
);
4009 printf (_("ELF Header:\n"));
4010 printf (_(" Magic: "));
4011 for (i
= 0; i
< EI_NIDENT
; i
++)
4012 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4014 printf (_(" Class: %s\n"),
4015 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4016 printf (_(" Data: %s\n"),
4017 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4018 printf (_(" Version: %d %s\n"),
4019 elf_header
.e_ident
[EI_VERSION
],
4020 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4022 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4023 ? _("<unknown: %lx>")
4025 printf (_(" OS/ABI: %s\n"),
4026 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4027 printf (_(" ABI Version: %d\n"),
4028 elf_header
.e_ident
[EI_ABIVERSION
]);
4029 printf (_(" Type: %s\n"),
4030 get_file_type (elf_header
.e_type
));
4031 printf (_(" Machine: %s\n"),
4032 get_machine_name (elf_header
.e_machine
));
4033 printf (_(" Version: 0x%lx\n"),
4034 (unsigned long) elf_header
.e_version
);
4036 printf (_(" Entry point address: "));
4037 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4038 printf (_("\n Start of program headers: "));
4039 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4040 printf (_(" (bytes into file)\n Start of section headers: "));
4041 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4042 printf (_(" (bytes into file)\n"));
4044 printf (_(" Flags: 0x%lx%s\n"),
4045 (unsigned long) elf_header
.e_flags
,
4046 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4047 printf (_(" Size of this header: %ld (bytes)\n"),
4048 (long) elf_header
.e_ehsize
);
4049 printf (_(" Size of program headers: %ld (bytes)\n"),
4050 (long) elf_header
.e_phentsize
);
4051 printf (_(" Number of program headers: %ld"),
4052 (long) elf_header
.e_phnum
);
4053 if (section_headers
!= NULL
4054 && elf_header
.e_phnum
== PN_XNUM
4055 && section_headers
[0].sh_info
!= 0)
4056 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4057 putc ('\n', stdout
);
4058 printf (_(" Size of section headers: %ld (bytes)\n"),
4059 (long) elf_header
.e_shentsize
);
4060 printf (_(" Number of section headers: %ld"),
4061 (long) elf_header
.e_shnum
);
4062 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4063 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4064 putc ('\n', stdout
);
4065 printf (_(" Section header string table index: %ld"),
4066 (long) elf_header
.e_shstrndx
);
4067 if (section_headers
!= NULL
4068 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4069 printf (" (%u)", section_headers
[0].sh_link
);
4070 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4071 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4072 printf (_(" <corrupt: out of range>"));
4073 putc ('\n', stdout
);
4076 if (section_headers
!= NULL
)
4078 if (elf_header
.e_phnum
== PN_XNUM
4079 && section_headers
[0].sh_info
!= 0)
4080 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4081 if (elf_header
.e_shnum
== SHN_UNDEF
)
4082 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4083 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4084 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4085 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4086 elf_header
.e_shstrndx
= SHN_UNDEF
;
4087 free (section_headers
);
4088 section_headers
= NULL
;
4096 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4098 Elf32_External_Phdr
* phdrs
;
4099 Elf32_External_Phdr
* external
;
4100 Elf_Internal_Phdr
* internal
;
4103 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4104 elf_header
.e_phentsize
,
4106 _("program headers"));
4110 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4111 i
< elf_header
.e_phnum
;
4112 i
++, internal
++, external
++)
4114 internal
->p_type
= BYTE_GET (external
->p_type
);
4115 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4116 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4117 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4118 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4119 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4120 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4121 internal
->p_align
= BYTE_GET (external
->p_align
);
4130 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4132 Elf64_External_Phdr
* phdrs
;
4133 Elf64_External_Phdr
* external
;
4134 Elf_Internal_Phdr
* internal
;
4137 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4138 elf_header
.e_phentsize
,
4140 _("program headers"));
4144 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4145 i
< elf_header
.e_phnum
;
4146 i
++, internal
++, external
++)
4148 internal
->p_type
= BYTE_GET (external
->p_type
);
4149 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4150 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4151 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4152 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4153 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4154 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4155 internal
->p_align
= BYTE_GET (external
->p_align
);
4163 /* Returns 1 if the program headers were read into `program_headers'. */
4166 get_program_headers (FILE * file
)
4168 Elf_Internal_Phdr
* phdrs
;
4170 /* Check cache of prior read. */
4171 if (program_headers
!= NULL
)
4174 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4175 sizeof (Elf_Internal_Phdr
));
4179 error (_("Out of memory\n"));
4184 ? get_32bit_program_headers (file
, phdrs
)
4185 : get_64bit_program_headers (file
, phdrs
))
4187 program_headers
= phdrs
;
4195 /* Returns 1 if the program headers were loaded. */
4198 process_program_headers (FILE * file
)
4200 Elf_Internal_Phdr
* segment
;
4203 if (elf_header
.e_phnum
== 0)
4205 /* PR binutils/12467. */
4206 if (elf_header
.e_phoff
!= 0)
4207 warn (_("possibly corrupt ELF header - it has a non-zero program"
4208 " header offset, but no program headers"));
4209 else if (do_segments
)
4210 printf (_("\nThere are no program headers in this file.\n"));
4214 if (do_segments
&& !do_header
)
4216 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4217 printf (_("Entry point "));
4218 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4219 printf (_("\nThere are %d program headers, starting at offset "),
4220 elf_header
.e_phnum
);
4221 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4225 if (! get_program_headers (file
))
4230 if (elf_header
.e_phnum
> 1)
4231 printf (_("\nProgram Headers:\n"));
4233 printf (_("\nProgram Headers:\n"));
4237 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4240 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4244 (_(" Type Offset VirtAddr PhysAddr\n"));
4246 (_(" FileSiz MemSiz Flags Align\n"));
4253 for (i
= 0, segment
= program_headers
;
4254 i
< elf_header
.e_phnum
;
4259 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4263 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4264 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4265 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4266 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4267 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4269 (segment
->p_flags
& PF_R
? 'R' : ' '),
4270 (segment
->p_flags
& PF_W
? 'W' : ' '),
4271 (segment
->p_flags
& PF_X
? 'E' : ' '));
4272 printf ("%#lx", (unsigned long) segment
->p_align
);
4276 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4277 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4280 print_vma (segment
->p_offset
, FULL_HEX
);
4284 print_vma (segment
->p_vaddr
, FULL_HEX
);
4286 print_vma (segment
->p_paddr
, FULL_HEX
);
4289 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4290 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4293 print_vma (segment
->p_filesz
, FULL_HEX
);
4297 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4298 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4301 print_vma (segment
->p_memsz
, FULL_HEX
);
4305 (segment
->p_flags
& PF_R
? 'R' : ' '),
4306 (segment
->p_flags
& PF_W
? 'W' : ' '),
4307 (segment
->p_flags
& PF_X
? 'E' : ' '));
4309 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4310 printf ("%#lx", (unsigned long) segment
->p_align
);
4313 print_vma (segment
->p_align
, PREFIX_HEX
);
4318 print_vma (segment
->p_offset
, FULL_HEX
);
4320 print_vma (segment
->p_vaddr
, FULL_HEX
);
4322 print_vma (segment
->p_paddr
, FULL_HEX
);
4324 print_vma (segment
->p_filesz
, FULL_HEX
);
4326 print_vma (segment
->p_memsz
, FULL_HEX
);
4328 (segment
->p_flags
& PF_R
? 'R' : ' '),
4329 (segment
->p_flags
& PF_W
? 'W' : ' '),
4330 (segment
->p_flags
& PF_X
? 'E' : ' '));
4331 print_vma (segment
->p_align
, HEX
);
4335 switch (segment
->p_type
)
4339 error (_("more than one dynamic segment\n"));
4341 /* By default, assume that the .dynamic section is the first
4342 section in the DYNAMIC segment. */
4343 dynamic_addr
= segment
->p_offset
;
4344 dynamic_size
= segment
->p_filesz
;
4346 /* Try to locate the .dynamic section. If there is
4347 a section header table, we can easily locate it. */
4348 if (section_headers
!= NULL
)
4350 Elf_Internal_Shdr
* sec
;
4352 sec
= find_section (".dynamic");
4353 if (sec
== NULL
|| sec
->sh_size
== 0)
4355 /* A corresponding .dynamic section is expected, but on
4356 IA-64/OpenVMS it is OK for it to be missing. */
4357 if (!is_ia64_vms ())
4358 error (_("no .dynamic section in the dynamic segment\n"));
4362 if (sec
->sh_type
== SHT_NOBITS
)
4368 dynamic_addr
= sec
->sh_offset
;
4369 dynamic_size
= sec
->sh_size
;
4371 if (dynamic_addr
< segment
->p_offset
4372 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4373 warn (_("the .dynamic section is not contained"
4374 " within the dynamic segment\n"));
4375 else if (dynamic_addr
> segment
->p_offset
)
4376 warn (_("the .dynamic section is not the first section"
4377 " in the dynamic segment.\n"));
4382 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4384 error (_("Unable to find program interpreter name\n"));
4388 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4390 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4391 error (_("Internal error: failed to create format string to display program interpreter\n"));
4393 program_interpreter
[0] = 0;
4394 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4395 error (_("Unable to read program interpreter name\n"));
4398 printf (_("\n [Requesting program interpreter: %s]"),
4399 program_interpreter
);
4405 putc ('\n', stdout
);
4408 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4410 printf (_("\n Section to Segment mapping:\n"));
4411 printf (_(" Segment Sections...\n"));
4413 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4416 Elf_Internal_Shdr
* section
;
4418 segment
= program_headers
+ i
;
4419 section
= section_headers
+ 1;
4421 printf (" %2.2d ", i
);
4423 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4425 if (!ELF_TBSS_SPECIAL (section
, segment
)
4426 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4427 printf ("%s ", SECTION_NAME (section
));
4438 /* Find the file offset corresponding to VMA by using the program headers. */
4441 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4443 Elf_Internal_Phdr
* seg
;
4445 if (! get_program_headers (file
))
4447 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4451 for (seg
= program_headers
;
4452 seg
< program_headers
+ elf_header
.e_phnum
;
4455 if (seg
->p_type
!= PT_LOAD
)
4458 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4459 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4460 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4463 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4464 (unsigned long) vma
);
4470 get_32bit_section_headers (FILE * file
, unsigned int num
)
4472 Elf32_External_Shdr
* shdrs
;
4473 Elf_Internal_Shdr
* internal
;
4476 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4477 elf_header
.e_shentsize
, num
,
4478 _("section headers"));
4482 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4483 sizeof (Elf_Internal_Shdr
));
4485 if (section_headers
== NULL
)
4487 error (_("Out of memory\n"));
4491 for (i
= 0, internal
= section_headers
;
4495 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4496 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4497 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4498 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4499 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4500 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4501 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4502 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4503 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4504 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4513 get_64bit_section_headers (FILE * file
, unsigned int num
)
4515 Elf64_External_Shdr
* shdrs
;
4516 Elf_Internal_Shdr
* internal
;
4519 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4520 elf_header
.e_shentsize
, num
,
4521 _("section headers"));
4525 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4526 sizeof (Elf_Internal_Shdr
));
4528 if (section_headers
== NULL
)
4530 error (_("Out of memory\n"));
4534 for (i
= 0, internal
= section_headers
;
4538 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4539 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4540 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4541 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4542 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4543 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4544 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4545 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4546 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4547 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4555 static Elf_Internal_Sym
*
4556 get_32bit_elf_symbols (FILE * file
,
4557 Elf_Internal_Shdr
* section
,
4558 unsigned long * num_syms_return
)
4560 unsigned long number
= 0;
4561 Elf32_External_Sym
* esyms
= NULL
;
4562 Elf_External_Sym_Shndx
* shndx
= NULL
;
4563 Elf_Internal_Sym
* isyms
= NULL
;
4564 Elf_Internal_Sym
* psym
;
4567 /* Run some sanity checks first. */
4568 if (section
->sh_entsize
== 0)
4570 error (_("sh_entsize is zero\n"));
4574 number
= section
->sh_size
/ section
->sh_entsize
;
4576 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4578 error (_("Invalid sh_entsize\n"));
4582 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4583 section
->sh_size
, _("symbols"));
4588 if (symtab_shndx_hdr
!= NULL
4589 && (symtab_shndx_hdr
->sh_link
4590 == (unsigned long) (section
- section_headers
)))
4592 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4593 symtab_shndx_hdr
->sh_offset
,
4594 1, symtab_shndx_hdr
->sh_size
,
4595 _("symbol table section indicies"));
4600 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4604 error (_("Out of memory\n"));
4608 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4610 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4611 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4612 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4613 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4614 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4616 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4617 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4618 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4619 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4620 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4629 if (num_syms_return
!= NULL
)
4630 * num_syms_return
= isyms
== NULL
? 0 : number
;
4635 static Elf_Internal_Sym
*
4636 get_64bit_elf_symbols (FILE * file
,
4637 Elf_Internal_Shdr
* section
,
4638 unsigned long * num_syms_return
)
4640 unsigned long number
= 0;
4641 Elf64_External_Sym
* esyms
= NULL
;
4642 Elf_External_Sym_Shndx
* shndx
= NULL
;
4643 Elf_Internal_Sym
* isyms
= NULL
;
4644 Elf_Internal_Sym
* psym
;
4647 /* Run some sanity checks first. */
4648 if (section
->sh_entsize
== 0)
4650 error (_("sh_entsize is zero\n"));
4654 number
= section
->sh_size
/ section
->sh_entsize
;
4656 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4658 error (_("Invalid sh_entsize\n"));
4662 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4663 section
->sh_size
, _("symbols"));
4667 if (symtab_shndx_hdr
!= NULL
4668 && (symtab_shndx_hdr
->sh_link
4669 == (unsigned long) (section
- section_headers
)))
4671 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4672 symtab_shndx_hdr
->sh_offset
,
4673 1, symtab_shndx_hdr
->sh_size
,
4674 _("symbol table section indicies"));
4679 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4683 error (_("Out of memory\n"));
4687 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4689 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4690 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4691 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4692 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4694 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4696 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4697 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4698 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4700 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4701 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4710 if (num_syms_return
!= NULL
)
4711 * num_syms_return
= isyms
== NULL
? 0 : number
;
4717 get_elf_section_flags (bfd_vma sh_flags
)
4719 static char buff
[1024];
4721 int field_size
= is_32bit_elf
? 8 : 16;
4723 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4724 bfd_vma os_flags
= 0;
4725 bfd_vma proc_flags
= 0;
4726 bfd_vma unknown_flags
= 0;
4734 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4735 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4736 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4737 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4738 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4739 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4740 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4741 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4742 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4743 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4744 /* IA-64 specific. */
4745 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4746 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4747 /* IA-64 OpenVMS specific. */
4748 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4749 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4750 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4751 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4752 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4753 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4755 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4756 /* SPARC specific. */
4757 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4760 if (do_section_details
)
4762 sprintf (buff
, "[%*.*lx]: ",
4763 field_size
, field_size
, (unsigned long) sh_flags
);
4764 p
+= field_size
+ 4;
4771 flag
= sh_flags
& - sh_flags
;
4774 if (do_section_details
)
4778 case SHF_WRITE
: sindex
= 0; break;
4779 case SHF_ALLOC
: sindex
= 1; break;
4780 case SHF_EXECINSTR
: sindex
= 2; break;
4781 case SHF_MERGE
: sindex
= 3; break;
4782 case SHF_STRINGS
: sindex
= 4; break;
4783 case SHF_INFO_LINK
: sindex
= 5; break;
4784 case SHF_LINK_ORDER
: sindex
= 6; break;
4785 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4786 case SHF_GROUP
: sindex
= 8; break;
4787 case SHF_TLS
: sindex
= 9; break;
4788 case SHF_EXCLUDE
: sindex
= 18; break;
4792 switch (elf_header
.e_machine
)
4795 if (flag
== SHF_IA_64_SHORT
)
4797 else if (flag
== SHF_IA_64_NORECOV
)
4800 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4803 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4804 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4805 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4806 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4807 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4808 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4819 case EM_OLD_SPARCV9
:
4820 case EM_SPARC32PLUS
:
4823 if (flag
== SHF_ORDERED
)
4833 if (p
!= buff
+ field_size
+ 4)
4835 if (size
< (10 + 2))
4842 size
-= flags
[sindex
].len
;
4843 p
= stpcpy (p
, flags
[sindex
].str
);
4845 else if (flag
& SHF_MASKOS
)
4847 else if (flag
& SHF_MASKPROC
)
4850 unknown_flags
|= flag
;
4856 case SHF_WRITE
: *p
= 'W'; break;
4857 case SHF_ALLOC
: *p
= 'A'; break;
4858 case SHF_EXECINSTR
: *p
= 'X'; break;
4859 case SHF_MERGE
: *p
= 'M'; break;
4860 case SHF_STRINGS
: *p
= 'S'; break;
4861 case SHF_INFO_LINK
: *p
= 'I'; break;
4862 case SHF_LINK_ORDER
: *p
= 'L'; break;
4863 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4864 case SHF_GROUP
: *p
= 'G'; break;
4865 case SHF_TLS
: *p
= 'T'; break;
4866 case SHF_EXCLUDE
: *p
= 'E'; break;
4869 if ((elf_header
.e_machine
== EM_X86_64
4870 || elf_header
.e_machine
== EM_L1OM
4871 || elf_header
.e_machine
== EM_K1OM
)
4872 && flag
== SHF_X86_64_LARGE
)
4874 else if (flag
& SHF_MASKOS
)
4877 sh_flags
&= ~ SHF_MASKOS
;
4879 else if (flag
& SHF_MASKPROC
)
4882 sh_flags
&= ~ SHF_MASKPROC
;
4892 if (do_section_details
)
4896 size
-= 5 + field_size
;
4897 if (p
!= buff
+ field_size
+ 4)
4905 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4906 (unsigned long) os_flags
);
4907 p
+= 5 + field_size
;
4911 size
-= 7 + field_size
;
4912 if (p
!= buff
+ field_size
+ 4)
4920 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4921 (unsigned long) proc_flags
);
4922 p
+= 7 + field_size
;
4926 size
-= 10 + field_size
;
4927 if (p
!= buff
+ field_size
+ 4)
4935 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4936 (unsigned long) unknown_flags
);
4937 p
+= 10 + field_size
;
4946 process_section_headers (FILE * file
)
4948 Elf_Internal_Shdr
* section
;
4951 section_headers
= NULL
;
4953 if (elf_header
.e_shnum
== 0)
4955 /* PR binutils/12467. */
4956 if (elf_header
.e_shoff
!= 0)
4957 warn (_("possibly corrupt ELF file header - it has a non-zero"
4958 " section header offset, but no section headers\n"));
4959 else if (do_sections
)
4960 printf (_("\nThere are no sections in this file.\n"));
4965 if (do_sections
&& !do_header
)
4966 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4967 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4971 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4974 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4977 /* Read in the string table, so that we have names to display. */
4978 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4979 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4981 section
= section_headers
+ elf_header
.e_shstrndx
;
4983 if (section
->sh_size
!= 0)
4985 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4986 1, section
->sh_size
,
4989 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4993 /* Scan the sections for the dynamic symbol table
4994 and dynamic string table and debug sections. */
4995 dynamic_symbols
= NULL
;
4996 dynamic_strings
= NULL
;
4997 dynamic_syminfo
= NULL
;
4998 symtab_shndx_hdr
= NULL
;
5000 eh_addr_size
= is_32bit_elf
? 4 : 8;
5001 switch (elf_header
.e_machine
)
5004 case EM_MIPS_RS3_LE
:
5005 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5006 FDE addresses. However, the ABI also has a semi-official ILP32
5007 variant for which the normal FDE address size rules apply.
5009 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5010 section, where XX is the size of longs in bits. Unfortunately,
5011 earlier compilers provided no way of distinguishing ILP32 objects
5012 from LP64 objects, so if there's any doubt, we should assume that
5013 the official LP64 form is being used. */
5014 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5015 && find_section (".gcc_compiled_long32") == NULL
)
5021 switch (elf_header
.e_flags
& EF_H8_MACH
)
5023 case E_H8_MACH_H8300
:
5024 case E_H8_MACH_H8300HN
:
5025 case E_H8_MACH_H8300SN
:
5026 case E_H8_MACH_H8300SXN
:
5029 case E_H8_MACH_H8300H
:
5030 case E_H8_MACH_H8300S
:
5031 case E_H8_MACH_H8300SX
:
5039 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5041 case EF_M32C_CPU_M16C
:
5048 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5051 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5052 if (section->sh_entsize != expected_entsize) \
5054 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5055 i, section->sh_entsize); \
5056 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5057 (int) expected_entsize); \
5058 section->sh_entsize = expected_entsize; \
5063 #define CHECK_ENTSIZE(section, i, type) \
5064 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5065 sizeof (Elf64_External_##type))
5067 for (i
= 0, section
= section_headers
;
5068 i
< elf_header
.e_shnum
;
5071 char * name
= SECTION_NAME (section
);
5073 if (section
->sh_type
== SHT_DYNSYM
)
5075 if (dynamic_symbols
!= NULL
)
5077 error (_("File contains multiple dynamic symbol tables\n"));
5081 CHECK_ENTSIZE (section
, i
, Sym
);
5082 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5084 else if (section
->sh_type
== SHT_STRTAB
5085 && streq (name
, ".dynstr"))
5087 if (dynamic_strings
!= NULL
)
5089 error (_("File contains multiple dynamic string tables\n"));
5093 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5094 1, section
->sh_size
,
5095 _("dynamic strings"));
5096 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5098 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5100 if (symtab_shndx_hdr
!= NULL
)
5102 error (_("File contains multiple symtab shndx tables\n"));
5105 symtab_shndx_hdr
= section
;
5107 else if (section
->sh_type
== SHT_SYMTAB
)
5108 CHECK_ENTSIZE (section
, i
, Sym
);
5109 else if (section
->sh_type
== SHT_GROUP
)
5110 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5111 else if (section
->sh_type
== SHT_REL
)
5112 CHECK_ENTSIZE (section
, i
, Rel
);
5113 else if (section
->sh_type
== SHT_RELA
)
5114 CHECK_ENTSIZE (section
, i
, Rela
);
5115 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5116 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5117 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5118 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5119 || do_debug_addr
|| do_debug_cu_index
)
5120 && (const_strneq (name
, ".debug_")
5121 || const_strneq (name
, ".zdebug_")))
5124 name
+= sizeof (".zdebug_") - 1;
5126 name
+= sizeof (".debug_") - 1;
5129 || (do_debug_info
&& const_strneq (name
, "info"))
5130 || (do_debug_info
&& const_strneq (name
, "types"))
5131 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5132 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5133 || (do_debug_lines
&& const_strneq (name
, "line."))
5134 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5135 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5136 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5137 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5138 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5139 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5140 || (do_debug_frames
&& const_strneq (name
, "frame"))
5141 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5142 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5143 || (do_debug_str
&& const_strneq (name
, "str"))
5144 || (do_debug_loc
&& const_strneq (name
, "loc"))
5145 || (do_debug_addr
&& const_strneq (name
, "addr"))
5146 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5147 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5149 request_dump_bynumber (i
, DEBUG_DUMP
);
5151 /* Linkonce section to be combined with .debug_info at link time. */
5152 else if ((do_debugging
|| do_debug_info
)
5153 && const_strneq (name
, ".gnu.linkonce.wi."))
5154 request_dump_bynumber (i
, DEBUG_DUMP
);
5155 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5156 request_dump_bynumber (i
, DEBUG_DUMP
);
5157 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5158 request_dump_bynumber (i
, DEBUG_DUMP
);
5159 /* Trace sections for Itanium VMS. */
5160 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5161 || do_trace_aranges
)
5162 && const_strneq (name
, ".trace_"))
5164 name
+= sizeof (".trace_") - 1;
5167 || (do_trace_info
&& streq (name
, "info"))
5168 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5169 || (do_trace_aranges
&& streq (name
, "aranges"))
5171 request_dump_bynumber (i
, DEBUG_DUMP
);
5179 if (elf_header
.e_shnum
> 1)
5180 printf (_("\nSection Headers:\n"));
5182 printf (_("\nSection Header:\n"));
5186 if (do_section_details
)
5188 printf (_(" [Nr] Name\n"));
5189 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5193 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5197 if (do_section_details
)
5199 printf (_(" [Nr] Name\n"));
5200 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5204 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5208 if (do_section_details
)
5210 printf (_(" [Nr] Name\n"));
5211 printf (_(" Type Address Offset Link\n"));
5212 printf (_(" Size EntSize Info Align\n"));
5216 printf (_(" [Nr] Name Type Address Offset\n"));
5217 printf (_(" Size EntSize Flags Link Info Align\n"));
5221 if (do_section_details
)
5222 printf (_(" Flags\n"));
5224 for (i
= 0, section
= section_headers
;
5225 i
< elf_header
.e_shnum
;
5228 printf (" [%2u] ", i
);
5229 if (do_section_details
)
5231 print_symbol (INT_MAX
, SECTION_NAME (section
));
5236 print_symbol (-17, SECTION_NAME (section
));
5239 printf (do_wide
? " %-15s " : " %-15.15s ",
5240 get_section_type_name (section
->sh_type
));
5244 const char * link_too_big
= NULL
;
5246 print_vma (section
->sh_addr
, LONG_HEX
);
5248 printf ( " %6.6lx %6.6lx %2.2lx",
5249 (unsigned long) section
->sh_offset
,
5250 (unsigned long) section
->sh_size
,
5251 (unsigned long) section
->sh_entsize
);
5253 if (do_section_details
)
5254 fputs (" ", stdout
);
5256 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5258 if (section
->sh_link
>= elf_header
.e_shnum
)
5261 /* The sh_link value is out of range. Normally this indicates
5262 an error but it can have special values in Solaris binaries. */
5263 switch (elf_header
.e_machine
)
5270 case EM_OLD_SPARCV9
:
5271 case EM_SPARC32PLUS
:
5274 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5275 link_too_big
= "BEFORE";
5276 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5277 link_too_big
= "AFTER";
5284 if (do_section_details
)
5286 if (link_too_big
!= NULL
&& * link_too_big
)
5287 printf ("<%s> ", link_too_big
);
5289 printf ("%2u ", section
->sh_link
);
5290 printf ("%3u %2lu\n", section
->sh_info
,
5291 (unsigned long) section
->sh_addralign
);
5294 printf ("%2u %3u %2lu\n",
5297 (unsigned long) section
->sh_addralign
);
5299 if (link_too_big
&& ! * link_too_big
)
5300 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5301 i
, section
->sh_link
);
5305 print_vma (section
->sh_addr
, LONG_HEX
);
5307 if ((long) section
->sh_offset
== section
->sh_offset
)
5308 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5312 print_vma (section
->sh_offset
, LONG_HEX
);
5315 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5316 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5320 print_vma (section
->sh_size
, LONG_HEX
);
5323 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5324 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5328 print_vma (section
->sh_entsize
, LONG_HEX
);
5331 if (do_section_details
)
5332 fputs (" ", stdout
);
5334 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5336 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5338 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5339 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5342 print_vma (section
->sh_addralign
, DEC
);
5346 else if (do_section_details
)
5348 printf (" %-15.15s ",
5349 get_section_type_name (section
->sh_type
));
5350 print_vma (section
->sh_addr
, LONG_HEX
);
5351 if ((long) section
->sh_offset
== section
->sh_offset
)
5352 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5356 print_vma (section
->sh_offset
, LONG_HEX
);
5358 printf (" %u\n ", section
->sh_link
);
5359 print_vma (section
->sh_size
, LONG_HEX
);
5361 print_vma (section
->sh_entsize
, LONG_HEX
);
5363 printf (" %-16u %lu\n",
5365 (unsigned long) section
->sh_addralign
);
5370 print_vma (section
->sh_addr
, LONG_HEX
);
5371 if ((long) section
->sh_offset
== section
->sh_offset
)
5372 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5376 print_vma (section
->sh_offset
, LONG_HEX
);
5379 print_vma (section
->sh_size
, LONG_HEX
);
5381 print_vma (section
->sh_entsize
, LONG_HEX
);
5383 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5385 printf (" %2u %3u %lu\n",
5388 (unsigned long) section
->sh_addralign
);
5391 if (do_section_details
)
5392 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5395 if (!do_section_details
)
5397 if (elf_header
.e_machine
== EM_X86_64
5398 || elf_header
.e_machine
== EM_L1OM
5399 || elf_header
.e_machine
== EM_K1OM
)
5400 printf (_("Key to Flags:\n\
5401 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5402 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5403 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5405 printf (_("Key to Flags:\n\
5406 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5407 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5408 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5415 get_group_flags (unsigned int flags
)
5417 static char buff
[32];
5427 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5434 process_section_groups (FILE * file
)
5436 Elf_Internal_Shdr
* section
;
5438 struct group
* group
;
5439 Elf_Internal_Shdr
* symtab_sec
;
5440 Elf_Internal_Shdr
* strtab_sec
;
5441 Elf_Internal_Sym
* symtab
;
5442 unsigned long num_syms
;
5446 /* Don't process section groups unless needed. */
5447 if (!do_unwind
&& !do_section_groups
)
5450 if (elf_header
.e_shnum
== 0)
5452 if (do_section_groups
)
5453 printf (_("\nThere are no sections to group in this file.\n"));
5458 if (section_headers
== NULL
)
5460 error (_("Section headers are not available!\n"));
5461 /* PR 13622: This can happen with a corrupt ELF header. */
5465 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5466 sizeof (struct group
*));
5468 if (section_headers_groups
== NULL
)
5470 error (_("Out of memory\n"));
5474 /* Scan the sections for the group section. */
5476 for (i
= 0, section
= section_headers
;
5477 i
< elf_header
.e_shnum
;
5479 if (section
->sh_type
== SHT_GROUP
)
5482 if (group_count
== 0)
5484 if (do_section_groups
)
5485 printf (_("\nThere are no section groups in this file.\n"));
5490 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5492 if (section_groups
== NULL
)
5494 error (_("Out of memory\n"));
5504 for (i
= 0, section
= section_headers
, group
= section_groups
;
5505 i
< elf_header
.e_shnum
;
5508 if (section
->sh_type
== SHT_GROUP
)
5510 char * name
= SECTION_NAME (section
);
5512 unsigned char * start
;
5513 unsigned char * indices
;
5514 unsigned int entry
, j
, size
;
5515 Elf_Internal_Shdr
* sec
;
5516 Elf_Internal_Sym
* sym
;
5518 /* Get the symbol table. */
5519 if (section
->sh_link
>= elf_header
.e_shnum
5520 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5523 error (_("Bad sh_link in group section `%s'\n"), name
);
5527 if (symtab_sec
!= sec
)
5532 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5537 error (_("Corrupt header in group section `%s'\n"), name
);
5541 if (section
->sh_info
>= num_syms
)
5543 error (_("Bad sh_info in group section `%s'\n"), name
);
5547 sym
= symtab
+ section
->sh_info
;
5549 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5551 if (sym
->st_shndx
== 0
5552 || sym
->st_shndx
>= elf_header
.e_shnum
)
5554 error (_("Bad sh_info in group section `%s'\n"), name
);
5558 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5567 /* Get the string table. */
5568 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5577 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5582 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5583 1, strtab_sec
->sh_size
,
5585 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5587 group_name
= sym
->st_name
< strtab_size
5588 ? strtab
+ sym
->st_name
: _("<corrupt>");
5591 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5592 1, section
->sh_size
,
5598 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5599 entry
= byte_get (indices
, 4);
5602 if (do_section_groups
)
5604 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5605 get_group_flags (entry
), i
, name
, group_name
, size
);
5607 printf (_(" [Index] Name\n"));
5610 group
->group_index
= i
;
5612 for (j
= 0; j
< size
; j
++)
5614 struct group_list
* g
;
5616 entry
= byte_get (indices
, 4);
5619 if (entry
>= elf_header
.e_shnum
)
5621 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5622 entry
, i
, elf_header
.e_shnum
- 1);
5626 if (section_headers_groups
[entry
] != NULL
)
5630 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5632 section_headers_groups
[entry
]->group_index
);
5637 /* Intel C/C++ compiler may put section 0 in a
5638 section group. We just warn it the first time
5639 and ignore it afterwards. */
5640 static int warned
= 0;
5643 error (_("section 0 in group section [%5u]\n"),
5644 section_headers_groups
[entry
]->group_index
);
5650 section_headers_groups
[entry
] = group
;
5652 if (do_section_groups
)
5654 sec
= section_headers
+ entry
;
5655 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5658 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5659 g
->section_index
= entry
;
5660 g
->next
= group
->root
;
5678 /* Data used to display dynamic fixups. */
5680 struct ia64_vms_dynfixup
5682 bfd_vma needed_ident
; /* Library ident number. */
5683 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5684 bfd_vma fixup_needed
; /* Index of the library. */
5685 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5686 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5689 /* Data used to display dynamic relocations. */
5691 struct ia64_vms_dynimgrela
5693 bfd_vma img_rela_cnt
; /* Number of relocations. */
5694 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5697 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5701 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5702 const char *strtab
, unsigned int strtab_sz
)
5704 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5706 const char *lib_name
;
5708 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5709 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5710 _("dynamic section image fixups"));
5714 if (fixup
->needed
< strtab_sz
)
5715 lib_name
= strtab
+ fixup
->needed
;
5718 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5719 (unsigned long) fixup
->needed
);
5722 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5723 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5725 (_("Seg Offset Type SymVec DataType\n"));
5727 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5732 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5733 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5734 type
= BYTE_GET (imfs
[i
].type
);
5735 rtype
= elf_ia64_reloc_type (type
);
5737 printf (" 0x%08x ", type
);
5739 printf (" %-32s ", rtype
);
5740 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5741 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5747 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5750 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5752 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5755 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5756 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5757 _("dynamic section image relocations"));
5761 printf (_("\nImage relocs\n"));
5763 (_("Seg Offset Type Addend Seg Sym Off\n"));
5765 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5770 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5771 printf ("%08" BFD_VMA_FMT
"x ",
5772 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5773 type
= BYTE_GET (imrs
[i
].type
);
5774 rtype
= elf_ia64_reloc_type (type
);
5776 printf ("0x%08x ", type
);
5778 printf ("%-31s ", rtype
);
5779 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5780 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5781 printf ("%08" BFD_VMA_FMT
"x\n",
5782 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5788 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5791 process_ia64_vms_dynamic_relocs (FILE *file
)
5793 struct ia64_vms_dynfixup fixup
;
5794 struct ia64_vms_dynimgrela imgrela
;
5795 Elf_Internal_Dyn
*entry
;
5797 bfd_vma strtab_off
= 0;
5798 bfd_vma strtab_sz
= 0;
5799 char *strtab
= NULL
;
5801 memset (&fixup
, 0, sizeof (fixup
));
5802 memset (&imgrela
, 0, sizeof (imgrela
));
5804 /* Note: the order of the entries is specified by the OpenVMS specs. */
5805 for (entry
= dynamic_section
;
5806 entry
< dynamic_section
+ dynamic_nent
;
5809 switch (entry
->d_tag
)
5811 case DT_IA_64_VMS_STRTAB_OFFSET
:
5812 strtab_off
= entry
->d_un
.d_val
;
5815 strtab_sz
= entry
->d_un
.d_val
;
5817 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5818 1, strtab_sz
, _("dynamic string section"));
5821 case DT_IA_64_VMS_NEEDED_IDENT
:
5822 fixup
.needed_ident
= entry
->d_un
.d_val
;
5825 fixup
.needed
= entry
->d_un
.d_val
;
5827 case DT_IA_64_VMS_FIXUP_NEEDED
:
5828 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5830 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5831 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5833 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5834 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5836 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5839 case DT_IA_64_VMS_IMG_RELA_CNT
:
5840 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5842 case DT_IA_64_VMS_IMG_RELA_OFF
:
5843 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5845 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5865 } dynamic_relocations
[] =
5867 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5868 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5869 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5872 /* Process the reloc section. */
5875 process_relocs (FILE * file
)
5877 unsigned long rel_size
;
5878 unsigned long rel_offset
;
5884 if (do_using_dynamic
)
5888 int has_dynamic_reloc
;
5891 has_dynamic_reloc
= 0;
5893 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5895 is_rela
= dynamic_relocations
[i
].rela
;
5896 name
= dynamic_relocations
[i
].name
;
5897 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5898 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5900 has_dynamic_reloc
|= rel_size
;
5902 if (is_rela
== UNKNOWN
)
5904 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5905 switch (dynamic_info
[DT_PLTREL
])
5919 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5920 name
, rel_offset
, rel_size
);
5922 dump_relocations (file
,
5923 offset_from_vma (file
, rel_offset
, rel_size
),
5925 dynamic_symbols
, num_dynamic_syms
,
5926 dynamic_strings
, dynamic_strings_length
, is_rela
);
5931 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5933 if (! has_dynamic_reloc
)
5934 printf (_("\nThere are no dynamic relocations in this file.\n"));
5938 Elf_Internal_Shdr
* section
;
5942 for (i
= 0, section
= section_headers
;
5943 i
< elf_header
.e_shnum
;
5946 if ( section
->sh_type
!= SHT_RELA
5947 && section
->sh_type
!= SHT_REL
)
5950 rel_offset
= section
->sh_offset
;
5951 rel_size
= section
->sh_size
;
5955 Elf_Internal_Shdr
* strsec
;
5958 printf (_("\nRelocation section "));
5960 if (string_table
== NULL
)
5961 printf ("%d", section
->sh_name
);
5963 printf ("'%s'", SECTION_NAME (section
));
5965 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5966 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5968 is_rela
= section
->sh_type
== SHT_RELA
;
5970 if (section
->sh_link
!= 0
5971 && section
->sh_link
< elf_header
.e_shnum
)
5973 Elf_Internal_Shdr
* symsec
;
5974 Elf_Internal_Sym
* symtab
;
5975 unsigned long nsyms
;
5976 unsigned long strtablen
= 0;
5977 char * strtab
= NULL
;
5979 symsec
= section_headers
+ section
->sh_link
;
5980 if (symsec
->sh_type
!= SHT_SYMTAB
5981 && symsec
->sh_type
!= SHT_DYNSYM
)
5984 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5989 if (symsec
->sh_link
!= 0
5990 && symsec
->sh_link
< elf_header
.e_shnum
)
5992 strsec
= section_headers
+ symsec
->sh_link
;
5994 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5997 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6000 dump_relocations (file
, rel_offset
, rel_size
,
6001 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6007 dump_relocations (file
, rel_offset
, rel_size
,
6008 NULL
, 0, NULL
, 0, is_rela
);
6015 printf (_("\nThere are no relocations in this file.\n"));
6021 /* Process the unwind section. */
6023 #include "unwind-ia64.h"
6025 /* An absolute address consists of a section and an offset. If the
6026 section is NULL, the offset itself is the address, otherwise, the
6027 address equals to LOAD_ADDRESS(section) + offset. */
6031 unsigned short section
;
6035 #define ABSADDR(a) \
6037 ? section_headers [(a).section].sh_addr + (a).offset \
6040 struct ia64_unw_table_entry
6042 struct absaddr start
;
6044 struct absaddr info
;
6047 struct ia64_unw_aux_info
6050 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6051 unsigned long table_len
; /* Length of unwind table. */
6052 unsigned char * info
; /* Unwind info. */
6053 unsigned long info_size
; /* Size of unwind info. */
6054 bfd_vma info_addr
; /* starting address of unwind info. */
6055 bfd_vma seg_base
; /* Starting address of segment. */
6056 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6057 unsigned long nsyms
; /* Number of symbols. */
6058 char * strtab
; /* The string table. */
6059 unsigned long strtab_size
; /* Size of string table. */
6063 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6064 unsigned long nsyms
,
6065 const char * strtab
,
6066 unsigned long strtab_size
,
6067 struct absaddr addr
,
6068 const char ** symname
,
6071 bfd_vma dist
= 0x100000;
6072 Elf_Internal_Sym
* sym
;
6073 Elf_Internal_Sym
* best
= NULL
;
6076 REMOVE_ARCH_BITS (addr
.offset
);
6078 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6080 bfd_vma value
= sym
->st_value
;
6082 REMOVE_ARCH_BITS (value
);
6084 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6085 && sym
->st_name
!= 0
6086 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6087 && addr
.offset
>= value
6088 && addr
.offset
- value
< dist
)
6091 dist
= addr
.offset
- value
;
6099 *symname
= (best
->st_name
>= strtab_size
6100 ? _("<corrupt>") : strtab
+ best
->st_name
);
6106 *offset
= addr
.offset
;
6110 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6112 struct ia64_unw_table_entry
* tp
;
6115 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6119 const unsigned char * dp
;
6120 const unsigned char * head
;
6121 const char * procname
;
6123 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6124 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6126 fputs ("\n<", stdout
);
6130 fputs (procname
, stdout
);
6133 printf ("+%lx", (unsigned long) offset
);
6136 fputs (">: [", stdout
);
6137 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6138 fputc ('-', stdout
);
6139 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6140 printf ("], info at +0x%lx\n",
6141 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6143 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6144 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6146 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6147 (unsigned) UNW_VER (stamp
),
6148 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6149 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6150 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6151 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6153 if (UNW_VER (stamp
) != 1)
6155 printf (_("\tUnknown version.\n"));
6160 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6161 dp
= unw_decode (dp
, in_body
, & in_body
);
6166 slurp_ia64_unwind_table (FILE * file
,
6167 struct ia64_unw_aux_info
* aux
,
6168 Elf_Internal_Shdr
* sec
)
6170 unsigned long size
, nrelas
, i
;
6171 Elf_Internal_Phdr
* seg
;
6172 struct ia64_unw_table_entry
* tep
;
6173 Elf_Internal_Shdr
* relsec
;
6174 Elf_Internal_Rela
* rela
;
6175 Elf_Internal_Rela
* rp
;
6176 unsigned char * table
;
6178 Elf_Internal_Sym
* sym
;
6179 const char * relname
;
6181 /* First, find the starting address of the segment that includes
6184 if (elf_header
.e_phnum
)
6186 if (! get_program_headers (file
))
6189 for (seg
= program_headers
;
6190 seg
< program_headers
+ elf_header
.e_phnum
;
6193 if (seg
->p_type
!= PT_LOAD
)
6196 if (sec
->sh_addr
>= seg
->p_vaddr
6197 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6199 aux
->seg_base
= seg
->p_vaddr
;
6205 /* Second, build the unwind table from the contents of the unwind section: */
6206 size
= sec
->sh_size
;
6207 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6212 aux
->table
= (struct ia64_unw_table_entry
*)
6213 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6215 for (tp
= table
; tp
< table
+ size
; ++tep
)
6217 tep
->start
.section
= SHN_UNDEF
;
6218 tep
->end
.section
= SHN_UNDEF
;
6219 tep
->info
.section
= SHN_UNDEF
;
6220 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6221 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6222 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6223 tep
->start
.offset
+= aux
->seg_base
;
6224 tep
->end
.offset
+= aux
->seg_base
;
6225 tep
->info
.offset
+= aux
->seg_base
;
6229 /* Third, apply any relocations to the unwind table: */
6230 for (relsec
= section_headers
;
6231 relsec
< section_headers
+ elf_header
.e_shnum
;
6234 if (relsec
->sh_type
!= SHT_RELA
6235 || relsec
->sh_info
>= elf_header
.e_shnum
6236 || section_headers
+ relsec
->sh_info
!= sec
)
6239 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6243 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6245 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6246 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6248 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6250 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6254 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6256 switch (rp
->r_offset
/eh_addr_size
% 3)
6259 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6260 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6263 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6264 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6267 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6268 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6278 aux
->table_len
= size
/ (3 * eh_addr_size
);
6283 ia64_process_unwind (FILE * file
)
6285 Elf_Internal_Shdr
* sec
;
6286 Elf_Internal_Shdr
* unwsec
= NULL
;
6287 Elf_Internal_Shdr
* strsec
;
6288 unsigned long i
, unwcount
= 0, unwstart
= 0;
6289 struct ia64_unw_aux_info aux
;
6291 memset (& aux
, 0, sizeof (aux
));
6293 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6295 if (sec
->sh_type
== SHT_SYMTAB
6296 && sec
->sh_link
< elf_header
.e_shnum
)
6298 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6300 strsec
= section_headers
+ sec
->sh_link
;
6301 assert (aux
.strtab
== NULL
);
6302 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6305 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6307 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6312 printf (_("\nThere are no unwind sections in this file.\n"));
6314 while (unwcount
-- > 0)
6319 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6320 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6321 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6328 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6330 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6332 /* We need to find which section group it is in. */
6333 struct group_list
* g
= section_headers_groups
[i
]->root
;
6335 for (; g
!= NULL
; g
= g
->next
)
6337 sec
= section_headers
+ g
->section_index
;
6339 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6344 i
= elf_header
.e_shnum
;
6346 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6348 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6349 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6350 suffix
= SECTION_NAME (unwsec
) + len
;
6351 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6353 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6354 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6359 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6360 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6361 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6362 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6364 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6365 suffix
= SECTION_NAME (unwsec
) + len
;
6366 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6368 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6369 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6373 if (i
== elf_header
.e_shnum
)
6375 printf (_("\nCould not find unwind info section for "));
6377 if (string_table
== NULL
)
6378 printf ("%d", unwsec
->sh_name
);
6380 printf (_("'%s'"), SECTION_NAME (unwsec
));
6384 aux
.info_addr
= sec
->sh_addr
;
6385 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6388 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6390 printf (_("\nUnwind section "));
6392 if (string_table
== NULL
)
6393 printf ("%d", unwsec
->sh_name
);
6395 printf (_("'%s'"), SECTION_NAME (unwsec
));
6397 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6398 (unsigned long) unwsec
->sh_offset
,
6399 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6401 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6403 if (aux
.table_len
> 0)
6404 dump_ia64_unwind (& aux
);
6407 free ((char *) aux
.table
);
6409 free ((char *) aux
.info
);
6418 free ((char *) aux
.strtab
);
6421 struct hppa_unw_table_entry
6423 struct absaddr start
;
6425 unsigned int Cannot_unwind
:1; /* 0 */
6426 unsigned int Millicode
:1; /* 1 */
6427 unsigned int Millicode_save_sr0
:1; /* 2 */
6428 unsigned int Region_description
:2; /* 3..4 */
6429 unsigned int reserved1
:1; /* 5 */
6430 unsigned int Entry_SR
:1; /* 6 */
6431 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6432 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6433 unsigned int Args_stored
:1; /* 16 */
6434 unsigned int Variable_Frame
:1; /* 17 */
6435 unsigned int Separate_Package_Body
:1; /* 18 */
6436 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6437 unsigned int Stack_Overflow_Check
:1; /* 20 */
6438 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6439 unsigned int Ada_Region
:1; /* 22 */
6440 unsigned int cxx_info
:1; /* 23 */
6441 unsigned int cxx_try_catch
:1; /* 24 */
6442 unsigned int sched_entry_seq
:1; /* 25 */
6443 unsigned int reserved2
:1; /* 26 */
6444 unsigned int Save_SP
:1; /* 27 */
6445 unsigned int Save_RP
:1; /* 28 */
6446 unsigned int Save_MRP_in_frame
:1; /* 29 */
6447 unsigned int extn_ptr_defined
:1; /* 30 */
6448 unsigned int Cleanup_defined
:1; /* 31 */
6450 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6451 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6452 unsigned int Large_frame
:1; /* 2 */
6453 unsigned int Pseudo_SP_Set
:1; /* 3 */
6454 unsigned int reserved4
:1; /* 4 */
6455 unsigned int Total_frame_size
:27; /* 5..31 */
6458 struct hppa_unw_aux_info
6460 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6461 unsigned long table_len
; /* Length of unwind table. */
6462 bfd_vma seg_base
; /* Starting address of segment. */
6463 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6464 unsigned long nsyms
; /* Number of symbols. */
6465 char * strtab
; /* The string table. */
6466 unsigned long strtab_size
; /* Size of string table. */
6470 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6472 struct hppa_unw_table_entry
* tp
;
6474 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6477 const char * procname
;
6479 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6480 aux
->strtab_size
, tp
->start
, &procname
,
6483 fputs ("\n<", stdout
);
6487 fputs (procname
, stdout
);
6490 printf ("+%lx", (unsigned long) offset
);
6493 fputs (">: [", stdout
);
6494 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6495 fputc ('-', stdout
);
6496 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6499 #define PF(_m) if (tp->_m) printf (#_m " ");
6500 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6503 PF(Millicode_save_sr0
);
6504 /* PV(Region_description); */
6510 PF(Separate_Package_Body
);
6511 PF(Frame_Extension_Millicode
);
6512 PF(Stack_Overflow_Check
);
6513 PF(Two_Instruction_SP_Increment
);
6517 PF(sched_entry_seq
);
6520 PF(Save_MRP_in_frame
);
6521 PF(extn_ptr_defined
);
6522 PF(Cleanup_defined
);
6523 PF(MPE_XL_interrupt_marker
);
6524 PF(HP_UX_interrupt_marker
);
6527 PV(Total_frame_size
);
6536 slurp_hppa_unwind_table (FILE * file
,
6537 struct hppa_unw_aux_info
* aux
,
6538 Elf_Internal_Shdr
* sec
)
6540 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6541 Elf_Internal_Phdr
* seg
;
6542 struct hppa_unw_table_entry
* tep
;
6543 Elf_Internal_Shdr
* relsec
;
6544 Elf_Internal_Rela
* rela
;
6545 Elf_Internal_Rela
* rp
;
6546 unsigned char * table
;
6548 Elf_Internal_Sym
* sym
;
6549 const char * relname
;
6551 /* First, find the starting address of the segment that includes
6554 if (elf_header
.e_phnum
)
6556 if (! get_program_headers (file
))
6559 for (seg
= program_headers
;
6560 seg
< program_headers
+ elf_header
.e_phnum
;
6563 if (seg
->p_type
!= PT_LOAD
)
6566 if (sec
->sh_addr
>= seg
->p_vaddr
6567 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6569 aux
->seg_base
= seg
->p_vaddr
;
6575 /* Second, build the unwind table from the contents of the unwind
6577 size
= sec
->sh_size
;
6578 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6584 nentries
= size
/ unw_ent_size
;
6585 size
= unw_ent_size
* nentries
;
6587 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6588 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6590 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6592 unsigned int tmp1
, tmp2
;
6594 tep
->start
.section
= SHN_UNDEF
;
6595 tep
->end
.section
= SHN_UNDEF
;
6597 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6598 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6599 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6600 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6602 tep
->start
.offset
+= aux
->seg_base
;
6603 tep
->end
.offset
+= aux
->seg_base
;
6605 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6606 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6607 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6608 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6609 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6610 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6611 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6612 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6613 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6614 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6615 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6616 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6617 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6618 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6619 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6620 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6621 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6622 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6623 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6624 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6625 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6626 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6627 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6628 tep
->Cleanup_defined
= tmp1
& 0x1;
6630 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6631 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6632 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6633 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6634 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6635 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6639 /* Third, apply any relocations to the unwind table. */
6640 for (relsec
= section_headers
;
6641 relsec
< section_headers
+ elf_header
.e_shnum
;
6644 if (relsec
->sh_type
!= SHT_RELA
6645 || relsec
->sh_info
>= elf_header
.e_shnum
6646 || section_headers
+ relsec
->sh_info
!= sec
)
6649 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6653 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6655 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6656 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6658 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6659 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6661 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6665 i
= rp
->r_offset
/ unw_ent_size
;
6667 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6670 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6671 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6674 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6675 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6685 aux
->table_len
= nentries
;
6691 hppa_process_unwind (FILE * file
)
6693 struct hppa_unw_aux_info aux
;
6694 Elf_Internal_Shdr
* unwsec
= NULL
;
6695 Elf_Internal_Shdr
* strsec
;
6696 Elf_Internal_Shdr
* sec
;
6699 if (string_table
== NULL
)
6702 memset (& aux
, 0, sizeof (aux
));
6704 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6706 if (sec
->sh_type
== SHT_SYMTAB
6707 && sec
->sh_link
< elf_header
.e_shnum
)
6709 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6711 strsec
= section_headers
+ sec
->sh_link
;
6712 assert (aux
.strtab
== NULL
);
6713 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6716 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6718 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6723 printf (_("\nThere are no unwind sections in this file.\n"));
6725 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6727 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6729 printf (_("\nUnwind section "));
6730 printf (_("'%s'"), SECTION_NAME (sec
));
6732 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6733 (unsigned long) sec
->sh_offset
,
6734 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6736 slurp_hppa_unwind_table (file
, &aux
, sec
);
6737 if (aux
.table_len
> 0)
6738 dump_hppa_unwind (&aux
);
6741 free ((char *) aux
.table
);
6749 free ((char *) aux
.strtab
);
6754 unsigned char * data
; /* The unwind data. */
6755 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6756 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6757 unsigned long nrelas
; /* The number of relocations. */
6758 unsigned int rel_type
; /* REL or RELA ? */
6759 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6762 struct arm_unw_aux_info
6764 FILE * file
; /* The file containing the unwind sections. */
6765 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6766 unsigned long nsyms
; /* Number of symbols. */
6767 char * strtab
; /* The file's string table. */
6768 unsigned long strtab_size
; /* Size of string table. */
6772 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6773 bfd_vma fn
, struct absaddr addr
)
6775 const char *procname
;
6778 if (addr
.section
== SHN_UNDEF
)
6781 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6782 aux
->strtab_size
, addr
, &procname
,
6785 print_vma (fn
, PREFIX_HEX
);
6789 fputs (" <", stdout
);
6790 fputs (procname
, stdout
);
6793 printf ("+0x%lx", (unsigned long) sym_offset
);
6794 fputc ('>', stdout
);
6801 arm_free_section (struct arm_section
*arm_sec
)
6803 if (arm_sec
->data
!= NULL
)
6804 free (arm_sec
->data
);
6806 if (arm_sec
->rela
!= NULL
)
6807 free (arm_sec
->rela
);
6810 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6811 cached section and install SEC instead.
6812 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6813 and return its valued in * WORDP, relocating if necessary.
6814 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6815 relocation's offset in ADDR.
6816 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6817 into the string table of the symbol associated with the reloc. If no
6818 reloc was applied store -1 there.
6819 5) Return TRUE upon success, FALSE otherwise. */
6822 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6823 struct arm_section
* arm_sec
,
6824 Elf_Internal_Shdr
* sec
,
6825 bfd_vma word_offset
,
6826 unsigned int * wordp
,
6827 struct absaddr
* addr
,
6830 Elf_Internal_Rela
*rp
;
6831 Elf_Internal_Sym
*sym
;
6832 const char * relname
;
6834 bfd_boolean wrapped
;
6836 addr
->section
= SHN_UNDEF
;
6839 if (sym_name
!= NULL
)
6840 *sym_name
= (bfd_vma
) -1;
6842 /* If necessary, update the section cache. */
6843 if (sec
!= arm_sec
->sec
)
6845 Elf_Internal_Shdr
*relsec
;
6847 arm_free_section (arm_sec
);
6850 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6851 sec
->sh_size
, _("unwind data"));
6852 arm_sec
->rela
= NULL
;
6853 arm_sec
->nrelas
= 0;
6855 for (relsec
= section_headers
;
6856 relsec
< section_headers
+ elf_header
.e_shnum
;
6859 if (relsec
->sh_info
>= elf_header
.e_shnum
6860 || section_headers
+ relsec
->sh_info
!= sec
6861 /* PR 15745: Check the section type as well. */
6862 || (relsec
->sh_type
!= SHT_REL
6863 && relsec
->sh_type
!= SHT_RELA
))
6866 arm_sec
->rel_type
= relsec
->sh_type
;
6867 if (relsec
->sh_type
== SHT_REL
)
6869 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6871 & arm_sec
->rela
, & arm_sec
->nrelas
))
6874 else /* relsec->sh_type == SHT_RELA */
6876 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6878 & arm_sec
->rela
, & arm_sec
->nrelas
))
6884 arm_sec
->next_rela
= arm_sec
->rela
;
6887 /* If there is no unwind data we can do nothing. */
6888 if (arm_sec
->data
== NULL
)
6891 /* Get the word at the required offset. */
6892 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6894 /* Look through the relocs to find the one that applies to the provided offset. */
6896 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6898 bfd_vma prelval
, offset
;
6900 if (rp
->r_offset
> word_offset
&& !wrapped
)
6905 if (rp
->r_offset
> word_offset
)
6908 if (rp
->r_offset
& 3)
6910 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6911 (unsigned long) rp
->r_offset
);
6915 if (rp
->r_offset
< word_offset
)
6918 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6920 if (arm_sec
->rel_type
== SHT_REL
)
6922 offset
= word
& 0x7fffffff;
6923 if (offset
& 0x40000000)
6924 offset
|= ~ (bfd_vma
) 0x7fffffff;
6926 else if (arm_sec
->rel_type
== SHT_RELA
)
6927 offset
= rp
->r_addend
;
6931 offset
+= sym
->st_value
;
6932 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6934 /* Check that we are processing the expected reloc type. */
6935 if (elf_header
.e_machine
== EM_ARM
)
6937 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6939 if (streq (relname
, "R_ARM_NONE"))
6942 if (! streq (relname
, "R_ARM_PREL31"))
6944 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6948 else if (elf_header
.e_machine
== EM_TI_C6000
)
6950 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6952 if (streq (relname
, "R_C6000_NONE"))
6955 if (! streq (relname
, "R_C6000_PREL31"))
6957 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6964 /* This function currently only supports ARM and TI unwinders. */
6967 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6968 addr
->section
= sym
->st_shndx
;
6969 addr
->offset
= offset
;
6971 * sym_name
= sym
->st_name
;
6976 arm_sec
->next_rela
= rp
;
6981 static const char *tic6x_unwind_regnames
[16] =
6983 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6984 "A14", "A13", "A12", "A11", "A10",
6985 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6989 decode_tic6x_unwind_regmask (unsigned int mask
)
6993 for (i
= 12; mask
; mask
>>= 1, i
--)
6997 fputs (tic6x_unwind_regnames
[i
], stdout
);
6999 fputs (", ", stdout
);
7005 if (remaining == 0 && more_words) \
7008 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7009 data_offset, & word, & addr, NULL)) \
7015 #define GET_OP(OP) \
7020 (OP) = word >> 24; \
7025 printf (_("[Truncated opcode]\n")); \
7028 printf ("0x%02x ", OP)
7031 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7032 unsigned int word
, unsigned int remaining
,
7033 unsigned int more_words
,
7034 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7035 struct arm_section
*data_arm_sec
)
7037 struct absaddr addr
;
7039 /* Decode the unwinding instructions. */
7042 unsigned int op
, op2
;
7051 printf (" 0x%02x ", op
);
7053 if ((op
& 0xc0) == 0x00)
7055 int offset
= ((op
& 0x3f) << 2) + 4;
7057 printf (" vsp = vsp + %d", offset
);
7059 else if ((op
& 0xc0) == 0x40)
7061 int offset
= ((op
& 0x3f) << 2) + 4;
7063 printf (" vsp = vsp - %d", offset
);
7065 else if ((op
& 0xf0) == 0x80)
7068 if (op
== 0x80 && op2
== 0)
7069 printf (_("Refuse to unwind"));
7072 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7077 for (i
= 0; i
< 12; i
++)
7078 if (mask
& (1 << i
))
7084 printf ("r%d", 4 + i
);
7089 else if ((op
& 0xf0) == 0x90)
7091 if (op
== 0x9d || op
== 0x9f)
7092 printf (_(" [Reserved]"));
7094 printf (" vsp = r%d", op
& 0x0f);
7096 else if ((op
& 0xf0) == 0xa0)
7098 int end
= 4 + (op
& 0x07);
7103 for (i
= 4; i
<= end
; i
++)
7119 else if (op
== 0xb0)
7120 printf (_(" finish"));
7121 else if (op
== 0xb1)
7124 if (op2
== 0 || (op2
& 0xf0) != 0)
7125 printf (_("[Spare]"));
7128 unsigned int mask
= op2
& 0x0f;
7133 for (i
= 0; i
< 12; i
++)
7134 if (mask
& (1 << i
))
7145 else if (op
== 0xb2)
7147 unsigned char buf
[9];
7148 unsigned int i
, len
;
7149 unsigned long offset
;
7151 for (i
= 0; i
< sizeof (buf
); i
++)
7154 if ((buf
[i
] & 0x80) == 0)
7157 assert (i
< sizeof (buf
));
7158 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7159 assert (len
== i
+ 1);
7160 offset
= offset
* 4 + 0x204;
7161 printf ("vsp = vsp + %ld", offset
);
7163 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7165 unsigned int first
, last
;
7172 printf ("pop {D%d", first
);
7174 printf ("-D%d", first
+ last
);
7177 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7179 unsigned int count
= op
& 0x07;
7183 printf ("-D%d", 8 + count
);
7186 else if (op
>= 0xc0 && op
<= 0xc5)
7188 unsigned int count
= op
& 0x07;
7190 printf (" pop {wR10");
7192 printf ("-wR%d", 10 + count
);
7195 else if (op
== 0xc6)
7197 unsigned int first
, last
;
7202 printf ("pop {wR%d", first
);
7204 printf ("-wR%d", first
+ last
);
7207 else if (op
== 0xc7)
7210 if (op2
== 0 || (op2
& 0xf0) != 0)
7211 printf (_("[Spare]"));
7214 unsigned int mask
= op2
& 0x0f;
7219 for (i
= 0; i
< 4; i
++)
7220 if (mask
& (1 << i
))
7226 printf ("wCGR%d", i
);
7232 printf (_(" [unsupported opcode]"));
7238 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7239 unsigned int word
, unsigned int remaining
,
7240 unsigned int more_words
,
7241 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7242 struct arm_section
*data_arm_sec
)
7244 struct absaddr addr
;
7246 /* Decode the unwinding instructions. */
7249 unsigned int op
, op2
;
7258 printf (" 0x%02x ", op
);
7260 if ((op
& 0xc0) == 0x00)
7262 int offset
= ((op
& 0x3f) << 3) + 8;
7263 printf (" sp = sp + %d", offset
);
7265 else if ((op
& 0xc0) == 0x80)
7268 if (op
== 0x80 && op2
== 0)
7269 printf (_("Refuse to unwind"));
7272 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7274 printf ("pop compact {");
7278 decode_tic6x_unwind_regmask (mask
);
7282 else if ((op
& 0xf0) == 0xc0)
7290 unsigned int offset
;
7294 /* Scan entire instruction first so that GET_OP output is not
7295 interleaved with disassembly. */
7297 for (i
= 0; nregs
< (op
& 0xf); i
++)
7303 regpos
[nregs
].offset
= i
* 2;
7304 regpos
[nregs
].reg
= reg
;
7311 regpos
[nregs
].offset
= i
* 2 + 1;
7312 regpos
[nregs
].reg
= reg
;
7317 printf (_("pop frame {"));
7319 for (i
= i
* 2; i
> 0; i
--)
7321 if (regpos
[reg
].offset
== i
- 1)
7323 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7330 fputs (name
, stdout
);
7337 else if (op
== 0xd0)
7338 printf (" MOV FP, SP");
7339 else if (op
== 0xd1)
7340 printf (" __c6xabi_pop_rts");
7341 else if (op
== 0xd2)
7343 unsigned char buf
[9];
7344 unsigned int i
, len
;
7345 unsigned long offset
;
7347 for (i
= 0; i
< sizeof (buf
); i
++)
7350 if ((buf
[i
] & 0x80) == 0)
7353 assert (i
< sizeof (buf
));
7354 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7355 assert (len
== i
+ 1);
7356 offset
= offset
* 8 + 0x408;
7357 printf (_("sp = sp + %ld"), offset
);
7359 else if ((op
& 0xf0) == 0xe0)
7361 if ((op
& 0x0f) == 7)
7364 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7368 printf (_(" [unsupported opcode]"));
7375 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7379 offset
= word
& 0x7fffffff;
7380 if (offset
& 0x40000000)
7381 offset
|= ~ (bfd_vma
) 0x7fffffff;
7383 if (elf_header
.e_machine
== EM_TI_C6000
)
7386 return offset
+ where
;
7390 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7392 unsigned int remaining
,
7393 bfd_vma data_offset
,
7394 Elf_Internal_Shdr
* data_sec
,
7395 struct arm_section
* data_arm_sec
)
7398 unsigned int more_words
= 0;
7399 struct absaddr addr
;
7400 bfd_vma sym_name
= (bfd_vma
) -1;
7404 /* Fetch the first word.
7405 Note - when decoding an object file the address extracted
7406 here will always be 0. So we also pass in the sym_name
7407 parameter so that we can find the symbol associated with
7408 the personality routine. */
7409 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7410 & word
, & addr
, & sym_name
))
7416 if ((word
& 0x80000000) == 0)
7418 /* Expand prel31 for personality routine. */
7420 const char *procname
;
7422 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7423 printf (_(" Personality routine: "));
7425 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7426 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7428 procname
= aux
->strtab
+ sym_name
;
7429 print_vma (fn
, PREFIX_HEX
);
7432 fputs (" <", stdout
);
7433 fputs (procname
, stdout
);
7434 fputc ('>', stdout
);
7438 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7439 fputc ('\n', stdout
);
7441 /* The GCC personality routines use the standard compact
7442 encoding, starting with one byte giving the number of
7444 if (procname
!= NULL
7445 && (const_strneq (procname
, "__gcc_personality_v0")
7446 || const_strneq (procname
, "__gxx_personality_v0")
7447 || const_strneq (procname
, "__gcj_personality_v0")
7448 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7455 printf (_(" [Truncated data]\n"));
7458 more_words
= word
>> 24;
7468 /* ARM EHABI Section 6.3:
7470 An exception-handling table entry for the compact model looks like:
7474 1 0 index Data for personalityRoutine[index] */
7476 if (elf_header
.e_machine
== EM_ARM
7477 && (word
& 0x70000000))
7478 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7480 per_index
= (word
>> 24) & 0x7f;
7481 printf (_(" Compact model index: %d\n"), per_index
);
7488 else if (per_index
< 3)
7490 more_words
= (word
>> 16) & 0xff;
7496 switch (elf_header
.e_machine
)
7501 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7502 data_offset
, data_sec
, data_arm_sec
);
7506 warn (_("Unknown ARM compact model index encountered\n"));
7507 printf (_(" [reserved]\n"));
7514 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7515 data_offset
, data_sec
, data_arm_sec
);
7517 else if (per_index
< 5)
7519 if (((word
>> 17) & 0x7f) == 0x7f)
7520 printf (_(" Restore stack from frame pointer\n"));
7522 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7523 printf (_(" Registers restored: "));
7525 printf (" (compact) ");
7526 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7528 printf (_(" Return register: %s\n"),
7529 tic6x_unwind_regnames
[word
& 0xf]);
7532 printf (_(" [reserved (%d)]\n"), per_index
);
7536 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7537 elf_header
.e_machine
);
7540 /* Decode the descriptors. Not implemented. */
7544 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7546 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7547 unsigned int i
, exidx_len
;
7549 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7550 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7551 exidx_len
= exidx_sec
->sh_size
/ 8;
7553 for (i
= 0; i
< exidx_len
; i
++)
7555 unsigned int exidx_fn
, exidx_entry
;
7556 struct absaddr fn_addr
, entry_addr
;
7559 fputc ('\n', stdout
);
7561 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7562 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7563 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7564 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7566 arm_free_section (& exidx_arm_sec
);
7567 arm_free_section (& extab_arm_sec
);
7571 /* ARM EHABI, Section 5:
7572 An index table entry consists of 2 words.
7573 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7574 if (exidx_fn
& 0x80000000)
7575 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7577 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7579 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7580 fputs (": ", stdout
);
7582 if (exidx_entry
== 1)
7584 print_vma (exidx_entry
, PREFIX_HEX
);
7585 fputs (" [cantunwind]\n", stdout
);
7587 else if (exidx_entry
& 0x80000000)
7589 print_vma (exidx_entry
, PREFIX_HEX
);
7590 fputc ('\n', stdout
);
7591 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7595 bfd_vma table
, table_offset
= 0;
7596 Elf_Internal_Shdr
*table_sec
;
7598 fputs ("@", stdout
);
7599 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7600 print_vma (table
, PREFIX_HEX
);
7603 /* Locate the matching .ARM.extab. */
7604 if (entry_addr
.section
!= SHN_UNDEF
7605 && entry_addr
.section
< elf_header
.e_shnum
)
7607 table_sec
= section_headers
+ entry_addr
.section
;
7608 table_offset
= entry_addr
.offset
;
7612 table_sec
= find_section_by_address (table
);
7613 if (table_sec
!= NULL
)
7614 table_offset
= table
- table_sec
->sh_addr
;
7616 if (table_sec
== NULL
)
7618 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7619 (unsigned long) table
);
7622 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7629 arm_free_section (&exidx_arm_sec
);
7630 arm_free_section (&extab_arm_sec
);
7633 /* Used for both ARM and C6X unwinding tables. */
7636 arm_process_unwind (FILE *file
)
7638 struct arm_unw_aux_info aux
;
7639 Elf_Internal_Shdr
*unwsec
= NULL
;
7640 Elf_Internal_Shdr
*strsec
;
7641 Elf_Internal_Shdr
*sec
;
7643 unsigned int sec_type
;
7645 switch (elf_header
.e_machine
)
7648 sec_type
= SHT_ARM_EXIDX
;
7652 sec_type
= SHT_C6000_UNWIND
;
7656 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7657 elf_header
.e_machine
);
7661 if (string_table
== NULL
)
7664 memset (& aux
, 0, sizeof (aux
));
7667 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7669 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7671 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7673 strsec
= section_headers
+ sec
->sh_link
;
7674 assert (aux
.strtab
== NULL
);
7675 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7676 1, strsec
->sh_size
, _("string table"));
7677 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7679 else if (sec
->sh_type
== sec_type
)
7684 printf (_("\nThere are no unwind sections in this file.\n"));
7686 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7688 if (sec
->sh_type
== sec_type
)
7690 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7692 (unsigned long) sec
->sh_offset
,
7693 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7695 dump_arm_unwind (&aux
, sec
);
7702 free ((char *) aux
.strtab
);
7706 process_unwind (FILE * file
)
7708 struct unwind_handler
7711 void (* handler
)(FILE *);
7714 { EM_ARM
, arm_process_unwind
},
7715 { EM_IA_64
, ia64_process_unwind
},
7716 { EM_PARISC
, hppa_process_unwind
},
7717 { EM_TI_C6000
, arm_process_unwind
},
7725 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7726 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7728 handlers
[i
].handler (file
);
7732 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7733 get_machine_name (elf_header
.e_machine
));
7737 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7739 switch (entry
->d_tag
)
7742 if (entry
->d_un
.d_val
== 0)
7746 static const char * opts
[] =
7748 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7749 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7750 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7751 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7757 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7758 if (entry
->d_un
.d_val
& (1 << cnt
))
7760 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7766 case DT_MIPS_IVERSION
:
7767 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7768 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7770 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7773 case DT_MIPS_TIME_STAMP
:
7778 time_t atime
= entry
->d_un
.d_val
;
7779 tmp
= gmtime (&atime
);
7780 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7781 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7782 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7783 printf (_("Time Stamp: %s"), timebuf
);
7787 case DT_MIPS_RLD_VERSION
:
7788 case DT_MIPS_LOCAL_GOTNO
:
7789 case DT_MIPS_CONFLICTNO
:
7790 case DT_MIPS_LIBLISTNO
:
7791 case DT_MIPS_SYMTABNO
:
7792 case DT_MIPS_UNREFEXTNO
:
7793 case DT_MIPS_HIPAGENO
:
7794 case DT_MIPS_DELTA_CLASS_NO
:
7795 case DT_MIPS_DELTA_INSTANCE_NO
:
7796 case DT_MIPS_DELTA_RELOC_NO
:
7797 case DT_MIPS_DELTA_SYM_NO
:
7798 case DT_MIPS_DELTA_CLASSSYM_NO
:
7799 case DT_MIPS_COMPACT_SIZE
:
7800 print_vma (entry
->d_un
.d_ptr
, DEC
);
7804 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7810 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7812 switch (entry
->d_tag
)
7814 case DT_HP_DLD_FLAGS
:
7823 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7824 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7825 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7826 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7827 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7828 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7829 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7830 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7831 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7832 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7833 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7834 { DT_HP_GST
, "HP_GST" },
7835 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7836 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7837 { DT_HP_NODELETE
, "HP_NODELETE" },
7838 { DT_HP_GROUP
, "HP_GROUP" },
7839 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7843 bfd_vma val
= entry
->d_un
.d_val
;
7845 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7846 if (val
& flags
[cnt
].bit
)
7850 fputs (flags
[cnt
].str
, stdout
);
7852 val
^= flags
[cnt
].bit
;
7855 if (val
!= 0 || first
)
7859 print_vma (val
, HEX
);
7865 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7873 /* VMS vs Unix time offset and factor. */
7875 #define VMS_EPOCH_OFFSET 35067168000000000LL
7876 #define VMS_GRANULARITY_FACTOR 10000000
7878 /* Display a VMS time in a human readable format. */
7881 print_vms_time (bfd_int64_t vmstime
)
7886 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7887 tm
= gmtime (&unxtime
);
7888 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7889 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7890 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7895 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7897 switch (entry
->d_tag
)
7899 case DT_IA_64_PLT_RESERVE
:
7900 /* First 3 slots reserved. */
7901 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7903 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7906 case DT_IA_64_VMS_LINKTIME
:
7908 print_vms_time (entry
->d_un
.d_val
);
7912 case DT_IA_64_VMS_LNKFLAGS
:
7913 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7914 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7915 printf (" CALL_DEBUG");
7916 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7917 printf (" NOP0BUFS");
7918 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7919 printf (" P0IMAGE");
7920 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7921 printf (" MKTHREADS");
7922 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7923 printf (" UPCALLS");
7924 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7926 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7927 printf (" INITIALIZE");
7928 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7930 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7931 printf (" EXE_INIT");
7932 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7933 printf (" TBK_IN_IMG");
7934 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7935 printf (" DBG_IN_IMG");
7936 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7937 printf (" TBK_IN_DSF");
7938 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7939 printf (" DBG_IN_DSF");
7940 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7941 printf (" SIGNATURES");
7942 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7943 printf (" REL_SEG_OFF");
7947 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7954 get_32bit_dynamic_section (FILE * file
)
7956 Elf32_External_Dyn
* edyn
;
7957 Elf32_External_Dyn
* ext
;
7958 Elf_Internal_Dyn
* entry
;
7960 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7961 dynamic_size
, _("dynamic section"));
7965 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7966 might not have the luxury of section headers. Look for the DT_NULL
7967 terminator to determine the number of entries. */
7968 for (ext
= edyn
, dynamic_nent
= 0;
7969 (char *) ext
< (char *) edyn
+ dynamic_size
;
7973 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7977 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7979 if (dynamic_section
== NULL
)
7981 error (_("Out of memory\n"));
7986 for (ext
= edyn
, entry
= dynamic_section
;
7987 entry
< dynamic_section
+ dynamic_nent
;
7990 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7991 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8000 get_64bit_dynamic_section (FILE * file
)
8002 Elf64_External_Dyn
* edyn
;
8003 Elf64_External_Dyn
* ext
;
8004 Elf_Internal_Dyn
* entry
;
8006 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8007 dynamic_size
, _("dynamic section"));
8011 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8012 might not have the luxury of section headers. Look for the DT_NULL
8013 terminator to determine the number of entries. */
8014 for (ext
= edyn
, dynamic_nent
= 0;
8015 (char *) ext
< (char *) edyn
+ dynamic_size
;
8019 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8023 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8025 if (dynamic_section
== NULL
)
8027 error (_("Out of memory\n"));
8032 for (ext
= edyn
, entry
= dynamic_section
;
8033 entry
< dynamic_section
+ dynamic_nent
;
8036 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8037 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8046 print_dynamic_flags (bfd_vma flags
)
8054 flag
= flags
& - flags
;
8064 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8065 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8066 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8067 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8068 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8069 default: fputs (_("unknown"), stdout
); break;
8075 /* Parse and display the contents of the dynamic section. */
8078 process_dynamic_section (FILE * file
)
8080 Elf_Internal_Dyn
* entry
;
8082 if (dynamic_size
== 0)
8085 printf (_("\nThere is no dynamic section in this file.\n"));
8092 if (! get_32bit_dynamic_section (file
))
8095 else if (! get_64bit_dynamic_section (file
))
8098 /* Find the appropriate symbol table. */
8099 if (dynamic_symbols
== NULL
)
8101 for (entry
= dynamic_section
;
8102 entry
< dynamic_section
+ dynamic_nent
;
8105 Elf_Internal_Shdr section
;
8107 if (entry
->d_tag
!= DT_SYMTAB
)
8110 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8112 /* Since we do not know how big the symbol table is,
8113 we default to reading in the entire file (!) and
8114 processing that. This is overkill, I know, but it
8116 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8118 if (archive_file_offset
!= 0)
8119 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8122 if (fseek (file
, 0, SEEK_END
))
8123 error (_("Unable to seek to end of file!\n"));
8125 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8129 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8131 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8133 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8134 if (num_dynamic_syms
< 1)
8136 error (_("Unable to determine the number of symbols to load\n"));
8142 /* Similarly find a string table. */
8143 if (dynamic_strings
== NULL
)
8145 for (entry
= dynamic_section
;
8146 entry
< dynamic_section
+ dynamic_nent
;
8149 unsigned long offset
;
8152 if (entry
->d_tag
!= DT_STRTAB
)
8155 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8157 /* Since we do not know how big the string table is,
8158 we default to reading in the entire file (!) and
8159 processing that. This is overkill, I know, but it
8162 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8164 if (archive_file_offset
!= 0)
8165 str_tab_len
= archive_file_size
- offset
;
8168 if (fseek (file
, 0, SEEK_END
))
8169 error (_("Unable to seek to end of file\n"));
8170 str_tab_len
= ftell (file
) - offset
;
8173 if (str_tab_len
< 1)
8176 (_("Unable to determine the length of the dynamic string table\n"));
8180 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8182 _("dynamic string table"));
8183 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8188 /* And find the syminfo section if available. */
8189 if (dynamic_syminfo
== NULL
)
8191 unsigned long syminsz
= 0;
8193 for (entry
= dynamic_section
;
8194 entry
< dynamic_section
+ dynamic_nent
;
8197 if (entry
->d_tag
== DT_SYMINENT
)
8199 /* Note: these braces are necessary to avoid a syntax
8200 error from the SunOS4 C compiler. */
8201 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
8203 else if (entry
->d_tag
== DT_SYMINSZ
)
8204 syminsz
= entry
->d_un
.d_val
;
8205 else if (entry
->d_tag
== DT_SYMINFO
)
8206 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8210 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8212 Elf_External_Syminfo
* extsyminfo
;
8213 Elf_External_Syminfo
* extsym
;
8214 Elf_Internal_Syminfo
* syminfo
;
8216 /* There is a syminfo section. Read the data. */
8217 extsyminfo
= (Elf_External_Syminfo
*)
8218 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8219 _("symbol information"));
8223 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8224 if (dynamic_syminfo
== NULL
)
8226 error (_("Out of memory\n"));
8230 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8231 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8232 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8233 ++syminfo
, ++extsym
)
8235 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8236 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8243 if (do_dynamic
&& dynamic_addr
)
8244 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8245 dynamic_addr
, dynamic_nent
);
8247 printf (_(" Tag Type Name/Value\n"));
8249 for (entry
= dynamic_section
;
8250 entry
< dynamic_section
+ dynamic_nent
;
8258 print_vma (entry
->d_tag
, FULL_HEX
);
8259 dtype
= get_dynamic_type (entry
->d_tag
);
8260 printf (" (%s)%*s", dtype
,
8261 ((is_32bit_elf
? 27 : 19)
8262 - (int) strlen (dtype
)),
8266 switch (entry
->d_tag
)
8270 print_dynamic_flags (entry
->d_un
.d_val
);
8280 switch (entry
->d_tag
)
8283 printf (_("Auxiliary library"));
8287 printf (_("Filter library"));
8291 printf (_("Configuration file"));
8295 printf (_("Dependency audit library"));
8299 printf (_("Audit library"));
8303 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8304 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8317 printf (_("Flags:"));
8319 if (entry
->d_un
.d_val
== 0)
8320 printf (_(" None\n"));
8323 unsigned long int val
= entry
->d_un
.d_val
;
8325 if (val
& DTF_1_PARINIT
)
8327 printf (" PARINIT");
8328 val
^= DTF_1_PARINIT
;
8330 if (val
& DTF_1_CONFEXP
)
8332 printf (" CONFEXP");
8333 val
^= DTF_1_CONFEXP
;
8336 printf (" %lx", val
);
8345 printf (_("Flags:"));
8347 if (entry
->d_un
.d_val
== 0)
8348 printf (_(" None\n"));
8351 unsigned long int val
= entry
->d_un
.d_val
;
8353 if (val
& DF_P1_LAZYLOAD
)
8355 printf (" LAZYLOAD");
8356 val
^= DF_P1_LAZYLOAD
;
8358 if (val
& DF_P1_GROUPPERM
)
8360 printf (" GROUPPERM");
8361 val
^= DF_P1_GROUPPERM
;
8364 printf (" %lx", val
);
8373 printf (_("Flags:"));
8374 if (entry
->d_un
.d_val
== 0)
8375 printf (_(" None\n"));
8378 unsigned long int val
= entry
->d_un
.d_val
;
8385 if (val
& DF_1_GLOBAL
)
8390 if (val
& DF_1_GROUP
)
8395 if (val
& DF_1_NODELETE
)
8397 printf (" NODELETE");
8398 val
^= DF_1_NODELETE
;
8400 if (val
& DF_1_LOADFLTR
)
8402 printf (" LOADFLTR");
8403 val
^= DF_1_LOADFLTR
;
8405 if (val
& DF_1_INITFIRST
)
8407 printf (" INITFIRST");
8408 val
^= DF_1_INITFIRST
;
8410 if (val
& DF_1_NOOPEN
)
8415 if (val
& DF_1_ORIGIN
)
8420 if (val
& DF_1_DIRECT
)
8425 if (val
& DF_1_TRANS
)
8430 if (val
& DF_1_INTERPOSE
)
8432 printf (" INTERPOSE");
8433 val
^= DF_1_INTERPOSE
;
8435 if (val
& DF_1_NODEFLIB
)
8437 printf (" NODEFLIB");
8438 val
^= DF_1_NODEFLIB
;
8440 if (val
& DF_1_NODUMP
)
8445 if (val
& DF_1_CONFALT
)
8447 printf (" CONFALT");
8448 val
^= DF_1_CONFALT
;
8450 if (val
& DF_1_ENDFILTEE
)
8452 printf (" ENDFILTEE");
8453 val
^= DF_1_ENDFILTEE
;
8455 if (val
& DF_1_DISPRELDNE
)
8457 printf (" DISPRELDNE");
8458 val
^= DF_1_DISPRELDNE
;
8460 if (val
& DF_1_DISPRELPND
)
8462 printf (" DISPRELPND");
8463 val
^= DF_1_DISPRELPND
;
8465 if (val
& DF_1_NODIRECT
)
8467 printf (" NODIRECT");
8468 val
^= DF_1_NODIRECT
;
8470 if (val
& DF_1_IGNMULDEF
)
8472 printf (" IGNMULDEF");
8473 val
^= DF_1_IGNMULDEF
;
8475 if (val
& DF_1_NOKSYMS
)
8477 printf (" NOKSYMS");
8478 val
^= DF_1_NOKSYMS
;
8480 if (val
& DF_1_NOHDR
)
8485 if (val
& DF_1_EDITED
)
8490 if (val
& DF_1_NORELOC
)
8492 printf (" NORELOC");
8493 val
^= DF_1_NORELOC
;
8495 if (val
& DF_1_SYMINTPOSE
)
8497 printf (" SYMINTPOSE");
8498 val
^= DF_1_SYMINTPOSE
;
8500 if (val
& DF_1_GLOBAUDIT
)
8502 printf (" GLOBAUDIT");
8503 val
^= DF_1_GLOBAUDIT
;
8505 if (val
& DF_1_SINGLETON
)
8507 printf (" SINGLETON");
8508 val
^= DF_1_SINGLETON
;
8511 printf (" %lx", val
);
8518 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8520 puts (get_dynamic_type (entry
->d_un
.d_val
));
8540 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8546 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8547 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8553 switch (entry
->d_tag
)
8556 printf (_("Shared library: [%s]"), name
);
8558 if (streq (name
, program_interpreter
))
8559 printf (_(" program interpreter"));
8563 printf (_("Library soname: [%s]"), name
);
8567 printf (_("Library rpath: [%s]"), name
);
8571 printf (_("Library runpath: [%s]"), name
);
8575 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8580 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8593 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8597 case DT_INIT_ARRAYSZ
:
8598 case DT_FINI_ARRAYSZ
:
8599 case DT_GNU_CONFLICTSZ
:
8600 case DT_GNU_LIBLISTSZ
:
8603 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8604 printf (_(" (bytes)\n"));
8614 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8627 if (entry
->d_tag
== DT_USED
8628 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8630 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8634 printf (_("Not needed object: [%s]\n"), name
);
8639 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8645 /* The value of this entry is ignored. */
8650 case DT_GNU_PRELINKED
:
8654 time_t atime
= entry
->d_un
.d_val
;
8656 tmp
= gmtime (&atime
);
8657 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8658 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8659 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8665 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8668 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8674 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8675 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8680 switch (elf_header
.e_machine
)
8683 case EM_MIPS_RS3_LE
:
8684 dynamic_section_mips_val (entry
);
8687 dynamic_section_parisc_val (entry
);
8690 dynamic_section_ia64_val (entry
);
8693 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8705 get_ver_flags (unsigned int flags
)
8707 static char buff
[32];
8714 if (flags
& VER_FLG_BASE
)
8715 strcat (buff
, "BASE ");
8717 if (flags
& VER_FLG_WEAK
)
8719 if (flags
& VER_FLG_BASE
)
8720 strcat (buff
, "| ");
8722 strcat (buff
, "WEAK ");
8725 if (flags
& VER_FLG_INFO
)
8727 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8728 strcat (buff
, "| ");
8730 strcat (buff
, "INFO ");
8733 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8734 strcat (buff
, _("| <unknown>"));
8739 /* Display the contents of the version sections. */
8742 process_version_sections (FILE * file
)
8744 Elf_Internal_Shdr
* section
;
8751 for (i
= 0, section
= section_headers
;
8752 i
< elf_header
.e_shnum
;
8755 switch (section
->sh_type
)
8757 case SHT_GNU_verdef
:
8759 Elf_External_Verdef
* edefs
;
8767 (_("\nVersion definition section '%s' contains %u entries:\n"),
8768 SECTION_NAME (section
), section
->sh_info
);
8770 printf (_(" Addr: 0x"));
8771 printf_vma (section
->sh_addr
);
8772 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8773 (unsigned long) section
->sh_offset
, section
->sh_link
,
8774 section
->sh_link
< elf_header
.e_shnum
8775 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8778 edefs
= (Elf_External_Verdef
*)
8779 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8780 _("version definition section"));
8783 endbuf
= (char *) edefs
+ section
->sh_size
;
8785 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8788 Elf_External_Verdef
* edef
;
8789 Elf_Internal_Verdef ent
;
8790 Elf_External_Verdaux
* eaux
;
8791 Elf_Internal_Verdaux aux
;
8795 /* Check for very large indicies. */
8796 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8799 vstart
= ((char *) edefs
) + idx
;
8800 if (vstart
+ sizeof (*edef
) > endbuf
)
8803 edef
= (Elf_External_Verdef
*) vstart
;
8805 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8806 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8807 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8808 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8809 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8810 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8811 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8813 printf (_(" %#06x: Rev: %d Flags: %s"),
8814 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8816 printf (_(" Index: %d Cnt: %d "),
8817 ent
.vd_ndx
, ent
.vd_cnt
);
8819 /* Check for overflow. */
8820 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8823 vstart
+= ent
.vd_aux
;
8825 eaux
= (Elf_External_Verdaux
*) vstart
;
8827 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8828 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8830 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8831 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8833 printf (_("Name index: %ld\n"), aux
.vda_name
);
8835 isum
= idx
+ ent
.vd_aux
;
8837 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8839 /* Check for overflow. */
8840 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8843 isum
+= aux
.vda_next
;
8844 vstart
+= aux
.vda_next
;
8846 eaux
= (Elf_External_Verdaux
*) vstart
;
8847 if (vstart
+ sizeof (*eaux
) > endbuf
)
8850 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8851 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8853 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8854 printf (_(" %#06x: Parent %d: %s\n"),
8855 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8857 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8858 isum
, j
, aux
.vda_name
);
8862 printf (_(" Version def aux past end of section\n"));
8867 if (cnt
< section
->sh_info
)
8868 printf (_(" Version definition past end of section\n"));
8874 case SHT_GNU_verneed
:
8876 Elf_External_Verneed
* eneed
;
8883 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8884 SECTION_NAME (section
), section
->sh_info
);
8886 printf (_(" Addr: 0x"));
8887 printf_vma (section
->sh_addr
);
8888 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8889 (unsigned long) section
->sh_offset
, section
->sh_link
,
8890 section
->sh_link
< elf_header
.e_shnum
8891 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8894 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8895 section
->sh_offset
, 1,
8897 _("Version Needs section"));
8900 endbuf
= (char *) eneed
+ section
->sh_size
;
8902 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8904 Elf_External_Verneed
* entry
;
8905 Elf_Internal_Verneed ent
;
8910 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8913 vstart
= ((char *) eneed
) + idx
;
8914 if (vstart
+ sizeof (*entry
) > endbuf
)
8917 entry
= (Elf_External_Verneed
*) vstart
;
8919 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8920 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8921 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8922 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8923 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8925 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8927 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8928 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8930 printf (_(" File: %lx"), ent
.vn_file
);
8932 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8934 /* Check for overflow. */
8935 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8938 vstart
+= ent
.vn_aux
;
8940 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8942 Elf_External_Vernaux
* eaux
;
8943 Elf_Internal_Vernaux aux
;
8945 if (vstart
+ sizeof (*eaux
) > endbuf
)
8947 eaux
= (Elf_External_Vernaux
*) vstart
;
8949 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8950 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8951 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8952 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8953 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8955 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8956 printf (_(" %#06x: Name: %s"),
8957 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8959 printf (_(" %#06x: Name index: %lx"),
8960 isum
, aux
.vna_name
);
8962 printf (_(" Flags: %s Version: %d\n"),
8963 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8965 /* Check for overflow. */
8966 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8969 isum
+= aux
.vna_next
;
8970 vstart
+= aux
.vna_next
;
8974 warn (_("Missing Version Needs auxillary information\n"));
8976 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
8978 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8979 cnt
= section
->sh_info
;
8985 if (cnt
< section
->sh_info
)
8986 warn (_("Missing Version Needs information\n"));
8992 case SHT_GNU_versym
:
8994 Elf_Internal_Shdr
* link_section
;
8997 unsigned char * edata
;
8998 unsigned short * data
;
9000 Elf_Internal_Sym
* symbols
;
9001 Elf_Internal_Shdr
* string_sec
;
9002 unsigned long num_syms
;
9005 if (section
->sh_link
>= elf_header
.e_shnum
)
9008 link_section
= section_headers
+ section
->sh_link
;
9009 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9011 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9016 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9017 if (symbols
== NULL
)
9020 string_sec
= section_headers
+ link_section
->sh_link
;
9022 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9023 string_sec
->sh_size
,
9024 _("version string table"));
9031 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9032 SECTION_NAME (section
), total
);
9034 printf (_(" Addr: "));
9035 printf_vma (section
->sh_addr
);
9036 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9037 (unsigned long) section
->sh_offset
, section
->sh_link
,
9038 SECTION_NAME (link_section
));
9040 off
= offset_from_vma (file
,
9041 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9042 total
* sizeof (short));
9043 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9045 _("version symbol data"));
9053 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9055 for (cnt
= total
; cnt
--;)
9056 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9061 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9064 int check_def
, check_need
;
9067 printf (" %03x:", cnt
);
9069 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9070 switch (data
[cnt
+ j
])
9073 fputs (_(" 0 (*local*) "), stdout
);
9077 fputs (_(" 1 (*global*) "), stdout
);
9081 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9082 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9084 /* If this index value is greater than the size of the symbols
9085 array, break to avoid an out-of-bounds read. */
9086 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9088 warn (_("invalid index into symbol array\n"));
9094 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9095 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9098 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9105 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9107 Elf_Internal_Verneed ivn
;
9108 unsigned long offset
;
9110 offset
= offset_from_vma
9111 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9112 sizeof (Elf_External_Verneed
));
9116 Elf_Internal_Vernaux ivna
;
9117 Elf_External_Verneed evn
;
9118 Elf_External_Vernaux evna
;
9119 unsigned long a_off
;
9121 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9122 _("version need")) == NULL
)
9125 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9126 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9128 a_off
= offset
+ ivn
.vn_aux
;
9132 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9133 1, _("version need aux (2)")) == NULL
)
9140 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9141 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9144 a_off
+= ivna
.vna_next
;
9146 while (ivna
.vna_other
!= data
[cnt
+ j
]
9147 && ivna
.vna_next
!= 0);
9149 if (ivna
.vna_other
== data
[cnt
+ j
])
9151 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9153 if (ivna
.vna_name
>= string_sec
->sh_size
)
9154 name
= _("*invalid*");
9156 name
= strtab
+ ivna
.vna_name
;
9157 nn
+= printf ("(%s%-*s",
9159 12 - (int) strlen (name
),
9165 offset
+= ivn
.vn_next
;
9167 while (ivn
.vn_next
);
9170 if (check_def
&& data
[cnt
+ j
] != 0x8001
9171 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9173 Elf_Internal_Verdef ivd
;
9174 Elf_External_Verdef evd
;
9175 unsigned long offset
;
9177 offset
= offset_from_vma
9178 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9183 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9184 _("version def")) == NULL
)
9191 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9192 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9195 offset
+= ivd
.vd_next
;
9197 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9198 && ivd
.vd_next
!= 0);
9200 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9202 Elf_External_Verdaux evda
;
9203 Elf_Internal_Verdaux ivda
;
9205 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9207 if (get_data (&evda
, file
,
9208 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9210 _("version def aux")) == NULL
)
9213 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9215 if (ivda
.vda_name
>= string_sec
->sh_size
)
9216 name
= _("*invalid*");
9218 name
= strtab
+ ivda
.vda_name
;
9219 nn
+= printf ("(%s%-*s",
9221 12 - (int) strlen (name
),
9227 printf ("%*c", 18 - nn
, ' ');
9245 printf (_("\nNo version information found in this file.\n"));
9251 get_symbol_binding (unsigned int binding
)
9253 static char buff
[32];
9257 case STB_LOCAL
: return "LOCAL";
9258 case STB_GLOBAL
: return "GLOBAL";
9259 case STB_WEAK
: return "WEAK";
9261 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9262 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9264 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9266 if (binding
== STB_GNU_UNIQUE
9267 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9268 /* GNU is still using the default value 0. */
9269 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9271 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9274 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9280 get_symbol_type (unsigned int type
)
9282 static char buff
[32];
9286 case STT_NOTYPE
: return "NOTYPE";
9287 case STT_OBJECT
: return "OBJECT";
9288 case STT_FUNC
: return "FUNC";
9289 case STT_SECTION
: return "SECTION";
9290 case STT_FILE
: return "FILE";
9291 case STT_COMMON
: return "COMMON";
9292 case STT_TLS
: return "TLS";
9293 case STT_RELC
: return "RELC";
9294 case STT_SRELC
: return "SRELC";
9296 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9298 if (elf_header
.e_machine
== EM_ARM
)
9300 if (type
== STT_ARM_TFUNC
)
9301 return "THUMB_FUNC";
9302 if (type
== STT_ARM_16BIT
)
9303 return "THUMB_LABEL";
9306 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9309 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9310 return "PARISC_MILLI";
9312 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9314 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9316 if (elf_header
.e_machine
== EM_PARISC
)
9318 if (type
== STT_HP_OPAQUE
)
9320 if (type
== STT_HP_STUB
)
9324 if (type
== STT_GNU_IFUNC
9325 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9326 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9327 /* GNU is still using the default value 0. */
9328 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9331 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9334 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9340 get_symbol_visibility (unsigned int visibility
)
9344 case STV_DEFAULT
: return "DEFAULT";
9345 case STV_INTERNAL
: return "INTERNAL";
9346 case STV_HIDDEN
: return "HIDDEN";
9347 case STV_PROTECTED
: return "PROTECTED";
9353 get_mips_symbol_other (unsigned int other
)
9365 case STO_MICROMIPS
| STO_MIPS_PIC
:
9366 return "MICROMIPS, MIPS PIC";
9375 get_ia64_symbol_other (unsigned int other
)
9379 static char res
[32];
9383 /* Function types is for images and .STB files only. */
9384 switch (elf_header
.e_type
)
9388 switch (VMS_ST_FUNC_TYPE (other
))
9390 case VMS_SFT_CODE_ADDR
:
9391 strcat (res
, " CA");
9393 case VMS_SFT_SYMV_IDX
:
9394 strcat (res
, " VEC");
9397 strcat (res
, " FD");
9399 case VMS_SFT_RESERVE
:
9400 strcat (res
, " RSV");
9409 switch (VMS_ST_LINKAGE (other
))
9411 case VMS_STL_IGNORE
:
9412 strcat (res
, " IGN");
9414 case VMS_STL_RESERVE
:
9415 strcat (res
, " RSV");
9418 strcat (res
, " STD");
9421 strcat (res
, " LNK");
9436 get_ppc64_symbol_other (unsigned int other
)
9438 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9440 static char buf
[32];
9441 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9442 PPC64_LOCAL_ENTRY_OFFSET (other
));
9449 get_symbol_other (unsigned int other
)
9451 const char * result
= NULL
;
9452 static char buff
[32];
9457 switch (elf_header
.e_machine
)
9460 result
= get_mips_symbol_other (other
);
9463 result
= get_ia64_symbol_other (other
);
9466 result
= get_ppc64_symbol_other (other
);
9475 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9480 get_symbol_index_type (unsigned int type
)
9482 static char buff
[32];
9486 case SHN_UNDEF
: return "UND";
9487 case SHN_ABS
: return "ABS";
9488 case SHN_COMMON
: return "COM";
9490 if (type
== SHN_IA_64_ANSI_COMMON
9491 && elf_header
.e_machine
== EM_IA_64
9492 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9494 else if ((elf_header
.e_machine
== EM_X86_64
9495 || elf_header
.e_machine
== EM_L1OM
9496 || elf_header
.e_machine
== EM_K1OM
)
9497 && type
== SHN_X86_64_LCOMMON
)
9499 else if ((type
== SHN_MIPS_SCOMMON
9500 && elf_header
.e_machine
== EM_MIPS
)
9501 || (type
== SHN_TIC6X_SCOMMON
9502 && elf_header
.e_machine
== EM_TI_C6000
))
9504 else if (type
== SHN_MIPS_SUNDEFINED
9505 && elf_header
.e_machine
== EM_MIPS
)
9507 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9508 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9509 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9510 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9511 else if (type
>= SHN_LORESERVE
)
9512 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9513 else if (type
>= elf_header
.e_shnum
)
9514 sprintf (buff
, "bad section index[%3d]", type
);
9516 sprintf (buff
, "%3d", type
);
9524 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9526 unsigned char * e_data
;
9529 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9533 error (_("Out of memory\n"));
9537 if (fread (e_data
, ent_size
, number
, file
) != number
)
9539 error (_("Unable to read in dynamic data\n"));
9543 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9547 error (_("Out of memory\n"));
9553 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9561 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9563 Elf_Internal_Sym
* psym
;
9566 psym
= dynamic_symbols
+ si
;
9568 n
= print_vma (si
, DEC_5
);
9570 fputs (&" "[n
], stdout
);
9571 printf (" %3lu: ", hn
);
9572 print_vma (psym
->st_value
, LONG_HEX
);
9574 print_vma (psym
->st_size
, DEC_5
);
9576 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9577 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9578 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9579 /* Check to see if any other bits in the st_other field are set.
9580 Note - displaying this information disrupts the layout of the
9581 table being generated, but for the moment this case is very
9583 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9584 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9585 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9586 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9587 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9589 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9593 /* Dump the symbol table. */
9595 process_symbol_table (FILE * file
)
9597 Elf_Internal_Shdr
* section
;
9598 bfd_vma nbuckets
= 0;
9599 bfd_vma nchains
= 0;
9600 bfd_vma
* buckets
= NULL
;
9601 bfd_vma
* chains
= NULL
;
9602 bfd_vma ngnubuckets
= 0;
9603 bfd_vma
* gnubuckets
= NULL
;
9604 bfd_vma
* gnuchains
= NULL
;
9605 bfd_vma gnusymidx
= 0;
9607 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9610 if (dynamic_info
[DT_HASH
]
9612 || (do_using_dynamic
9614 && dynamic_strings
!= NULL
)))
9616 unsigned char nb
[8];
9617 unsigned char nc
[8];
9618 int hash_ent_size
= 4;
9620 if ((elf_header
.e_machine
== EM_ALPHA
9621 || elf_header
.e_machine
== EM_S390
9622 || elf_header
.e_machine
== EM_S390_OLD
)
9623 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9627 (archive_file_offset
9628 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9629 sizeof nb
+ sizeof nc
)),
9632 error (_("Unable to seek to start of dynamic information\n"));
9636 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9638 error (_("Failed to read in number of buckets\n"));
9642 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9644 error (_("Failed to read in number of chains\n"));
9648 nbuckets
= byte_get (nb
, hash_ent_size
);
9649 nchains
= byte_get (nc
, hash_ent_size
);
9651 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9652 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9655 if (buckets
== NULL
|| chains
== NULL
)
9657 if (do_using_dynamic
)
9668 if (dynamic_info_DT_GNU_HASH
9670 || (do_using_dynamic
9672 && dynamic_strings
!= NULL
)))
9674 unsigned char nb
[16];
9675 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9676 bfd_vma buckets_vma
;
9679 (archive_file_offset
9680 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9684 error (_("Unable to seek to start of dynamic information\n"));
9688 if (fread (nb
, 16, 1, file
) != 1)
9690 error (_("Failed to read in number of buckets\n"));
9694 ngnubuckets
= byte_get (nb
, 4);
9695 gnusymidx
= byte_get (nb
+ 4, 4);
9696 bitmaskwords
= byte_get (nb
+ 8, 4);
9697 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9699 buckets_vma
+= bitmaskwords
* 4;
9701 buckets_vma
+= bitmaskwords
* 8;
9704 (archive_file_offset
9705 + offset_from_vma (file
, buckets_vma
, 4)),
9708 error (_("Unable to seek to start of dynamic information\n"));
9712 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9714 if (gnubuckets
== NULL
)
9717 for (i
= 0; i
< ngnubuckets
; i
++)
9718 if (gnubuckets
[i
] != 0)
9720 if (gnubuckets
[i
] < gnusymidx
)
9723 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9724 maxchain
= gnubuckets
[i
];
9727 if (maxchain
== 0xffffffff)
9730 maxchain
-= gnusymidx
;
9733 (archive_file_offset
9734 + offset_from_vma (file
, buckets_vma
9735 + 4 * (ngnubuckets
+ maxchain
), 4)),
9738 error (_("Unable to seek to start of dynamic information\n"));
9744 if (fread (nb
, 4, 1, file
) != 1)
9746 error (_("Failed to determine last chain length\n"));
9750 if (maxchain
+ 1 == 0)
9755 while ((byte_get (nb
, 4) & 1) == 0);
9758 (archive_file_offset
9759 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9762 error (_("Unable to seek to start of dynamic information\n"));
9766 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9769 if (gnuchains
== NULL
)
9774 if (do_using_dynamic
)
9779 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9782 && dynamic_strings
!= NULL
)
9786 if (dynamic_info
[DT_HASH
])
9790 printf (_("\nSymbol table for image:\n"));
9792 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9794 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9796 for (hn
= 0; hn
< nbuckets
; hn
++)
9801 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9802 print_dynamic_symbol (si
, hn
);
9806 if (dynamic_info_DT_GNU_HASH
)
9808 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9810 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9812 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9814 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9815 if (gnubuckets
[hn
] != 0)
9817 bfd_vma si
= gnubuckets
[hn
];
9818 bfd_vma off
= si
- gnusymidx
;
9822 print_dynamic_symbol (si
, hn
);
9825 while ((gnuchains
[off
++] & 1) == 0);
9829 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9833 for (i
= 0, section
= section_headers
;
9834 i
< elf_header
.e_shnum
;
9838 char * strtab
= NULL
;
9839 unsigned long int strtab_size
= 0;
9840 Elf_Internal_Sym
* symtab
;
9841 Elf_Internal_Sym
* psym
;
9842 unsigned long num_syms
;
9844 if ((section
->sh_type
!= SHT_SYMTAB
9845 && section
->sh_type
!= SHT_DYNSYM
)
9847 && section
->sh_type
== SHT_SYMTAB
))
9850 if (section
->sh_entsize
== 0)
9852 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9853 SECTION_NAME (section
));
9857 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9858 SECTION_NAME (section
),
9859 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9862 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9864 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9866 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9870 if (section
->sh_link
== elf_header
.e_shstrndx
)
9872 strtab
= string_table
;
9873 strtab_size
= string_table_length
;
9875 else if (section
->sh_link
< elf_header
.e_shnum
)
9877 Elf_Internal_Shdr
* string_sec
;
9879 string_sec
= section_headers
+ section
->sh_link
;
9881 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9882 1, string_sec
->sh_size
,
9884 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9887 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9889 printf ("%6d: ", si
);
9890 print_vma (psym
->st_value
, LONG_HEX
);
9892 print_vma (psym
->st_size
, DEC_5
);
9893 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9894 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9895 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9896 /* Check to see if any other bits in the st_other field are set.
9897 Note - displaying this information disrupts the layout of the
9898 table being generated, but for the moment this case is very rare. */
9899 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9900 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9901 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9902 print_symbol (25, psym
->st_name
< strtab_size
9903 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9905 if (section
->sh_type
== SHT_DYNSYM
9906 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9908 unsigned char data
[2];
9909 unsigned short vers_data
;
9910 unsigned long offset
;
9914 offset
= offset_from_vma
9915 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9916 sizeof data
+ si
* sizeof (vers_data
));
9918 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9919 sizeof (data
), 1, _("version data")) == NULL
)
9922 vers_data
= byte_get (data
, 2);
9924 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9925 && section_headers
[psym
->st_shndx
].sh_type
9928 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9930 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9932 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9933 && (is_nobits
|| ! check_def
))
9935 Elf_External_Verneed evn
;
9936 Elf_Internal_Verneed ivn
;
9937 Elf_Internal_Vernaux ivna
;
9939 /* We must test both. */
9940 offset
= offset_from_vma
9941 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9946 unsigned long vna_off
;
9948 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9949 _("version need")) == NULL
)
9957 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9958 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9960 vna_off
= offset
+ ivn
.vn_aux
;
9964 Elf_External_Vernaux evna
;
9966 if (get_data (&evna
, file
, vna_off
,
9968 _("version need aux (3)")) == NULL
)
9976 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9977 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9978 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9981 vna_off
+= ivna
.vna_next
;
9983 while (ivna
.vna_other
!= vers_data
9984 && ivna
.vna_next
!= 0);
9986 if (ivna
.vna_other
== vers_data
)
9989 offset
+= ivn
.vn_next
;
9991 while (ivn
.vn_next
!= 0);
9993 if (ivna
.vna_other
== vers_data
)
9996 ivna
.vna_name
< strtab_size
9997 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10001 else if (! is_nobits
)
10002 error (_("bad dynamic symbol\n"));
10009 if (vers_data
!= 0x8001
10010 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10012 Elf_Internal_Verdef ivd
;
10013 Elf_Internal_Verdaux ivda
;
10014 Elf_External_Verdaux evda
;
10017 off
= offset_from_vma
10019 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10020 sizeof (Elf_External_Verdef
));
10024 Elf_External_Verdef evd
;
10026 if (get_data (&evd
, file
, off
, sizeof (evd
),
10027 1, _("version def")) == NULL
)
10035 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10036 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10037 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10040 off
+= ivd
.vd_next
;
10042 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10043 && ivd
.vd_next
!= 0);
10045 off
-= ivd
.vd_next
;
10048 if (get_data (&evda
, file
, off
, sizeof (evda
),
10049 1, _("version def aux")) == NULL
)
10052 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10054 if (psym
->st_name
!= ivda
.vda_name
)
10055 printf ((vers_data
& VERSYM_HIDDEN
)
10057 ivda
.vda_name
< strtab_size
10058 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10068 if (strtab
!= string_table
)
10074 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10076 if (do_histogram
&& buckets
!= NULL
)
10078 unsigned long * lengths
;
10079 unsigned long * counts
;
10082 unsigned long maxlength
= 0;
10083 unsigned long nzero_counts
= 0;
10084 unsigned long nsyms
= 0;
10086 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10087 (unsigned long) nbuckets
);
10088 printf (_(" Length Number %% of total Coverage\n"));
10090 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10091 if (lengths
== NULL
)
10093 error (_("Out of memory\n"));
10096 for (hn
= 0; hn
< nbuckets
; ++hn
)
10098 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10101 if (maxlength
< ++lengths
[hn
])
10106 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10107 if (counts
== NULL
)
10110 error (_("Out of memory\n"));
10114 for (hn
= 0; hn
< nbuckets
; ++hn
)
10115 ++counts
[lengths
[hn
]];
10120 printf (" 0 %-10lu (%5.1f%%)\n",
10121 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10122 for (i
= 1; i
<= maxlength
; ++i
)
10124 nzero_counts
+= counts
[i
] * i
;
10125 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10126 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10127 (nzero_counts
* 100.0) / nsyms
);
10135 if (buckets
!= NULL
)
10141 if (do_histogram
&& gnubuckets
!= NULL
)
10143 unsigned long * lengths
;
10144 unsigned long * counts
;
10146 unsigned long maxlength
= 0;
10147 unsigned long nzero_counts
= 0;
10148 unsigned long nsyms
= 0;
10150 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10151 if (lengths
== NULL
)
10153 error (_("Out of memory\n"));
10157 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10158 (unsigned long) ngnubuckets
);
10159 printf (_(" Length Number %% of total Coverage\n"));
10161 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10162 if (gnubuckets
[hn
] != 0)
10164 bfd_vma off
, length
= 1;
10166 for (off
= gnubuckets
[hn
] - gnusymidx
;
10167 (gnuchains
[off
] & 1) == 0; ++off
)
10169 lengths
[hn
] = length
;
10170 if (length
> maxlength
)
10171 maxlength
= length
;
10175 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10176 if (counts
== NULL
)
10179 error (_("Out of memory\n"));
10183 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10184 ++counts
[lengths
[hn
]];
10186 if (ngnubuckets
> 0)
10189 printf (" 0 %-10lu (%5.1f%%)\n",
10190 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10191 for (j
= 1; j
<= maxlength
; ++j
)
10193 nzero_counts
+= counts
[j
] * j
;
10194 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10195 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10196 (nzero_counts
* 100.0) / nsyms
);
10210 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10214 if (dynamic_syminfo
== NULL
10216 /* No syminfo, this is ok. */
10219 /* There better should be a dynamic symbol section. */
10220 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10224 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10225 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10227 printf (_(" Num: Name BoundTo Flags\n"));
10228 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10230 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10232 printf ("%4d: ", i
);
10233 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10234 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10236 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10239 switch (dynamic_syminfo
[i
].si_boundto
)
10241 case SYMINFO_BT_SELF
:
10242 fputs ("SELF ", stdout
);
10244 case SYMINFO_BT_PARENT
:
10245 fputs ("PARENT ", stdout
);
10248 if (dynamic_syminfo
[i
].si_boundto
> 0
10249 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10250 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10252 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10256 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10260 if (flags
& SYMINFO_FLG_DIRECT
)
10261 printf (" DIRECT");
10262 if (flags
& SYMINFO_FLG_PASSTHRU
)
10263 printf (" PASSTHRU");
10264 if (flags
& SYMINFO_FLG_COPY
)
10266 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10267 printf (" LAZYLOAD");
10275 /* Check to see if the given reloc needs to be handled in a target specific
10276 manner. If so then process the reloc and return TRUE otherwise return
10280 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10281 unsigned char * start
,
10282 Elf_Internal_Sym
* symtab
)
10284 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10286 switch (elf_header
.e_machine
)
10289 case EM_MSP430_OLD
:
10291 static Elf_Internal_Sym
* saved_sym
= NULL
;
10293 switch (reloc_type
)
10295 case 10: /* R_MSP430_SYM_DIFF */
10296 if (uses_msp430x_relocs ())
10298 case 21: /* R_MSP430X_SYM_DIFF */
10299 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10302 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10303 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10304 goto handle_sym_diff
;
10306 case 5: /* R_MSP430_16_BYTE */
10307 case 9: /* R_MSP430_8 */
10308 if (uses_msp430x_relocs ())
10310 goto handle_sym_diff
;
10312 case 2: /* R_MSP430_ABS16 */
10313 case 15: /* R_MSP430X_ABS16 */
10314 if (! uses_msp430x_relocs ())
10316 goto handle_sym_diff
;
10319 if (saved_sym
!= NULL
)
10323 value
= reloc
->r_addend
10324 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10325 - saved_sym
->st_value
);
10327 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10335 if (saved_sym
!= NULL
)
10336 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10343 case EM_CYGNUS_MN10300
:
10345 static Elf_Internal_Sym
* saved_sym
= NULL
;
10347 switch (reloc_type
)
10349 case 34: /* R_MN10300_ALIGN */
10351 case 33: /* R_MN10300_SYM_DIFF */
10352 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10354 case 1: /* R_MN10300_32 */
10355 case 2: /* R_MN10300_16 */
10356 if (saved_sym
!= NULL
)
10360 value
= reloc
->r_addend
10361 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10362 - saved_sym
->st_value
);
10364 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10371 if (saved_sym
!= NULL
)
10372 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10382 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10383 DWARF debug sections. This is a target specific test. Note - we do not
10384 go through the whole including-target-headers-multiple-times route, (as
10385 we have already done with <elf/h8.h>) because this would become very
10386 messy and even then this function would have to contain target specific
10387 information (the names of the relocs instead of their numeric values).
10388 FIXME: This is not the correct way to solve this problem. The proper way
10389 is to have target specific reloc sizing and typing functions created by
10390 the reloc-macros.h header, in the same way that it already creates the
10391 reloc naming functions. */
10394 is_32bit_abs_reloc (unsigned int reloc_type
)
10396 switch (elf_header
.e_machine
)
10400 return reloc_type
== 1; /* R_386_32. */
10402 return reloc_type
== 1; /* R_68K_32. */
10404 return reloc_type
== 1; /* R_860_32. */
10406 return reloc_type
== 2; /* R_960_32. */
10408 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10410 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10412 return reloc_type
== 1; /* R_ARC_32. */
10414 return reloc_type
== 2; /* R_ARM_ABS32 */
10417 return reloc_type
== 1;
10418 case EM_ADAPTEVA_EPIPHANY
:
10419 return reloc_type
== 3;
10421 return reloc_type
== 0x12; /* R_byte4_data. */
10423 return reloc_type
== 3; /* R_CRIS_32. */
10425 return reloc_type
== 3; /* R_CR16_NUM32. */
10427 return reloc_type
== 15; /* R_CRX_NUM32. */
10428 case EM_CYGNUS_FRV
:
10429 return reloc_type
== 1;
10430 case EM_CYGNUS_D10V
:
10432 return reloc_type
== 6; /* R_D10V_32. */
10433 case EM_CYGNUS_D30V
:
10435 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10437 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10438 case EM_CYGNUS_FR30
:
10440 return reloc_type
== 3; /* R_FR30_32. */
10444 return reloc_type
== 1; /* R_H8_DIR32. */
10446 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10449 return reloc_type
== 2; /* R_IP2K_32. */
10451 return reloc_type
== 2; /* R_IQ2000_32. */
10452 case EM_LATTICEMICO32
:
10453 return reloc_type
== 3; /* R_LM32_32. */
10456 return reloc_type
== 3; /* R_M32C_32. */
10458 return reloc_type
== 34; /* R_M32R_32_RELA. */
10460 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10461 case EM_CYGNUS_MEP
:
10462 return reloc_type
== 4; /* R_MEP_32. */
10464 return reloc_type
== 2; /* R_METAG_ADDR32. */
10465 case EM_MICROBLAZE
:
10466 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10468 return reloc_type
== 2; /* R_MIPS_32. */
10470 return reloc_type
== 4; /* R_MMIX_32. */
10471 case EM_CYGNUS_MN10200
:
10473 return reloc_type
== 1; /* R_MN10200_32. */
10474 case EM_CYGNUS_MN10300
:
10476 return reloc_type
== 1; /* R_MN10300_32. */
10478 return reloc_type
== 1; /* R_MOXIE_32. */
10479 case EM_MSP430_OLD
:
10481 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10483 return reloc_type
== 2; /* R_MT_32. */
10485 return reloc_type
== 20; /* R_NDS32_RELA. */
10486 case EM_ALTERA_NIOS2
:
10487 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10489 return reloc_type
== 1; /* R_NIOS_32. */
10491 return reloc_type
== 1; /* R_OR1K_32. */
10493 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10494 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10497 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10499 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10501 return reloc_type
== 1; /* R_PPC_ADDR32. */
10503 return reloc_type
== 1; /* R_RL78_DIR32. */
10505 return reloc_type
== 1; /* R_RX_DIR32. */
10507 return reloc_type
== 1; /* R_I370_ADDR31. */
10510 return reloc_type
== 4; /* R_S390_32. */
10512 return reloc_type
== 8; /* R_SCORE_ABS32. */
10514 return reloc_type
== 1; /* R_SH_DIR32. */
10515 case EM_SPARC32PLUS
:
10518 return reloc_type
== 3 /* R_SPARC_32. */
10519 || reloc_type
== 23; /* R_SPARC_UA32. */
10521 return reloc_type
== 6; /* R_SPU_ADDR32 */
10523 return reloc_type
== 1; /* R_C6000_ABS32. */
10525 return reloc_type
== 2; /* R_TILEGX_32. */
10527 return reloc_type
== 1; /* R_TILEPRO_32. */
10528 case EM_CYGNUS_V850
:
10530 return reloc_type
== 6; /* R_V850_ABS32. */
10532 return reloc_type
== 0x33; /* R_V810_WORD. */
10534 return reloc_type
== 1; /* R_VAX_32. */
10538 return reloc_type
== 10; /* R_X86_64_32. */
10541 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10543 return reloc_type
== 4; /* R_XGATE_32. */
10545 return reloc_type
== 1; /* R_XSTROMY16_32. */
10546 case EM_XTENSA_OLD
:
10548 return reloc_type
== 1; /* R_XTENSA_32. */
10550 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10551 elf_header
.e_machine
);
10556 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10557 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10560 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10562 switch (elf_header
.e_machine
)
10566 return reloc_type
== 2; /* R_386_PC32. */
10568 return reloc_type
== 4; /* R_68K_PC32. */
10570 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10571 case EM_ADAPTEVA_EPIPHANY
:
10572 return reloc_type
== 6;
10574 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10576 return reloc_type
== 3; /* R_ARM_REL32 */
10577 case EM_MICROBLAZE
:
10578 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10580 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10582 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10584 return reloc_type
== 26; /* R_PPC_REL32. */
10586 return reloc_type
== 26; /* R_PPC64_REL32. */
10589 return reloc_type
== 5; /* R_390_PC32. */
10591 return reloc_type
== 2; /* R_SH_REL32. */
10592 case EM_SPARC32PLUS
:
10595 return reloc_type
== 6; /* R_SPARC_DISP32. */
10597 return reloc_type
== 13; /* R_SPU_REL32. */
10599 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10601 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10605 return reloc_type
== 2; /* R_X86_64_PC32. */
10606 case EM_XTENSA_OLD
:
10608 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10610 /* Do not abort or issue an error message here. Not all targets use
10611 pc-relative 32-bit relocs in their DWARF debug information and we
10612 have already tested for target coverage in is_32bit_abs_reloc. A
10613 more helpful warning message will be generated by apply_relocations
10614 anyway, so just return. */
10619 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10620 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10623 is_64bit_abs_reloc (unsigned int reloc_type
)
10625 switch (elf_header
.e_machine
)
10628 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10630 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10632 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10634 return reloc_type
== 80; /* R_PARISC_DIR64. */
10636 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10637 case EM_SPARC32PLUS
:
10640 return reloc_type
== 54; /* R_SPARC_UA64. */
10644 return reloc_type
== 1; /* R_X86_64_64. */
10647 return reloc_type
== 22; /* R_S390_64. */
10649 return reloc_type
== 1; /* R_TILEGX_64. */
10651 return reloc_type
== 18; /* R_MIPS_64. */
10657 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10658 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10661 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10663 switch (elf_header
.e_machine
)
10666 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10668 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10670 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10672 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10674 return reloc_type
== 44; /* R_PPC64_REL64. */
10675 case EM_SPARC32PLUS
:
10678 return reloc_type
== 46; /* R_SPARC_DISP64. */
10682 return reloc_type
== 24; /* R_X86_64_PC64. */
10685 return reloc_type
== 23; /* R_S390_PC64. */
10687 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10693 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10694 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10697 is_24bit_abs_reloc (unsigned int reloc_type
)
10699 switch (elf_header
.e_machine
)
10701 case EM_CYGNUS_MN10200
:
10703 return reloc_type
== 4; /* R_MN10200_24. */
10709 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10710 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10713 is_16bit_abs_reloc (unsigned int reloc_type
)
10715 switch (elf_header
.e_machine
)
10719 return reloc_type
== 4; /* R_AVR_16. */
10720 case EM_ADAPTEVA_EPIPHANY
:
10721 return reloc_type
== 5;
10722 case EM_CYGNUS_D10V
:
10724 return reloc_type
== 3; /* R_D10V_16. */
10728 return reloc_type
== R_H8_DIR16
;
10731 return reloc_type
== 1; /* R_IP2K_16. */
10734 return reloc_type
== 1; /* R_M32C_16 */
10736 if (uses_msp430x_relocs ())
10737 return reloc_type
== 2; /* R_MSP430_ABS16. */
10738 case EM_MSP430_OLD
:
10739 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10741 return reloc_type
== 19; /* R_NDS32_RELA. */
10742 case EM_ALTERA_NIOS2
:
10743 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10745 return reloc_type
== 9; /* R_NIOS_16. */
10747 return reloc_type
== 2; /* R_OR1K_16. */
10749 return reloc_type
== 2; /* R_C6000_ABS16. */
10752 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10753 case EM_CYGNUS_MN10200
:
10755 return reloc_type
== 2; /* R_MN10200_16. */
10756 case EM_CYGNUS_MN10300
:
10758 return reloc_type
== 2; /* R_MN10300_16. */
10760 return reloc_type
== 3; /* R_XGATE_16. */
10766 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10767 relocation entries (possibly formerly used for SHT_GROUP sections). */
10770 is_none_reloc (unsigned int reloc_type
)
10772 switch (elf_header
.e_machine
)
10774 case EM_68K
: /* R_68K_NONE. */
10775 case EM_386
: /* R_386_NONE. */
10776 case EM_SPARC32PLUS
:
10778 case EM_SPARC
: /* R_SPARC_NONE. */
10779 case EM_MIPS
: /* R_MIPS_NONE. */
10780 case EM_PARISC
: /* R_PARISC_NONE. */
10781 case EM_ALPHA
: /* R_ALPHA_NONE. */
10782 case EM_ADAPTEVA_EPIPHANY
:
10783 case EM_PPC
: /* R_PPC_NONE. */
10784 case EM_PPC64
: /* R_PPC64_NONE. */
10785 case EM_ARM
: /* R_ARM_NONE. */
10786 case EM_IA_64
: /* R_IA64_NONE. */
10787 case EM_SH
: /* R_SH_NONE. */
10789 case EM_S390
: /* R_390_NONE. */
10790 case EM_CRIS
: /* R_CRIS_NONE. */
10791 case EM_X86_64
: /* R_X86_64_NONE. */
10792 case EM_L1OM
: /* R_X86_64_NONE. */
10793 case EM_K1OM
: /* R_X86_64_NONE. */
10794 case EM_MN10300
: /* R_MN10300_NONE. */
10795 case EM_MOXIE
: /* R_MOXIE_NONE. */
10796 case EM_M32R
: /* R_M32R_NONE. */
10797 case EM_TI_C6000
:/* R_C6000_NONE. */
10798 case EM_TILEGX
: /* R_TILEGX_NONE. */
10799 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10801 case EM_C166
: /* R_XC16X_NONE. */
10802 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10803 case EM_NIOS32
: /* R_NIOS_NONE. */
10804 case EM_OR1K
: /* R_OR1K_NONE. */
10805 return reloc_type
== 0;
10807 return reloc_type
== 0 || reloc_type
== 256;
10809 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10810 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10811 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10812 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10813 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10814 case EM_XTENSA_OLD
:
10816 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10817 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10818 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10819 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10821 return reloc_type
== 3; /* R_METAG_NONE. */
10826 /* Apply relocations to a section.
10827 Note: So far support has been added only for those relocations
10828 which can be found in debug sections.
10829 FIXME: Add support for more relocations ? */
10832 apply_relocations (void * file
,
10833 Elf_Internal_Shdr
* section
,
10834 unsigned char * start
)
10836 Elf_Internal_Shdr
* relsec
;
10837 unsigned char * end
= start
+ section
->sh_size
;
10839 if (elf_header
.e_type
!= ET_REL
)
10842 /* Find the reloc section associated with the section. */
10843 for (relsec
= section_headers
;
10844 relsec
< section_headers
+ elf_header
.e_shnum
;
10847 bfd_boolean is_rela
;
10848 unsigned long num_relocs
;
10849 Elf_Internal_Rela
* relocs
;
10850 Elf_Internal_Rela
* rp
;
10851 Elf_Internal_Shdr
* symsec
;
10852 Elf_Internal_Sym
* symtab
;
10853 unsigned long num_syms
;
10854 Elf_Internal_Sym
* sym
;
10856 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10857 || relsec
->sh_info
>= elf_header
.e_shnum
10858 || section_headers
+ relsec
->sh_info
!= section
10859 || relsec
->sh_size
== 0
10860 || relsec
->sh_link
>= elf_header
.e_shnum
)
10863 is_rela
= relsec
->sh_type
== SHT_RELA
;
10867 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10868 relsec
->sh_size
, & relocs
, & num_relocs
))
10873 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10874 relsec
->sh_size
, & relocs
, & num_relocs
))
10878 /* SH uses RELA but uses in place value instead of the addend field. */
10879 if (elf_header
.e_machine
== EM_SH
)
10882 symsec
= section_headers
+ relsec
->sh_link
;
10883 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10885 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10888 unsigned int reloc_type
;
10889 unsigned int reloc_size
;
10890 unsigned char * rloc
;
10891 unsigned long sym_index
;
10893 reloc_type
= get_reloc_type (rp
->r_info
);
10895 if (target_specific_reloc_handling (rp
, start
, symtab
))
10897 else if (is_none_reloc (reloc_type
))
10899 else if (is_32bit_abs_reloc (reloc_type
)
10900 || is_32bit_pcrel_reloc (reloc_type
))
10902 else if (is_64bit_abs_reloc (reloc_type
)
10903 || is_64bit_pcrel_reloc (reloc_type
))
10905 else if (is_24bit_abs_reloc (reloc_type
))
10907 else if (is_16bit_abs_reloc (reloc_type
))
10911 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10912 reloc_type
, SECTION_NAME (section
));
10916 rloc
= start
+ rp
->r_offset
;
10917 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10919 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10920 (unsigned long) rp
->r_offset
,
10921 SECTION_NAME (section
));
10925 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10926 if (sym_index
>= num_syms
)
10928 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10929 sym_index
, SECTION_NAME (section
));
10932 sym
= symtab
+ sym_index
;
10934 /* If the reloc has a symbol associated with it,
10935 make sure that it is of an appropriate type.
10937 Relocations against symbols without type can happen.
10938 Gcc -feliminate-dwarf2-dups may generate symbols
10939 without type for debug info.
10941 Icc generates relocations against function symbols
10942 instead of local labels.
10944 Relocations against object symbols can happen, eg when
10945 referencing a global array. For an example of this see
10946 the _clz.o binary in libgcc.a. */
10948 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10950 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10951 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10952 (long int)(rp
- relocs
),
10953 SECTION_NAME (relsec
));
10959 addend
+= rp
->r_addend
;
10960 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10961 partial_inplace. */
10963 || (elf_header
.e_machine
== EM_XTENSA
10964 && reloc_type
== 1)
10965 || ((elf_header
.e_machine
== EM_PJ
10966 || elf_header
.e_machine
== EM_PJ_OLD
)
10967 && reloc_type
== 1)
10968 || ((elf_header
.e_machine
== EM_D30V
10969 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10970 && reloc_type
== 12))
10971 addend
+= byte_get (rloc
, reloc_size
);
10973 if (is_32bit_pcrel_reloc (reloc_type
)
10974 || is_64bit_pcrel_reloc (reloc_type
))
10976 /* On HPPA, all pc-relative relocations are biased by 8. */
10977 if (elf_header
.e_machine
== EM_PARISC
)
10979 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10983 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10992 #ifdef SUPPORT_DISASSEMBLY
10994 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10996 printf (_("\nAssembly dump of section %s\n"),
10997 SECTION_NAME (section
));
10999 /* XXX -- to be done --- XXX */
11005 /* Reads in the contents of SECTION from FILE, returning a pointer
11006 to a malloc'ed buffer or NULL if something went wrong. */
11009 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11011 bfd_size_type num_bytes
;
11013 num_bytes
= section
->sh_size
;
11015 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11017 printf (_("\nSection '%s' has no data to dump.\n"),
11018 SECTION_NAME (section
));
11022 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11023 _("section contents"));
11028 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11030 Elf_Internal_Shdr
* relsec
;
11031 bfd_size_type num_bytes
;
11035 char * name
= SECTION_NAME (section
);
11036 bfd_boolean some_strings_shown
;
11038 start
= get_section_contents (section
, file
);
11042 printf (_("\nString dump of section '%s':\n"), name
);
11044 /* If the section being dumped has relocations against it the user might
11045 be expecting these relocations to have been applied. Check for this
11046 case and issue a warning message in order to avoid confusion.
11047 FIXME: Maybe we ought to have an option that dumps a section with
11048 relocs applied ? */
11049 for (relsec
= section_headers
;
11050 relsec
< section_headers
+ elf_header
.e_shnum
;
11053 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11054 || relsec
->sh_info
>= elf_header
.e_shnum
11055 || section_headers
+ relsec
->sh_info
!= section
11056 || relsec
->sh_size
== 0
11057 || relsec
->sh_link
>= elf_header
.e_shnum
)
11060 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11064 num_bytes
= section
->sh_size
;
11066 end
= start
+ num_bytes
;
11067 some_strings_shown
= FALSE
;
11071 while (!ISPRINT (* data
))
11072 if (++ data
>= end
)
11078 /* PR 11128: Use two separate invocations in order to work
11079 around bugs in the Solaris 8 implementation of printf. */
11080 printf (" [%6tx] ", data
- start
);
11081 printf ("%s\n", data
);
11083 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11085 data
+= strlen (data
);
11086 some_strings_shown
= TRUE
;
11090 if (! some_strings_shown
)
11091 printf (_(" No strings found in this section."));
11099 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11101 bfd_boolean relocate
)
11103 Elf_Internal_Shdr
* relsec
;
11104 bfd_size_type bytes
;
11106 unsigned char * data
;
11107 unsigned char * start
;
11109 start
= (unsigned char *) get_section_contents (section
, file
);
11113 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11117 apply_relocations (file
, section
, start
);
11121 /* If the section being dumped has relocations against it the user might
11122 be expecting these relocations to have been applied. Check for this
11123 case and issue a warning message in order to avoid confusion.
11124 FIXME: Maybe we ought to have an option that dumps a section with
11125 relocs applied ? */
11126 for (relsec
= section_headers
;
11127 relsec
< section_headers
+ elf_header
.e_shnum
;
11130 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11131 || relsec
->sh_info
>= elf_header
.e_shnum
11132 || section_headers
+ relsec
->sh_info
!= section
11133 || relsec
->sh_size
== 0
11134 || relsec
->sh_link
>= elf_header
.e_shnum
)
11137 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11142 addr
= section
->sh_addr
;
11143 bytes
= section
->sh_size
;
11152 lbytes
= (bytes
> 16 ? 16 : bytes
);
11154 printf (" 0x%8.8lx ", (unsigned long) addr
);
11156 for (j
= 0; j
< 16; j
++)
11159 printf ("%2.2x", data
[j
]);
11167 for (j
= 0; j
< lbytes
; j
++)
11170 if (k
>= ' ' && k
< 0x7f)
11188 /* Uncompresses a section that was compressed using zlib, in place. */
11191 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11192 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11194 #ifndef HAVE_ZLIB_H
11197 dwarf_size_type compressed_size
= *size
;
11198 unsigned char * compressed_buffer
= *buffer
;
11199 dwarf_size_type uncompressed_size
;
11200 unsigned char * uncompressed_buffer
;
11203 dwarf_size_type header_size
= 12;
11205 /* Read the zlib header. In this case, it should be "ZLIB" followed
11206 by the uncompressed section size, 8 bytes in big-endian order. */
11207 if (compressed_size
< header_size
11208 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11211 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11212 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11213 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11214 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11215 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11216 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11217 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11218 uncompressed_size
+= compressed_buffer
[11];
11220 /* It is possible the section consists of several compressed
11221 buffers concatenated together, so we uncompress in a loop. */
11222 strm
.zalloc
= NULL
;
11224 strm
.opaque
= NULL
;
11225 strm
.avail_in
= compressed_size
- header_size
;
11226 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11227 strm
.avail_out
= uncompressed_size
;
11228 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11230 rc
= inflateInit (& strm
);
11231 while (strm
.avail_in
> 0)
11235 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11236 + (uncompressed_size
- strm
.avail_out
));
11237 rc
= inflate (&strm
, Z_FINISH
);
11238 if (rc
!= Z_STREAM_END
)
11240 rc
= inflateReset (& strm
);
11242 rc
= inflateEnd (& strm
);
11244 || strm
.avail_out
!= 0)
11247 free (compressed_buffer
);
11248 *buffer
= uncompressed_buffer
;
11249 *size
= uncompressed_size
;
11253 free (uncompressed_buffer
);
11254 /* Indicate decompression failure. */
11257 #endif /* HAVE_ZLIB_H */
11261 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11262 Elf_Internal_Shdr
* sec
, void * file
)
11264 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11267 /* If it is already loaded, do nothing. */
11268 if (section
->start
!= NULL
)
11271 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11272 section
->address
= sec
->sh_addr
;
11273 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11275 sec
->sh_size
, buf
);
11276 if (section
->start
== NULL
)
11280 section
->size
= sec
->sh_size
;
11281 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11282 sec
->sh_size
= section
->size
;
11285 if (section
->start
== NULL
)
11288 if (debug_displays
[debug
].relocate
)
11289 apply_relocations ((FILE *) file
, sec
, section
->start
);
11294 /* If this is not NULL, load_debug_section will only look for sections
11295 within the list of sections given here. */
11296 unsigned int *section_subset
= NULL
;
11299 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11301 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11302 Elf_Internal_Shdr
* sec
;
11304 /* Locate the debug section. */
11305 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11307 section
->name
= section
->uncompressed_name
;
11310 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11312 section
->name
= section
->compressed_name
;
11317 /* If we're loading from a subset of sections, and we've loaded
11318 a section matching this name before, it's likely that it's a
11320 if (section_subset
!= NULL
)
11321 free_debug_section (debug
);
11323 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11327 free_debug_section (enum dwarf_section_display_enum debug
)
11329 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11331 if (section
->start
== NULL
)
11334 free ((char *) section
->start
);
11335 section
->start
= NULL
;
11336 section
->address
= 0;
11341 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11343 char * name
= SECTION_NAME (section
);
11344 bfd_size_type length
;
11348 length
= section
->sh_size
;
11351 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11354 if (section
->sh_type
== SHT_NOBITS
)
11356 /* There is no point in dumping the contents of a debugging section
11357 which has the NOBITS type - the bits in the file will be random.
11358 This can happen when a file containing a .eh_frame section is
11359 stripped with the --only-keep-debug command line option. */
11360 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11364 if (const_strneq (name
, ".gnu.linkonce.wi."))
11365 name
= ".debug_info";
11367 /* See if we know how to display the contents of this section. */
11368 for (i
= 0; i
< max
; i
++)
11369 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11370 || (i
== line
&& const_strneq (name
, ".debug_line."))
11371 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11373 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11374 int secondary
= (section
!= find_section (name
));
11377 free_debug_section ((enum dwarf_section_display_enum
) i
);
11379 if (i
== line
&& const_strneq (name
, ".debug_line."))
11381 else if (streq (sec
->uncompressed_name
, name
))
11382 sec
->name
= sec
->uncompressed_name
;
11384 sec
->name
= sec
->compressed_name
;
11385 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11388 /* If this debug section is part of a CU/TU set in a .dwp file,
11389 restrict load_debug_section to the sections in that set. */
11390 section_subset
= find_cu_tu_set (file
, shndx
);
11392 result
&= debug_displays
[i
].display (sec
, file
);
11394 section_subset
= NULL
;
11396 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11397 free_debug_section ((enum dwarf_section_display_enum
) i
);
11405 printf (_("Unrecognized debug section: %s\n"), name
);
11412 /* Set DUMP_SECTS for all sections where dumps were requested
11413 based on section name. */
11416 initialise_dumps_byname (void)
11418 struct dump_list_entry
* cur
;
11420 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11425 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11426 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11428 request_dump_bynumber (i
, cur
->type
);
11433 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11439 process_section_contents (FILE * file
)
11441 Elf_Internal_Shdr
* section
;
11447 initialise_dumps_byname ();
11449 for (i
= 0, section
= section_headers
;
11450 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11453 #ifdef SUPPORT_DISASSEMBLY
11454 if (dump_sects
[i
] & DISASS_DUMP
)
11455 disassemble_section (section
, file
);
11457 if (dump_sects
[i
] & HEX_DUMP
)
11458 dump_section_as_bytes (section
, file
, FALSE
);
11460 if (dump_sects
[i
] & RELOC_DUMP
)
11461 dump_section_as_bytes (section
, file
, TRUE
);
11463 if (dump_sects
[i
] & STRING_DUMP
)
11464 dump_section_as_strings (section
, file
);
11466 if (dump_sects
[i
] & DEBUG_DUMP
)
11467 display_debug_section (i
, section
, file
);
11470 /* Check to see if the user requested a
11471 dump of a section that does not exist. */
11472 while (i
++ < num_dump_sects
)
11474 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11478 process_mips_fpe_exception (int mask
)
11483 if (mask
& OEX_FPU_INEX
)
11484 fputs ("INEX", stdout
), first
= 0;
11485 if (mask
& OEX_FPU_UFLO
)
11486 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11487 if (mask
& OEX_FPU_OFLO
)
11488 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11489 if (mask
& OEX_FPU_DIV0
)
11490 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11491 if (mask
& OEX_FPU_INVAL
)
11492 printf ("%sINVAL", first
? "" : "|");
11495 fputs ("0", stdout
);
11498 /* Display's the value of TAG at location P. If TAG is
11499 greater than 0 it is assumed to be an unknown tag, and
11500 a message is printed to this effect. Otherwise it is
11501 assumed that a message has already been printed.
11503 If the bottom bit of TAG is set it assumed to have a
11504 string value, otherwise it is assumed to have an integer
11507 Returns an updated P pointing to the first unread byte
11508 beyond the end of TAG's value.
11510 Reads at or beyond END will not be made. */
11512 static unsigned char *
11513 display_tag_value (int tag
,
11515 const unsigned char * const end
)
11520 printf (" Tag_unknown_%d: ", tag
);
11524 warn (_("corrupt tag\n"));
11528 /* FIXME: we could read beyond END here. */
11529 printf ("\"%s\"\n", p
);
11530 p
+= strlen ((char *) p
) + 1;
11536 val
= read_uleb128 (p
, &len
, end
);
11538 printf ("%ld (0x%lx)\n", val
, val
);
11544 /* ARM EABI attributes section. */
11549 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11551 const char ** table
;
11552 } arm_attr_public_tag
;
11554 static const char * arm_attr_tag_CPU_arch
[] =
11555 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11556 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11557 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11558 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11559 {"No", "Thumb-1", "Thumb-2"};
11560 static const char * arm_attr_tag_FP_arch
[] =
11561 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11563 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11564 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11565 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11566 static const char * arm_attr_tag_PCS_config
[] =
11567 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11568 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11569 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11570 {"V6", "SB", "TLS", "Unused"};
11571 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11572 {"Absolute", "PC-relative", "SB-relative", "None"};
11573 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11574 {"Absolute", "PC-relative", "None"};
11575 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11576 {"None", "direct", "GOT-indirect"};
11577 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11578 {"None", "??? 1", "2", "??? 3", "4"};
11579 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11580 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11581 {"Unused", "Needed", "Sign only"};
11582 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11583 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11584 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11585 {"Unused", "Finite", "RTABI", "IEEE 754"};
11586 static const char * arm_attr_tag_ABI_enum_size
[] =
11587 {"Unused", "small", "int", "forced to int"};
11588 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11589 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11590 static const char * arm_attr_tag_ABI_VFP_args
[] =
11591 {"AAPCS", "VFP registers", "custom"};
11592 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11593 {"AAPCS", "WMMX registers", "custom"};
11594 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11595 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11596 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11597 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11598 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11599 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11600 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11601 static const char * arm_attr_tag_FP_HP_extension
[] =
11602 {"Not Allowed", "Allowed"};
11603 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11604 {"None", "IEEE 754", "Alternative Format"};
11605 static const char * arm_attr_tag_MPextension_use
[] =
11606 {"Not Allowed", "Allowed"};
11607 static const char * arm_attr_tag_DIV_use
[] =
11608 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11609 "Allowed in v7-A with integer division extension"};
11610 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11611 static const char * arm_attr_tag_Virtualization_use
[] =
11612 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11613 "TrustZone and Virtualization Extensions"};
11614 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11615 {"Not Allowed", "Allowed"};
11617 #define LOOKUP(id, name) \
11618 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11619 static arm_attr_public_tag arm_attr_public_tags
[] =
11621 {4, "CPU_raw_name", 1, NULL
},
11622 {5, "CPU_name", 1, NULL
},
11623 LOOKUP(6, CPU_arch
),
11624 {7, "CPU_arch_profile", 0, NULL
},
11625 LOOKUP(8, ARM_ISA_use
),
11626 LOOKUP(9, THUMB_ISA_use
),
11627 LOOKUP(10, FP_arch
),
11628 LOOKUP(11, WMMX_arch
),
11629 LOOKUP(12, Advanced_SIMD_arch
),
11630 LOOKUP(13, PCS_config
),
11631 LOOKUP(14, ABI_PCS_R9_use
),
11632 LOOKUP(15, ABI_PCS_RW_data
),
11633 LOOKUP(16, ABI_PCS_RO_data
),
11634 LOOKUP(17, ABI_PCS_GOT_use
),
11635 LOOKUP(18, ABI_PCS_wchar_t
),
11636 LOOKUP(19, ABI_FP_rounding
),
11637 LOOKUP(20, ABI_FP_denormal
),
11638 LOOKUP(21, ABI_FP_exceptions
),
11639 LOOKUP(22, ABI_FP_user_exceptions
),
11640 LOOKUP(23, ABI_FP_number_model
),
11641 {24, "ABI_align_needed", 0, NULL
},
11642 {25, "ABI_align_preserved", 0, NULL
},
11643 LOOKUP(26, ABI_enum_size
),
11644 LOOKUP(27, ABI_HardFP_use
),
11645 LOOKUP(28, ABI_VFP_args
),
11646 LOOKUP(29, ABI_WMMX_args
),
11647 LOOKUP(30, ABI_optimization_goals
),
11648 LOOKUP(31, ABI_FP_optimization_goals
),
11649 {32, "compatibility", 0, NULL
},
11650 LOOKUP(34, CPU_unaligned_access
),
11651 LOOKUP(36, FP_HP_extension
),
11652 LOOKUP(38, ABI_FP_16bit_format
),
11653 LOOKUP(42, MPextension_use
),
11654 LOOKUP(44, DIV_use
),
11655 {64, "nodefaults", 0, NULL
},
11656 {65, "also_compatible_with", 0, NULL
},
11657 LOOKUP(66, T2EE_use
),
11658 {67, "conformance", 1, NULL
},
11659 LOOKUP(68, Virtualization_use
),
11660 LOOKUP(70, MPextension_use_legacy
)
11664 static unsigned char *
11665 display_arm_attribute (unsigned char * p
,
11666 const unsigned char * const end
)
11671 arm_attr_public_tag
* attr
;
11675 tag
= read_uleb128 (p
, &len
, end
);
11678 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11680 if (arm_attr_public_tags
[i
].tag
== tag
)
11682 attr
= &arm_attr_public_tags
[i
];
11689 printf (" Tag_%s: ", attr
->name
);
11690 switch (attr
->type
)
11695 case 7: /* Tag_CPU_arch_profile. */
11696 val
= read_uleb128 (p
, &len
, end
);
11700 case 0: printf (_("None\n")); break;
11701 case 'A': printf (_("Application\n")); break;
11702 case 'R': printf (_("Realtime\n")); break;
11703 case 'M': printf (_("Microcontroller\n")); break;
11704 case 'S': printf (_("Application or Realtime\n")); break;
11705 default: printf ("??? (%d)\n", val
); break;
11709 case 24: /* Tag_align_needed. */
11710 val
= read_uleb128 (p
, &len
, end
);
11714 case 0: printf (_("None\n")); break;
11715 case 1: printf (_("8-byte\n")); break;
11716 case 2: printf (_("4-byte\n")); break;
11717 case 3: printf ("??? 3\n"); break;
11720 printf (_("8-byte and up to %d-byte extended\n"),
11723 printf ("??? (%d)\n", val
);
11728 case 25: /* Tag_align_preserved. */
11729 val
= read_uleb128 (p
, &len
, end
);
11733 case 0: printf (_("None\n")); break;
11734 case 1: printf (_("8-byte, except leaf SP\n")); break;
11735 case 2: printf (_("8-byte\n")); break;
11736 case 3: printf ("??? 3\n"); break;
11739 printf (_("8-byte and up to %d-byte extended\n"),
11742 printf ("??? (%d)\n", val
);
11747 case 32: /* Tag_compatibility. */
11748 val
= read_uleb128 (p
, &len
, end
);
11750 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11751 p
+= strlen ((char *) p
) + 1;
11754 case 64: /* Tag_nodefaults. */
11756 printf (_("True\n"));
11759 case 65: /* Tag_also_compatible_with. */
11760 val
= read_uleb128 (p
, &len
, end
);
11762 if (val
== 6 /* Tag_CPU_arch. */)
11764 val
= read_uleb128 (p
, &len
, end
);
11766 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11767 printf ("??? (%d)\n", val
);
11769 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11773 while (*(p
++) != '\0' /* NUL terminator. */);
11782 return display_tag_value (-1, p
, end
);
11784 return display_tag_value (0, p
, end
);
11787 assert (attr
->type
& 0x80);
11788 val
= read_uleb128 (p
, &len
, end
);
11790 type
= attr
->type
& 0x7f;
11792 printf ("??? (%d)\n", val
);
11794 printf ("%s\n", attr
->table
[val
]);
11799 return display_tag_value (tag
, p
, end
);
11802 static unsigned char *
11803 display_gnu_attribute (unsigned char * p
,
11804 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11805 const unsigned char * const end
)
11811 tag
= read_uleb128 (p
, &len
, end
);
11814 /* Tag_compatibility is the only generic GNU attribute defined at
11818 val
= read_uleb128 (p
, &len
, end
);
11822 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11823 warn (_("corrupt vendor attribute\n"));
11827 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11828 p
+= strlen ((char *) p
) + 1;
11833 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11834 return display_proc_gnu_attribute (p
, tag
, end
);
11836 return display_tag_value (tag
, p
, end
);
11839 static unsigned char *
11840 display_power_gnu_attribute (unsigned char * p
,
11842 const unsigned char * const end
)
11847 if (tag
== Tag_GNU_Power_ABI_FP
)
11849 val
= read_uleb128 (p
, &len
, end
);
11851 printf (" Tag_GNU_Power_ABI_FP: ");
11856 printf (_("Hard or soft float\n"));
11859 printf (_("Hard float\n"));
11862 printf (_("Soft float\n"));
11865 printf (_("Single-precision hard float\n"));
11868 printf ("??? (%d)\n", val
);
11874 if (tag
== Tag_GNU_Power_ABI_Vector
)
11876 val
= read_uleb128 (p
, &len
, end
);
11878 printf (" Tag_GNU_Power_ABI_Vector: ");
11882 printf (_("Any\n"));
11885 printf (_("Generic\n"));
11888 printf ("AltiVec\n");
11894 printf ("??? (%d)\n", val
);
11900 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11904 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11908 val
= read_uleb128 (p
, &len
, end
);
11910 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11914 printf (_("Any\n"));
11917 printf ("r3/r4\n");
11920 printf (_("Memory\n"));
11923 printf ("??? (%d)\n", val
);
11929 return display_tag_value (tag
& 1, p
, end
);
11933 display_sparc_hwcaps (int mask
)
11938 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11939 fputs ("mul32", stdout
), first
= 0;
11940 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11941 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11942 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11943 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11944 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11945 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11946 if (mask
& ELF_SPARC_HWCAP_POPC
)
11947 printf ("%spopc", first
? "" : "|"), first
= 0;
11948 if (mask
& ELF_SPARC_HWCAP_VIS
)
11949 printf ("%svis", first
? "" : "|"), first
= 0;
11950 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11951 printf ("%svis2", first
? "" : "|"), first
= 0;
11952 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11953 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11954 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11955 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11956 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11957 printf ("%svis3", first
? "" : "|"), first
= 0;
11958 if (mask
& ELF_SPARC_HWCAP_HPC
)
11959 printf ("%shpc", first
? "" : "|"), first
= 0;
11960 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11961 printf ("%srandom", first
? "" : "|"), first
= 0;
11962 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11963 printf ("%strans", first
? "" : "|"), first
= 0;
11964 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11965 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11966 if (mask
& ELF_SPARC_HWCAP_IMA
)
11967 printf ("%sima", first
? "" : "|"), first
= 0;
11968 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11969 printf ("%scspare", first
? "" : "|"), first
= 0;
11972 fputc('0', stdout
);
11973 fputc('\n', stdout
);
11976 static unsigned char *
11977 display_sparc_gnu_attribute (unsigned char * p
,
11979 const unsigned char * const end
)
11981 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11986 val
= read_uleb128 (p
, &len
, end
);
11988 printf (" Tag_GNU_Sparc_HWCAPS: ");
11989 display_sparc_hwcaps (val
);
11993 return display_tag_value (tag
, p
, end
);
11996 static unsigned char *
11997 display_mips_gnu_attribute (unsigned char * p
,
11999 const unsigned char * const end
)
12001 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12006 val
= read_uleb128 (p
, &len
, end
);
12008 printf (" Tag_GNU_MIPS_ABI_FP: ");
12012 case Val_GNU_MIPS_ABI_FP_ANY
:
12013 printf (_("Hard or soft float\n"));
12015 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12016 printf (_("Hard float (double precision)\n"));
12018 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12019 printf (_("Hard float (single precision)\n"));
12021 case Val_GNU_MIPS_ABI_FP_SOFT
:
12022 printf (_("Soft float\n"));
12024 case Val_GNU_MIPS_ABI_FP_64
:
12025 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
12028 printf ("??? (%d)\n", val
);
12034 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12039 val
= read_uleb128 (p
, &len
, end
);
12041 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12045 case Val_GNU_MIPS_ABI_MSA_ANY
:
12046 printf (_("Any MSA or not\n"));
12048 case Val_GNU_MIPS_ABI_MSA_128
:
12049 printf (_("128-bit MSA\n"));
12052 printf ("??? (%d)\n", val
);
12058 return display_tag_value (tag
& 1, p
, end
);
12061 static unsigned char *
12062 display_tic6x_attribute (unsigned char * p
,
12063 const unsigned char * const end
)
12069 tag
= read_uleb128 (p
, &len
, end
);
12075 val
= read_uleb128 (p
, &len
, end
);
12077 printf (" Tag_ISA: ");
12081 case C6XABI_Tag_ISA_none
:
12082 printf (_("None\n"));
12084 case C6XABI_Tag_ISA_C62X
:
12087 case C6XABI_Tag_ISA_C67X
:
12090 case C6XABI_Tag_ISA_C67XP
:
12091 printf ("C67x+\n");
12093 case C6XABI_Tag_ISA_C64X
:
12096 case C6XABI_Tag_ISA_C64XP
:
12097 printf ("C64x+\n");
12099 case C6XABI_Tag_ISA_C674X
:
12100 printf ("C674x\n");
12103 printf ("??? (%d)\n", val
);
12108 case Tag_ABI_wchar_t
:
12109 val
= read_uleb128 (p
, &len
, end
);
12111 printf (" Tag_ABI_wchar_t: ");
12115 printf (_("Not used\n"));
12118 printf (_("2 bytes\n"));
12121 printf (_("4 bytes\n"));
12124 printf ("??? (%d)\n", val
);
12129 case Tag_ABI_stack_align_needed
:
12130 val
= read_uleb128 (p
, &len
, end
);
12132 printf (" Tag_ABI_stack_align_needed: ");
12136 printf (_("8-byte\n"));
12139 printf (_("16-byte\n"));
12142 printf ("??? (%d)\n", val
);
12147 case Tag_ABI_stack_align_preserved
:
12148 val
= read_uleb128 (p
, &len
, end
);
12150 printf (" Tag_ABI_stack_align_preserved: ");
12154 printf (_("8-byte\n"));
12157 printf (_("16-byte\n"));
12160 printf ("??? (%d)\n", val
);
12166 val
= read_uleb128 (p
, &len
, end
);
12168 printf (" Tag_ABI_DSBT: ");
12172 printf (_("DSBT addressing not used\n"));
12175 printf (_("DSBT addressing used\n"));
12178 printf ("??? (%d)\n", val
);
12184 val
= read_uleb128 (p
, &len
, end
);
12186 printf (" Tag_ABI_PID: ");
12190 printf (_("Data addressing position-dependent\n"));
12193 printf (_("Data addressing position-independent, GOT near DP\n"));
12196 printf (_("Data addressing position-independent, GOT far from DP\n"));
12199 printf ("??? (%d)\n", val
);
12205 val
= read_uleb128 (p
, &len
, end
);
12207 printf (" Tag_ABI_PIC: ");
12211 printf (_("Code addressing position-dependent\n"));
12214 printf (_("Code addressing position-independent\n"));
12217 printf ("??? (%d)\n", val
);
12222 case Tag_ABI_array_object_alignment
:
12223 val
= read_uleb128 (p
, &len
, end
);
12225 printf (" Tag_ABI_array_object_alignment: ");
12229 printf (_("8-byte\n"));
12232 printf (_("4-byte\n"));
12235 printf (_("16-byte\n"));
12238 printf ("??? (%d)\n", val
);
12243 case Tag_ABI_array_object_align_expected
:
12244 val
= read_uleb128 (p
, &len
, end
);
12246 printf (" Tag_ABI_array_object_align_expected: ");
12250 printf (_("8-byte\n"));
12253 printf (_("4-byte\n"));
12256 printf (_("16-byte\n"));
12259 printf ("??? (%d)\n", val
);
12264 case Tag_ABI_compatibility
:
12265 val
= read_uleb128 (p
, &len
, end
);
12267 printf (" Tag_ABI_compatibility: ");
12268 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12269 p
+= strlen ((char *) p
) + 1;
12272 case Tag_ABI_conformance
:
12273 printf (" Tag_ABI_conformance: ");
12274 printf ("\"%s\"\n", p
);
12275 p
+= strlen ((char *) p
) + 1;
12279 return display_tag_value (tag
, p
, end
);
12283 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12285 unsigned long addr
= 0;
12286 size_t bytes
= end
- p
;
12292 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12294 printf (" 0x%8.8lx ", addr
);
12296 for (j
= 0; j
< 16; j
++)
12299 printf ("%2.2x", p
[j
]);
12307 for (j
= 0; j
< lbytes
; j
++)
12310 if (k
>= ' ' && k
< 0x7f)
12326 static unsigned char *
12327 display_msp430x_attribute (unsigned char * p
,
12328 const unsigned char * const end
)
12334 tag
= read_uleb128 (p
, & len
, end
);
12339 case OFBA_MSPABI_Tag_ISA
:
12340 val
= read_uleb128 (p
, &len
, end
);
12342 printf (" Tag_ISA: ");
12345 case 0: printf (_("None\n")); break;
12346 case 1: printf (_("MSP430\n")); break;
12347 case 2: printf (_("MSP430X\n")); break;
12348 default: printf ("??? (%d)\n", val
); break;
12352 case OFBA_MSPABI_Tag_Code_Model
:
12353 val
= read_uleb128 (p
, &len
, end
);
12355 printf (" Tag_Code_Model: ");
12358 case 0: printf (_("None\n")); break;
12359 case 1: printf (_("Small\n")); break;
12360 case 2: printf (_("Large\n")); break;
12361 default: printf ("??? (%d)\n", val
); break;
12365 case OFBA_MSPABI_Tag_Data_Model
:
12366 val
= read_uleb128 (p
, &len
, end
);
12368 printf (" Tag_Data_Model: ");
12371 case 0: printf (_("None\n")); break;
12372 case 1: printf (_("Small\n")); break;
12373 case 2: printf (_("Large\n")); break;
12374 case 3: printf (_("Restricted Large\n")); break;
12375 default: printf ("??? (%d)\n", val
); break;
12380 printf (_(" <unknown tag %d>: "), tag
);
12384 printf ("\"%s\"\n", p
);
12385 p
+= strlen ((char *) p
) + 1;
12389 val
= read_uleb128 (p
, &len
, end
);
12391 printf ("%d (0x%x)\n", val
, val
);
12400 process_attributes (FILE * file
,
12401 const char * public_name
,
12402 unsigned int proc_type
,
12403 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12404 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12406 Elf_Internal_Shdr
* sect
;
12407 unsigned char * contents
;
12409 unsigned char * end
;
12410 bfd_vma section_len
;
12414 /* Find the section header so that we get the size. */
12415 for (i
= 0, sect
= section_headers
;
12416 i
< elf_header
.e_shnum
;
12419 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12422 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12423 sect
->sh_size
, _("attributes"));
12424 if (contents
== NULL
)
12430 len
= sect
->sh_size
- 1;
12435 unsigned int namelen
;
12436 bfd_boolean public_section
;
12437 bfd_boolean gnu_section
;
12439 section_len
= byte_get (p
, 4);
12442 if (section_len
> len
)
12444 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12445 (unsigned) section_len
, (unsigned) len
);
12449 len
-= section_len
;
12452 namelen
= strnlen ((char *) p
, section_len
) + 1;
12453 if (namelen
== 0 || namelen
>= section_len
)
12455 error (_("Corrupt attribute section name\n"));
12459 printf (_("Attribute Section: %s\n"), p
);
12461 if (public_name
&& streq ((char *) p
, public_name
))
12462 public_section
= TRUE
;
12464 public_section
= FALSE
;
12466 if (streq ((char *) p
, "gnu"))
12467 gnu_section
= TRUE
;
12469 gnu_section
= FALSE
;
12472 section_len
-= namelen
;
12473 while (section_len
> 0)
12479 size
= byte_get (p
, 4);
12480 if (size
> section_len
)
12482 error (_("Bad subsection length (%u > %u)\n"),
12483 (unsigned) size
, (unsigned) section_len
);
12484 size
= section_len
;
12487 section_len
-= size
;
12488 end
= p
+ size
- 1;
12494 printf (_("File Attributes\n"));
12497 printf (_("Section Attributes:"));
12500 printf (_("Symbol Attributes:"));
12506 val
= read_uleb128 (p
, &j
, end
);
12510 printf (" %d", val
);
12515 printf (_("Unknown tag: %d\n"), tag
);
12516 public_section
= FALSE
;
12520 if (public_section
)
12523 p
= display_pub_attribute (p
, end
);
12525 else if (gnu_section
)
12528 p
= display_gnu_attribute (p
,
12529 display_proc_gnu_attribute
,
12534 printf (_(" Unknown section contexts\n"));
12535 display_raw_attribute (p
, end
);
12542 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12550 process_arm_specific (FILE * file
)
12552 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12553 display_arm_attribute
, NULL
);
12557 process_power_specific (FILE * file
)
12559 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12560 display_power_gnu_attribute
);
12564 process_sparc_specific (FILE * file
)
12566 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12567 display_sparc_gnu_attribute
);
12571 process_tic6x_specific (FILE * file
)
12573 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12574 display_tic6x_attribute
, NULL
);
12578 process_msp430x_specific (FILE * file
)
12580 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12581 display_msp430x_attribute
, NULL
);
12584 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12585 Print the Address, Access and Initial fields of an entry at VMA ADDR
12586 and return the VMA of the next entry. */
12589 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12592 print_vma (addr
, LONG_HEX
);
12594 if (addr
< pltgot
+ 0xfff0)
12595 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12597 printf ("%10s", "");
12600 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12605 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12606 print_vma (entry
, LONG_HEX
);
12608 return addr
+ (is_32bit_elf
? 4 : 8);
12611 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12612 PLTGOT. Print the Address and Initial fields of an entry at VMA
12613 ADDR and return the VMA of the next entry. */
12616 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12619 print_vma (addr
, LONG_HEX
);
12622 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12627 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12628 print_vma (entry
, LONG_HEX
);
12630 return addr
+ (is_32bit_elf
? 4 : 8);
12634 process_mips_specific (FILE * file
)
12636 Elf_Internal_Dyn
* entry
;
12637 size_t liblist_offset
= 0;
12638 size_t liblistno
= 0;
12639 size_t conflictsno
= 0;
12640 size_t options_offset
= 0;
12641 size_t conflicts_offset
= 0;
12642 size_t pltrelsz
= 0;
12644 bfd_vma pltgot
= 0;
12645 bfd_vma mips_pltgot
= 0;
12646 bfd_vma jmprel
= 0;
12647 bfd_vma local_gotno
= 0;
12648 bfd_vma gotsym
= 0;
12649 bfd_vma symtabno
= 0;
12651 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12652 display_mips_gnu_attribute
);
12654 /* We have a lot of special sections. Thanks SGI! */
12655 if (dynamic_section
== NULL
)
12656 /* No information available. */
12659 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12660 switch (entry
->d_tag
)
12662 case DT_MIPS_LIBLIST
:
12664 = offset_from_vma (file
, entry
->d_un
.d_val
,
12665 liblistno
* sizeof (Elf32_External_Lib
));
12667 case DT_MIPS_LIBLISTNO
:
12668 liblistno
= entry
->d_un
.d_val
;
12670 case DT_MIPS_OPTIONS
:
12671 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12673 case DT_MIPS_CONFLICT
:
12675 = offset_from_vma (file
, entry
->d_un
.d_val
,
12676 conflictsno
* sizeof (Elf32_External_Conflict
));
12678 case DT_MIPS_CONFLICTNO
:
12679 conflictsno
= entry
->d_un
.d_val
;
12682 pltgot
= entry
->d_un
.d_ptr
;
12684 case DT_MIPS_LOCAL_GOTNO
:
12685 local_gotno
= entry
->d_un
.d_val
;
12687 case DT_MIPS_GOTSYM
:
12688 gotsym
= entry
->d_un
.d_val
;
12690 case DT_MIPS_SYMTABNO
:
12691 symtabno
= entry
->d_un
.d_val
;
12693 case DT_MIPS_PLTGOT
:
12694 mips_pltgot
= entry
->d_un
.d_ptr
;
12697 pltrel
= entry
->d_un
.d_val
;
12700 pltrelsz
= entry
->d_un
.d_val
;
12703 jmprel
= entry
->d_un
.d_ptr
;
12709 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12711 Elf32_External_Lib
* elib
;
12714 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12716 sizeof (Elf32_External_Lib
),
12717 _("liblist section data"));
12720 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12721 (unsigned long) liblistno
);
12722 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12725 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12732 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12733 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12734 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12735 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12736 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12738 tmp
= gmtime (&atime
);
12739 snprintf (timebuf
, sizeof (timebuf
),
12740 "%04u-%02u-%02uT%02u:%02u:%02u",
12741 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12742 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12744 printf ("%3lu: ", (unsigned long) cnt
);
12745 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12746 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12748 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12749 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12750 liblist
.l_version
);
12752 if (liblist
.l_flags
== 0)
12756 static const struct
12763 { " EXACT_MATCH", LL_EXACT_MATCH
},
12764 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12765 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12766 { " EXPORTS", LL_EXPORTS
},
12767 { " DELAY_LOAD", LL_DELAY_LOAD
},
12768 { " DELTA", LL_DELTA
}
12770 int flags
= liblist
.l_flags
;
12773 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12774 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12776 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12777 flags
^= l_flags_vals
[fcnt
].bit
;
12780 printf (" %#x", (unsigned int) flags
);
12790 if (options_offset
!= 0)
12792 Elf_External_Options
* eopt
;
12793 Elf_Internal_Shdr
* sect
= section_headers
;
12794 Elf_Internal_Options
* iopt
;
12795 Elf_Internal_Options
* option
;
12799 /* Find the section header so that we get the size. */
12800 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12803 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12804 sect
->sh_size
, _("options"));
12807 iopt
= (Elf_Internal_Options
*)
12808 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12811 error (_("Out of memory\n"));
12818 while (offset
< sect
->sh_size
)
12820 Elf_External_Options
* eoption
;
12822 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12824 option
->kind
= BYTE_GET (eoption
->kind
);
12825 option
->size
= BYTE_GET (eoption
->size
);
12826 option
->section
= BYTE_GET (eoption
->section
);
12827 option
->info
= BYTE_GET (eoption
->info
);
12829 offset
+= option
->size
;
12835 printf (_("\nSection '%s' contains %d entries:\n"),
12836 SECTION_NAME (sect
), cnt
);
12844 switch (option
->kind
)
12847 /* This shouldn't happen. */
12848 printf (" NULL %d %lx", option
->section
, option
->info
);
12851 printf (" REGINFO ");
12852 if (elf_header
.e_machine
== EM_MIPS
)
12855 Elf32_External_RegInfo
* ereg
;
12856 Elf32_RegInfo reginfo
;
12858 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12859 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12860 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12861 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12862 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12863 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12864 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12866 printf ("GPR %08lx GP 0x%lx\n",
12867 reginfo
.ri_gprmask
,
12868 (unsigned long) reginfo
.ri_gp_value
);
12869 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12870 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12871 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12876 Elf64_External_RegInfo
* ereg
;
12877 Elf64_Internal_RegInfo reginfo
;
12879 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12880 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12881 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12882 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12883 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12884 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12885 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12887 printf ("GPR %08lx GP 0x",
12888 reginfo
.ri_gprmask
);
12889 printf_vma (reginfo
.ri_gp_value
);
12892 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12893 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12894 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12898 case ODK_EXCEPTIONS
:
12899 fputs (" EXCEPTIONS fpe_min(", stdout
);
12900 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12901 fputs (") fpe_max(", stdout
);
12902 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12903 fputs (")", stdout
);
12905 if (option
->info
& OEX_PAGE0
)
12906 fputs (" PAGE0", stdout
);
12907 if (option
->info
& OEX_SMM
)
12908 fputs (" SMM", stdout
);
12909 if (option
->info
& OEX_FPDBUG
)
12910 fputs (" FPDBUG", stdout
);
12911 if (option
->info
& OEX_DISMISS
)
12912 fputs (" DISMISS", stdout
);
12915 fputs (" PAD ", stdout
);
12916 if (option
->info
& OPAD_PREFIX
)
12917 fputs (" PREFIX", stdout
);
12918 if (option
->info
& OPAD_POSTFIX
)
12919 fputs (" POSTFIX", stdout
);
12920 if (option
->info
& OPAD_SYMBOL
)
12921 fputs (" SYMBOL", stdout
);
12924 fputs (" HWPATCH ", stdout
);
12925 if (option
->info
& OHW_R4KEOP
)
12926 fputs (" R4KEOP", stdout
);
12927 if (option
->info
& OHW_R8KPFETCH
)
12928 fputs (" R8KPFETCH", stdout
);
12929 if (option
->info
& OHW_R5KEOP
)
12930 fputs (" R5KEOP", stdout
);
12931 if (option
->info
& OHW_R5KCVTL
)
12932 fputs (" R5KCVTL", stdout
);
12935 fputs (" FILL ", stdout
);
12936 /* XXX Print content of info word? */
12939 fputs (" TAGS ", stdout
);
12940 /* XXX Print content of info word? */
12943 fputs (" HWAND ", stdout
);
12944 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12945 fputs (" R4KEOP_CHECKED", stdout
);
12946 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12947 fputs (" R4KEOP_CLEAN", stdout
);
12950 fputs (" HWOR ", stdout
);
12951 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12952 fputs (" R4KEOP_CHECKED", stdout
);
12953 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12954 fputs (" R4KEOP_CLEAN", stdout
);
12957 printf (" GP_GROUP %#06lx self-contained %#06lx",
12958 option
->info
& OGP_GROUP
,
12959 (option
->info
& OGP_SELF
) >> 16);
12962 printf (" IDENT %#06lx self-contained %#06lx",
12963 option
->info
& OGP_GROUP
,
12964 (option
->info
& OGP_SELF
) >> 16);
12967 /* This shouldn't happen. */
12968 printf (" %3d ??? %d %lx",
12969 option
->kind
, option
->section
, option
->info
);
12973 len
= sizeof (* eopt
);
12974 while (len
< option
->size
)
12975 if (((char *) option
)[len
] >= ' '
12976 && ((char *) option
)[len
] < 0x7f)
12977 printf ("%c", ((char *) option
)[len
++]);
12979 printf ("\\%03o", ((char *) option
)[len
++]);
12981 fputs ("\n", stdout
);
12989 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12991 Elf32_Conflict
* iconf
;
12994 if (dynamic_symbols
== NULL
)
12996 error (_("conflict list found without a dynamic symbol table\n"));
13000 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13003 error (_("Out of memory\n"));
13009 Elf32_External_Conflict
* econf32
;
13011 econf32
= (Elf32_External_Conflict
*)
13012 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13013 sizeof (* econf32
), _("conflict"));
13017 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13018 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13024 Elf64_External_Conflict
* econf64
;
13026 econf64
= (Elf64_External_Conflict
*)
13027 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13028 sizeof (* econf64
), _("conflict"));
13032 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13033 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13038 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13039 (unsigned long) conflictsno
);
13040 puts (_(" Num: Index Value Name"));
13042 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13044 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13046 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13047 print_vma (psym
->st_value
, FULL_HEX
);
13049 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13050 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13052 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13059 if (pltgot
!= 0 && local_gotno
!= 0)
13061 bfd_vma ent
, local_end
, global_end
;
13063 unsigned char * data
;
13067 addr_size
= (is_32bit_elf
? 4 : 8);
13068 local_end
= pltgot
+ local_gotno
* addr_size
;
13069 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13071 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13072 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13073 global_end
- pltgot
, 1,
13074 _("Global Offset Table data"));
13078 printf (_("\nPrimary GOT:\n"));
13079 printf (_(" Canonical gp value: "));
13080 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13083 printf (_(" Reserved entries:\n"));
13084 printf (_(" %*s %10s %*s Purpose\n"),
13085 addr_size
* 2, _("Address"), _("Access"),
13086 addr_size
* 2, _("Initial"));
13087 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13088 printf (_(" Lazy resolver\n"));
13090 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13091 >> (addr_size
* 8 - 1)) != 0)
13093 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13094 printf (_(" Module pointer (GNU extension)\n"));
13098 if (ent
< local_end
)
13100 printf (_(" Local entries:\n"));
13101 printf (" %*s %10s %*s\n",
13102 addr_size
* 2, _("Address"), _("Access"),
13103 addr_size
* 2, _("Initial"));
13104 while (ent
< local_end
)
13106 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13112 if (gotsym
< symtabno
)
13116 printf (_(" Global entries:\n"));
13117 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13118 addr_size
* 2, _("Address"),
13120 addr_size
* 2, _("Initial"),
13121 addr_size
* 2, _("Sym.Val."),
13123 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13124 _("Ndx"), _("Name"));
13126 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13127 for (i
= gotsym
; i
< symtabno
; i
++)
13129 Elf_Internal_Sym
* psym
;
13131 psym
= dynamic_symbols
+ i
;
13132 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13134 print_vma (psym
->st_value
, LONG_HEX
);
13135 printf (" %-7s %3s ",
13136 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13137 get_symbol_index_type (psym
->st_shndx
));
13138 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13139 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13141 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13151 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13154 size_t offset
, rel_offset
;
13155 unsigned long count
, i
;
13156 unsigned char * data
;
13157 int addr_size
, sym_width
;
13158 Elf_Internal_Rela
* rels
;
13160 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13161 if (pltrel
== DT_RELA
)
13163 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13168 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13173 addr_size
= (is_32bit_elf
? 4 : 8);
13174 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13176 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13177 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13178 1, _("Procedure Linkage Table data"));
13182 printf ("\nPLT GOT:\n\n");
13183 printf (_(" Reserved entries:\n"));
13184 printf (_(" %*s %*s Purpose\n"),
13185 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13186 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13187 printf (_(" PLT lazy resolver\n"));
13188 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13189 printf (_(" Module pointer\n"));
13192 printf (_(" Entries:\n"));
13193 printf (" %*s %*s %*s %-7s %3s %s\n",
13194 addr_size
* 2, _("Address"),
13195 addr_size
* 2, _("Initial"),
13196 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13197 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13198 for (i
= 0; i
< count
; i
++)
13200 Elf_Internal_Sym
* psym
;
13202 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13203 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13205 print_vma (psym
->st_value
, LONG_HEX
);
13206 printf (" %-7s %3s ",
13207 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13208 get_symbol_index_type (psym
->st_shndx
));
13209 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13210 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13212 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13226 process_nds32_specific (FILE * file
)
13228 Elf_Internal_Shdr
*sect
= NULL
;
13230 sect
= find_section (".nds32_e_flags");
13233 unsigned int *flag
;
13235 printf ("\nNDS32 elf flags section:\n");
13236 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13237 sect
->sh_size
, _("NDS32 elf flags section"));
13239 switch ((*flag
) & 0x3)
13242 printf ("(VEC_SIZE):\tNo entry.\n");
13245 printf ("(VEC_SIZE):\t4 bytes\n");
13248 printf ("(VEC_SIZE):\t16 bytes\n");
13251 printf ("(VEC_SIZE):\treserved\n");
13260 process_gnu_liblist (FILE * file
)
13262 Elf_Internal_Shdr
* section
;
13263 Elf_Internal_Shdr
* string_sec
;
13264 Elf32_External_Lib
* elib
;
13266 size_t strtab_size
;
13273 for (i
= 0, section
= section_headers
;
13274 i
< elf_header
.e_shnum
;
13277 switch (section
->sh_type
)
13279 case SHT_GNU_LIBLIST
:
13280 if (section
->sh_link
>= elf_header
.e_shnum
)
13283 elib
= (Elf32_External_Lib
*)
13284 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13285 _("liblist section data"));
13289 string_sec
= section_headers
+ section
->sh_link
;
13291 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13292 string_sec
->sh_size
,
13293 _("liblist string table"));
13295 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13301 strtab_size
= string_sec
->sh_size
;
13303 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13304 SECTION_NAME (section
),
13305 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13307 puts (_(" Library Time Stamp Checksum Version Flags"));
13309 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13317 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13318 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13319 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13320 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13321 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13323 tmp
= gmtime (&atime
);
13324 snprintf (timebuf
, sizeof (timebuf
),
13325 "%04u-%02u-%02uT%02u:%02u:%02u",
13326 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13327 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13329 printf ("%3lu: ", (unsigned long) cnt
);
13331 printf ("%-20s", liblist
.l_name
< strtab_size
13332 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13334 printf ("%-20.20s", liblist
.l_name
< strtab_size
13335 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13336 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13337 liblist
.l_version
, liblist
.l_flags
);
13348 static const char *
13349 get_note_type (unsigned e_type
)
13351 static char buff
[64];
13353 if (elf_header
.e_type
== ET_CORE
)
13357 return _("NT_AUXV (auxiliary vector)");
13359 return _("NT_PRSTATUS (prstatus structure)");
13361 return _("NT_FPREGSET (floating point registers)");
13363 return _("NT_PRPSINFO (prpsinfo structure)");
13364 case NT_TASKSTRUCT
:
13365 return _("NT_TASKSTRUCT (task structure)");
13367 return _("NT_PRXFPREG (user_xfpregs structure)");
13369 return _("NT_PPC_VMX (ppc Altivec registers)");
13371 return _("NT_PPC_VSX (ppc VSX registers)");
13373 return _("NT_386_TLS (x86 TLS information)");
13374 case NT_386_IOPERM
:
13375 return _("NT_386_IOPERM (x86 I/O permissions)");
13376 case NT_X86_XSTATE
:
13377 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13378 case NT_S390_HIGH_GPRS
:
13379 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13380 case NT_S390_TIMER
:
13381 return _("NT_S390_TIMER (s390 timer register)");
13382 case NT_S390_TODCMP
:
13383 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13384 case NT_S390_TODPREG
:
13385 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13387 return _("NT_S390_CTRS (s390 control registers)");
13388 case NT_S390_PREFIX
:
13389 return _("NT_S390_PREFIX (s390 prefix register)");
13390 case NT_S390_LAST_BREAK
:
13391 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13392 case NT_S390_SYSTEM_CALL
:
13393 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13395 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13397 return _("NT_ARM_VFP (arm VFP registers)");
13399 return _("NT_ARM_TLS (AArch TLS registers)");
13400 case NT_ARM_HW_BREAK
:
13401 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13402 case NT_ARM_HW_WATCH
:
13403 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13405 return _("NT_PSTATUS (pstatus structure)");
13407 return _("NT_FPREGS (floating point registers)");
13409 return _("NT_PSINFO (psinfo structure)");
13411 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13413 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13414 case NT_WIN32PSTATUS
:
13415 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13417 return _("NT_SIGINFO (siginfo_t data)");
13419 return _("NT_FILE (mapped files)");
13427 return _("NT_VERSION (version)");
13429 return _("NT_ARCH (architecture)");
13434 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13439 print_core_note (Elf_Internal_Note
*pnote
)
13441 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13442 bfd_vma count
, page_size
;
13443 unsigned char *descdata
, *filenames
, *descend
;
13445 if (pnote
->type
!= NT_FILE
)
13451 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13452 /* Still "successful". */
13457 if (pnote
->descsz
< 2 * addr_size
)
13459 printf (_(" Malformed note - too short for header\n"));
13463 descdata
= (unsigned char *) pnote
->descdata
;
13464 descend
= descdata
+ pnote
->descsz
;
13466 if (descdata
[pnote
->descsz
- 1] != '\0')
13468 printf (_(" Malformed note - does not end with \\0\n"));
13472 count
= byte_get (descdata
, addr_size
);
13473 descdata
+= addr_size
;
13475 page_size
= byte_get (descdata
, addr_size
);
13476 descdata
+= addr_size
;
13478 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13480 printf (_(" Malformed note - too short for supplied file count\n"));
13484 printf (_(" Page size: "));
13485 print_vma (page_size
, DEC
);
13488 printf (_(" %*s%*s%*s\n"),
13489 (int) (2 + 2 * addr_size
), _("Start"),
13490 (int) (4 + 2 * addr_size
), _("End"),
13491 (int) (4 + 2 * addr_size
), _("Page Offset"));
13492 filenames
= descdata
+ count
* 3 * addr_size
;
13493 while (--count
> 0)
13495 bfd_vma start
, end
, file_ofs
;
13497 if (filenames
== descend
)
13499 printf (_(" Malformed note - filenames end too early\n"));
13503 start
= byte_get (descdata
, addr_size
);
13504 descdata
+= addr_size
;
13505 end
= byte_get (descdata
, addr_size
);
13506 descdata
+= addr_size
;
13507 file_ofs
= byte_get (descdata
, addr_size
);
13508 descdata
+= addr_size
;
13511 print_vma (start
, FULL_HEX
);
13513 print_vma (end
, FULL_HEX
);
13515 print_vma (file_ofs
, FULL_HEX
);
13516 printf ("\n %s\n", filenames
);
13518 filenames
+= 1 + strlen ((char *) filenames
);
13524 static const char *
13525 get_gnu_elf_note_type (unsigned e_type
)
13527 static char buff
[64];
13531 case NT_GNU_ABI_TAG
:
13532 return _("NT_GNU_ABI_TAG (ABI version tag)");
13534 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13535 case NT_GNU_BUILD_ID
:
13536 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13537 case NT_GNU_GOLD_VERSION
:
13538 return _("NT_GNU_GOLD_VERSION (gold version)");
13543 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13548 print_gnu_note (Elf_Internal_Note
*pnote
)
13550 switch (pnote
->type
)
13552 case NT_GNU_BUILD_ID
:
13556 printf (_(" Build ID: "));
13557 for (i
= 0; i
< pnote
->descsz
; ++i
)
13558 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13563 case NT_GNU_ABI_TAG
:
13565 unsigned long os
, major
, minor
, subminor
;
13566 const char *osname
;
13568 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13569 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13570 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13571 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13575 case GNU_ABI_TAG_LINUX
:
13578 case GNU_ABI_TAG_HURD
:
13581 case GNU_ABI_TAG_SOLARIS
:
13582 osname
= "Solaris";
13584 case GNU_ABI_TAG_FREEBSD
:
13585 osname
= "FreeBSD";
13587 case GNU_ABI_TAG_NETBSD
:
13591 osname
= "Unknown";
13595 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13596 major
, minor
, subminor
);
13600 case NT_GNU_GOLD_VERSION
:
13604 printf (_(" Version: "));
13605 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13606 printf ("%c", pnote
->descdata
[i
]);
13615 static const char *
13616 get_netbsd_elfcore_note_type (unsigned e_type
)
13618 static char buff
[64];
13620 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13622 /* NetBSD core "procinfo" structure. */
13623 return _("NetBSD procinfo structure");
13626 /* As of Jan 2002 there are no other machine-independent notes
13627 defined for NetBSD core files. If the note type is less
13628 than the start of the machine-dependent note types, we don't
13631 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13633 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13637 switch (elf_header
.e_machine
)
13639 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13640 and PT_GETFPREGS == mach+2. */
13645 case EM_SPARC32PLUS
:
13649 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13650 return _("PT_GETREGS (reg structure)");
13651 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13652 return _("PT_GETFPREGS (fpreg structure)");
13658 /* On all other arch's, PT_GETREGS == mach+1 and
13659 PT_GETFPREGS == mach+3. */
13663 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13664 return _("PT_GETREGS (reg structure)");
13665 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13666 return _("PT_GETFPREGS (fpreg structure)");
13672 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13673 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13677 static const char *
13678 get_stapsdt_note_type (unsigned e_type
)
13680 static char buff
[64];
13685 return _("NT_STAPSDT (SystemTap probe descriptors)");
13691 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13696 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13698 int addr_size
= is_32bit_elf
? 4 : 8;
13699 char *data
= pnote
->descdata
;
13700 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13701 bfd_vma pc
, base_addr
, semaphore
;
13702 char *provider
, *probe
, *arg_fmt
;
13704 pc
= byte_get ((unsigned char *) data
, addr_size
);
13706 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13708 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13712 data
+= strlen (data
) + 1;
13714 data
+= strlen (data
) + 1;
13716 data
+= strlen (data
) + 1;
13718 printf (_(" Provider: %s\n"), provider
);
13719 printf (_(" Name: %s\n"), probe
);
13720 printf (_(" Location: "));
13721 print_vma (pc
, FULL_HEX
);
13722 printf (_(", Base: "));
13723 print_vma (base_addr
, FULL_HEX
);
13724 printf (_(", Semaphore: "));
13725 print_vma (semaphore
, FULL_HEX
);
13727 printf (_(" Arguments: %s\n"), arg_fmt
);
13729 return data
== data_end
;
13732 static const char *
13733 get_ia64_vms_note_type (unsigned e_type
)
13735 static char buff
[64];
13740 return _("NT_VMS_MHD (module header)");
13742 return _("NT_VMS_LNM (language name)");
13744 return _("NT_VMS_SRC (source files)");
13746 return "NT_VMS_TITLE";
13748 return _("NT_VMS_EIDC (consistency check)");
13749 case NT_VMS_FPMODE
:
13750 return _("NT_VMS_FPMODE (FP mode)");
13751 case NT_VMS_LINKTIME
:
13752 return "NT_VMS_LINKTIME";
13753 case NT_VMS_IMGNAM
:
13754 return _("NT_VMS_IMGNAM (image name)");
13756 return _("NT_VMS_IMGID (image id)");
13757 case NT_VMS_LINKID
:
13758 return _("NT_VMS_LINKID (link id)");
13759 case NT_VMS_IMGBID
:
13760 return _("NT_VMS_IMGBID (build id)");
13761 case NT_VMS_GSTNAM
:
13762 return _("NT_VMS_GSTNAM (sym table name)");
13763 case NT_VMS_ORIG_DYN
:
13764 return "NT_VMS_ORIG_DYN";
13765 case NT_VMS_PATCHTIME
:
13766 return "NT_VMS_PATCHTIME";
13768 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13774 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13776 switch (pnote
->type
)
13779 if (pnote
->descsz
> 36)
13781 size_t l
= strlen (pnote
->descdata
+ 34);
13782 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13783 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13784 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13785 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13788 printf (_(" Invalid size\n"));
13791 printf (_(" Language: %s\n"), pnote
->descdata
);
13794 case NT_VMS_FPMODE
:
13795 printf (_(" Floating Point mode: "));
13796 printf ("0x%016" BFD_VMA_FMT
"x\n",
13797 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13799 case NT_VMS_LINKTIME
:
13800 printf (_(" Link time: "));
13802 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13805 case NT_VMS_PATCHTIME
:
13806 printf (_(" Patch time: "));
13808 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13811 case NT_VMS_ORIG_DYN
:
13812 printf (_(" Major id: %u, minor id: %u\n"),
13813 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13814 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13815 printf (_(" Last modified : "));
13817 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13818 printf (_("\n Link flags : "));
13819 printf ("0x%016" BFD_VMA_FMT
"x\n",
13820 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13821 printf (_(" Header flags: 0x%08x\n"),
13822 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13823 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13826 case NT_VMS_IMGNAM
:
13827 printf (_(" Image name: %s\n"), pnote
->descdata
);
13829 case NT_VMS_GSTNAM
:
13830 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13833 printf (_(" Image id: %s\n"), pnote
->descdata
);
13835 case NT_VMS_LINKID
:
13836 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13844 /* Note that by the ELF standard, the name field is already null byte
13845 terminated, and namesz includes the terminating null byte.
13846 I.E. the value of namesz for the name "FSF" is 4.
13848 If the value of namesz is zero, there is no name present. */
13850 process_note (Elf_Internal_Note
* pnote
)
13852 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13855 if (pnote
->namesz
== 0)
13856 /* If there is no note name, then use the default set of
13857 note type strings. */
13858 nt
= get_note_type (pnote
->type
);
13860 else if (const_strneq (pnote
->namedata
, "GNU"))
13861 /* GNU-specific object file notes. */
13862 nt
= get_gnu_elf_note_type (pnote
->type
);
13864 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13865 /* NetBSD-specific core file notes. */
13866 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13868 else if (strneq (pnote
->namedata
, "SPU/", 4))
13870 /* SPU-specific core file notes. */
13871 nt
= pnote
->namedata
+ 4;
13875 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13876 /* VMS/ia64-specific file notes. */
13877 nt
= get_ia64_vms_note_type (pnote
->type
);
13879 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13880 nt
= get_stapsdt_note_type (pnote
->type
);
13883 /* Don't recognize this note name; just use the default set of
13884 note type strings. */
13885 nt
= get_note_type (pnote
->type
);
13887 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13889 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13890 return print_ia64_vms_note (pnote
);
13891 else if (const_strneq (pnote
->namedata
, "GNU"))
13892 return print_gnu_note (pnote
);
13893 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13894 return print_stapsdt_note (pnote
);
13895 else if (const_strneq (pnote
->namedata
, "CORE"))
13896 return print_core_note (pnote
);
13903 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13905 Elf_External_Note
* pnotes
;
13906 Elf_External_Note
* external
;
13912 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13914 if (pnotes
== NULL
)
13919 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13920 (unsigned long) offset
, (unsigned long) length
);
13921 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13923 while ((char *) external
< (char *) pnotes
+ length
)
13925 Elf_Internal_Note inote
;
13928 char * temp
= NULL
;
13929 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
13931 if (!is_ia64_vms ())
13933 /* PR binutils/15191
13934 Make sure that there is enough data to read. */
13935 min_notesz
= offsetof (Elf_External_Note
, name
);
13936 if (data_remaining
< min_notesz
)
13938 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13939 (int) data_remaining
);
13942 inote
.type
= BYTE_GET (external
->type
);
13943 inote
.namesz
= BYTE_GET (external
->namesz
);
13944 inote
.namedata
= external
->name
;
13945 inote
.descsz
= BYTE_GET (external
->descsz
);
13946 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13947 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13948 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
13952 Elf64_External_VMS_Note
*vms_external
;
13954 /* PR binutils/15191
13955 Make sure that there is enough data to read. */
13956 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
13957 if (data_remaining
< min_notesz
)
13959 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13960 (int) data_remaining
);
13964 vms_external
= (Elf64_External_VMS_Note
*) external
;
13965 inote
.type
= BYTE_GET (vms_external
->type
);
13966 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13967 inote
.namedata
= vms_external
->name
;
13968 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13969 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13970 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13971 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
13974 if (inote
.descdata
< (char *) external
+ min_notesz
13975 || next
< (char *) external
+ min_notesz
13976 || data_remaining
< (size_t)(next
- (char *) external
))
13978 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13979 (unsigned long) ((char *) external
- (char *) pnotes
));
13980 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13981 inote
.type
, inote
.namesz
, inote
.descsz
);
13985 external
= (Elf_External_Note
*) next
;
13987 /* Verify that name is null terminated. It appears that at least
13988 one version of Linux (RedHat 6.0) generates corefiles that don't
13989 comply with the ELF spec by failing to include the null byte in
13991 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13993 temp
= (char *) malloc (inote
.namesz
+ 1);
13997 error (_("Out of memory\n"));
14002 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14003 temp
[inote
.namesz
] = 0;
14005 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14006 inote
.namedata
= temp
;
14009 res
&= process_note (& inote
);
14024 process_corefile_note_segments (FILE * file
)
14026 Elf_Internal_Phdr
* segment
;
14030 if (! get_program_headers (file
))
14033 for (i
= 0, segment
= program_headers
;
14034 i
< elf_header
.e_phnum
;
14037 if (segment
->p_type
== PT_NOTE
)
14038 res
&= process_corefile_note_segment (file
,
14039 (bfd_vma
) segment
->p_offset
,
14040 (bfd_vma
) segment
->p_filesz
);
14047 process_note_sections (FILE * file
)
14049 Elf_Internal_Shdr
* section
;
14053 for (i
= 0, section
= section_headers
;
14054 i
< elf_header
.e_shnum
&& section
!= NULL
;
14056 if (section
->sh_type
== SHT_NOTE
)
14057 res
&= process_corefile_note_segment (file
,
14058 (bfd_vma
) section
->sh_offset
,
14059 (bfd_vma
) section
->sh_size
);
14065 process_notes (FILE * file
)
14067 /* If we have not been asked to display the notes then do nothing. */
14071 if (elf_header
.e_type
!= ET_CORE
)
14072 return process_note_sections (file
);
14074 /* No program headers means no NOTE segment. */
14075 if (elf_header
.e_phnum
> 0)
14076 return process_corefile_note_segments (file
);
14078 printf (_("No note segments present in the core file.\n"));
14083 process_arch_specific (FILE * file
)
14088 switch (elf_header
.e_machine
)
14091 return process_arm_specific (file
);
14093 case EM_MIPS_RS3_LE
:
14094 return process_mips_specific (file
);
14097 return process_nds32_specific (file
);
14100 return process_power_specific (file
);
14103 case EM_SPARC32PLUS
:
14105 return process_sparc_specific (file
);
14108 return process_tic6x_specific (file
);
14111 return process_msp430x_specific (file
);
14119 get_file_header (FILE * file
)
14121 /* Read in the identity array. */
14122 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14125 /* Determine how to read the rest of the header. */
14126 switch (elf_header
.e_ident
[EI_DATA
])
14128 default: /* fall through */
14129 case ELFDATANONE
: /* fall through */
14131 byte_get
= byte_get_little_endian
;
14132 byte_put
= byte_put_little_endian
;
14135 byte_get
= byte_get_big_endian
;
14136 byte_put
= byte_put_big_endian
;
14140 /* For now we only support 32 bit and 64 bit ELF files. */
14141 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14143 /* Read in the rest of the header. */
14146 Elf32_External_Ehdr ehdr32
;
14148 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14151 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14152 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14153 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14154 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14155 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14156 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14157 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14158 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14159 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14160 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14161 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14162 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14163 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14167 Elf64_External_Ehdr ehdr64
;
14169 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14170 we will not be able to cope with the 64bit data found in
14171 64 ELF files. Detect this now and abort before we start
14172 overwriting things. */
14173 if (sizeof (bfd_vma
) < 8)
14175 error (_("This instance of readelf has been built without support for a\n\
14176 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14180 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14183 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14184 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14185 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14186 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14187 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14188 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14189 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14190 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14191 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14192 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14193 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14194 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14195 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14198 if (elf_header
.e_shoff
)
14200 /* There may be some extensions in the first section header. Don't
14201 bomb if we can't read it. */
14203 get_32bit_section_headers (file
, 1);
14205 get_64bit_section_headers (file
, 1);
14211 /* Process one ELF object file according to the command line options.
14212 This file may actually be stored in an archive. The file is
14213 positioned at the start of the ELF object. */
14216 process_object (char * file_name
, FILE * file
)
14220 if (! get_file_header (file
))
14222 error (_("%s: Failed to read file header\n"), file_name
);
14226 /* Initialise per file variables. */
14227 for (i
= ARRAY_SIZE (version_info
); i
--;)
14228 version_info
[i
] = 0;
14230 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14231 dynamic_info
[i
] = 0;
14232 dynamic_info_DT_GNU_HASH
= 0;
14234 /* Process the file. */
14236 printf (_("\nFile: %s\n"), file_name
);
14238 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14239 Note we do this even if cmdline_dump_sects is empty because we
14240 must make sure that the dump_sets array is zeroed out before each
14241 object file is processed. */
14242 if (num_dump_sects
> num_cmdline_dump_sects
)
14243 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14245 if (num_cmdline_dump_sects
> 0)
14247 if (num_dump_sects
== 0)
14248 /* A sneaky way of allocating the dump_sects array. */
14249 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14251 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14252 memcpy (dump_sects
, cmdline_dump_sects
,
14253 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14256 if (! process_file_header ())
14259 if (! process_section_headers (file
))
14261 /* Without loaded section headers we cannot process lots of
14263 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14265 if (! do_using_dynamic
)
14266 do_syms
= do_dyn_syms
= do_reloc
= 0;
14269 if (! process_section_groups (file
))
14271 /* Without loaded section groups we cannot process unwind. */
14275 if (process_program_headers (file
))
14276 process_dynamic_section (file
);
14278 process_relocs (file
);
14280 process_unwind (file
);
14282 process_symbol_table (file
);
14284 process_syminfo (file
);
14286 process_version_sections (file
);
14288 process_section_contents (file
);
14290 process_notes (file
);
14292 process_gnu_liblist (file
);
14294 process_arch_specific (file
);
14296 if (program_headers
)
14298 free (program_headers
);
14299 program_headers
= NULL
;
14302 if (section_headers
)
14304 free (section_headers
);
14305 section_headers
= NULL
;
14310 free (string_table
);
14311 string_table
= NULL
;
14312 string_table_length
= 0;
14315 if (dynamic_strings
)
14317 free (dynamic_strings
);
14318 dynamic_strings
= NULL
;
14319 dynamic_strings_length
= 0;
14322 if (dynamic_symbols
)
14324 free (dynamic_symbols
);
14325 dynamic_symbols
= NULL
;
14326 num_dynamic_syms
= 0;
14329 if (dynamic_syminfo
)
14331 free (dynamic_syminfo
);
14332 dynamic_syminfo
= NULL
;
14335 if (dynamic_section
)
14337 free (dynamic_section
);
14338 dynamic_section
= NULL
;
14341 if (section_headers_groups
)
14343 free (section_headers_groups
);
14344 section_headers_groups
= NULL
;
14347 if (section_groups
)
14349 struct group_list
* g
;
14350 struct group_list
* next
;
14352 for (i
= 0; i
< group_count
; i
++)
14354 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14361 free (section_groups
);
14362 section_groups
= NULL
;
14365 free_debug_memory ();
14370 /* Process an ELF archive.
14371 On entry the file is positioned just after the ARMAG string. */
14374 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14376 struct archive_info arch
;
14377 struct archive_info nested_arch
;
14383 /* The ARCH structure is used to hold information about this archive. */
14384 arch
.file_name
= NULL
;
14386 arch
.index_array
= NULL
;
14387 arch
.sym_table
= NULL
;
14388 arch
.longnames
= NULL
;
14390 /* The NESTED_ARCH structure is used as a single-item cache of information
14391 about a nested archive (when members of a thin archive reside within
14392 another regular archive file). */
14393 nested_arch
.file_name
= NULL
;
14394 nested_arch
.file
= NULL
;
14395 nested_arch
.index_array
= NULL
;
14396 nested_arch
.sym_table
= NULL
;
14397 nested_arch
.longnames
= NULL
;
14399 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14405 if (do_archive_index
)
14407 if (arch
.sym_table
== NULL
)
14408 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14412 unsigned long current_pos
;
14414 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14415 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14416 current_pos
= ftell (file
);
14418 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14420 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14422 char * member_name
;
14424 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14426 if (member_name
!= NULL
)
14428 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14430 if (qualified_name
!= NULL
)
14432 printf (_("Contents of binary %s at offset "), qualified_name
);
14433 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14435 free (qualified_name
);
14440 if (l
>= arch
.sym_size
)
14442 error (_("%s: end of the symbol table reached before the end of the index\n"),
14446 printf ("\t%s\n", arch
.sym_table
+ l
);
14447 l
+= strlen (arch
.sym_table
+ l
) + 1;
14450 if (arch
.uses_64bit_indicies
)
14455 if (l
< arch
.sym_size
)
14456 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14457 file_name
, arch
.sym_size
- l
);
14459 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14461 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14467 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14468 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14469 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14470 && !do_section_groups
&& !do_dyn_syms
)
14472 ret
= 0; /* Archive index only. */
14483 char * qualified_name
;
14485 /* Read the next archive header. */
14486 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14488 error (_("%s: failed to seek to next archive header\n"), file_name
);
14491 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14492 if (got
!= sizeof arch
.arhdr
)
14496 error (_("%s: failed to read archive header\n"), file_name
);
14500 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14502 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14507 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14509 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14510 if (archive_file_size
& 01)
14511 ++archive_file_size
;
14513 name
= get_archive_member_name (&arch
, &nested_arch
);
14516 error (_("%s: bad archive file name\n"), file_name
);
14520 namelen
= strlen (name
);
14522 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14523 if (qualified_name
== NULL
)
14525 error (_("%s: bad archive file name\n"), file_name
);
14530 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14532 /* This is a proxy for an external member of a thin archive. */
14533 FILE * member_file
;
14534 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14535 if (member_file_name
== NULL
)
14541 member_file
= fopen (member_file_name
, "rb");
14542 if (member_file
== NULL
)
14544 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14545 free (member_file_name
);
14550 archive_file_offset
= arch
.nested_member_origin
;
14552 ret
|= process_object (qualified_name
, member_file
);
14554 fclose (member_file
);
14555 free (member_file_name
);
14557 else if (is_thin_archive
)
14559 /* PR 15140: Allow for corrupt thin archives. */
14560 if (nested_arch
.file
== NULL
)
14562 error (_("%s: contains corrupt thin archive: %s\n"),
14568 /* This is a proxy for a member of a nested archive. */
14569 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14571 /* The nested archive file will have been opened and setup by
14572 get_archive_member_name. */
14573 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14575 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14580 ret
|= process_object (qualified_name
, nested_arch
.file
);
14584 archive_file_offset
= arch
.next_arhdr_offset
;
14585 arch
.next_arhdr_offset
+= archive_file_size
;
14587 ret
|= process_object (qualified_name
, file
);
14590 if (dump_sects
!= NULL
)
14594 num_dump_sects
= 0;
14597 free (qualified_name
);
14601 if (nested_arch
.file
!= NULL
)
14602 fclose (nested_arch
.file
);
14603 release_archive (&nested_arch
);
14604 release_archive (&arch
);
14610 process_file (char * file_name
)
14613 struct stat statbuf
;
14614 char armag
[SARMAG
];
14617 if (stat (file_name
, &statbuf
) < 0)
14619 if (errno
== ENOENT
)
14620 error (_("'%s': No such file\n"), file_name
);
14622 error (_("Could not locate '%s'. System error message: %s\n"),
14623 file_name
, strerror (errno
));
14627 if (! S_ISREG (statbuf
.st_mode
))
14629 error (_("'%s' is not an ordinary file\n"), file_name
);
14633 file
= fopen (file_name
, "rb");
14636 error (_("Input file '%s' is not readable.\n"), file_name
);
14640 if (fread (armag
, SARMAG
, 1, file
) != 1)
14642 error (_("%s: Failed to read file's magic number\n"), file_name
);
14647 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14648 ret
= process_archive (file_name
, file
, FALSE
);
14649 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14650 ret
= process_archive (file_name
, file
, TRUE
);
14653 if (do_archive_index
)
14654 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14658 archive_file_size
= archive_file_offset
= 0;
14659 ret
= process_object (file_name
, file
);
14667 #ifdef SUPPORT_DISASSEMBLY
14668 /* Needed by the i386 disassembler. For extra credit, someone could
14669 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14673 print_address (unsigned int addr
, FILE * outfile
)
14675 fprintf (outfile
,"0x%8.8x", addr
);
14678 /* Needed by the i386 disassembler. */
14680 db_task_printsym (unsigned int addr
)
14682 print_address (addr
, stderr
);
14687 main (int argc
, char ** argv
)
14691 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14692 setlocale (LC_MESSAGES
, "");
14694 #if defined (HAVE_SETLOCALE)
14695 setlocale (LC_CTYPE
, "");
14697 bindtextdomain (PACKAGE
, LOCALEDIR
);
14698 textdomain (PACKAGE
);
14700 expandargv (&argc
, &argv
);
14702 parse_args (argc
, argv
);
14704 if (num_dump_sects
> 0)
14706 /* Make a copy of the dump_sects array. */
14707 cmdline_dump_sects
= (dump_type
*)
14708 malloc (num_dump_sects
* sizeof (* dump_sects
));
14709 if (cmdline_dump_sects
== NULL
)
14710 error (_("Out of memory allocating dump request table.\n"));
14713 memcpy (cmdline_dump_sects
, dump_sects
,
14714 num_dump_sects
* sizeof (* dump_sects
));
14715 num_cmdline_dump_sects
= num_dump_sects
;
14719 if (optind
< (argc
- 1))
14723 while (optind
< argc
)
14724 err
|= process_file (argv
[optind
++]);
14726 if (dump_sects
!= NULL
)
14728 if (cmdline_dump_sects
!= NULL
)
14729 free (cmdline_dump_sects
);