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 */
2332 static const char *VER_STRINGS
[] =
2334 "Andes ELF V1.3 or older",
2338 static const char *ARCH_STRINGS
[] =
2347 abi
= EF_NDS_ABI
& e_flags
;
2348 arch
= EF_NDS_ARCH
& e_flags
;
2349 config
= EF_NDS_INST
& e_flags
;
2350 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2352 memset (buf
, 0, size
);
2359 case E_NDS_ABI_V2FP
:
2360 case E_NDS_ABI_AABI
:
2361 case E_NDS_ABI_V2FP_PLUS
:
2362 /* In case there are holes in the array. */
2363 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2367 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2373 case E_NDS32_ELF_VER_1_2
:
2374 case E_NDS32_ELF_VER_1_3
:
2375 case E_NDS32_ELF_VER_1_4
:
2376 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2380 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2384 if (E_NDS_ABI_V0
== abi
)
2386 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2387 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2388 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2389 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2395 case E_NDS_ARCH_STAR_V1_0
:
2396 case E_NDS_ARCH_STAR_V2_0
:
2397 case E_NDS_ARCH_STAR_V3_0
:
2398 case E_NDS_ARCH_STAR_V3_M
:
2399 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2403 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2404 /* ARCH version determines how the e_flags are interpreted.
2405 If it is unknown, we cannot proceed. */
2409 /* Newer ABI; Now handle architecture specific flags. */
2410 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2412 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2413 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2415 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2416 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2418 if (config
& E_NDS32_HAS_DIV_INST
)
2419 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2421 if (config
& E_NDS32_HAS_16BIT_INST
)
2422 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2426 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2428 if (version
<= E_NDS32_ELF_VER_1_3
)
2429 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2431 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2434 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2435 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2437 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2438 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2440 if (config
& E_NDS32_HAS_16BIT_INST
)
2442 if (version
<= E_NDS32_ELF_VER_1_3
)
2443 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2445 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2449 if (config
& E_NDS32_HAS_EXT_INST
)
2450 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2452 if (config
& E_NDS32_HAS_EXT2_INST
)
2453 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2455 if (config
& E_NDS32_HAS_FPU_INST
)
2458 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2461 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2464 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2467 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2470 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2475 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2477 case E_NDS32_FPU_REG_8SP_4DP
:
2478 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2480 case E_NDS32_FPU_REG_16SP_8DP
:
2481 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2483 case E_NDS32_FPU_REG_32SP_16DP
:
2484 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2486 case E_NDS32_FPU_REG_32SP_32DP
:
2487 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2492 if (config
& E_NDS32_HAS_AUDIO_INST
)
2493 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2495 if (config
& E_NDS32_HAS_STRING_INST
)
2496 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2498 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2499 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2501 if (config
& E_NDS32_HAS_VIDEO_INST
)
2503 if (version
<= E_NDS32_ELF_VER_1_3
)
2504 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2506 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2509 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2510 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2512 if (config
& E_NDS32_HAS_L2C_INST
)
2513 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2517 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2519 static char buf
[1024];
2531 decode_ARM_machine_flags (e_flags
, buf
);
2535 if (e_flags
& EF_BFIN_PIC
)
2536 strcat (buf
, ", PIC");
2538 if (e_flags
& EF_BFIN_FDPIC
)
2539 strcat (buf
, ", FDPIC");
2541 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2542 strcat (buf
, ", code in L1");
2544 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2545 strcat (buf
, ", data in L1");
2550 switch (e_flags
& EF_FRV_CPU_MASK
)
2552 case EF_FRV_CPU_GENERIC
:
2556 strcat (buf
, ", fr???");
2559 case EF_FRV_CPU_FR300
:
2560 strcat (buf
, ", fr300");
2563 case EF_FRV_CPU_FR400
:
2564 strcat (buf
, ", fr400");
2566 case EF_FRV_CPU_FR405
:
2567 strcat (buf
, ", fr405");
2570 case EF_FRV_CPU_FR450
:
2571 strcat (buf
, ", fr450");
2574 case EF_FRV_CPU_FR500
:
2575 strcat (buf
, ", fr500");
2577 case EF_FRV_CPU_FR550
:
2578 strcat (buf
, ", fr550");
2581 case EF_FRV_CPU_SIMPLE
:
2582 strcat (buf
, ", simple");
2584 case EF_FRV_CPU_TOMCAT
:
2585 strcat (buf
, ", tomcat");
2591 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2592 strcat (buf
, ", m68000");
2593 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2594 strcat (buf
, ", cpu32");
2595 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2596 strcat (buf
, ", fido_a");
2599 char const * isa
= _("unknown");
2600 char const * mac
= _("unknown mac");
2601 char const * additional
= NULL
;
2603 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2605 case EF_M68K_CF_ISA_A_NODIV
:
2607 additional
= ", nodiv";
2609 case EF_M68K_CF_ISA_A
:
2612 case EF_M68K_CF_ISA_A_PLUS
:
2615 case EF_M68K_CF_ISA_B_NOUSP
:
2617 additional
= ", nousp";
2619 case EF_M68K_CF_ISA_B
:
2622 case EF_M68K_CF_ISA_C
:
2625 case EF_M68K_CF_ISA_C_NODIV
:
2627 additional
= ", nodiv";
2630 strcat (buf
, ", cf, isa ");
2633 strcat (buf
, additional
);
2634 if (e_flags
& EF_M68K_CF_FLOAT
)
2635 strcat (buf
, ", float");
2636 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2641 case EF_M68K_CF_MAC
:
2644 case EF_M68K_CF_EMAC
:
2647 case EF_M68K_CF_EMAC_B
:
2660 if (e_flags
& EF_PPC_EMB
)
2661 strcat (buf
, ", emb");
2663 if (e_flags
& EF_PPC_RELOCATABLE
)
2664 strcat (buf
, _(", relocatable"));
2666 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2667 strcat (buf
, _(", relocatable-lib"));
2671 if (e_flags
& EF_PPC64_ABI
)
2673 char abi
[] = ", abiv0";
2675 abi
[6] += e_flags
& EF_PPC64_ABI
;
2681 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2682 strcat (buf
, ", RH850 ABI");
2684 if (e_flags
& EF_V800_850E3
)
2685 strcat (buf
, ", V3 architecture");
2687 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2688 strcat (buf
, ", FPU not used");
2690 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2691 strcat (buf
, ", regmode: COMMON");
2693 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2694 strcat (buf
, ", r4 not used");
2696 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2697 strcat (buf
, ", r30 not used");
2699 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2700 strcat (buf
, ", r5 not used");
2702 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2703 strcat (buf
, ", r2 not used");
2705 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2707 switch (e_flags
& - e_flags
)
2709 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2710 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2711 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2712 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2713 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2714 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2715 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2716 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2717 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2718 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2719 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2720 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2721 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2722 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2723 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2724 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2731 case EM_CYGNUS_V850
:
2732 switch (e_flags
& EF_V850_ARCH
)
2734 case E_V850E3V5_ARCH
:
2735 strcat (buf
, ", v850e3v5");
2737 case E_V850E2V3_ARCH
:
2738 strcat (buf
, ", v850e2v3");
2741 strcat (buf
, ", v850e2");
2744 strcat (buf
, ", v850e1");
2747 strcat (buf
, ", v850e");
2750 strcat (buf
, ", v850");
2753 strcat (buf
, _(", unknown v850 architecture variant"));
2759 case EM_CYGNUS_M32R
:
2760 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2761 strcat (buf
, ", m32r");
2765 case EM_MIPS_RS3_LE
:
2766 if (e_flags
& EF_MIPS_NOREORDER
)
2767 strcat (buf
, ", noreorder");
2769 if (e_flags
& EF_MIPS_PIC
)
2770 strcat (buf
, ", pic");
2772 if (e_flags
& EF_MIPS_CPIC
)
2773 strcat (buf
, ", cpic");
2775 if (e_flags
& EF_MIPS_UCODE
)
2776 strcat (buf
, ", ugen_reserved");
2778 if (e_flags
& EF_MIPS_ABI2
)
2779 strcat (buf
, ", abi2");
2781 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2782 strcat (buf
, ", odk first");
2784 if (e_flags
& EF_MIPS_32BITMODE
)
2785 strcat (buf
, ", 32bitmode");
2787 if (e_flags
& EF_MIPS_NAN2008
)
2788 strcat (buf
, ", nan2008");
2790 if (e_flags
& EF_MIPS_FP64
)
2791 strcat (buf
, ", fp64");
2793 switch ((e_flags
& EF_MIPS_MACH
))
2795 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2796 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2797 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2798 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2799 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2800 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2801 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2802 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2803 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2804 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2805 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2806 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2807 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2808 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2809 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2810 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2811 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2813 /* We simply ignore the field in this case to avoid confusion:
2814 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2817 default: strcat (buf
, _(", unknown CPU")); break;
2820 switch ((e_flags
& EF_MIPS_ABI
))
2822 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2823 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2824 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2825 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2827 /* We simply ignore the field in this case to avoid confusion:
2828 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2829 This means it is likely to be an o32 file, but not for
2832 default: strcat (buf
, _(", unknown ABI")); break;
2835 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2836 strcat (buf
, ", mdmx");
2838 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2839 strcat (buf
, ", mips16");
2841 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2842 strcat (buf
, ", micromips");
2844 switch ((e_flags
& EF_MIPS_ARCH
))
2846 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2847 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2848 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2849 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2850 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2851 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2852 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2853 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
2854 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2855 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2856 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
2857 default: strcat (buf
, _(", unknown ISA")); break;
2862 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2866 switch ((e_flags
& EF_SH_MACH_MASK
))
2868 case EF_SH1
: strcat (buf
, ", sh1"); break;
2869 case EF_SH2
: strcat (buf
, ", sh2"); break;
2870 case EF_SH3
: strcat (buf
, ", sh3"); break;
2871 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2872 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2873 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2874 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2875 case EF_SH4
: strcat (buf
, ", sh4"); break;
2876 case EF_SH5
: strcat (buf
, ", sh5"); break;
2877 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2878 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2879 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2880 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2881 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2882 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2883 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2884 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2885 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2886 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2887 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2888 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2889 default: strcat (buf
, _(", unknown ISA")); break;
2892 if (e_flags
& EF_SH_PIC
)
2893 strcat (buf
, ", pic");
2895 if (e_flags
& EF_SH_FDPIC
)
2896 strcat (buf
, ", fdpic");
2900 if (e_flags
& EF_OR1K_NODELAY
)
2901 strcat (buf
, ", no delay");
2905 if (e_flags
& EF_SPARC_32PLUS
)
2906 strcat (buf
, ", v8+");
2908 if (e_flags
& EF_SPARC_SUN_US1
)
2909 strcat (buf
, ", ultrasparcI");
2911 if (e_flags
& EF_SPARC_SUN_US3
)
2912 strcat (buf
, ", ultrasparcIII");
2914 if (e_flags
& EF_SPARC_HAL_R1
)
2915 strcat (buf
, ", halr1");
2917 if (e_flags
& EF_SPARC_LEDATA
)
2918 strcat (buf
, ", ledata");
2920 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2921 strcat (buf
, ", tso");
2923 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2924 strcat (buf
, ", pso");
2926 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2927 strcat (buf
, ", rmo");
2931 switch (e_flags
& EF_PARISC_ARCH
)
2933 case EFA_PARISC_1_0
:
2934 strcpy (buf
, ", PA-RISC 1.0");
2936 case EFA_PARISC_1_1
:
2937 strcpy (buf
, ", PA-RISC 1.1");
2939 case EFA_PARISC_2_0
:
2940 strcpy (buf
, ", PA-RISC 2.0");
2945 if (e_flags
& EF_PARISC_TRAPNIL
)
2946 strcat (buf
, ", trapnil");
2947 if (e_flags
& EF_PARISC_EXT
)
2948 strcat (buf
, ", ext");
2949 if (e_flags
& EF_PARISC_LSB
)
2950 strcat (buf
, ", lsb");
2951 if (e_flags
& EF_PARISC_WIDE
)
2952 strcat (buf
, ", wide");
2953 if (e_flags
& EF_PARISC_NO_KABP
)
2954 strcat (buf
, ", no kabp");
2955 if (e_flags
& EF_PARISC_LAZYSWAP
)
2956 strcat (buf
, ", lazyswap");
2961 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2962 strcat (buf
, ", new calling convention");
2964 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2965 strcat (buf
, ", gnu calling convention");
2969 if ((e_flags
& EF_IA_64_ABI64
))
2970 strcat (buf
, ", 64-bit");
2972 strcat (buf
, ", 32-bit");
2973 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2974 strcat (buf
, ", reduced fp model");
2975 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2976 strcat (buf
, ", no function descriptors, constant gp");
2977 else if ((e_flags
& EF_IA_64_CONS_GP
))
2978 strcat (buf
, ", constant gp");
2979 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2980 strcat (buf
, ", absolute");
2981 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2983 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2984 strcat (buf
, ", vms_linkages");
2985 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2987 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2989 case EF_IA_64_VMS_COMCOD_WARNING
:
2990 strcat (buf
, ", warning");
2992 case EF_IA_64_VMS_COMCOD_ERROR
:
2993 strcat (buf
, ", error");
2995 case EF_IA_64_VMS_COMCOD_ABORT
:
2996 strcat (buf
, ", abort");
3005 if ((e_flags
& EF_VAX_NONPIC
))
3006 strcat (buf
, ", non-PIC");
3007 if ((e_flags
& EF_VAX_DFLOAT
))
3008 strcat (buf
, ", D-Float");
3009 if ((e_flags
& EF_VAX_GFLOAT
))
3010 strcat (buf
, ", G-Float");
3014 if (e_flags
& E_FLAG_RL78_G10
)
3015 strcat (buf
, ", G10");
3016 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3017 strcat (buf
, ", 64-bit doubles");
3021 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3022 strcat (buf
, ", 64-bit doubles");
3023 if (e_flags
& E_FLAG_RX_DSP
)
3024 strcat (buf
, ", dsp");
3025 if (e_flags
& E_FLAG_RX_PID
)
3026 strcat (buf
, ", pid");
3027 if (e_flags
& E_FLAG_RX_ABI
)
3028 strcat (buf
, ", RX ABI");
3032 if (e_flags
& EF_S390_HIGH_GPRS
)
3033 strcat (buf
, ", highgprs");
3037 if ((e_flags
& EF_C6000_REL
))
3038 strcat (buf
, ", relocatable module");
3042 strcat (buf
, _(": architecture variant: "));
3043 switch (e_flags
& EF_MSP430_MACH
)
3045 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3046 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3047 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3048 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3049 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3050 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3051 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3052 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3053 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3054 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3055 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3056 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3057 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3058 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3059 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3061 strcat (buf
, _(": unknown")); break;
3064 if (e_flags
& ~ EF_MSP430_MACH
)
3065 strcat (buf
, _(": unknown extra flag bits also present"));
3073 get_osabi_name (unsigned int osabi
)
3075 static char buff
[32];
3079 case ELFOSABI_NONE
: return "UNIX - System V";
3080 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3081 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3082 case ELFOSABI_GNU
: return "UNIX - GNU";
3083 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3084 case ELFOSABI_AIX
: return "UNIX - AIX";
3085 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3086 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3087 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3088 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3089 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3090 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3091 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3092 case ELFOSABI_AROS
: return "AROS";
3093 case ELFOSABI_FENIXOS
: return "FenixOS";
3096 switch (elf_header
.e_machine
)
3101 case ELFOSABI_ARM
: return "ARM";
3111 case ELFOSABI_STANDALONE
: return _("Standalone App");
3120 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3121 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3130 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3136 get_aarch64_segment_type (unsigned long type
)
3140 case PT_AARCH64_ARCHEXT
:
3141 return "AARCH64_ARCHEXT";
3150 get_arm_segment_type (unsigned long type
)
3164 get_mips_segment_type (unsigned long type
)
3168 case PT_MIPS_REGINFO
:
3170 case PT_MIPS_RTPROC
:
3172 case PT_MIPS_OPTIONS
:
3174 case PT_MIPS_ABIFLAGS
:
3184 get_parisc_segment_type (unsigned long type
)
3188 case PT_HP_TLS
: return "HP_TLS";
3189 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3190 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3191 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3192 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3193 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3194 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3195 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3196 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3197 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3198 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3199 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3200 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3201 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3202 case PT_HP_STACK
: return "HP_STACK";
3203 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3204 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3205 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3206 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3215 get_ia64_segment_type (unsigned long type
)
3219 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3220 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3221 case PT_HP_TLS
: return "HP_TLS";
3222 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3223 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3224 case PT_IA_64_HP_STACK
: return "HP_STACK";
3233 get_tic6x_segment_type (unsigned long type
)
3237 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3246 get_segment_type (unsigned long p_type
)
3248 static char buff
[32];
3252 case PT_NULL
: return "NULL";
3253 case PT_LOAD
: return "LOAD";
3254 case PT_DYNAMIC
: return "DYNAMIC";
3255 case PT_INTERP
: return "INTERP";
3256 case PT_NOTE
: return "NOTE";
3257 case PT_SHLIB
: return "SHLIB";
3258 case PT_PHDR
: return "PHDR";
3259 case PT_TLS
: return "TLS";
3261 case PT_GNU_EH_FRAME
:
3262 return "GNU_EH_FRAME";
3263 case PT_GNU_STACK
: return "GNU_STACK";
3264 case PT_GNU_RELRO
: return "GNU_RELRO";
3267 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3269 const char * result
;
3271 switch (elf_header
.e_machine
)
3274 result
= get_aarch64_segment_type (p_type
);
3277 result
= get_arm_segment_type (p_type
);
3280 case EM_MIPS_RS3_LE
:
3281 result
= get_mips_segment_type (p_type
);
3284 result
= get_parisc_segment_type (p_type
);
3287 result
= get_ia64_segment_type (p_type
);
3290 result
= get_tic6x_segment_type (p_type
);
3300 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3302 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3304 const char * result
;
3306 switch (elf_header
.e_machine
)
3309 result
= get_parisc_segment_type (p_type
);
3312 result
= get_ia64_segment_type (p_type
);
3322 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3325 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3332 get_mips_section_type_name (unsigned int sh_type
)
3336 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3337 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3338 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3339 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3340 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3341 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3342 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3343 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3344 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3345 case SHT_MIPS_RELD
: return "MIPS_RELD";
3346 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3347 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3348 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3349 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3350 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3351 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3352 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3353 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3354 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3355 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3356 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3357 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3358 case SHT_MIPS_LINE
: return "MIPS_LINE";
3359 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3360 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3361 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3362 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3363 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3364 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3365 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3366 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3367 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3368 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3369 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3370 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3371 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3372 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3373 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3374 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3375 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3383 get_parisc_section_type_name (unsigned int sh_type
)
3387 case SHT_PARISC_EXT
: return "PARISC_EXT";
3388 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3389 case SHT_PARISC_DOC
: return "PARISC_DOC";
3390 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3391 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3392 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3393 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3401 get_ia64_section_type_name (unsigned int sh_type
)
3403 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3404 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3405 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3409 case SHT_IA_64_EXT
: return "IA_64_EXT";
3410 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3411 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3412 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3413 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3414 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3415 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3416 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3417 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3418 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3426 get_x86_64_section_type_name (unsigned int sh_type
)
3430 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3438 get_aarch64_section_type_name (unsigned int sh_type
)
3442 case SHT_AARCH64_ATTRIBUTES
:
3443 return "AARCH64_ATTRIBUTES";
3451 get_arm_section_type_name (unsigned int sh_type
)
3455 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3456 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3457 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3458 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3459 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3467 get_tic6x_section_type_name (unsigned int sh_type
)
3471 case SHT_C6000_UNWIND
:
3472 return "C6000_UNWIND";
3473 case SHT_C6000_PREEMPTMAP
:
3474 return "C6000_PREEMPTMAP";
3475 case SHT_C6000_ATTRIBUTES
:
3476 return "C6000_ATTRIBUTES";
3481 case SHT_TI_HANDLER
:
3482 return "TI_HANDLER";
3483 case SHT_TI_INITINFO
:
3484 return "TI_INITINFO";
3485 case SHT_TI_PHATTRS
:
3486 return "TI_PHATTRS";
3494 get_msp430x_section_type_name (unsigned int sh_type
)
3498 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3499 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3500 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3501 default: return NULL
;
3506 get_section_type_name (unsigned int sh_type
)
3508 static char buff
[32];
3512 case SHT_NULL
: return "NULL";
3513 case SHT_PROGBITS
: return "PROGBITS";
3514 case SHT_SYMTAB
: return "SYMTAB";
3515 case SHT_STRTAB
: return "STRTAB";
3516 case SHT_RELA
: return "RELA";
3517 case SHT_HASH
: return "HASH";
3518 case SHT_DYNAMIC
: return "DYNAMIC";
3519 case SHT_NOTE
: return "NOTE";
3520 case SHT_NOBITS
: return "NOBITS";
3521 case SHT_REL
: return "REL";
3522 case SHT_SHLIB
: return "SHLIB";
3523 case SHT_DYNSYM
: return "DYNSYM";
3524 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3525 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3526 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3527 case SHT_GNU_HASH
: return "GNU_HASH";
3528 case SHT_GROUP
: return "GROUP";
3529 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3530 case SHT_GNU_verdef
: return "VERDEF";
3531 case SHT_GNU_verneed
: return "VERNEED";
3532 case SHT_GNU_versym
: return "VERSYM";
3533 case 0x6ffffff0: return "VERSYM";
3534 case 0x6ffffffc: return "VERDEF";
3535 case 0x7ffffffd: return "AUXILIARY";
3536 case 0x7fffffff: return "FILTER";
3537 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3540 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3542 const char * result
;
3544 switch (elf_header
.e_machine
)
3547 case EM_MIPS_RS3_LE
:
3548 result
= get_mips_section_type_name (sh_type
);
3551 result
= get_parisc_section_type_name (sh_type
);
3554 result
= get_ia64_section_type_name (sh_type
);
3559 result
= get_x86_64_section_type_name (sh_type
);
3562 result
= get_aarch64_section_type_name (sh_type
);
3565 result
= get_arm_section_type_name (sh_type
);
3568 result
= get_tic6x_section_type_name (sh_type
);
3571 result
= get_msp430x_section_type_name (sh_type
);
3581 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3583 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3585 const char * result
;
3587 switch (elf_header
.e_machine
)
3590 result
= get_ia64_section_type_name (sh_type
);
3600 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3602 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3603 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3605 /* This message is probably going to be displayed in a 15
3606 character wide field, so put the hex value first. */
3607 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3613 #define OPTION_DEBUG_DUMP 512
3614 #define OPTION_DYN_SYMS 513
3615 #define OPTION_DWARF_DEPTH 514
3616 #define OPTION_DWARF_START 515
3617 #define OPTION_DWARF_CHECK 516
3619 static struct option options
[] =
3621 {"all", no_argument
, 0, 'a'},
3622 {"file-header", no_argument
, 0, 'h'},
3623 {"program-headers", no_argument
, 0, 'l'},
3624 {"headers", no_argument
, 0, 'e'},
3625 {"histogram", no_argument
, 0, 'I'},
3626 {"segments", no_argument
, 0, 'l'},
3627 {"sections", no_argument
, 0, 'S'},
3628 {"section-headers", no_argument
, 0, 'S'},
3629 {"section-groups", no_argument
, 0, 'g'},
3630 {"section-details", no_argument
, 0, 't'},
3631 {"full-section-name",no_argument
, 0, 'N'},
3632 {"symbols", no_argument
, 0, 's'},
3633 {"syms", no_argument
, 0, 's'},
3634 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3635 {"relocs", no_argument
, 0, 'r'},
3636 {"notes", no_argument
, 0, 'n'},
3637 {"dynamic", no_argument
, 0, 'd'},
3638 {"arch-specific", no_argument
, 0, 'A'},
3639 {"version-info", no_argument
, 0, 'V'},
3640 {"use-dynamic", no_argument
, 0, 'D'},
3641 {"unwind", no_argument
, 0, 'u'},
3642 {"archive-index", no_argument
, 0, 'c'},
3643 {"hex-dump", required_argument
, 0, 'x'},
3644 {"relocated-dump", required_argument
, 0, 'R'},
3645 {"string-dump", required_argument
, 0, 'p'},
3646 #ifdef SUPPORT_DISASSEMBLY
3647 {"instruction-dump", required_argument
, 0, 'i'},
3649 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3651 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3652 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3653 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3655 {"version", no_argument
, 0, 'v'},
3656 {"wide", no_argument
, 0, 'W'},
3657 {"help", no_argument
, 0, 'H'},
3658 {0, no_argument
, 0, 0}
3662 usage (FILE * stream
)
3664 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3665 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3666 fprintf (stream
, _(" Options are:\n\
3667 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3668 -h --file-header Display the ELF file header\n\
3669 -l --program-headers Display the program headers\n\
3670 --segments An alias for --program-headers\n\
3671 -S --section-headers Display the sections' header\n\
3672 --sections An alias for --section-headers\n\
3673 -g --section-groups Display the section groups\n\
3674 -t --section-details Display the section details\n\
3675 -e --headers Equivalent to: -h -l -S\n\
3676 -s --syms Display the symbol table\n\
3677 --symbols An alias for --syms\n\
3678 --dyn-syms Display the dynamic symbol table\n\
3679 -n --notes Display the core notes (if present)\n\
3680 -r --relocs Display the relocations (if present)\n\
3681 -u --unwind Display the unwind info (if present)\n\
3682 -d --dynamic Display the dynamic section (if present)\n\
3683 -V --version-info Display the version sections (if present)\n\
3684 -A --arch-specific Display architecture specific information (if any)\n\
3685 -c --archive-index Display the symbol/file index in an archive\n\
3686 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3687 -x --hex-dump=<number|name>\n\
3688 Dump the contents of section <number|name> as bytes\n\
3689 -p --string-dump=<number|name>\n\
3690 Dump the contents of section <number|name> as strings\n\
3691 -R --relocated-dump=<number|name>\n\
3692 Dump the contents of section <number|name> as relocated bytes\n\
3693 -w[lLiaprmfFsoRt] or\n\
3694 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3695 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3696 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3698 Display the contents of DWARF2 debug sections\n"));
3699 fprintf (stream
, _("\
3700 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3701 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3703 #ifdef SUPPORT_DISASSEMBLY
3704 fprintf (stream
, _("\
3705 -i --instruction-dump=<number|name>\n\
3706 Disassemble the contents of section <number|name>\n"));
3708 fprintf (stream
, _("\
3709 -I --histogram Display histogram of bucket list lengths\n\
3710 -W --wide Allow output width to exceed 80 characters\n\
3711 @<file> Read options from <file>\n\
3712 -H --help Display this information\n\
3713 -v --version Display the version number of readelf\n"));
3715 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3716 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3718 exit (stream
== stdout
? 0 : 1);
3721 /* Record the fact that the user wants the contents of section number
3722 SECTION to be displayed using the method(s) encoded as flags bits
3723 in TYPE. Note, TYPE can be zero if we are creating the array for
3727 request_dump_bynumber (unsigned int section
, dump_type type
)
3729 if (section
>= num_dump_sects
)
3731 dump_type
* new_dump_sects
;
3733 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3734 sizeof (* dump_sects
));
3736 if (new_dump_sects
== NULL
)
3737 error (_("Out of memory allocating dump request table.\n"));
3740 /* Copy current flag settings. */
3741 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3745 dump_sects
= new_dump_sects
;
3746 num_dump_sects
= section
+ 1;
3751 dump_sects
[section
] |= type
;
3756 /* Request a dump by section name. */
3759 request_dump_byname (const char * section
, dump_type type
)
3761 struct dump_list_entry
* new_request
;
3763 new_request
= (struct dump_list_entry
*)
3764 malloc (sizeof (struct dump_list_entry
));
3766 error (_("Out of memory allocating dump request table.\n"));
3768 new_request
->name
= strdup (section
);
3769 if (!new_request
->name
)
3770 error (_("Out of memory allocating dump request table.\n"));
3772 new_request
->type
= type
;
3774 new_request
->next
= dump_sects_byname
;
3775 dump_sects_byname
= new_request
;
3779 request_dump (dump_type type
)
3785 section
= strtoul (optarg
, & cp
, 0);
3787 if (! *cp
&& section
>= 0)
3788 request_dump_bynumber (section
, type
);
3790 request_dump_byname (optarg
, type
);
3795 parse_args (int argc
, char ** argv
)
3802 while ((c
= getopt_long
3803 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3821 do_section_groups
++;
3829 do_section_groups
++;
3834 do_section_details
++;
3878 request_dump (HEX_DUMP
);
3881 request_dump (STRING_DUMP
);
3884 request_dump (RELOC_DUMP
);
3891 dwarf_select_sections_all ();
3896 dwarf_select_sections_by_letters (optarg
);
3899 case OPTION_DEBUG_DUMP
:
3906 dwarf_select_sections_by_names (optarg
);
3909 case OPTION_DWARF_DEPTH
:
3913 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3916 case OPTION_DWARF_START
:
3920 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3923 case OPTION_DWARF_CHECK
:
3926 case OPTION_DYN_SYMS
:
3929 #ifdef SUPPORT_DISASSEMBLY
3931 request_dump (DISASS_DUMP
);
3935 print_version (program_name
);
3944 /* xgettext:c-format */
3945 error (_("Invalid option '-%c'\n"), c
);
3952 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3953 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3954 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3955 && !do_section_groups
&& !do_archive_index
3960 warn (_("Nothing to do.\n"));
3966 get_elf_class (unsigned int elf_class
)
3968 static char buff
[32];
3972 case ELFCLASSNONE
: return _("none");
3973 case ELFCLASS32
: return "ELF32";
3974 case ELFCLASS64
: return "ELF64";
3976 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3982 get_data_encoding (unsigned int encoding
)
3984 static char buff
[32];
3988 case ELFDATANONE
: return _("none");
3989 case ELFDATA2LSB
: return _("2's complement, little endian");
3990 case ELFDATA2MSB
: return _("2's complement, big endian");
3992 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3997 /* Decode the data held in 'elf_header'. */
4000 process_file_header (void)
4002 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4003 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4004 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4005 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4008 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4012 init_dwarf_regnames (elf_header
.e_machine
);
4018 printf (_("ELF Header:\n"));
4019 printf (_(" Magic: "));
4020 for (i
= 0; i
< EI_NIDENT
; i
++)
4021 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4023 printf (_(" Class: %s\n"),
4024 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4025 printf (_(" Data: %s\n"),
4026 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4027 printf (_(" Version: %d %s\n"),
4028 elf_header
.e_ident
[EI_VERSION
],
4029 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4031 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4032 ? _("<unknown: %lx>")
4034 printf (_(" OS/ABI: %s\n"),
4035 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4036 printf (_(" ABI Version: %d\n"),
4037 elf_header
.e_ident
[EI_ABIVERSION
]);
4038 printf (_(" Type: %s\n"),
4039 get_file_type (elf_header
.e_type
));
4040 printf (_(" Machine: %s\n"),
4041 get_machine_name (elf_header
.e_machine
));
4042 printf (_(" Version: 0x%lx\n"),
4043 (unsigned long) elf_header
.e_version
);
4045 printf (_(" Entry point address: "));
4046 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4047 printf (_("\n Start of program headers: "));
4048 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4049 printf (_(" (bytes into file)\n Start of section headers: "));
4050 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4051 printf (_(" (bytes into file)\n"));
4053 printf (_(" Flags: 0x%lx%s\n"),
4054 (unsigned long) elf_header
.e_flags
,
4055 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4056 printf (_(" Size of this header: %ld (bytes)\n"),
4057 (long) elf_header
.e_ehsize
);
4058 printf (_(" Size of program headers: %ld (bytes)\n"),
4059 (long) elf_header
.e_phentsize
);
4060 printf (_(" Number of program headers: %ld"),
4061 (long) elf_header
.e_phnum
);
4062 if (section_headers
!= NULL
4063 && elf_header
.e_phnum
== PN_XNUM
4064 && section_headers
[0].sh_info
!= 0)
4065 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4066 putc ('\n', stdout
);
4067 printf (_(" Size of section headers: %ld (bytes)\n"),
4068 (long) elf_header
.e_shentsize
);
4069 printf (_(" Number of section headers: %ld"),
4070 (long) elf_header
.e_shnum
);
4071 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4072 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4073 putc ('\n', stdout
);
4074 printf (_(" Section header string table index: %ld"),
4075 (long) elf_header
.e_shstrndx
);
4076 if (section_headers
!= NULL
4077 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4078 printf (" (%u)", section_headers
[0].sh_link
);
4079 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4080 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4081 printf (_(" <corrupt: out of range>"));
4082 putc ('\n', stdout
);
4085 if (section_headers
!= NULL
)
4087 if (elf_header
.e_phnum
== PN_XNUM
4088 && section_headers
[0].sh_info
!= 0)
4089 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4090 if (elf_header
.e_shnum
== SHN_UNDEF
)
4091 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4092 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4093 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4094 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4095 elf_header
.e_shstrndx
= SHN_UNDEF
;
4096 free (section_headers
);
4097 section_headers
= NULL
;
4105 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4107 Elf32_External_Phdr
* phdrs
;
4108 Elf32_External_Phdr
* external
;
4109 Elf_Internal_Phdr
* internal
;
4112 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4113 elf_header
.e_phentsize
,
4115 _("program headers"));
4119 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4120 i
< elf_header
.e_phnum
;
4121 i
++, internal
++, external
++)
4123 internal
->p_type
= BYTE_GET (external
->p_type
);
4124 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4125 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4126 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4127 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4128 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4129 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4130 internal
->p_align
= BYTE_GET (external
->p_align
);
4139 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4141 Elf64_External_Phdr
* phdrs
;
4142 Elf64_External_Phdr
* external
;
4143 Elf_Internal_Phdr
* internal
;
4146 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4147 elf_header
.e_phentsize
,
4149 _("program headers"));
4153 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4154 i
< elf_header
.e_phnum
;
4155 i
++, internal
++, external
++)
4157 internal
->p_type
= BYTE_GET (external
->p_type
);
4158 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4159 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4160 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4161 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4162 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4163 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4164 internal
->p_align
= BYTE_GET (external
->p_align
);
4172 /* Returns 1 if the program headers were read into `program_headers'. */
4175 get_program_headers (FILE * file
)
4177 Elf_Internal_Phdr
* phdrs
;
4179 /* Check cache of prior read. */
4180 if (program_headers
!= NULL
)
4183 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4184 sizeof (Elf_Internal_Phdr
));
4188 error (_("Out of memory\n"));
4193 ? get_32bit_program_headers (file
, phdrs
)
4194 : get_64bit_program_headers (file
, phdrs
))
4196 program_headers
= phdrs
;
4204 /* Returns 1 if the program headers were loaded. */
4207 process_program_headers (FILE * file
)
4209 Elf_Internal_Phdr
* segment
;
4212 if (elf_header
.e_phnum
== 0)
4214 /* PR binutils/12467. */
4215 if (elf_header
.e_phoff
!= 0)
4216 warn (_("possibly corrupt ELF header - it has a non-zero program"
4217 " header offset, but no program headers"));
4218 else if (do_segments
)
4219 printf (_("\nThere are no program headers in this file.\n"));
4223 if (do_segments
&& !do_header
)
4225 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4226 printf (_("Entry point "));
4227 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4228 printf (_("\nThere are %d program headers, starting at offset "),
4229 elf_header
.e_phnum
);
4230 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4234 if (! get_program_headers (file
))
4239 if (elf_header
.e_phnum
> 1)
4240 printf (_("\nProgram Headers:\n"));
4242 printf (_("\nProgram Headers:\n"));
4246 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4249 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4253 (_(" Type Offset VirtAddr PhysAddr\n"));
4255 (_(" FileSiz MemSiz Flags Align\n"));
4262 for (i
= 0, segment
= program_headers
;
4263 i
< elf_header
.e_phnum
;
4268 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4272 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4273 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4274 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4275 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4276 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4278 (segment
->p_flags
& PF_R
? 'R' : ' '),
4279 (segment
->p_flags
& PF_W
? 'W' : ' '),
4280 (segment
->p_flags
& PF_X
? 'E' : ' '));
4281 printf ("%#lx", (unsigned long) segment
->p_align
);
4285 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4286 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4289 print_vma (segment
->p_offset
, FULL_HEX
);
4293 print_vma (segment
->p_vaddr
, FULL_HEX
);
4295 print_vma (segment
->p_paddr
, FULL_HEX
);
4298 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4299 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4302 print_vma (segment
->p_filesz
, FULL_HEX
);
4306 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4307 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4310 print_vma (segment
->p_memsz
, FULL_HEX
);
4314 (segment
->p_flags
& PF_R
? 'R' : ' '),
4315 (segment
->p_flags
& PF_W
? 'W' : ' '),
4316 (segment
->p_flags
& PF_X
? 'E' : ' '));
4318 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4319 printf ("%#lx", (unsigned long) segment
->p_align
);
4322 print_vma (segment
->p_align
, PREFIX_HEX
);
4327 print_vma (segment
->p_offset
, FULL_HEX
);
4329 print_vma (segment
->p_vaddr
, FULL_HEX
);
4331 print_vma (segment
->p_paddr
, FULL_HEX
);
4333 print_vma (segment
->p_filesz
, FULL_HEX
);
4335 print_vma (segment
->p_memsz
, FULL_HEX
);
4337 (segment
->p_flags
& PF_R
? 'R' : ' '),
4338 (segment
->p_flags
& PF_W
? 'W' : ' '),
4339 (segment
->p_flags
& PF_X
? 'E' : ' '));
4340 print_vma (segment
->p_align
, HEX
);
4344 switch (segment
->p_type
)
4348 error (_("more than one dynamic segment\n"));
4350 /* By default, assume that the .dynamic section is the first
4351 section in the DYNAMIC segment. */
4352 dynamic_addr
= segment
->p_offset
;
4353 dynamic_size
= segment
->p_filesz
;
4355 /* Try to locate the .dynamic section. If there is
4356 a section header table, we can easily locate it. */
4357 if (section_headers
!= NULL
)
4359 Elf_Internal_Shdr
* sec
;
4361 sec
= find_section (".dynamic");
4362 if (sec
== NULL
|| sec
->sh_size
== 0)
4364 /* A corresponding .dynamic section is expected, but on
4365 IA-64/OpenVMS it is OK for it to be missing. */
4366 if (!is_ia64_vms ())
4367 error (_("no .dynamic section in the dynamic segment\n"));
4371 if (sec
->sh_type
== SHT_NOBITS
)
4377 dynamic_addr
= sec
->sh_offset
;
4378 dynamic_size
= sec
->sh_size
;
4380 if (dynamic_addr
< segment
->p_offset
4381 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4382 warn (_("the .dynamic section is not contained"
4383 " within the dynamic segment\n"));
4384 else if (dynamic_addr
> segment
->p_offset
)
4385 warn (_("the .dynamic section is not the first section"
4386 " in the dynamic segment.\n"));
4391 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4393 error (_("Unable to find program interpreter name\n"));
4397 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4399 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4400 error (_("Internal error: failed to create format string to display program interpreter\n"));
4402 program_interpreter
[0] = 0;
4403 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4404 error (_("Unable to read program interpreter name\n"));
4407 printf (_("\n [Requesting program interpreter: %s]"),
4408 program_interpreter
);
4414 putc ('\n', stdout
);
4417 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4419 printf (_("\n Section to Segment mapping:\n"));
4420 printf (_(" Segment Sections...\n"));
4422 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4425 Elf_Internal_Shdr
* section
;
4427 segment
= program_headers
+ i
;
4428 section
= section_headers
+ 1;
4430 printf (" %2.2d ", i
);
4432 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4434 if (!ELF_TBSS_SPECIAL (section
, segment
)
4435 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4436 printf ("%s ", SECTION_NAME (section
));
4447 /* Find the file offset corresponding to VMA by using the program headers. */
4450 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4452 Elf_Internal_Phdr
* seg
;
4454 if (! get_program_headers (file
))
4456 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4460 for (seg
= program_headers
;
4461 seg
< program_headers
+ elf_header
.e_phnum
;
4464 if (seg
->p_type
!= PT_LOAD
)
4467 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4468 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4469 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4472 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4473 (unsigned long) vma
);
4479 get_32bit_section_headers (FILE * file
, unsigned int num
)
4481 Elf32_External_Shdr
* shdrs
;
4482 Elf_Internal_Shdr
* internal
;
4485 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4486 elf_header
.e_shentsize
, num
,
4487 _("section headers"));
4491 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4492 sizeof (Elf_Internal_Shdr
));
4494 if (section_headers
== NULL
)
4496 error (_("Out of memory\n"));
4500 for (i
= 0, internal
= section_headers
;
4504 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4505 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4506 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4507 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4508 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4509 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4510 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4511 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4512 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4513 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4522 get_64bit_section_headers (FILE * file
, unsigned int num
)
4524 Elf64_External_Shdr
* shdrs
;
4525 Elf_Internal_Shdr
* internal
;
4528 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4529 elf_header
.e_shentsize
, num
,
4530 _("section headers"));
4534 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4535 sizeof (Elf_Internal_Shdr
));
4537 if (section_headers
== NULL
)
4539 error (_("Out of memory\n"));
4543 for (i
= 0, internal
= section_headers
;
4547 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4548 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4549 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4550 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4551 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4552 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4553 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4554 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4555 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4556 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4564 static Elf_Internal_Sym
*
4565 get_32bit_elf_symbols (FILE * file
,
4566 Elf_Internal_Shdr
* section
,
4567 unsigned long * num_syms_return
)
4569 unsigned long number
= 0;
4570 Elf32_External_Sym
* esyms
= NULL
;
4571 Elf_External_Sym_Shndx
* shndx
= NULL
;
4572 Elf_Internal_Sym
* isyms
= NULL
;
4573 Elf_Internal_Sym
* psym
;
4576 /* Run some sanity checks first. */
4577 if (section
->sh_entsize
== 0)
4579 error (_("sh_entsize is zero\n"));
4583 number
= section
->sh_size
/ section
->sh_entsize
;
4585 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4587 error (_("Invalid sh_entsize\n"));
4591 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4592 section
->sh_size
, _("symbols"));
4597 if (symtab_shndx_hdr
!= NULL
4598 && (symtab_shndx_hdr
->sh_link
4599 == (unsigned long) (section
- section_headers
)))
4601 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4602 symtab_shndx_hdr
->sh_offset
,
4603 1, symtab_shndx_hdr
->sh_size
,
4604 _("symbol table section indicies"));
4609 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4613 error (_("Out of memory\n"));
4617 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4619 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4620 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4621 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4622 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4623 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4625 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4626 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4627 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4628 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4629 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4638 if (num_syms_return
!= NULL
)
4639 * num_syms_return
= isyms
== NULL
? 0 : number
;
4644 static Elf_Internal_Sym
*
4645 get_64bit_elf_symbols (FILE * file
,
4646 Elf_Internal_Shdr
* section
,
4647 unsigned long * num_syms_return
)
4649 unsigned long number
= 0;
4650 Elf64_External_Sym
* esyms
= NULL
;
4651 Elf_External_Sym_Shndx
* shndx
= NULL
;
4652 Elf_Internal_Sym
* isyms
= NULL
;
4653 Elf_Internal_Sym
* psym
;
4656 /* Run some sanity checks first. */
4657 if (section
->sh_entsize
== 0)
4659 error (_("sh_entsize is zero\n"));
4663 number
= section
->sh_size
/ section
->sh_entsize
;
4665 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4667 error (_("Invalid sh_entsize\n"));
4671 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4672 section
->sh_size
, _("symbols"));
4676 if (symtab_shndx_hdr
!= NULL
4677 && (symtab_shndx_hdr
->sh_link
4678 == (unsigned long) (section
- section_headers
)))
4680 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4681 symtab_shndx_hdr
->sh_offset
,
4682 1, symtab_shndx_hdr
->sh_size
,
4683 _("symbol table section indicies"));
4688 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4692 error (_("Out of memory\n"));
4696 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4698 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4699 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4700 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4701 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4703 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4705 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4706 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4707 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4709 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4710 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4719 if (num_syms_return
!= NULL
)
4720 * num_syms_return
= isyms
== NULL
? 0 : number
;
4726 get_elf_section_flags (bfd_vma sh_flags
)
4728 static char buff
[1024];
4730 int field_size
= is_32bit_elf
? 8 : 16;
4732 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4733 bfd_vma os_flags
= 0;
4734 bfd_vma proc_flags
= 0;
4735 bfd_vma unknown_flags
= 0;
4743 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4744 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4745 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4746 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4747 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4748 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4749 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4750 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4751 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4752 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4753 /* IA-64 specific. */
4754 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4755 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4756 /* IA-64 OpenVMS specific. */
4757 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4758 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4759 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4760 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4761 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4762 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4764 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4765 /* SPARC specific. */
4766 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4769 if (do_section_details
)
4771 sprintf (buff
, "[%*.*lx]: ",
4772 field_size
, field_size
, (unsigned long) sh_flags
);
4773 p
+= field_size
+ 4;
4780 flag
= sh_flags
& - sh_flags
;
4783 if (do_section_details
)
4787 case SHF_WRITE
: sindex
= 0; break;
4788 case SHF_ALLOC
: sindex
= 1; break;
4789 case SHF_EXECINSTR
: sindex
= 2; break;
4790 case SHF_MERGE
: sindex
= 3; break;
4791 case SHF_STRINGS
: sindex
= 4; break;
4792 case SHF_INFO_LINK
: sindex
= 5; break;
4793 case SHF_LINK_ORDER
: sindex
= 6; break;
4794 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4795 case SHF_GROUP
: sindex
= 8; break;
4796 case SHF_TLS
: sindex
= 9; break;
4797 case SHF_EXCLUDE
: sindex
= 18; break;
4801 switch (elf_header
.e_machine
)
4804 if (flag
== SHF_IA_64_SHORT
)
4806 else if (flag
== SHF_IA_64_NORECOV
)
4809 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4812 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4813 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4814 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4815 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4816 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4817 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4828 case EM_OLD_SPARCV9
:
4829 case EM_SPARC32PLUS
:
4832 if (flag
== SHF_ORDERED
)
4842 if (p
!= buff
+ field_size
+ 4)
4844 if (size
< (10 + 2))
4851 size
-= flags
[sindex
].len
;
4852 p
= stpcpy (p
, flags
[sindex
].str
);
4854 else if (flag
& SHF_MASKOS
)
4856 else if (flag
& SHF_MASKPROC
)
4859 unknown_flags
|= flag
;
4865 case SHF_WRITE
: *p
= 'W'; break;
4866 case SHF_ALLOC
: *p
= 'A'; break;
4867 case SHF_EXECINSTR
: *p
= 'X'; break;
4868 case SHF_MERGE
: *p
= 'M'; break;
4869 case SHF_STRINGS
: *p
= 'S'; break;
4870 case SHF_INFO_LINK
: *p
= 'I'; break;
4871 case SHF_LINK_ORDER
: *p
= 'L'; break;
4872 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4873 case SHF_GROUP
: *p
= 'G'; break;
4874 case SHF_TLS
: *p
= 'T'; break;
4875 case SHF_EXCLUDE
: *p
= 'E'; break;
4878 if ((elf_header
.e_machine
== EM_X86_64
4879 || elf_header
.e_machine
== EM_L1OM
4880 || elf_header
.e_machine
== EM_K1OM
)
4881 && flag
== SHF_X86_64_LARGE
)
4883 else if (flag
& SHF_MASKOS
)
4886 sh_flags
&= ~ SHF_MASKOS
;
4888 else if (flag
& SHF_MASKPROC
)
4891 sh_flags
&= ~ SHF_MASKPROC
;
4901 if (do_section_details
)
4905 size
-= 5 + field_size
;
4906 if (p
!= buff
+ field_size
+ 4)
4914 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4915 (unsigned long) os_flags
);
4916 p
+= 5 + field_size
;
4920 size
-= 7 + field_size
;
4921 if (p
!= buff
+ field_size
+ 4)
4929 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4930 (unsigned long) proc_flags
);
4931 p
+= 7 + field_size
;
4935 size
-= 10 + field_size
;
4936 if (p
!= buff
+ field_size
+ 4)
4944 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4945 (unsigned long) unknown_flags
);
4946 p
+= 10 + field_size
;
4955 process_section_headers (FILE * file
)
4957 Elf_Internal_Shdr
* section
;
4960 section_headers
= NULL
;
4962 if (elf_header
.e_shnum
== 0)
4964 /* PR binutils/12467. */
4965 if (elf_header
.e_shoff
!= 0)
4966 warn (_("possibly corrupt ELF file header - it has a non-zero"
4967 " section header offset, but no section headers\n"));
4968 else if (do_sections
)
4969 printf (_("\nThere are no sections in this file.\n"));
4974 if (do_sections
&& !do_header
)
4975 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4976 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4980 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4983 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4986 /* Read in the string table, so that we have names to display. */
4987 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4988 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4990 section
= section_headers
+ elf_header
.e_shstrndx
;
4992 if (section
->sh_size
!= 0)
4994 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4995 1, section
->sh_size
,
4998 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5002 /* Scan the sections for the dynamic symbol table
5003 and dynamic string table and debug sections. */
5004 dynamic_symbols
= NULL
;
5005 dynamic_strings
= NULL
;
5006 dynamic_syminfo
= NULL
;
5007 symtab_shndx_hdr
= NULL
;
5009 eh_addr_size
= is_32bit_elf
? 4 : 8;
5010 switch (elf_header
.e_machine
)
5013 case EM_MIPS_RS3_LE
:
5014 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5015 FDE addresses. However, the ABI also has a semi-official ILP32
5016 variant for which the normal FDE address size rules apply.
5018 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5019 section, where XX is the size of longs in bits. Unfortunately,
5020 earlier compilers provided no way of distinguishing ILP32 objects
5021 from LP64 objects, so if there's any doubt, we should assume that
5022 the official LP64 form is being used. */
5023 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5024 && find_section (".gcc_compiled_long32") == NULL
)
5030 switch (elf_header
.e_flags
& EF_H8_MACH
)
5032 case E_H8_MACH_H8300
:
5033 case E_H8_MACH_H8300HN
:
5034 case E_H8_MACH_H8300SN
:
5035 case E_H8_MACH_H8300SXN
:
5038 case E_H8_MACH_H8300H
:
5039 case E_H8_MACH_H8300S
:
5040 case E_H8_MACH_H8300SX
:
5048 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5050 case EF_M32C_CPU_M16C
:
5057 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5060 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5061 if (section->sh_entsize != expected_entsize) \
5064 sprintf_vma (buf, section->sh_entsize); \
5065 /* Note: coded this way so that there is a single string for \
5067 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5068 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5069 (unsigned) expected_entsize); \
5070 section->sh_entsize = expected_entsize; \
5075 #define CHECK_ENTSIZE(section, i, type) \
5076 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5077 sizeof (Elf64_External_##type))
5079 for (i
= 0, section
= section_headers
;
5080 i
< elf_header
.e_shnum
;
5083 char * name
= SECTION_NAME (section
);
5085 if (section
->sh_type
== SHT_DYNSYM
)
5087 if (dynamic_symbols
!= NULL
)
5089 error (_("File contains multiple dynamic symbol tables\n"));
5093 CHECK_ENTSIZE (section
, i
, Sym
);
5094 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5096 else if (section
->sh_type
== SHT_STRTAB
5097 && streq (name
, ".dynstr"))
5099 if (dynamic_strings
!= NULL
)
5101 error (_("File contains multiple dynamic string tables\n"));
5105 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5106 1, section
->sh_size
,
5107 _("dynamic strings"));
5108 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5110 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5112 if (symtab_shndx_hdr
!= NULL
)
5114 error (_("File contains multiple symtab shndx tables\n"));
5117 symtab_shndx_hdr
= section
;
5119 else if (section
->sh_type
== SHT_SYMTAB
)
5120 CHECK_ENTSIZE (section
, i
, Sym
);
5121 else if (section
->sh_type
== SHT_GROUP
)
5122 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5123 else if (section
->sh_type
== SHT_REL
)
5124 CHECK_ENTSIZE (section
, i
, Rel
);
5125 else if (section
->sh_type
== SHT_RELA
)
5126 CHECK_ENTSIZE (section
, i
, Rela
);
5127 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5128 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5129 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5130 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5131 || do_debug_addr
|| do_debug_cu_index
)
5132 && (const_strneq (name
, ".debug_")
5133 || const_strneq (name
, ".zdebug_")))
5136 name
+= sizeof (".zdebug_") - 1;
5138 name
+= sizeof (".debug_") - 1;
5141 || (do_debug_info
&& const_strneq (name
, "info"))
5142 || (do_debug_info
&& const_strneq (name
, "types"))
5143 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5144 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5145 || (do_debug_lines
&& const_strneq (name
, "line."))
5146 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5147 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5148 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5149 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5150 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5151 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5152 || (do_debug_frames
&& const_strneq (name
, "frame"))
5153 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5154 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5155 || (do_debug_str
&& const_strneq (name
, "str"))
5156 || (do_debug_loc
&& const_strneq (name
, "loc"))
5157 || (do_debug_addr
&& const_strneq (name
, "addr"))
5158 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5159 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5161 request_dump_bynumber (i
, DEBUG_DUMP
);
5163 /* Linkonce section to be combined with .debug_info at link time. */
5164 else if ((do_debugging
|| do_debug_info
)
5165 && const_strneq (name
, ".gnu.linkonce.wi."))
5166 request_dump_bynumber (i
, DEBUG_DUMP
);
5167 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5168 request_dump_bynumber (i
, DEBUG_DUMP
);
5169 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5170 request_dump_bynumber (i
, DEBUG_DUMP
);
5171 /* Trace sections for Itanium VMS. */
5172 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5173 || do_trace_aranges
)
5174 && const_strneq (name
, ".trace_"))
5176 name
+= sizeof (".trace_") - 1;
5179 || (do_trace_info
&& streq (name
, "info"))
5180 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5181 || (do_trace_aranges
&& streq (name
, "aranges"))
5183 request_dump_bynumber (i
, DEBUG_DUMP
);
5191 if (elf_header
.e_shnum
> 1)
5192 printf (_("\nSection Headers:\n"));
5194 printf (_("\nSection Header:\n"));
5198 if (do_section_details
)
5200 printf (_(" [Nr] Name\n"));
5201 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5205 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5209 if (do_section_details
)
5211 printf (_(" [Nr] Name\n"));
5212 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5216 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5220 if (do_section_details
)
5222 printf (_(" [Nr] Name\n"));
5223 printf (_(" Type Address Offset Link\n"));
5224 printf (_(" Size EntSize Info Align\n"));
5228 printf (_(" [Nr] Name Type Address Offset\n"));
5229 printf (_(" Size EntSize Flags Link Info Align\n"));
5233 if (do_section_details
)
5234 printf (_(" Flags\n"));
5236 for (i
= 0, section
= section_headers
;
5237 i
< elf_header
.e_shnum
;
5240 printf (" [%2u] ", i
);
5241 if (do_section_details
)
5243 print_symbol (INT_MAX
, SECTION_NAME (section
));
5248 print_symbol (-17, SECTION_NAME (section
));
5251 printf (do_wide
? " %-15s " : " %-15.15s ",
5252 get_section_type_name (section
->sh_type
));
5256 const char * link_too_big
= NULL
;
5258 print_vma (section
->sh_addr
, LONG_HEX
);
5260 printf ( " %6.6lx %6.6lx %2.2lx",
5261 (unsigned long) section
->sh_offset
,
5262 (unsigned long) section
->sh_size
,
5263 (unsigned long) section
->sh_entsize
);
5265 if (do_section_details
)
5266 fputs (" ", stdout
);
5268 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5270 if (section
->sh_link
>= elf_header
.e_shnum
)
5273 /* The sh_link value is out of range. Normally this indicates
5274 an error but it can have special values in Solaris binaries. */
5275 switch (elf_header
.e_machine
)
5282 case EM_OLD_SPARCV9
:
5283 case EM_SPARC32PLUS
:
5286 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5287 link_too_big
= "BEFORE";
5288 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5289 link_too_big
= "AFTER";
5296 if (do_section_details
)
5298 if (link_too_big
!= NULL
&& * link_too_big
)
5299 printf ("<%s> ", link_too_big
);
5301 printf ("%2u ", section
->sh_link
);
5302 printf ("%3u %2lu\n", section
->sh_info
,
5303 (unsigned long) section
->sh_addralign
);
5306 printf ("%2u %3u %2lu\n",
5309 (unsigned long) section
->sh_addralign
);
5311 if (link_too_big
&& ! * link_too_big
)
5312 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5313 i
, section
->sh_link
);
5317 print_vma (section
->sh_addr
, LONG_HEX
);
5319 if ((long) section
->sh_offset
== section
->sh_offset
)
5320 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5324 print_vma (section
->sh_offset
, LONG_HEX
);
5327 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5328 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5332 print_vma (section
->sh_size
, LONG_HEX
);
5335 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5336 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5340 print_vma (section
->sh_entsize
, LONG_HEX
);
5343 if (do_section_details
)
5344 fputs (" ", stdout
);
5346 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5348 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5350 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5351 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5354 print_vma (section
->sh_addralign
, DEC
);
5358 else if (do_section_details
)
5360 printf (" %-15.15s ",
5361 get_section_type_name (section
->sh_type
));
5362 print_vma (section
->sh_addr
, LONG_HEX
);
5363 if ((long) section
->sh_offset
== section
->sh_offset
)
5364 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5368 print_vma (section
->sh_offset
, LONG_HEX
);
5370 printf (" %u\n ", section
->sh_link
);
5371 print_vma (section
->sh_size
, LONG_HEX
);
5373 print_vma (section
->sh_entsize
, LONG_HEX
);
5375 printf (" %-16u %lu\n",
5377 (unsigned long) section
->sh_addralign
);
5382 print_vma (section
->sh_addr
, LONG_HEX
);
5383 if ((long) section
->sh_offset
== section
->sh_offset
)
5384 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5388 print_vma (section
->sh_offset
, LONG_HEX
);
5391 print_vma (section
->sh_size
, LONG_HEX
);
5393 print_vma (section
->sh_entsize
, LONG_HEX
);
5395 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5397 printf (" %2u %3u %lu\n",
5400 (unsigned long) section
->sh_addralign
);
5403 if (do_section_details
)
5404 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5407 if (!do_section_details
)
5409 if (elf_header
.e_machine
== EM_X86_64
5410 || elf_header
.e_machine
== EM_L1OM
5411 || elf_header
.e_machine
== EM_K1OM
)
5412 printf (_("Key to Flags:\n\
5413 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5414 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5415 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5417 printf (_("Key to Flags:\n\
5418 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5419 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5420 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5427 get_group_flags (unsigned int flags
)
5429 static char buff
[32];
5439 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5446 process_section_groups (FILE * file
)
5448 Elf_Internal_Shdr
* section
;
5450 struct group
* group
;
5451 Elf_Internal_Shdr
* symtab_sec
;
5452 Elf_Internal_Shdr
* strtab_sec
;
5453 Elf_Internal_Sym
* symtab
;
5454 unsigned long num_syms
;
5458 /* Don't process section groups unless needed. */
5459 if (!do_unwind
&& !do_section_groups
)
5462 if (elf_header
.e_shnum
== 0)
5464 if (do_section_groups
)
5465 printf (_("\nThere are no sections to group in this file.\n"));
5470 if (section_headers
== NULL
)
5472 error (_("Section headers are not available!\n"));
5473 /* PR 13622: This can happen with a corrupt ELF header. */
5477 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5478 sizeof (struct group
*));
5480 if (section_headers_groups
== NULL
)
5482 error (_("Out of memory\n"));
5486 /* Scan the sections for the group section. */
5488 for (i
= 0, section
= section_headers
;
5489 i
< elf_header
.e_shnum
;
5491 if (section
->sh_type
== SHT_GROUP
)
5494 if (group_count
== 0)
5496 if (do_section_groups
)
5497 printf (_("\nThere are no section groups in this file.\n"));
5502 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5504 if (section_groups
== NULL
)
5506 error (_("Out of memory\n"));
5516 for (i
= 0, section
= section_headers
, group
= section_groups
;
5517 i
< elf_header
.e_shnum
;
5520 if (section
->sh_type
== SHT_GROUP
)
5522 char * name
= SECTION_NAME (section
);
5524 unsigned char * start
;
5525 unsigned char * indices
;
5526 unsigned int entry
, j
, size
;
5527 Elf_Internal_Shdr
* sec
;
5528 Elf_Internal_Sym
* sym
;
5530 /* Get the symbol table. */
5531 if (section
->sh_link
>= elf_header
.e_shnum
5532 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5535 error (_("Bad sh_link in group section `%s'\n"), name
);
5539 if (symtab_sec
!= sec
)
5544 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5549 error (_("Corrupt header in group section `%s'\n"), name
);
5553 if (section
->sh_info
>= num_syms
)
5555 error (_("Bad sh_info in group section `%s'\n"), name
);
5559 sym
= symtab
+ section
->sh_info
;
5561 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5563 if (sym
->st_shndx
== 0
5564 || sym
->st_shndx
>= elf_header
.e_shnum
)
5566 error (_("Bad sh_info in group section `%s'\n"), name
);
5570 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5579 /* Get the string table. */
5580 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5589 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5594 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5595 1, strtab_sec
->sh_size
,
5597 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5599 group_name
= sym
->st_name
< strtab_size
5600 ? strtab
+ sym
->st_name
: _("<corrupt>");
5603 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5604 1, section
->sh_size
,
5610 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5611 entry
= byte_get (indices
, 4);
5614 if (do_section_groups
)
5616 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5617 get_group_flags (entry
), i
, name
, group_name
, size
);
5619 printf (_(" [Index] Name\n"));
5622 group
->group_index
= i
;
5624 for (j
= 0; j
< size
; j
++)
5626 struct group_list
* g
;
5628 entry
= byte_get (indices
, 4);
5631 if (entry
>= elf_header
.e_shnum
)
5633 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5634 entry
, i
, elf_header
.e_shnum
- 1);
5638 if (section_headers_groups
[entry
] != NULL
)
5642 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5644 section_headers_groups
[entry
]->group_index
);
5649 /* Intel C/C++ compiler may put section 0 in a
5650 section group. We just warn it the first time
5651 and ignore it afterwards. */
5652 static int warned
= 0;
5655 error (_("section 0 in group section [%5u]\n"),
5656 section_headers_groups
[entry
]->group_index
);
5662 section_headers_groups
[entry
] = group
;
5664 if (do_section_groups
)
5666 sec
= section_headers
+ entry
;
5667 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5670 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5671 g
->section_index
= entry
;
5672 g
->next
= group
->root
;
5690 /* Data used to display dynamic fixups. */
5692 struct ia64_vms_dynfixup
5694 bfd_vma needed_ident
; /* Library ident number. */
5695 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5696 bfd_vma fixup_needed
; /* Index of the library. */
5697 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5698 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5701 /* Data used to display dynamic relocations. */
5703 struct ia64_vms_dynimgrela
5705 bfd_vma img_rela_cnt
; /* Number of relocations. */
5706 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5709 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5713 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5714 const char *strtab
, unsigned int strtab_sz
)
5716 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5718 const char *lib_name
;
5720 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5721 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5722 _("dynamic section image fixups"));
5726 if (fixup
->needed
< strtab_sz
)
5727 lib_name
= strtab
+ fixup
->needed
;
5730 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5731 (unsigned long) fixup
->needed
);
5734 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5735 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5737 (_("Seg Offset Type SymVec DataType\n"));
5739 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5744 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5745 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5746 type
= BYTE_GET (imfs
[i
].type
);
5747 rtype
= elf_ia64_reloc_type (type
);
5749 printf (" 0x%08x ", type
);
5751 printf (" %-32s ", rtype
);
5752 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5753 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5759 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5762 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5764 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5767 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5768 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5769 _("dynamic section image relocations"));
5773 printf (_("\nImage relocs\n"));
5775 (_("Seg Offset Type Addend Seg Sym Off\n"));
5777 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5782 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5783 printf ("%08" BFD_VMA_FMT
"x ",
5784 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5785 type
= BYTE_GET (imrs
[i
].type
);
5786 rtype
= elf_ia64_reloc_type (type
);
5788 printf ("0x%08x ", type
);
5790 printf ("%-31s ", rtype
);
5791 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5792 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5793 printf ("%08" BFD_VMA_FMT
"x\n",
5794 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5800 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5803 process_ia64_vms_dynamic_relocs (FILE *file
)
5805 struct ia64_vms_dynfixup fixup
;
5806 struct ia64_vms_dynimgrela imgrela
;
5807 Elf_Internal_Dyn
*entry
;
5809 bfd_vma strtab_off
= 0;
5810 bfd_vma strtab_sz
= 0;
5811 char *strtab
= NULL
;
5813 memset (&fixup
, 0, sizeof (fixup
));
5814 memset (&imgrela
, 0, sizeof (imgrela
));
5816 /* Note: the order of the entries is specified by the OpenVMS specs. */
5817 for (entry
= dynamic_section
;
5818 entry
< dynamic_section
+ dynamic_nent
;
5821 switch (entry
->d_tag
)
5823 case DT_IA_64_VMS_STRTAB_OFFSET
:
5824 strtab_off
= entry
->d_un
.d_val
;
5827 strtab_sz
= entry
->d_un
.d_val
;
5829 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5830 1, strtab_sz
, _("dynamic string section"));
5833 case DT_IA_64_VMS_NEEDED_IDENT
:
5834 fixup
.needed_ident
= entry
->d_un
.d_val
;
5837 fixup
.needed
= entry
->d_un
.d_val
;
5839 case DT_IA_64_VMS_FIXUP_NEEDED
:
5840 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5842 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5843 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5845 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5846 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5848 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5851 case DT_IA_64_VMS_IMG_RELA_CNT
:
5852 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5854 case DT_IA_64_VMS_IMG_RELA_OFF
:
5855 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5857 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5877 } dynamic_relocations
[] =
5879 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5880 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5881 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5884 /* Process the reloc section. */
5887 process_relocs (FILE * file
)
5889 unsigned long rel_size
;
5890 unsigned long rel_offset
;
5896 if (do_using_dynamic
)
5900 int has_dynamic_reloc
;
5903 has_dynamic_reloc
= 0;
5905 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5907 is_rela
= dynamic_relocations
[i
].rela
;
5908 name
= dynamic_relocations
[i
].name
;
5909 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5910 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5912 has_dynamic_reloc
|= rel_size
;
5914 if (is_rela
== UNKNOWN
)
5916 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5917 switch (dynamic_info
[DT_PLTREL
])
5931 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5932 name
, rel_offset
, rel_size
);
5934 dump_relocations (file
,
5935 offset_from_vma (file
, rel_offset
, rel_size
),
5937 dynamic_symbols
, num_dynamic_syms
,
5938 dynamic_strings
, dynamic_strings_length
, is_rela
);
5943 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5945 if (! has_dynamic_reloc
)
5946 printf (_("\nThere are no dynamic relocations in this file.\n"));
5950 Elf_Internal_Shdr
* section
;
5954 for (i
= 0, section
= section_headers
;
5955 i
< elf_header
.e_shnum
;
5958 if ( section
->sh_type
!= SHT_RELA
5959 && section
->sh_type
!= SHT_REL
)
5962 rel_offset
= section
->sh_offset
;
5963 rel_size
= section
->sh_size
;
5967 Elf_Internal_Shdr
* strsec
;
5970 printf (_("\nRelocation section "));
5972 if (string_table
== NULL
)
5973 printf ("%d", section
->sh_name
);
5975 printf ("'%s'", SECTION_NAME (section
));
5977 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5978 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5980 is_rela
= section
->sh_type
== SHT_RELA
;
5982 if (section
->sh_link
!= 0
5983 && section
->sh_link
< elf_header
.e_shnum
)
5985 Elf_Internal_Shdr
* symsec
;
5986 Elf_Internal_Sym
* symtab
;
5987 unsigned long nsyms
;
5988 unsigned long strtablen
= 0;
5989 char * strtab
= NULL
;
5991 symsec
= section_headers
+ section
->sh_link
;
5992 if (symsec
->sh_type
!= SHT_SYMTAB
5993 && symsec
->sh_type
!= SHT_DYNSYM
)
5996 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6001 if (symsec
->sh_link
!= 0
6002 && symsec
->sh_link
< elf_header
.e_shnum
)
6004 strsec
= section_headers
+ symsec
->sh_link
;
6006 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6009 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6012 dump_relocations (file
, rel_offset
, rel_size
,
6013 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6019 dump_relocations (file
, rel_offset
, rel_size
,
6020 NULL
, 0, NULL
, 0, is_rela
);
6027 printf (_("\nThere are no relocations in this file.\n"));
6033 /* Process the unwind section. */
6035 #include "unwind-ia64.h"
6037 /* An absolute address consists of a section and an offset. If the
6038 section is NULL, the offset itself is the address, otherwise, the
6039 address equals to LOAD_ADDRESS(section) + offset. */
6043 unsigned short section
;
6047 #define ABSADDR(a) \
6049 ? section_headers [(a).section].sh_addr + (a).offset \
6052 struct ia64_unw_table_entry
6054 struct absaddr start
;
6056 struct absaddr info
;
6059 struct ia64_unw_aux_info
6062 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6063 unsigned long table_len
; /* Length of unwind table. */
6064 unsigned char * info
; /* Unwind info. */
6065 unsigned long info_size
; /* Size of unwind info. */
6066 bfd_vma info_addr
; /* starting address of unwind info. */
6067 bfd_vma seg_base
; /* Starting address of segment. */
6068 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6069 unsigned long nsyms
; /* Number of symbols. */
6070 char * strtab
; /* The string table. */
6071 unsigned long strtab_size
; /* Size of string table. */
6075 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6076 unsigned long nsyms
,
6077 const char * strtab
,
6078 unsigned long strtab_size
,
6079 struct absaddr addr
,
6080 const char ** symname
,
6083 bfd_vma dist
= 0x100000;
6084 Elf_Internal_Sym
* sym
;
6085 Elf_Internal_Sym
* best
= NULL
;
6088 REMOVE_ARCH_BITS (addr
.offset
);
6090 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6092 bfd_vma value
= sym
->st_value
;
6094 REMOVE_ARCH_BITS (value
);
6096 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6097 && sym
->st_name
!= 0
6098 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6099 && addr
.offset
>= value
6100 && addr
.offset
- value
< dist
)
6103 dist
= addr
.offset
- value
;
6111 *symname
= (best
->st_name
>= strtab_size
6112 ? _("<corrupt>") : strtab
+ best
->st_name
);
6118 *offset
= addr
.offset
;
6122 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6124 struct ia64_unw_table_entry
* tp
;
6127 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6131 const unsigned char * dp
;
6132 const unsigned char * head
;
6133 const char * procname
;
6135 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6136 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6138 fputs ("\n<", stdout
);
6142 fputs (procname
, stdout
);
6145 printf ("+%lx", (unsigned long) offset
);
6148 fputs (">: [", stdout
);
6149 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6150 fputc ('-', stdout
);
6151 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6152 printf ("], info at +0x%lx\n",
6153 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6155 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6156 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6158 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6159 (unsigned) UNW_VER (stamp
),
6160 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6161 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6162 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6163 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6165 if (UNW_VER (stamp
) != 1)
6167 printf (_("\tUnknown version.\n"));
6172 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6173 dp
= unw_decode (dp
, in_body
, & in_body
);
6178 slurp_ia64_unwind_table (FILE * file
,
6179 struct ia64_unw_aux_info
* aux
,
6180 Elf_Internal_Shdr
* sec
)
6182 unsigned long size
, nrelas
, i
;
6183 Elf_Internal_Phdr
* seg
;
6184 struct ia64_unw_table_entry
* tep
;
6185 Elf_Internal_Shdr
* relsec
;
6186 Elf_Internal_Rela
* rela
;
6187 Elf_Internal_Rela
* rp
;
6188 unsigned char * table
;
6190 Elf_Internal_Sym
* sym
;
6191 const char * relname
;
6193 /* First, find the starting address of the segment that includes
6196 if (elf_header
.e_phnum
)
6198 if (! get_program_headers (file
))
6201 for (seg
= program_headers
;
6202 seg
< program_headers
+ elf_header
.e_phnum
;
6205 if (seg
->p_type
!= PT_LOAD
)
6208 if (sec
->sh_addr
>= seg
->p_vaddr
6209 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6211 aux
->seg_base
= seg
->p_vaddr
;
6217 /* Second, build the unwind table from the contents of the unwind section: */
6218 size
= sec
->sh_size
;
6219 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6224 aux
->table
= (struct ia64_unw_table_entry
*)
6225 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6227 for (tp
= table
; tp
< table
+ size
; ++tep
)
6229 tep
->start
.section
= SHN_UNDEF
;
6230 tep
->end
.section
= SHN_UNDEF
;
6231 tep
->info
.section
= SHN_UNDEF
;
6232 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6233 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6234 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6235 tep
->start
.offset
+= aux
->seg_base
;
6236 tep
->end
.offset
+= aux
->seg_base
;
6237 tep
->info
.offset
+= aux
->seg_base
;
6241 /* Third, apply any relocations to the unwind table: */
6242 for (relsec
= section_headers
;
6243 relsec
< section_headers
+ elf_header
.e_shnum
;
6246 if (relsec
->sh_type
!= SHT_RELA
6247 || relsec
->sh_info
>= elf_header
.e_shnum
6248 || section_headers
+ relsec
->sh_info
!= sec
)
6251 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6255 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6257 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6258 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6260 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6262 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6266 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6268 switch (rp
->r_offset
/eh_addr_size
% 3)
6271 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6272 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6275 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6276 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6279 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6280 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6290 aux
->table_len
= size
/ (3 * eh_addr_size
);
6295 ia64_process_unwind (FILE * file
)
6297 Elf_Internal_Shdr
* sec
;
6298 Elf_Internal_Shdr
* unwsec
= NULL
;
6299 Elf_Internal_Shdr
* strsec
;
6300 unsigned long i
, unwcount
= 0, unwstart
= 0;
6301 struct ia64_unw_aux_info aux
;
6303 memset (& aux
, 0, sizeof (aux
));
6305 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6307 if (sec
->sh_type
== SHT_SYMTAB
6308 && sec
->sh_link
< elf_header
.e_shnum
)
6310 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6312 strsec
= section_headers
+ sec
->sh_link
;
6313 assert (aux
.strtab
== NULL
);
6314 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6317 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6319 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6324 printf (_("\nThere are no unwind sections in this file.\n"));
6326 while (unwcount
-- > 0)
6331 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6332 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6333 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6340 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6342 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6344 /* We need to find which section group it is in. */
6345 struct group_list
* g
= section_headers_groups
[i
]->root
;
6347 for (; g
!= NULL
; g
= g
->next
)
6349 sec
= section_headers
+ g
->section_index
;
6351 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6356 i
= elf_header
.e_shnum
;
6358 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6360 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6361 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6362 suffix
= SECTION_NAME (unwsec
) + len
;
6363 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6365 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6366 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6371 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6372 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6373 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6374 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6376 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6377 suffix
= SECTION_NAME (unwsec
) + len
;
6378 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6380 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6381 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6385 if (i
== elf_header
.e_shnum
)
6387 printf (_("\nCould not find unwind info section for "));
6389 if (string_table
== NULL
)
6390 printf ("%d", unwsec
->sh_name
);
6392 printf (_("'%s'"), SECTION_NAME (unwsec
));
6396 aux
.info_addr
= sec
->sh_addr
;
6397 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6400 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6402 printf (_("\nUnwind section "));
6404 if (string_table
== NULL
)
6405 printf ("%d", unwsec
->sh_name
);
6407 printf (_("'%s'"), SECTION_NAME (unwsec
));
6409 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6410 (unsigned long) unwsec
->sh_offset
,
6411 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6413 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6415 if (aux
.table_len
> 0)
6416 dump_ia64_unwind (& aux
);
6419 free ((char *) aux
.table
);
6421 free ((char *) aux
.info
);
6430 free ((char *) aux
.strtab
);
6433 struct hppa_unw_table_entry
6435 struct absaddr start
;
6437 unsigned int Cannot_unwind
:1; /* 0 */
6438 unsigned int Millicode
:1; /* 1 */
6439 unsigned int Millicode_save_sr0
:1; /* 2 */
6440 unsigned int Region_description
:2; /* 3..4 */
6441 unsigned int reserved1
:1; /* 5 */
6442 unsigned int Entry_SR
:1; /* 6 */
6443 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6444 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6445 unsigned int Args_stored
:1; /* 16 */
6446 unsigned int Variable_Frame
:1; /* 17 */
6447 unsigned int Separate_Package_Body
:1; /* 18 */
6448 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6449 unsigned int Stack_Overflow_Check
:1; /* 20 */
6450 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6451 unsigned int Ada_Region
:1; /* 22 */
6452 unsigned int cxx_info
:1; /* 23 */
6453 unsigned int cxx_try_catch
:1; /* 24 */
6454 unsigned int sched_entry_seq
:1; /* 25 */
6455 unsigned int reserved2
:1; /* 26 */
6456 unsigned int Save_SP
:1; /* 27 */
6457 unsigned int Save_RP
:1; /* 28 */
6458 unsigned int Save_MRP_in_frame
:1; /* 29 */
6459 unsigned int extn_ptr_defined
:1; /* 30 */
6460 unsigned int Cleanup_defined
:1; /* 31 */
6462 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6463 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6464 unsigned int Large_frame
:1; /* 2 */
6465 unsigned int Pseudo_SP_Set
:1; /* 3 */
6466 unsigned int reserved4
:1; /* 4 */
6467 unsigned int Total_frame_size
:27; /* 5..31 */
6470 struct hppa_unw_aux_info
6472 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6473 unsigned long table_len
; /* Length of unwind table. */
6474 bfd_vma seg_base
; /* Starting address of segment. */
6475 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6476 unsigned long nsyms
; /* Number of symbols. */
6477 char * strtab
; /* The string table. */
6478 unsigned long strtab_size
; /* Size of string table. */
6482 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6484 struct hppa_unw_table_entry
* tp
;
6486 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6489 const char * procname
;
6491 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6492 aux
->strtab_size
, tp
->start
, &procname
,
6495 fputs ("\n<", stdout
);
6499 fputs (procname
, stdout
);
6502 printf ("+%lx", (unsigned long) offset
);
6505 fputs (">: [", stdout
);
6506 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6507 fputc ('-', stdout
);
6508 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6511 #define PF(_m) if (tp->_m) printf (#_m " ");
6512 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6515 PF(Millicode_save_sr0
);
6516 /* PV(Region_description); */
6522 PF(Separate_Package_Body
);
6523 PF(Frame_Extension_Millicode
);
6524 PF(Stack_Overflow_Check
);
6525 PF(Two_Instruction_SP_Increment
);
6529 PF(sched_entry_seq
);
6532 PF(Save_MRP_in_frame
);
6533 PF(extn_ptr_defined
);
6534 PF(Cleanup_defined
);
6535 PF(MPE_XL_interrupt_marker
);
6536 PF(HP_UX_interrupt_marker
);
6539 PV(Total_frame_size
);
6548 slurp_hppa_unwind_table (FILE * file
,
6549 struct hppa_unw_aux_info
* aux
,
6550 Elf_Internal_Shdr
* sec
)
6552 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6553 Elf_Internal_Phdr
* seg
;
6554 struct hppa_unw_table_entry
* tep
;
6555 Elf_Internal_Shdr
* relsec
;
6556 Elf_Internal_Rela
* rela
;
6557 Elf_Internal_Rela
* rp
;
6558 unsigned char * table
;
6560 Elf_Internal_Sym
* sym
;
6561 const char * relname
;
6563 /* First, find the starting address of the segment that includes
6566 if (elf_header
.e_phnum
)
6568 if (! get_program_headers (file
))
6571 for (seg
= program_headers
;
6572 seg
< program_headers
+ elf_header
.e_phnum
;
6575 if (seg
->p_type
!= PT_LOAD
)
6578 if (sec
->sh_addr
>= seg
->p_vaddr
6579 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6581 aux
->seg_base
= seg
->p_vaddr
;
6587 /* Second, build the unwind table from the contents of the unwind
6589 size
= sec
->sh_size
;
6590 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6596 nentries
= size
/ unw_ent_size
;
6597 size
= unw_ent_size
* nentries
;
6599 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6600 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6602 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6604 unsigned int tmp1
, tmp2
;
6606 tep
->start
.section
= SHN_UNDEF
;
6607 tep
->end
.section
= SHN_UNDEF
;
6609 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6610 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6611 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6612 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6614 tep
->start
.offset
+= aux
->seg_base
;
6615 tep
->end
.offset
+= aux
->seg_base
;
6617 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6618 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6619 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6620 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6621 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6622 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6623 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6624 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6625 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6626 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6627 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6628 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6629 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6630 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6631 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6632 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6633 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6634 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6635 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6636 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6637 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6638 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6639 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6640 tep
->Cleanup_defined
= tmp1
& 0x1;
6642 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6643 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6644 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6645 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6646 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6647 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6651 /* Third, apply any relocations to the unwind table. */
6652 for (relsec
= section_headers
;
6653 relsec
< section_headers
+ elf_header
.e_shnum
;
6656 if (relsec
->sh_type
!= SHT_RELA
6657 || relsec
->sh_info
>= elf_header
.e_shnum
6658 || section_headers
+ relsec
->sh_info
!= sec
)
6661 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6665 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6667 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6668 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6670 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6671 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6673 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6677 i
= rp
->r_offset
/ unw_ent_size
;
6679 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6682 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6683 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6686 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6687 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6697 aux
->table_len
= nentries
;
6703 hppa_process_unwind (FILE * file
)
6705 struct hppa_unw_aux_info aux
;
6706 Elf_Internal_Shdr
* unwsec
= NULL
;
6707 Elf_Internal_Shdr
* strsec
;
6708 Elf_Internal_Shdr
* sec
;
6711 if (string_table
== NULL
)
6714 memset (& aux
, 0, sizeof (aux
));
6716 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6718 if (sec
->sh_type
== SHT_SYMTAB
6719 && sec
->sh_link
< elf_header
.e_shnum
)
6721 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6723 strsec
= section_headers
+ sec
->sh_link
;
6724 assert (aux
.strtab
== NULL
);
6725 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6728 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6730 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6735 printf (_("\nThere are no unwind sections in this file.\n"));
6737 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6739 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6741 printf (_("\nUnwind section "));
6742 printf (_("'%s'"), SECTION_NAME (sec
));
6744 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6745 (unsigned long) sec
->sh_offset
,
6746 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6748 slurp_hppa_unwind_table (file
, &aux
, sec
);
6749 if (aux
.table_len
> 0)
6750 dump_hppa_unwind (&aux
);
6753 free ((char *) aux
.table
);
6761 free ((char *) aux
.strtab
);
6766 unsigned char * data
; /* The unwind data. */
6767 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6768 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6769 unsigned long nrelas
; /* The number of relocations. */
6770 unsigned int rel_type
; /* REL or RELA ? */
6771 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6774 struct arm_unw_aux_info
6776 FILE * file
; /* The file containing the unwind sections. */
6777 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6778 unsigned long nsyms
; /* Number of symbols. */
6779 char * strtab
; /* The file's string table. */
6780 unsigned long strtab_size
; /* Size of string table. */
6784 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6785 bfd_vma fn
, struct absaddr addr
)
6787 const char *procname
;
6790 if (addr
.section
== SHN_UNDEF
)
6793 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6794 aux
->strtab_size
, addr
, &procname
,
6797 print_vma (fn
, PREFIX_HEX
);
6801 fputs (" <", stdout
);
6802 fputs (procname
, stdout
);
6805 printf ("+0x%lx", (unsigned long) sym_offset
);
6806 fputc ('>', stdout
);
6813 arm_free_section (struct arm_section
*arm_sec
)
6815 if (arm_sec
->data
!= NULL
)
6816 free (arm_sec
->data
);
6818 if (arm_sec
->rela
!= NULL
)
6819 free (arm_sec
->rela
);
6822 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6823 cached section and install SEC instead.
6824 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6825 and return its valued in * WORDP, relocating if necessary.
6826 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6827 relocation's offset in ADDR.
6828 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6829 into the string table of the symbol associated with the reloc. If no
6830 reloc was applied store -1 there.
6831 5) Return TRUE upon success, FALSE otherwise. */
6834 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6835 struct arm_section
* arm_sec
,
6836 Elf_Internal_Shdr
* sec
,
6837 bfd_vma word_offset
,
6838 unsigned int * wordp
,
6839 struct absaddr
* addr
,
6842 Elf_Internal_Rela
*rp
;
6843 Elf_Internal_Sym
*sym
;
6844 const char * relname
;
6846 bfd_boolean wrapped
;
6848 addr
->section
= SHN_UNDEF
;
6851 if (sym_name
!= NULL
)
6852 *sym_name
= (bfd_vma
) -1;
6854 /* If necessary, update the section cache. */
6855 if (sec
!= arm_sec
->sec
)
6857 Elf_Internal_Shdr
*relsec
;
6859 arm_free_section (arm_sec
);
6862 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6863 sec
->sh_size
, _("unwind data"));
6864 arm_sec
->rela
= NULL
;
6865 arm_sec
->nrelas
= 0;
6867 for (relsec
= section_headers
;
6868 relsec
< section_headers
+ elf_header
.e_shnum
;
6871 if (relsec
->sh_info
>= elf_header
.e_shnum
6872 || section_headers
+ relsec
->sh_info
!= sec
6873 /* PR 15745: Check the section type as well. */
6874 || (relsec
->sh_type
!= SHT_REL
6875 && relsec
->sh_type
!= SHT_RELA
))
6878 arm_sec
->rel_type
= relsec
->sh_type
;
6879 if (relsec
->sh_type
== SHT_REL
)
6881 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6883 & arm_sec
->rela
, & arm_sec
->nrelas
))
6886 else /* relsec->sh_type == SHT_RELA */
6888 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6890 & arm_sec
->rela
, & arm_sec
->nrelas
))
6896 arm_sec
->next_rela
= arm_sec
->rela
;
6899 /* If there is no unwind data we can do nothing. */
6900 if (arm_sec
->data
== NULL
)
6903 /* Get the word at the required offset. */
6904 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6906 /* Look through the relocs to find the one that applies to the provided offset. */
6908 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6910 bfd_vma prelval
, offset
;
6912 if (rp
->r_offset
> word_offset
&& !wrapped
)
6917 if (rp
->r_offset
> word_offset
)
6920 if (rp
->r_offset
& 3)
6922 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6923 (unsigned long) rp
->r_offset
);
6927 if (rp
->r_offset
< word_offset
)
6930 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6932 if (arm_sec
->rel_type
== SHT_REL
)
6934 offset
= word
& 0x7fffffff;
6935 if (offset
& 0x40000000)
6936 offset
|= ~ (bfd_vma
) 0x7fffffff;
6938 else if (arm_sec
->rel_type
== SHT_RELA
)
6939 offset
= rp
->r_addend
;
6943 offset
+= sym
->st_value
;
6944 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6946 /* Check that we are processing the expected reloc type. */
6947 if (elf_header
.e_machine
== EM_ARM
)
6949 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6951 if (streq (relname
, "R_ARM_NONE"))
6954 if (! streq (relname
, "R_ARM_PREL31"))
6956 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6960 else if (elf_header
.e_machine
== EM_TI_C6000
)
6962 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6964 if (streq (relname
, "R_C6000_NONE"))
6967 if (! streq (relname
, "R_C6000_PREL31"))
6969 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6976 /* This function currently only supports ARM and TI unwinders. */
6979 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6980 addr
->section
= sym
->st_shndx
;
6981 addr
->offset
= offset
;
6983 * sym_name
= sym
->st_name
;
6988 arm_sec
->next_rela
= rp
;
6993 static const char *tic6x_unwind_regnames
[16] =
6995 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6996 "A14", "A13", "A12", "A11", "A10",
6997 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7001 decode_tic6x_unwind_regmask (unsigned int mask
)
7005 for (i
= 12; mask
; mask
>>= 1, i
--)
7009 fputs (tic6x_unwind_regnames
[i
], stdout
);
7011 fputs (", ", stdout
);
7017 if (remaining == 0 && more_words) \
7020 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7021 data_offset, & word, & addr, NULL)) \
7027 #define GET_OP(OP) \
7032 (OP) = word >> 24; \
7037 printf (_("[Truncated opcode]\n")); \
7040 printf ("0x%02x ", OP)
7043 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7044 unsigned int word
, unsigned int remaining
,
7045 unsigned int more_words
,
7046 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7047 struct arm_section
*data_arm_sec
)
7049 struct absaddr addr
;
7051 /* Decode the unwinding instructions. */
7054 unsigned int op
, op2
;
7063 printf (" 0x%02x ", op
);
7065 if ((op
& 0xc0) == 0x00)
7067 int offset
= ((op
& 0x3f) << 2) + 4;
7069 printf (" vsp = vsp + %d", offset
);
7071 else if ((op
& 0xc0) == 0x40)
7073 int offset
= ((op
& 0x3f) << 2) + 4;
7075 printf (" vsp = vsp - %d", offset
);
7077 else if ((op
& 0xf0) == 0x80)
7080 if (op
== 0x80 && op2
== 0)
7081 printf (_("Refuse to unwind"));
7084 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7089 for (i
= 0; i
< 12; i
++)
7090 if (mask
& (1 << i
))
7096 printf ("r%d", 4 + i
);
7101 else if ((op
& 0xf0) == 0x90)
7103 if (op
== 0x9d || op
== 0x9f)
7104 printf (_(" [Reserved]"));
7106 printf (" vsp = r%d", op
& 0x0f);
7108 else if ((op
& 0xf0) == 0xa0)
7110 int end
= 4 + (op
& 0x07);
7115 for (i
= 4; i
<= end
; i
++)
7131 else if (op
== 0xb0)
7132 printf (_(" finish"));
7133 else if (op
== 0xb1)
7136 if (op2
== 0 || (op2
& 0xf0) != 0)
7137 printf (_("[Spare]"));
7140 unsigned int mask
= op2
& 0x0f;
7145 for (i
= 0; i
< 12; i
++)
7146 if (mask
& (1 << i
))
7157 else if (op
== 0xb2)
7159 unsigned char buf
[9];
7160 unsigned int i
, len
;
7161 unsigned long offset
;
7163 for (i
= 0; i
< sizeof (buf
); i
++)
7166 if ((buf
[i
] & 0x80) == 0)
7169 assert (i
< sizeof (buf
));
7170 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7171 assert (len
== i
+ 1);
7172 offset
= offset
* 4 + 0x204;
7173 printf ("vsp = vsp + %ld", offset
);
7175 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7177 unsigned int first
, last
;
7184 printf ("pop {D%d", first
);
7186 printf ("-D%d", first
+ last
);
7189 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7191 unsigned int count
= op
& 0x07;
7195 printf ("-D%d", 8 + count
);
7198 else if (op
>= 0xc0 && op
<= 0xc5)
7200 unsigned int count
= op
& 0x07;
7202 printf (" pop {wR10");
7204 printf ("-wR%d", 10 + count
);
7207 else if (op
== 0xc6)
7209 unsigned int first
, last
;
7214 printf ("pop {wR%d", first
);
7216 printf ("-wR%d", first
+ last
);
7219 else if (op
== 0xc7)
7222 if (op2
== 0 || (op2
& 0xf0) != 0)
7223 printf (_("[Spare]"));
7226 unsigned int mask
= op2
& 0x0f;
7231 for (i
= 0; i
< 4; i
++)
7232 if (mask
& (1 << i
))
7238 printf ("wCGR%d", i
);
7244 printf (_(" [unsupported opcode]"));
7250 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7251 unsigned int word
, unsigned int remaining
,
7252 unsigned int more_words
,
7253 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7254 struct arm_section
*data_arm_sec
)
7256 struct absaddr addr
;
7258 /* Decode the unwinding instructions. */
7261 unsigned int op
, op2
;
7270 printf (" 0x%02x ", op
);
7272 if ((op
& 0xc0) == 0x00)
7274 int offset
= ((op
& 0x3f) << 3) + 8;
7275 printf (" sp = sp + %d", offset
);
7277 else if ((op
& 0xc0) == 0x80)
7280 if (op
== 0x80 && op2
== 0)
7281 printf (_("Refuse to unwind"));
7284 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7286 printf ("pop compact {");
7290 decode_tic6x_unwind_regmask (mask
);
7294 else if ((op
& 0xf0) == 0xc0)
7302 unsigned int offset
;
7306 /* Scan entire instruction first so that GET_OP output is not
7307 interleaved with disassembly. */
7309 for (i
= 0; nregs
< (op
& 0xf); i
++)
7315 regpos
[nregs
].offset
= i
* 2;
7316 regpos
[nregs
].reg
= reg
;
7323 regpos
[nregs
].offset
= i
* 2 + 1;
7324 regpos
[nregs
].reg
= reg
;
7329 printf (_("pop frame {"));
7331 for (i
= i
* 2; i
> 0; i
--)
7333 if (regpos
[reg
].offset
== i
- 1)
7335 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7342 fputs (name
, stdout
);
7349 else if (op
== 0xd0)
7350 printf (" MOV FP, SP");
7351 else if (op
== 0xd1)
7352 printf (" __c6xabi_pop_rts");
7353 else if (op
== 0xd2)
7355 unsigned char buf
[9];
7356 unsigned int i
, len
;
7357 unsigned long offset
;
7359 for (i
= 0; i
< sizeof (buf
); i
++)
7362 if ((buf
[i
] & 0x80) == 0)
7365 assert (i
< sizeof (buf
));
7366 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7367 assert (len
== i
+ 1);
7368 offset
= offset
* 8 + 0x408;
7369 printf (_("sp = sp + %ld"), offset
);
7371 else if ((op
& 0xf0) == 0xe0)
7373 if ((op
& 0x0f) == 7)
7376 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7380 printf (_(" [unsupported opcode]"));
7387 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7391 offset
= word
& 0x7fffffff;
7392 if (offset
& 0x40000000)
7393 offset
|= ~ (bfd_vma
) 0x7fffffff;
7395 if (elf_header
.e_machine
== EM_TI_C6000
)
7398 return offset
+ where
;
7402 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7404 unsigned int remaining
,
7405 bfd_vma data_offset
,
7406 Elf_Internal_Shdr
* data_sec
,
7407 struct arm_section
* data_arm_sec
)
7410 unsigned int more_words
= 0;
7411 struct absaddr addr
;
7412 bfd_vma sym_name
= (bfd_vma
) -1;
7416 /* Fetch the first word.
7417 Note - when decoding an object file the address extracted
7418 here will always be 0. So we also pass in the sym_name
7419 parameter so that we can find the symbol associated with
7420 the personality routine. */
7421 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7422 & word
, & addr
, & sym_name
))
7428 if ((word
& 0x80000000) == 0)
7430 /* Expand prel31 for personality routine. */
7432 const char *procname
;
7434 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7435 printf (_(" Personality routine: "));
7437 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7438 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7440 procname
= aux
->strtab
+ sym_name
;
7441 print_vma (fn
, PREFIX_HEX
);
7444 fputs (" <", stdout
);
7445 fputs (procname
, stdout
);
7446 fputc ('>', stdout
);
7450 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7451 fputc ('\n', stdout
);
7453 /* The GCC personality routines use the standard compact
7454 encoding, starting with one byte giving the number of
7456 if (procname
!= NULL
7457 && (const_strneq (procname
, "__gcc_personality_v0")
7458 || const_strneq (procname
, "__gxx_personality_v0")
7459 || const_strneq (procname
, "__gcj_personality_v0")
7460 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7467 printf (_(" [Truncated data]\n"));
7470 more_words
= word
>> 24;
7480 /* ARM EHABI Section 6.3:
7482 An exception-handling table entry for the compact model looks like:
7486 1 0 index Data for personalityRoutine[index] */
7488 if (elf_header
.e_machine
== EM_ARM
7489 && (word
& 0x70000000))
7490 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7492 per_index
= (word
>> 24) & 0x7f;
7493 printf (_(" Compact model index: %d\n"), per_index
);
7500 else if (per_index
< 3)
7502 more_words
= (word
>> 16) & 0xff;
7508 switch (elf_header
.e_machine
)
7513 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7514 data_offset
, data_sec
, data_arm_sec
);
7518 warn (_("Unknown ARM compact model index encountered\n"));
7519 printf (_(" [reserved]\n"));
7526 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7527 data_offset
, data_sec
, data_arm_sec
);
7529 else if (per_index
< 5)
7531 if (((word
>> 17) & 0x7f) == 0x7f)
7532 printf (_(" Restore stack from frame pointer\n"));
7534 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7535 printf (_(" Registers restored: "));
7537 printf (" (compact) ");
7538 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7540 printf (_(" Return register: %s\n"),
7541 tic6x_unwind_regnames
[word
& 0xf]);
7544 printf (_(" [reserved (%d)]\n"), per_index
);
7548 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7549 elf_header
.e_machine
);
7552 /* Decode the descriptors. Not implemented. */
7556 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7558 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7559 unsigned int i
, exidx_len
;
7561 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7562 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7563 exidx_len
= exidx_sec
->sh_size
/ 8;
7565 for (i
= 0; i
< exidx_len
; i
++)
7567 unsigned int exidx_fn
, exidx_entry
;
7568 struct absaddr fn_addr
, entry_addr
;
7571 fputc ('\n', stdout
);
7573 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7574 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7575 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7576 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7578 arm_free_section (& exidx_arm_sec
);
7579 arm_free_section (& extab_arm_sec
);
7583 /* ARM EHABI, Section 5:
7584 An index table entry consists of 2 words.
7585 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7586 if (exidx_fn
& 0x80000000)
7587 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7589 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7591 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7592 fputs (": ", stdout
);
7594 if (exidx_entry
== 1)
7596 print_vma (exidx_entry
, PREFIX_HEX
);
7597 fputs (" [cantunwind]\n", stdout
);
7599 else if (exidx_entry
& 0x80000000)
7601 print_vma (exidx_entry
, PREFIX_HEX
);
7602 fputc ('\n', stdout
);
7603 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7607 bfd_vma table
, table_offset
= 0;
7608 Elf_Internal_Shdr
*table_sec
;
7610 fputs ("@", stdout
);
7611 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7612 print_vma (table
, PREFIX_HEX
);
7615 /* Locate the matching .ARM.extab. */
7616 if (entry_addr
.section
!= SHN_UNDEF
7617 && entry_addr
.section
< elf_header
.e_shnum
)
7619 table_sec
= section_headers
+ entry_addr
.section
;
7620 table_offset
= entry_addr
.offset
;
7624 table_sec
= find_section_by_address (table
);
7625 if (table_sec
!= NULL
)
7626 table_offset
= table
- table_sec
->sh_addr
;
7628 if (table_sec
== NULL
)
7630 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7631 (unsigned long) table
);
7634 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7641 arm_free_section (&exidx_arm_sec
);
7642 arm_free_section (&extab_arm_sec
);
7645 /* Used for both ARM and C6X unwinding tables. */
7648 arm_process_unwind (FILE *file
)
7650 struct arm_unw_aux_info aux
;
7651 Elf_Internal_Shdr
*unwsec
= NULL
;
7652 Elf_Internal_Shdr
*strsec
;
7653 Elf_Internal_Shdr
*sec
;
7655 unsigned int sec_type
;
7657 switch (elf_header
.e_machine
)
7660 sec_type
= SHT_ARM_EXIDX
;
7664 sec_type
= SHT_C6000_UNWIND
;
7668 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7669 elf_header
.e_machine
);
7673 if (string_table
== NULL
)
7676 memset (& aux
, 0, sizeof (aux
));
7679 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7681 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7683 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7685 strsec
= section_headers
+ sec
->sh_link
;
7686 assert (aux
.strtab
== NULL
);
7687 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7688 1, strsec
->sh_size
, _("string table"));
7689 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7691 else if (sec
->sh_type
== sec_type
)
7696 printf (_("\nThere are no unwind sections in this file.\n"));
7698 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7700 if (sec
->sh_type
== sec_type
)
7702 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7704 (unsigned long) sec
->sh_offset
,
7705 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7707 dump_arm_unwind (&aux
, sec
);
7714 free ((char *) aux
.strtab
);
7718 process_unwind (FILE * file
)
7720 struct unwind_handler
7723 void (* handler
)(FILE *);
7726 { EM_ARM
, arm_process_unwind
},
7727 { EM_IA_64
, ia64_process_unwind
},
7728 { EM_PARISC
, hppa_process_unwind
},
7729 { EM_TI_C6000
, arm_process_unwind
},
7737 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7738 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7740 handlers
[i
].handler (file
);
7744 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7745 get_machine_name (elf_header
.e_machine
));
7749 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7751 switch (entry
->d_tag
)
7754 if (entry
->d_un
.d_val
== 0)
7758 static const char * opts
[] =
7760 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7761 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7762 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7763 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7769 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7770 if (entry
->d_un
.d_val
& (1 << cnt
))
7772 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7778 case DT_MIPS_IVERSION
:
7779 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7780 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7784 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
7785 /* Note: coded this way so that there is a single string for translation. */
7786 printf (_("<corrupt: %s>"), buf
);
7790 case DT_MIPS_TIME_STAMP
:
7795 time_t atime
= entry
->d_un
.d_val
;
7796 tmp
= gmtime (&atime
);
7797 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7798 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7799 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7800 printf (_("Time Stamp: %s"), timebuf
);
7804 case DT_MIPS_RLD_VERSION
:
7805 case DT_MIPS_LOCAL_GOTNO
:
7806 case DT_MIPS_CONFLICTNO
:
7807 case DT_MIPS_LIBLISTNO
:
7808 case DT_MIPS_SYMTABNO
:
7809 case DT_MIPS_UNREFEXTNO
:
7810 case DT_MIPS_HIPAGENO
:
7811 case DT_MIPS_DELTA_CLASS_NO
:
7812 case DT_MIPS_DELTA_INSTANCE_NO
:
7813 case DT_MIPS_DELTA_RELOC_NO
:
7814 case DT_MIPS_DELTA_SYM_NO
:
7815 case DT_MIPS_DELTA_CLASSSYM_NO
:
7816 case DT_MIPS_COMPACT_SIZE
:
7817 print_vma (entry
->d_un
.d_ptr
, DEC
);
7821 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7827 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7829 switch (entry
->d_tag
)
7831 case DT_HP_DLD_FLAGS
:
7840 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7841 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7842 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7843 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7844 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7845 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7846 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7847 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7848 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7849 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7850 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7851 { DT_HP_GST
, "HP_GST" },
7852 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7853 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7854 { DT_HP_NODELETE
, "HP_NODELETE" },
7855 { DT_HP_GROUP
, "HP_GROUP" },
7856 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7860 bfd_vma val
= entry
->d_un
.d_val
;
7862 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7863 if (val
& flags
[cnt
].bit
)
7867 fputs (flags
[cnt
].str
, stdout
);
7869 val
^= flags
[cnt
].bit
;
7872 if (val
!= 0 || first
)
7876 print_vma (val
, HEX
);
7882 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7890 /* VMS vs Unix time offset and factor. */
7892 #define VMS_EPOCH_OFFSET 35067168000000000LL
7893 #define VMS_GRANULARITY_FACTOR 10000000
7895 /* Display a VMS time in a human readable format. */
7898 print_vms_time (bfd_int64_t vmstime
)
7903 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7904 tm
= gmtime (&unxtime
);
7905 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7906 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7907 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7912 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7914 switch (entry
->d_tag
)
7916 case DT_IA_64_PLT_RESERVE
:
7917 /* First 3 slots reserved. */
7918 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7920 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7923 case DT_IA_64_VMS_LINKTIME
:
7925 print_vms_time (entry
->d_un
.d_val
);
7929 case DT_IA_64_VMS_LNKFLAGS
:
7930 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7931 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7932 printf (" CALL_DEBUG");
7933 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7934 printf (" NOP0BUFS");
7935 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7936 printf (" P0IMAGE");
7937 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7938 printf (" MKTHREADS");
7939 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7940 printf (" UPCALLS");
7941 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7943 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7944 printf (" INITIALIZE");
7945 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7947 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7948 printf (" EXE_INIT");
7949 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7950 printf (" TBK_IN_IMG");
7951 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7952 printf (" DBG_IN_IMG");
7953 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7954 printf (" TBK_IN_DSF");
7955 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7956 printf (" DBG_IN_DSF");
7957 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7958 printf (" SIGNATURES");
7959 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7960 printf (" REL_SEG_OFF");
7964 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7971 get_32bit_dynamic_section (FILE * file
)
7973 Elf32_External_Dyn
* edyn
;
7974 Elf32_External_Dyn
* ext
;
7975 Elf_Internal_Dyn
* entry
;
7977 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7978 dynamic_size
, _("dynamic section"));
7982 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7983 might not have the luxury of section headers. Look for the DT_NULL
7984 terminator to determine the number of entries. */
7985 for (ext
= edyn
, dynamic_nent
= 0;
7986 (char *) ext
< (char *) edyn
+ dynamic_size
;
7990 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7994 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7996 if (dynamic_section
== NULL
)
7998 error (_("Out of memory\n"));
8003 for (ext
= edyn
, entry
= dynamic_section
;
8004 entry
< dynamic_section
+ dynamic_nent
;
8007 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8008 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8017 get_64bit_dynamic_section (FILE * file
)
8019 Elf64_External_Dyn
* edyn
;
8020 Elf64_External_Dyn
* ext
;
8021 Elf_Internal_Dyn
* entry
;
8023 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8024 dynamic_size
, _("dynamic section"));
8028 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8029 might not have the luxury of section headers. Look for the DT_NULL
8030 terminator to determine the number of entries. */
8031 for (ext
= edyn
, dynamic_nent
= 0;
8032 (char *) ext
< (char *) edyn
+ dynamic_size
;
8036 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8040 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8042 if (dynamic_section
== NULL
)
8044 error (_("Out of memory\n"));
8049 for (ext
= edyn
, entry
= dynamic_section
;
8050 entry
< dynamic_section
+ dynamic_nent
;
8053 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8054 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8063 print_dynamic_flags (bfd_vma flags
)
8071 flag
= flags
& - flags
;
8081 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8082 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8083 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8084 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8085 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8086 default: fputs (_("unknown"), stdout
); break;
8092 /* Parse and display the contents of the dynamic section. */
8095 process_dynamic_section (FILE * file
)
8097 Elf_Internal_Dyn
* entry
;
8099 if (dynamic_size
== 0)
8102 printf (_("\nThere is no dynamic section in this file.\n"));
8109 if (! get_32bit_dynamic_section (file
))
8112 else if (! get_64bit_dynamic_section (file
))
8115 /* Find the appropriate symbol table. */
8116 if (dynamic_symbols
== NULL
)
8118 for (entry
= dynamic_section
;
8119 entry
< dynamic_section
+ dynamic_nent
;
8122 Elf_Internal_Shdr section
;
8124 if (entry
->d_tag
!= DT_SYMTAB
)
8127 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8129 /* Since we do not know how big the symbol table is,
8130 we default to reading in the entire file (!) and
8131 processing that. This is overkill, I know, but it
8133 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8135 if (archive_file_offset
!= 0)
8136 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8139 if (fseek (file
, 0, SEEK_END
))
8140 error (_("Unable to seek to end of file!\n"));
8142 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8146 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8148 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8150 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8151 if (num_dynamic_syms
< 1)
8153 error (_("Unable to determine the number of symbols to load\n"));
8159 /* Similarly find a string table. */
8160 if (dynamic_strings
== NULL
)
8162 for (entry
= dynamic_section
;
8163 entry
< dynamic_section
+ dynamic_nent
;
8166 unsigned long offset
;
8169 if (entry
->d_tag
!= DT_STRTAB
)
8172 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8174 /* Since we do not know how big the string table is,
8175 we default to reading in the entire file (!) and
8176 processing that. This is overkill, I know, but it
8179 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8181 if (archive_file_offset
!= 0)
8182 str_tab_len
= archive_file_size
- offset
;
8185 if (fseek (file
, 0, SEEK_END
))
8186 error (_("Unable to seek to end of file\n"));
8187 str_tab_len
= ftell (file
) - offset
;
8190 if (str_tab_len
< 1)
8193 (_("Unable to determine the length of the dynamic string table\n"));
8197 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8199 _("dynamic string table"));
8200 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8205 /* And find the syminfo section if available. */
8206 if (dynamic_syminfo
== NULL
)
8208 unsigned long syminsz
= 0;
8210 for (entry
= dynamic_section
;
8211 entry
< dynamic_section
+ dynamic_nent
;
8214 if (entry
->d_tag
== DT_SYMINENT
)
8216 /* Note: these braces are necessary to avoid a syntax
8217 error from the SunOS4 C compiler. */
8218 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
8220 else if (entry
->d_tag
== DT_SYMINSZ
)
8221 syminsz
= entry
->d_un
.d_val
;
8222 else if (entry
->d_tag
== DT_SYMINFO
)
8223 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8227 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8229 Elf_External_Syminfo
* extsyminfo
;
8230 Elf_External_Syminfo
* extsym
;
8231 Elf_Internal_Syminfo
* syminfo
;
8233 /* There is a syminfo section. Read the data. */
8234 extsyminfo
= (Elf_External_Syminfo
*)
8235 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8236 _("symbol information"));
8240 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8241 if (dynamic_syminfo
== NULL
)
8243 error (_("Out of memory\n"));
8247 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8248 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8249 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8250 ++syminfo
, ++extsym
)
8252 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8253 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8260 if (do_dynamic
&& dynamic_addr
)
8261 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8262 dynamic_addr
, dynamic_nent
);
8264 printf (_(" Tag Type Name/Value\n"));
8266 for (entry
= dynamic_section
;
8267 entry
< dynamic_section
+ dynamic_nent
;
8275 print_vma (entry
->d_tag
, FULL_HEX
);
8276 dtype
= get_dynamic_type (entry
->d_tag
);
8277 printf (" (%s)%*s", dtype
,
8278 ((is_32bit_elf
? 27 : 19)
8279 - (int) strlen (dtype
)),
8283 switch (entry
->d_tag
)
8287 print_dynamic_flags (entry
->d_un
.d_val
);
8297 switch (entry
->d_tag
)
8300 printf (_("Auxiliary library"));
8304 printf (_("Filter library"));
8308 printf (_("Configuration file"));
8312 printf (_("Dependency audit library"));
8316 printf (_("Audit library"));
8320 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8321 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8325 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8334 printf (_("Flags:"));
8336 if (entry
->d_un
.d_val
== 0)
8337 printf (_(" None\n"));
8340 unsigned long int val
= entry
->d_un
.d_val
;
8342 if (val
& DTF_1_PARINIT
)
8344 printf (" PARINIT");
8345 val
^= DTF_1_PARINIT
;
8347 if (val
& DTF_1_CONFEXP
)
8349 printf (" CONFEXP");
8350 val
^= DTF_1_CONFEXP
;
8353 printf (" %lx", val
);
8362 printf (_("Flags:"));
8364 if (entry
->d_un
.d_val
== 0)
8365 printf (_(" None\n"));
8368 unsigned long int val
= entry
->d_un
.d_val
;
8370 if (val
& DF_P1_LAZYLOAD
)
8372 printf (" LAZYLOAD");
8373 val
^= DF_P1_LAZYLOAD
;
8375 if (val
& DF_P1_GROUPPERM
)
8377 printf (" GROUPPERM");
8378 val
^= DF_P1_GROUPPERM
;
8381 printf (" %lx", val
);
8390 printf (_("Flags:"));
8391 if (entry
->d_un
.d_val
== 0)
8392 printf (_(" None\n"));
8395 unsigned long int val
= entry
->d_un
.d_val
;
8402 if (val
& DF_1_GLOBAL
)
8407 if (val
& DF_1_GROUP
)
8412 if (val
& DF_1_NODELETE
)
8414 printf (" NODELETE");
8415 val
^= DF_1_NODELETE
;
8417 if (val
& DF_1_LOADFLTR
)
8419 printf (" LOADFLTR");
8420 val
^= DF_1_LOADFLTR
;
8422 if (val
& DF_1_INITFIRST
)
8424 printf (" INITFIRST");
8425 val
^= DF_1_INITFIRST
;
8427 if (val
& DF_1_NOOPEN
)
8432 if (val
& DF_1_ORIGIN
)
8437 if (val
& DF_1_DIRECT
)
8442 if (val
& DF_1_TRANS
)
8447 if (val
& DF_1_INTERPOSE
)
8449 printf (" INTERPOSE");
8450 val
^= DF_1_INTERPOSE
;
8452 if (val
& DF_1_NODEFLIB
)
8454 printf (" NODEFLIB");
8455 val
^= DF_1_NODEFLIB
;
8457 if (val
& DF_1_NODUMP
)
8462 if (val
& DF_1_CONFALT
)
8464 printf (" CONFALT");
8465 val
^= DF_1_CONFALT
;
8467 if (val
& DF_1_ENDFILTEE
)
8469 printf (" ENDFILTEE");
8470 val
^= DF_1_ENDFILTEE
;
8472 if (val
& DF_1_DISPRELDNE
)
8474 printf (" DISPRELDNE");
8475 val
^= DF_1_DISPRELDNE
;
8477 if (val
& DF_1_DISPRELPND
)
8479 printf (" DISPRELPND");
8480 val
^= DF_1_DISPRELPND
;
8482 if (val
& DF_1_NODIRECT
)
8484 printf (" NODIRECT");
8485 val
^= DF_1_NODIRECT
;
8487 if (val
& DF_1_IGNMULDEF
)
8489 printf (" IGNMULDEF");
8490 val
^= DF_1_IGNMULDEF
;
8492 if (val
& DF_1_NOKSYMS
)
8494 printf (" NOKSYMS");
8495 val
^= DF_1_NOKSYMS
;
8497 if (val
& DF_1_NOHDR
)
8502 if (val
& DF_1_EDITED
)
8507 if (val
& DF_1_NORELOC
)
8509 printf (" NORELOC");
8510 val
^= DF_1_NORELOC
;
8512 if (val
& DF_1_SYMINTPOSE
)
8514 printf (" SYMINTPOSE");
8515 val
^= DF_1_SYMINTPOSE
;
8517 if (val
& DF_1_GLOBAUDIT
)
8519 printf (" GLOBAUDIT");
8520 val
^= DF_1_GLOBAUDIT
;
8522 if (val
& DF_1_SINGLETON
)
8524 printf (" SINGLETON");
8525 val
^= DF_1_SINGLETON
;
8528 printf (" %lx", val
);
8535 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8537 puts (get_dynamic_type (entry
->d_un
.d_val
));
8557 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8563 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8564 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8570 switch (entry
->d_tag
)
8573 printf (_("Shared library: [%s]"), name
);
8575 if (streq (name
, program_interpreter
))
8576 printf (_(" program interpreter"));
8580 printf (_("Library soname: [%s]"), name
);
8584 printf (_("Library rpath: [%s]"), name
);
8588 printf (_("Library runpath: [%s]"), name
);
8592 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8597 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8610 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8614 case DT_INIT_ARRAYSZ
:
8615 case DT_FINI_ARRAYSZ
:
8616 case DT_GNU_CONFLICTSZ
:
8617 case DT_GNU_LIBLISTSZ
:
8620 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8621 printf (_(" (bytes)\n"));
8631 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8644 if (entry
->d_tag
== DT_USED
8645 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8647 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8651 printf (_("Not needed object: [%s]\n"), name
);
8656 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8662 /* The value of this entry is ignored. */
8667 case DT_GNU_PRELINKED
:
8671 time_t atime
= entry
->d_un
.d_val
;
8673 tmp
= gmtime (&atime
);
8674 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8675 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8676 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8682 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8685 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8691 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8692 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8697 switch (elf_header
.e_machine
)
8700 case EM_MIPS_RS3_LE
:
8701 dynamic_section_mips_val (entry
);
8704 dynamic_section_parisc_val (entry
);
8707 dynamic_section_ia64_val (entry
);
8710 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8722 get_ver_flags (unsigned int flags
)
8724 static char buff
[32];
8731 if (flags
& VER_FLG_BASE
)
8732 strcat (buff
, "BASE ");
8734 if (flags
& VER_FLG_WEAK
)
8736 if (flags
& VER_FLG_BASE
)
8737 strcat (buff
, "| ");
8739 strcat (buff
, "WEAK ");
8742 if (flags
& VER_FLG_INFO
)
8744 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8745 strcat (buff
, "| ");
8747 strcat (buff
, "INFO ");
8750 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8751 strcat (buff
, _("| <unknown>"));
8756 /* Display the contents of the version sections. */
8759 process_version_sections (FILE * file
)
8761 Elf_Internal_Shdr
* section
;
8768 for (i
= 0, section
= section_headers
;
8769 i
< elf_header
.e_shnum
;
8772 switch (section
->sh_type
)
8774 case SHT_GNU_verdef
:
8776 Elf_External_Verdef
* edefs
;
8784 (_("\nVersion definition section '%s' contains %u entries:\n"),
8785 SECTION_NAME (section
), section
->sh_info
);
8787 printf (_(" Addr: 0x"));
8788 printf_vma (section
->sh_addr
);
8789 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8790 (unsigned long) section
->sh_offset
, section
->sh_link
,
8791 section
->sh_link
< elf_header
.e_shnum
8792 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8795 edefs
= (Elf_External_Verdef
*)
8796 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8797 _("version definition section"));
8800 endbuf
= (char *) edefs
+ section
->sh_size
;
8802 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8805 Elf_External_Verdef
* edef
;
8806 Elf_Internal_Verdef ent
;
8807 Elf_External_Verdaux
* eaux
;
8808 Elf_Internal_Verdaux aux
;
8812 /* Check for very large indicies. */
8813 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8816 vstart
= ((char *) edefs
) + idx
;
8817 if (vstart
+ sizeof (*edef
) > endbuf
)
8820 edef
= (Elf_External_Verdef
*) vstart
;
8822 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8823 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8824 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8825 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8826 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8827 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8828 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8830 printf (_(" %#06x: Rev: %d Flags: %s"),
8831 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8833 printf (_(" Index: %d Cnt: %d "),
8834 ent
.vd_ndx
, ent
.vd_cnt
);
8836 /* Check for overflow. */
8837 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8840 vstart
+= ent
.vd_aux
;
8842 eaux
= (Elf_External_Verdaux
*) vstart
;
8844 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8845 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8847 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8848 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8850 printf (_("Name index: %ld\n"), aux
.vda_name
);
8852 isum
= idx
+ ent
.vd_aux
;
8854 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8856 /* Check for overflow. */
8857 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8860 isum
+= aux
.vda_next
;
8861 vstart
+= aux
.vda_next
;
8863 eaux
= (Elf_External_Verdaux
*) vstart
;
8864 if (vstart
+ sizeof (*eaux
) > endbuf
)
8867 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8868 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8870 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8871 printf (_(" %#06x: Parent %d: %s\n"),
8872 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8874 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8875 isum
, j
, aux
.vda_name
);
8879 printf (_(" Version def aux past end of section\n"));
8884 if (cnt
< section
->sh_info
)
8885 printf (_(" Version definition past end of section\n"));
8891 case SHT_GNU_verneed
:
8893 Elf_External_Verneed
* eneed
;
8900 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8901 SECTION_NAME (section
), section
->sh_info
);
8903 printf (_(" Addr: 0x"));
8904 printf_vma (section
->sh_addr
);
8905 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8906 (unsigned long) section
->sh_offset
, section
->sh_link
,
8907 section
->sh_link
< elf_header
.e_shnum
8908 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8911 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8912 section
->sh_offset
, 1,
8914 _("Version Needs section"));
8917 endbuf
= (char *) eneed
+ section
->sh_size
;
8919 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8921 Elf_External_Verneed
* entry
;
8922 Elf_Internal_Verneed ent
;
8927 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8930 vstart
= ((char *) eneed
) + idx
;
8931 if (vstart
+ sizeof (*entry
) > endbuf
)
8934 entry
= (Elf_External_Verneed
*) vstart
;
8936 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8937 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8938 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8939 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8940 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8942 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8944 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8945 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8947 printf (_(" File: %lx"), ent
.vn_file
);
8949 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8951 /* Check for overflow. */
8952 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8955 vstart
+= ent
.vn_aux
;
8957 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8959 Elf_External_Vernaux
* eaux
;
8960 Elf_Internal_Vernaux aux
;
8962 if (vstart
+ sizeof (*eaux
) > endbuf
)
8964 eaux
= (Elf_External_Vernaux
*) vstart
;
8966 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8967 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8968 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8969 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8970 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8972 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8973 printf (_(" %#06x: Name: %s"),
8974 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8976 printf (_(" %#06x: Name index: %lx"),
8977 isum
, aux
.vna_name
);
8979 printf (_(" Flags: %s Version: %d\n"),
8980 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8982 /* Check for overflow. */
8983 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8986 isum
+= aux
.vna_next
;
8987 vstart
+= aux
.vna_next
;
8991 warn (_("Missing Version Needs auxillary information\n"));
8993 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
8995 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8996 cnt
= section
->sh_info
;
9002 if (cnt
< section
->sh_info
)
9003 warn (_("Missing Version Needs information\n"));
9009 case SHT_GNU_versym
:
9011 Elf_Internal_Shdr
* link_section
;
9014 unsigned char * edata
;
9015 unsigned short * data
;
9017 Elf_Internal_Sym
* symbols
;
9018 Elf_Internal_Shdr
* string_sec
;
9019 unsigned long num_syms
;
9022 if (section
->sh_link
>= elf_header
.e_shnum
)
9025 link_section
= section_headers
+ section
->sh_link
;
9026 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9028 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9033 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9034 if (symbols
== NULL
)
9037 string_sec
= section_headers
+ link_section
->sh_link
;
9039 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9040 string_sec
->sh_size
,
9041 _("version string table"));
9048 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9049 SECTION_NAME (section
), total
);
9051 printf (_(" Addr: "));
9052 printf_vma (section
->sh_addr
);
9053 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9054 (unsigned long) section
->sh_offset
, section
->sh_link
,
9055 SECTION_NAME (link_section
));
9057 off
= offset_from_vma (file
,
9058 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9059 total
* sizeof (short));
9060 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9062 _("version symbol data"));
9070 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9072 for (cnt
= total
; cnt
--;)
9073 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9078 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9081 int check_def
, check_need
;
9084 printf (" %03x:", cnt
);
9086 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9087 switch (data
[cnt
+ j
])
9090 fputs (_(" 0 (*local*) "), stdout
);
9094 fputs (_(" 1 (*global*) "), stdout
);
9098 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9099 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9101 /* If this index value is greater than the size of the symbols
9102 array, break to avoid an out-of-bounds read. */
9103 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9105 warn (_("invalid index into symbol array\n"));
9111 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9112 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9115 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9122 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9124 Elf_Internal_Verneed ivn
;
9125 unsigned long offset
;
9127 offset
= offset_from_vma
9128 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9129 sizeof (Elf_External_Verneed
));
9133 Elf_Internal_Vernaux ivna
;
9134 Elf_External_Verneed evn
;
9135 Elf_External_Vernaux evna
;
9136 unsigned long a_off
;
9138 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9139 _("version need")) == NULL
)
9142 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9143 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9145 a_off
= offset
+ ivn
.vn_aux
;
9149 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9150 1, _("version need aux (2)")) == NULL
)
9157 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9158 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9161 a_off
+= ivna
.vna_next
;
9163 while (ivna
.vna_other
!= data
[cnt
+ j
]
9164 && ivna
.vna_next
!= 0);
9166 if (ivna
.vna_other
== data
[cnt
+ j
])
9168 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9170 if (ivna
.vna_name
>= string_sec
->sh_size
)
9171 name
= _("*invalid*");
9173 name
= strtab
+ ivna
.vna_name
;
9174 nn
+= printf ("(%s%-*s",
9176 12 - (int) strlen (name
),
9182 offset
+= ivn
.vn_next
;
9184 while (ivn
.vn_next
);
9187 if (check_def
&& data
[cnt
+ j
] != 0x8001
9188 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9190 Elf_Internal_Verdef ivd
;
9191 Elf_External_Verdef evd
;
9192 unsigned long offset
;
9194 offset
= offset_from_vma
9195 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9200 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9201 _("version def")) == NULL
)
9208 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9209 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9212 offset
+= ivd
.vd_next
;
9214 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9215 && ivd
.vd_next
!= 0);
9217 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9219 Elf_External_Verdaux evda
;
9220 Elf_Internal_Verdaux ivda
;
9222 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9224 if (get_data (&evda
, file
,
9225 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9227 _("version def aux")) == NULL
)
9230 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9232 if (ivda
.vda_name
>= string_sec
->sh_size
)
9233 name
= _("*invalid*");
9235 name
= strtab
+ ivda
.vda_name
;
9236 nn
+= printf ("(%s%-*s",
9238 12 - (int) strlen (name
),
9244 printf ("%*c", 18 - nn
, ' ');
9262 printf (_("\nNo version information found in this file.\n"));
9268 get_symbol_binding (unsigned int binding
)
9270 static char buff
[32];
9274 case STB_LOCAL
: return "LOCAL";
9275 case STB_GLOBAL
: return "GLOBAL";
9276 case STB_WEAK
: return "WEAK";
9278 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9279 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9281 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9283 if (binding
== STB_GNU_UNIQUE
9284 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9285 /* GNU is still using the default value 0. */
9286 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9288 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9291 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9297 get_symbol_type (unsigned int type
)
9299 static char buff
[32];
9303 case STT_NOTYPE
: return "NOTYPE";
9304 case STT_OBJECT
: return "OBJECT";
9305 case STT_FUNC
: return "FUNC";
9306 case STT_SECTION
: return "SECTION";
9307 case STT_FILE
: return "FILE";
9308 case STT_COMMON
: return "COMMON";
9309 case STT_TLS
: return "TLS";
9310 case STT_RELC
: return "RELC";
9311 case STT_SRELC
: return "SRELC";
9313 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9315 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9316 return "THUMB_FUNC";
9318 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9321 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9322 return "PARISC_MILLI";
9324 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9326 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9328 if (elf_header
.e_machine
== EM_PARISC
)
9330 if (type
== STT_HP_OPAQUE
)
9332 if (type
== STT_HP_STUB
)
9336 if (type
== STT_GNU_IFUNC
9337 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9338 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9339 /* GNU is still using the default value 0. */
9340 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9343 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9346 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9352 get_symbol_visibility (unsigned int visibility
)
9356 case STV_DEFAULT
: return "DEFAULT";
9357 case STV_INTERNAL
: return "INTERNAL";
9358 case STV_HIDDEN
: return "HIDDEN";
9359 case STV_PROTECTED
: return "PROTECTED";
9365 get_mips_symbol_other (unsigned int other
)
9377 case STO_MICROMIPS
| STO_MIPS_PIC
:
9378 return "MICROMIPS, MIPS PIC";
9387 get_ia64_symbol_other (unsigned int other
)
9391 static char res
[32];
9395 /* Function types is for images and .STB files only. */
9396 switch (elf_header
.e_type
)
9400 switch (VMS_ST_FUNC_TYPE (other
))
9402 case VMS_SFT_CODE_ADDR
:
9403 strcat (res
, " CA");
9405 case VMS_SFT_SYMV_IDX
:
9406 strcat (res
, " VEC");
9409 strcat (res
, " FD");
9411 case VMS_SFT_RESERVE
:
9412 strcat (res
, " RSV");
9421 switch (VMS_ST_LINKAGE (other
))
9423 case VMS_STL_IGNORE
:
9424 strcat (res
, " IGN");
9426 case VMS_STL_RESERVE
:
9427 strcat (res
, " RSV");
9430 strcat (res
, " STD");
9433 strcat (res
, " LNK");
9448 get_ppc64_symbol_other (unsigned int other
)
9450 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9452 static char buf
[32];
9453 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9454 PPC64_LOCAL_ENTRY_OFFSET (other
));
9461 get_symbol_other (unsigned int other
)
9463 const char * result
= NULL
;
9464 static char buff
[32];
9469 switch (elf_header
.e_machine
)
9472 result
= get_mips_symbol_other (other
);
9475 result
= get_ia64_symbol_other (other
);
9478 result
= get_ppc64_symbol_other (other
);
9487 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9492 get_symbol_index_type (unsigned int type
)
9494 static char buff
[32];
9498 case SHN_UNDEF
: return "UND";
9499 case SHN_ABS
: return "ABS";
9500 case SHN_COMMON
: return "COM";
9502 if (type
== SHN_IA_64_ANSI_COMMON
9503 && elf_header
.e_machine
== EM_IA_64
9504 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9506 else if ((elf_header
.e_machine
== EM_X86_64
9507 || elf_header
.e_machine
== EM_L1OM
9508 || elf_header
.e_machine
== EM_K1OM
)
9509 && type
== SHN_X86_64_LCOMMON
)
9511 else if ((type
== SHN_MIPS_SCOMMON
9512 && elf_header
.e_machine
== EM_MIPS
)
9513 || (type
== SHN_TIC6X_SCOMMON
9514 && elf_header
.e_machine
== EM_TI_C6000
))
9516 else if (type
== SHN_MIPS_SUNDEFINED
9517 && elf_header
.e_machine
== EM_MIPS
)
9519 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9520 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9521 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9522 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9523 else if (type
>= SHN_LORESERVE
)
9524 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9525 else if (type
>= elf_header
.e_shnum
)
9526 sprintf (buff
, "bad section index[%3d]", type
);
9528 sprintf (buff
, "%3d", type
);
9536 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9538 unsigned char * e_data
;
9541 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9545 error (_("Out of memory\n"));
9549 if (fread (e_data
, ent_size
, number
, file
) != number
)
9551 error (_("Unable to read in dynamic data\n"));
9555 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9559 error (_("Out of memory\n"));
9565 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9573 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9575 Elf_Internal_Sym
* psym
;
9578 psym
= dynamic_symbols
+ si
;
9580 n
= print_vma (si
, DEC_5
);
9582 fputs (&" "[n
], stdout
);
9583 printf (" %3lu: ", hn
);
9584 print_vma (psym
->st_value
, LONG_HEX
);
9586 print_vma (psym
->st_size
, DEC_5
);
9588 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9589 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9590 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9591 /* Check to see if any other bits in the st_other field are set.
9592 Note - displaying this information disrupts the layout of the
9593 table being generated, but for the moment this case is very
9595 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9596 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9597 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9598 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9599 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9601 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9605 /* Dump the symbol table. */
9607 process_symbol_table (FILE * file
)
9609 Elf_Internal_Shdr
* section
;
9610 bfd_vma nbuckets
= 0;
9611 bfd_vma nchains
= 0;
9612 bfd_vma
* buckets
= NULL
;
9613 bfd_vma
* chains
= NULL
;
9614 bfd_vma ngnubuckets
= 0;
9615 bfd_vma
* gnubuckets
= NULL
;
9616 bfd_vma
* gnuchains
= NULL
;
9617 bfd_vma gnusymidx
= 0;
9619 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9622 if (dynamic_info
[DT_HASH
]
9624 || (do_using_dynamic
9626 && dynamic_strings
!= NULL
)))
9628 unsigned char nb
[8];
9629 unsigned char nc
[8];
9630 int hash_ent_size
= 4;
9632 if ((elf_header
.e_machine
== EM_ALPHA
9633 || elf_header
.e_machine
== EM_S390
9634 || elf_header
.e_machine
== EM_S390_OLD
)
9635 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9639 (archive_file_offset
9640 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9641 sizeof nb
+ sizeof nc
)),
9644 error (_("Unable to seek to start of dynamic information\n"));
9648 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9650 error (_("Failed to read in number of buckets\n"));
9654 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9656 error (_("Failed to read in number of chains\n"));
9660 nbuckets
= byte_get (nb
, hash_ent_size
);
9661 nchains
= byte_get (nc
, hash_ent_size
);
9663 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9664 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9667 if (buckets
== NULL
|| chains
== NULL
)
9669 if (do_using_dynamic
)
9680 if (dynamic_info_DT_GNU_HASH
9682 || (do_using_dynamic
9684 && dynamic_strings
!= NULL
)))
9686 unsigned char nb
[16];
9687 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9688 bfd_vma buckets_vma
;
9691 (archive_file_offset
9692 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9696 error (_("Unable to seek to start of dynamic information\n"));
9700 if (fread (nb
, 16, 1, file
) != 1)
9702 error (_("Failed to read in number of buckets\n"));
9706 ngnubuckets
= byte_get (nb
, 4);
9707 gnusymidx
= byte_get (nb
+ 4, 4);
9708 bitmaskwords
= byte_get (nb
+ 8, 4);
9709 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9711 buckets_vma
+= bitmaskwords
* 4;
9713 buckets_vma
+= bitmaskwords
* 8;
9716 (archive_file_offset
9717 + offset_from_vma (file
, buckets_vma
, 4)),
9720 error (_("Unable to seek to start of dynamic information\n"));
9724 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9726 if (gnubuckets
== NULL
)
9729 for (i
= 0; i
< ngnubuckets
; i
++)
9730 if (gnubuckets
[i
] != 0)
9732 if (gnubuckets
[i
] < gnusymidx
)
9735 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9736 maxchain
= gnubuckets
[i
];
9739 if (maxchain
== 0xffffffff)
9742 maxchain
-= gnusymidx
;
9745 (archive_file_offset
9746 + offset_from_vma (file
, buckets_vma
9747 + 4 * (ngnubuckets
+ maxchain
), 4)),
9750 error (_("Unable to seek to start of dynamic information\n"));
9756 if (fread (nb
, 4, 1, file
) != 1)
9758 error (_("Failed to determine last chain length\n"));
9762 if (maxchain
+ 1 == 0)
9767 while ((byte_get (nb
, 4) & 1) == 0);
9770 (archive_file_offset
9771 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9774 error (_("Unable to seek to start of dynamic information\n"));
9778 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9781 if (gnuchains
== NULL
)
9786 if (do_using_dynamic
)
9791 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9794 && dynamic_strings
!= NULL
)
9798 if (dynamic_info
[DT_HASH
])
9802 printf (_("\nSymbol table for image:\n"));
9804 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9806 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9808 for (hn
= 0; hn
< nbuckets
; hn
++)
9813 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9814 print_dynamic_symbol (si
, hn
);
9818 if (dynamic_info_DT_GNU_HASH
)
9820 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9822 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9824 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9826 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9827 if (gnubuckets
[hn
] != 0)
9829 bfd_vma si
= gnubuckets
[hn
];
9830 bfd_vma off
= si
- gnusymidx
;
9834 print_dynamic_symbol (si
, hn
);
9837 while ((gnuchains
[off
++] & 1) == 0);
9841 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9845 for (i
= 0, section
= section_headers
;
9846 i
< elf_header
.e_shnum
;
9850 char * strtab
= NULL
;
9851 unsigned long int strtab_size
= 0;
9852 Elf_Internal_Sym
* symtab
;
9853 Elf_Internal_Sym
* psym
;
9854 unsigned long num_syms
;
9856 if ((section
->sh_type
!= SHT_SYMTAB
9857 && section
->sh_type
!= SHT_DYNSYM
)
9859 && section
->sh_type
== SHT_SYMTAB
))
9862 if (section
->sh_entsize
== 0)
9864 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9865 SECTION_NAME (section
));
9869 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9870 SECTION_NAME (section
),
9871 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9874 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9876 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9878 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9882 if (section
->sh_link
== elf_header
.e_shstrndx
)
9884 strtab
= string_table
;
9885 strtab_size
= string_table_length
;
9887 else if (section
->sh_link
< elf_header
.e_shnum
)
9889 Elf_Internal_Shdr
* string_sec
;
9891 string_sec
= section_headers
+ section
->sh_link
;
9893 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9894 1, string_sec
->sh_size
,
9896 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9899 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9901 printf ("%6d: ", si
);
9902 print_vma (psym
->st_value
, LONG_HEX
);
9904 print_vma (psym
->st_size
, DEC_5
);
9905 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9906 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9907 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9908 /* Check to see if any other bits in the st_other field are set.
9909 Note - displaying this information disrupts the layout of the
9910 table being generated, but for the moment this case is very rare. */
9911 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9912 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9913 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9914 print_symbol (25, psym
->st_name
< strtab_size
9915 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9917 if (section
->sh_type
== SHT_DYNSYM
9918 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9920 unsigned char data
[2];
9921 unsigned short vers_data
;
9922 unsigned long offset
;
9926 offset
= offset_from_vma
9927 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9928 sizeof data
+ si
* sizeof (vers_data
));
9930 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9931 sizeof (data
), 1, _("version data")) == NULL
)
9934 vers_data
= byte_get (data
, 2);
9936 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9937 && section_headers
[psym
->st_shndx
].sh_type
9940 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9942 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9944 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9945 && (is_nobits
|| ! check_def
))
9947 Elf_External_Verneed evn
;
9948 Elf_Internal_Verneed ivn
;
9949 Elf_Internal_Vernaux ivna
;
9951 /* We must test both. */
9952 offset
= offset_from_vma
9953 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9958 unsigned long vna_off
;
9960 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9961 _("version need")) == NULL
)
9969 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9970 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9972 vna_off
= offset
+ ivn
.vn_aux
;
9976 Elf_External_Vernaux evna
;
9978 if (get_data (&evna
, file
, vna_off
,
9980 _("version need aux (3)")) == NULL
)
9988 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9989 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9990 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9993 vna_off
+= ivna
.vna_next
;
9995 while (ivna
.vna_other
!= vers_data
9996 && ivna
.vna_next
!= 0);
9998 if (ivna
.vna_other
== vers_data
)
10001 offset
+= ivn
.vn_next
;
10003 while (ivn
.vn_next
!= 0);
10005 if (ivna
.vna_other
== vers_data
)
10007 printf ("@%s (%d)",
10008 ivna
.vna_name
< strtab_size
10009 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10013 else if (! is_nobits
)
10014 error (_("bad dynamic symbol\n"));
10021 if (vers_data
!= 0x8001
10022 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10024 Elf_Internal_Verdef ivd
;
10025 Elf_Internal_Verdaux ivda
;
10026 Elf_External_Verdaux evda
;
10029 off
= offset_from_vma
10031 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10032 sizeof (Elf_External_Verdef
));
10036 Elf_External_Verdef evd
;
10038 if (get_data (&evd
, file
, off
, sizeof (evd
),
10039 1, _("version def")) == NULL
)
10047 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10048 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10049 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10052 off
+= ivd
.vd_next
;
10054 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10055 && ivd
.vd_next
!= 0);
10057 off
-= ivd
.vd_next
;
10060 if (get_data (&evda
, file
, off
, sizeof (evda
),
10061 1, _("version def aux")) == NULL
)
10064 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10066 if (psym
->st_name
!= ivda
.vda_name
)
10067 printf ((vers_data
& VERSYM_HIDDEN
)
10069 ivda
.vda_name
< strtab_size
10070 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10080 if (strtab
!= string_table
)
10086 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10088 if (do_histogram
&& buckets
!= NULL
)
10090 unsigned long * lengths
;
10091 unsigned long * counts
;
10094 unsigned long maxlength
= 0;
10095 unsigned long nzero_counts
= 0;
10096 unsigned long nsyms
= 0;
10098 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10099 (unsigned long) nbuckets
);
10100 printf (_(" Length Number %% of total Coverage\n"));
10102 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10103 if (lengths
== NULL
)
10105 error (_("Out of memory\n"));
10108 for (hn
= 0; hn
< nbuckets
; ++hn
)
10110 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10113 if (maxlength
< ++lengths
[hn
])
10118 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10119 if (counts
== NULL
)
10122 error (_("Out of memory\n"));
10126 for (hn
= 0; hn
< nbuckets
; ++hn
)
10127 ++counts
[lengths
[hn
]];
10132 printf (" 0 %-10lu (%5.1f%%)\n",
10133 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10134 for (i
= 1; i
<= maxlength
; ++i
)
10136 nzero_counts
+= counts
[i
] * i
;
10137 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10138 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10139 (nzero_counts
* 100.0) / nsyms
);
10147 if (buckets
!= NULL
)
10153 if (do_histogram
&& gnubuckets
!= NULL
)
10155 unsigned long * lengths
;
10156 unsigned long * counts
;
10158 unsigned long maxlength
= 0;
10159 unsigned long nzero_counts
= 0;
10160 unsigned long nsyms
= 0;
10162 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10163 if (lengths
== NULL
)
10165 error (_("Out of memory\n"));
10169 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10170 (unsigned long) ngnubuckets
);
10171 printf (_(" Length Number %% of total Coverage\n"));
10173 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10174 if (gnubuckets
[hn
] != 0)
10176 bfd_vma off
, length
= 1;
10178 for (off
= gnubuckets
[hn
] - gnusymidx
;
10179 (gnuchains
[off
] & 1) == 0; ++off
)
10181 lengths
[hn
] = length
;
10182 if (length
> maxlength
)
10183 maxlength
= length
;
10187 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10188 if (counts
== NULL
)
10191 error (_("Out of memory\n"));
10195 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10196 ++counts
[lengths
[hn
]];
10198 if (ngnubuckets
> 0)
10201 printf (" 0 %-10lu (%5.1f%%)\n",
10202 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10203 for (j
= 1; j
<= maxlength
; ++j
)
10205 nzero_counts
+= counts
[j
] * j
;
10206 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10207 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10208 (nzero_counts
* 100.0) / nsyms
);
10222 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10226 if (dynamic_syminfo
== NULL
10228 /* No syminfo, this is ok. */
10231 /* There better should be a dynamic symbol section. */
10232 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10236 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10237 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10239 printf (_(" Num: Name BoundTo Flags\n"));
10240 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10242 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10244 printf ("%4d: ", i
);
10245 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10246 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10248 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10251 switch (dynamic_syminfo
[i
].si_boundto
)
10253 case SYMINFO_BT_SELF
:
10254 fputs ("SELF ", stdout
);
10256 case SYMINFO_BT_PARENT
:
10257 fputs ("PARENT ", stdout
);
10260 if (dynamic_syminfo
[i
].si_boundto
> 0
10261 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10262 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10264 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10268 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10272 if (flags
& SYMINFO_FLG_DIRECT
)
10273 printf (" DIRECT");
10274 if (flags
& SYMINFO_FLG_PASSTHRU
)
10275 printf (" PASSTHRU");
10276 if (flags
& SYMINFO_FLG_COPY
)
10278 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10279 printf (" LAZYLOAD");
10287 /* Check to see if the given reloc needs to be handled in a target specific
10288 manner. If so then process the reloc and return TRUE otherwise return
10292 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10293 unsigned char * start
,
10294 Elf_Internal_Sym
* symtab
)
10296 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10298 switch (elf_header
.e_machine
)
10301 case EM_MSP430_OLD
:
10303 static Elf_Internal_Sym
* saved_sym
= NULL
;
10305 switch (reloc_type
)
10307 case 10: /* R_MSP430_SYM_DIFF */
10308 if (uses_msp430x_relocs ())
10310 case 21: /* R_MSP430X_SYM_DIFF */
10311 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10314 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10315 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10316 goto handle_sym_diff
;
10318 case 5: /* R_MSP430_16_BYTE */
10319 case 9: /* R_MSP430_8 */
10320 if (uses_msp430x_relocs ())
10322 goto handle_sym_diff
;
10324 case 2: /* R_MSP430_ABS16 */
10325 case 15: /* R_MSP430X_ABS16 */
10326 if (! uses_msp430x_relocs ())
10328 goto handle_sym_diff
;
10331 if (saved_sym
!= NULL
)
10335 value
= reloc
->r_addend
10336 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10337 - saved_sym
->st_value
);
10339 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10347 if (saved_sym
!= NULL
)
10348 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10355 case EM_CYGNUS_MN10300
:
10357 static Elf_Internal_Sym
* saved_sym
= NULL
;
10359 switch (reloc_type
)
10361 case 34: /* R_MN10300_ALIGN */
10363 case 33: /* R_MN10300_SYM_DIFF */
10364 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10366 case 1: /* R_MN10300_32 */
10367 case 2: /* R_MN10300_16 */
10368 if (saved_sym
!= NULL
)
10372 value
= reloc
->r_addend
10373 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10374 - saved_sym
->st_value
);
10376 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10383 if (saved_sym
!= NULL
)
10384 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10394 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10395 DWARF debug sections. This is a target specific test. Note - we do not
10396 go through the whole including-target-headers-multiple-times route, (as
10397 we have already done with <elf/h8.h>) because this would become very
10398 messy and even then this function would have to contain target specific
10399 information (the names of the relocs instead of their numeric values).
10400 FIXME: This is not the correct way to solve this problem. The proper way
10401 is to have target specific reloc sizing and typing functions created by
10402 the reloc-macros.h header, in the same way that it already creates the
10403 reloc naming functions. */
10406 is_32bit_abs_reloc (unsigned int reloc_type
)
10408 switch (elf_header
.e_machine
)
10412 return reloc_type
== 1; /* R_386_32. */
10414 return reloc_type
== 1; /* R_68K_32. */
10416 return reloc_type
== 1; /* R_860_32. */
10418 return reloc_type
== 2; /* R_960_32. */
10420 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10422 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10424 return reloc_type
== 1; /* R_ARC_32. */
10426 return reloc_type
== 2; /* R_ARM_ABS32 */
10429 return reloc_type
== 1;
10430 case EM_ADAPTEVA_EPIPHANY
:
10431 return reloc_type
== 3;
10433 return reloc_type
== 0x12; /* R_byte4_data. */
10435 return reloc_type
== 3; /* R_CRIS_32. */
10437 return reloc_type
== 3; /* R_CR16_NUM32. */
10439 return reloc_type
== 15; /* R_CRX_NUM32. */
10440 case EM_CYGNUS_FRV
:
10441 return reloc_type
== 1;
10442 case EM_CYGNUS_D10V
:
10444 return reloc_type
== 6; /* R_D10V_32. */
10445 case EM_CYGNUS_D30V
:
10447 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10449 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10450 case EM_CYGNUS_FR30
:
10452 return reloc_type
== 3; /* R_FR30_32. */
10456 return reloc_type
== 1; /* R_H8_DIR32. */
10458 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10461 return reloc_type
== 2; /* R_IP2K_32. */
10463 return reloc_type
== 2; /* R_IQ2000_32. */
10464 case EM_LATTICEMICO32
:
10465 return reloc_type
== 3; /* R_LM32_32. */
10468 return reloc_type
== 3; /* R_M32C_32. */
10470 return reloc_type
== 34; /* R_M32R_32_RELA. */
10472 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10473 case EM_CYGNUS_MEP
:
10474 return reloc_type
== 4; /* R_MEP_32. */
10476 return reloc_type
== 2; /* R_METAG_ADDR32. */
10477 case EM_MICROBLAZE
:
10478 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10480 return reloc_type
== 2; /* R_MIPS_32. */
10482 return reloc_type
== 4; /* R_MMIX_32. */
10483 case EM_CYGNUS_MN10200
:
10485 return reloc_type
== 1; /* R_MN10200_32. */
10486 case EM_CYGNUS_MN10300
:
10488 return reloc_type
== 1; /* R_MN10300_32. */
10490 return reloc_type
== 1; /* R_MOXIE_32. */
10491 case EM_MSP430_OLD
:
10493 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10495 return reloc_type
== 2; /* R_MT_32. */
10497 return reloc_type
== 20; /* R_NDS32_RELA. */
10498 case EM_ALTERA_NIOS2
:
10499 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10501 return reloc_type
== 1; /* R_NIOS_32. */
10503 return reloc_type
== 1; /* R_OR1K_32. */
10505 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10506 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10509 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10511 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10513 return reloc_type
== 1; /* R_PPC_ADDR32. */
10515 return reloc_type
== 1; /* R_RL78_DIR32. */
10517 return reloc_type
== 1; /* R_RX_DIR32. */
10519 return reloc_type
== 1; /* R_I370_ADDR31. */
10522 return reloc_type
== 4; /* R_S390_32. */
10524 return reloc_type
== 8; /* R_SCORE_ABS32. */
10526 return reloc_type
== 1; /* R_SH_DIR32. */
10527 case EM_SPARC32PLUS
:
10530 return reloc_type
== 3 /* R_SPARC_32. */
10531 || reloc_type
== 23; /* R_SPARC_UA32. */
10533 return reloc_type
== 6; /* R_SPU_ADDR32 */
10535 return reloc_type
== 1; /* R_C6000_ABS32. */
10537 return reloc_type
== 2; /* R_TILEGX_32. */
10539 return reloc_type
== 1; /* R_TILEPRO_32. */
10540 case EM_CYGNUS_V850
:
10542 return reloc_type
== 6; /* R_V850_ABS32. */
10544 return reloc_type
== 0x33; /* R_V810_WORD. */
10546 return reloc_type
== 1; /* R_VAX_32. */
10550 return reloc_type
== 10; /* R_X86_64_32. */
10553 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10555 return reloc_type
== 4; /* R_XGATE_32. */
10557 return reloc_type
== 1; /* R_XSTROMY16_32. */
10558 case EM_XTENSA_OLD
:
10560 return reloc_type
== 1; /* R_XTENSA_32. */
10562 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10563 elf_header
.e_machine
);
10568 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10569 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10572 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10574 switch (elf_header
.e_machine
)
10578 return reloc_type
== 2; /* R_386_PC32. */
10580 return reloc_type
== 4; /* R_68K_PC32. */
10582 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10583 case EM_ADAPTEVA_EPIPHANY
:
10584 return reloc_type
== 6;
10586 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10588 return reloc_type
== 3; /* R_ARM_REL32 */
10589 case EM_MICROBLAZE
:
10590 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10592 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10594 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10596 return reloc_type
== 26; /* R_PPC_REL32. */
10598 return reloc_type
== 26; /* R_PPC64_REL32. */
10601 return reloc_type
== 5; /* R_390_PC32. */
10603 return reloc_type
== 2; /* R_SH_REL32. */
10604 case EM_SPARC32PLUS
:
10607 return reloc_type
== 6; /* R_SPARC_DISP32. */
10609 return reloc_type
== 13; /* R_SPU_REL32. */
10611 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10613 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10617 return reloc_type
== 2; /* R_X86_64_PC32. */
10618 case EM_XTENSA_OLD
:
10620 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10622 /* Do not abort or issue an error message here. Not all targets use
10623 pc-relative 32-bit relocs in their DWARF debug information and we
10624 have already tested for target coverage in is_32bit_abs_reloc. A
10625 more helpful warning message will be generated by apply_relocations
10626 anyway, so just return. */
10631 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10632 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10635 is_64bit_abs_reloc (unsigned int reloc_type
)
10637 switch (elf_header
.e_machine
)
10640 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10642 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10644 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10646 return reloc_type
== 80; /* R_PARISC_DIR64. */
10648 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10649 case EM_SPARC32PLUS
:
10652 return reloc_type
== 54; /* R_SPARC_UA64. */
10656 return reloc_type
== 1; /* R_X86_64_64. */
10659 return reloc_type
== 22; /* R_S390_64. */
10661 return reloc_type
== 1; /* R_TILEGX_64. */
10663 return reloc_type
== 18; /* R_MIPS_64. */
10669 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10670 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10673 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10675 switch (elf_header
.e_machine
)
10678 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10680 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10682 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10684 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10686 return reloc_type
== 44; /* R_PPC64_REL64. */
10687 case EM_SPARC32PLUS
:
10690 return reloc_type
== 46; /* R_SPARC_DISP64. */
10694 return reloc_type
== 24; /* R_X86_64_PC64. */
10697 return reloc_type
== 23; /* R_S390_PC64. */
10699 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10706 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10709 is_24bit_abs_reloc (unsigned int reloc_type
)
10711 switch (elf_header
.e_machine
)
10713 case EM_CYGNUS_MN10200
:
10715 return reloc_type
== 4; /* R_MN10200_24. */
10721 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10722 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10725 is_16bit_abs_reloc (unsigned int reloc_type
)
10727 switch (elf_header
.e_machine
)
10731 return reloc_type
== 4; /* R_AVR_16. */
10732 case EM_ADAPTEVA_EPIPHANY
:
10733 return reloc_type
== 5;
10734 case EM_CYGNUS_D10V
:
10736 return reloc_type
== 3; /* R_D10V_16. */
10740 return reloc_type
== R_H8_DIR16
;
10743 return reloc_type
== 1; /* R_IP2K_16. */
10746 return reloc_type
== 1; /* R_M32C_16 */
10748 if (uses_msp430x_relocs ())
10749 return reloc_type
== 2; /* R_MSP430_ABS16. */
10750 case EM_MSP430_OLD
:
10751 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10753 return reloc_type
== 19; /* R_NDS32_RELA. */
10754 case EM_ALTERA_NIOS2
:
10755 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10757 return reloc_type
== 9; /* R_NIOS_16. */
10759 return reloc_type
== 2; /* R_OR1K_16. */
10761 return reloc_type
== 2; /* R_C6000_ABS16. */
10764 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10765 case EM_CYGNUS_MN10200
:
10767 return reloc_type
== 2; /* R_MN10200_16. */
10768 case EM_CYGNUS_MN10300
:
10770 return reloc_type
== 2; /* R_MN10300_16. */
10772 return reloc_type
== 3; /* R_XGATE_16. */
10778 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10779 relocation entries (possibly formerly used for SHT_GROUP sections). */
10782 is_none_reloc (unsigned int reloc_type
)
10784 switch (elf_header
.e_machine
)
10786 case EM_68K
: /* R_68K_NONE. */
10787 case EM_386
: /* R_386_NONE. */
10788 case EM_SPARC32PLUS
:
10790 case EM_SPARC
: /* R_SPARC_NONE. */
10791 case EM_MIPS
: /* R_MIPS_NONE. */
10792 case EM_PARISC
: /* R_PARISC_NONE. */
10793 case EM_ALPHA
: /* R_ALPHA_NONE. */
10794 case EM_ADAPTEVA_EPIPHANY
:
10795 case EM_PPC
: /* R_PPC_NONE. */
10796 case EM_PPC64
: /* R_PPC64_NONE. */
10797 case EM_ARM
: /* R_ARM_NONE. */
10798 case EM_IA_64
: /* R_IA64_NONE. */
10799 case EM_SH
: /* R_SH_NONE. */
10801 case EM_S390
: /* R_390_NONE. */
10802 case EM_CRIS
: /* R_CRIS_NONE. */
10803 case EM_X86_64
: /* R_X86_64_NONE. */
10804 case EM_L1OM
: /* R_X86_64_NONE. */
10805 case EM_K1OM
: /* R_X86_64_NONE. */
10806 case EM_MN10300
: /* R_MN10300_NONE. */
10807 case EM_MOXIE
: /* R_MOXIE_NONE. */
10808 case EM_M32R
: /* R_M32R_NONE. */
10809 case EM_TI_C6000
:/* R_C6000_NONE. */
10810 case EM_TILEGX
: /* R_TILEGX_NONE. */
10811 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10813 case EM_C166
: /* R_XC16X_NONE. */
10814 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10815 case EM_NIOS32
: /* R_NIOS_NONE. */
10816 case EM_OR1K
: /* R_OR1K_NONE. */
10817 return reloc_type
== 0;
10819 return reloc_type
== 0 || reloc_type
== 256;
10821 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10822 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10823 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10824 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10825 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10826 case EM_XTENSA_OLD
:
10828 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10829 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10830 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10831 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10833 return reloc_type
== 3; /* R_METAG_NONE. */
10838 /* Apply relocations to a section.
10839 Note: So far support has been added only for those relocations
10840 which can be found in debug sections.
10841 FIXME: Add support for more relocations ? */
10844 apply_relocations (void * file
,
10845 Elf_Internal_Shdr
* section
,
10846 unsigned char * start
)
10848 Elf_Internal_Shdr
* relsec
;
10849 unsigned char * end
= start
+ section
->sh_size
;
10851 if (elf_header
.e_type
!= ET_REL
)
10854 /* Find the reloc section associated with the section. */
10855 for (relsec
= section_headers
;
10856 relsec
< section_headers
+ elf_header
.e_shnum
;
10859 bfd_boolean is_rela
;
10860 unsigned long num_relocs
;
10861 Elf_Internal_Rela
* relocs
;
10862 Elf_Internal_Rela
* rp
;
10863 Elf_Internal_Shdr
* symsec
;
10864 Elf_Internal_Sym
* symtab
;
10865 unsigned long num_syms
;
10866 Elf_Internal_Sym
* sym
;
10868 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10869 || relsec
->sh_info
>= elf_header
.e_shnum
10870 || section_headers
+ relsec
->sh_info
!= section
10871 || relsec
->sh_size
== 0
10872 || relsec
->sh_link
>= elf_header
.e_shnum
)
10875 is_rela
= relsec
->sh_type
== SHT_RELA
;
10879 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10880 relsec
->sh_size
, & relocs
, & num_relocs
))
10885 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10886 relsec
->sh_size
, & relocs
, & num_relocs
))
10890 /* SH uses RELA but uses in place value instead of the addend field. */
10891 if (elf_header
.e_machine
== EM_SH
)
10894 symsec
= section_headers
+ relsec
->sh_link
;
10895 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10897 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10900 unsigned int reloc_type
;
10901 unsigned int reloc_size
;
10902 unsigned char * rloc
;
10903 unsigned long sym_index
;
10905 reloc_type
= get_reloc_type (rp
->r_info
);
10907 if (target_specific_reloc_handling (rp
, start
, symtab
))
10909 else if (is_none_reloc (reloc_type
))
10911 else if (is_32bit_abs_reloc (reloc_type
)
10912 || is_32bit_pcrel_reloc (reloc_type
))
10914 else if (is_64bit_abs_reloc (reloc_type
)
10915 || is_64bit_pcrel_reloc (reloc_type
))
10917 else if (is_24bit_abs_reloc (reloc_type
))
10919 else if (is_16bit_abs_reloc (reloc_type
))
10923 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10924 reloc_type
, SECTION_NAME (section
));
10928 rloc
= start
+ rp
->r_offset
;
10929 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10931 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10932 (unsigned long) rp
->r_offset
,
10933 SECTION_NAME (section
));
10937 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10938 if (sym_index
>= num_syms
)
10940 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10941 sym_index
, SECTION_NAME (section
));
10944 sym
= symtab
+ sym_index
;
10946 /* If the reloc has a symbol associated with it,
10947 make sure that it is of an appropriate type.
10949 Relocations against symbols without type can happen.
10950 Gcc -feliminate-dwarf2-dups may generate symbols
10951 without type for debug info.
10953 Icc generates relocations against function symbols
10954 instead of local labels.
10956 Relocations against object symbols can happen, eg when
10957 referencing a global array. For an example of this see
10958 the _clz.o binary in libgcc.a. */
10960 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10962 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10963 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10964 (long int)(rp
- relocs
),
10965 SECTION_NAME (relsec
));
10971 addend
+= rp
->r_addend
;
10972 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10973 partial_inplace. */
10975 || (elf_header
.e_machine
== EM_XTENSA
10976 && reloc_type
== 1)
10977 || ((elf_header
.e_machine
== EM_PJ
10978 || elf_header
.e_machine
== EM_PJ_OLD
)
10979 && reloc_type
== 1)
10980 || ((elf_header
.e_machine
== EM_D30V
10981 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10982 && reloc_type
== 12))
10983 addend
+= byte_get (rloc
, reloc_size
);
10985 if (is_32bit_pcrel_reloc (reloc_type
)
10986 || is_64bit_pcrel_reloc (reloc_type
))
10988 /* On HPPA, all pc-relative relocations are biased by 8. */
10989 if (elf_header
.e_machine
== EM_PARISC
)
10991 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10995 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11004 #ifdef SUPPORT_DISASSEMBLY
11006 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11008 printf (_("\nAssembly dump of section %s\n"),
11009 SECTION_NAME (section
));
11011 /* XXX -- to be done --- XXX */
11017 /* Reads in the contents of SECTION from FILE, returning a pointer
11018 to a malloc'ed buffer or NULL if something went wrong. */
11021 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11023 bfd_size_type num_bytes
;
11025 num_bytes
= section
->sh_size
;
11027 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11029 printf (_("\nSection '%s' has no data to dump.\n"),
11030 SECTION_NAME (section
));
11034 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11035 _("section contents"));
11040 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11042 Elf_Internal_Shdr
* relsec
;
11043 bfd_size_type num_bytes
;
11047 char * name
= SECTION_NAME (section
);
11048 bfd_boolean some_strings_shown
;
11050 start
= get_section_contents (section
, file
);
11054 printf (_("\nString dump of section '%s':\n"), name
);
11056 /* If the section being dumped has relocations against it the user might
11057 be expecting these relocations to have been applied. Check for this
11058 case and issue a warning message in order to avoid confusion.
11059 FIXME: Maybe we ought to have an option that dumps a section with
11060 relocs applied ? */
11061 for (relsec
= section_headers
;
11062 relsec
< section_headers
+ elf_header
.e_shnum
;
11065 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11066 || relsec
->sh_info
>= elf_header
.e_shnum
11067 || section_headers
+ relsec
->sh_info
!= section
11068 || relsec
->sh_size
== 0
11069 || relsec
->sh_link
>= elf_header
.e_shnum
)
11072 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11076 num_bytes
= section
->sh_size
;
11078 end
= start
+ num_bytes
;
11079 some_strings_shown
= FALSE
;
11083 while (!ISPRINT (* data
))
11084 if (++ data
>= end
)
11090 /* PR 11128: Use two separate invocations in order to work
11091 around bugs in the Solaris 8 implementation of printf. */
11092 printf (" [%6tx] ", data
- start
);
11093 printf ("%s\n", data
);
11095 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11097 data
+= strlen (data
);
11098 some_strings_shown
= TRUE
;
11102 if (! some_strings_shown
)
11103 printf (_(" No strings found in this section."));
11111 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11113 bfd_boolean relocate
)
11115 Elf_Internal_Shdr
* relsec
;
11116 bfd_size_type bytes
;
11118 unsigned char * data
;
11119 unsigned char * start
;
11121 start
= (unsigned char *) get_section_contents (section
, file
);
11125 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11129 apply_relocations (file
, section
, start
);
11133 /* If the section being dumped has relocations against it the user might
11134 be expecting these relocations to have been applied. Check for this
11135 case and issue a warning message in order to avoid confusion.
11136 FIXME: Maybe we ought to have an option that dumps a section with
11137 relocs applied ? */
11138 for (relsec
= section_headers
;
11139 relsec
< section_headers
+ elf_header
.e_shnum
;
11142 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11143 || relsec
->sh_info
>= elf_header
.e_shnum
11144 || section_headers
+ relsec
->sh_info
!= section
11145 || relsec
->sh_size
== 0
11146 || relsec
->sh_link
>= elf_header
.e_shnum
)
11149 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11154 addr
= section
->sh_addr
;
11155 bytes
= section
->sh_size
;
11164 lbytes
= (bytes
> 16 ? 16 : bytes
);
11166 printf (" 0x%8.8lx ", (unsigned long) addr
);
11168 for (j
= 0; j
< 16; j
++)
11171 printf ("%2.2x", data
[j
]);
11179 for (j
= 0; j
< lbytes
; j
++)
11182 if (k
>= ' ' && k
< 0x7f)
11200 /* Uncompresses a section that was compressed using zlib, in place. */
11203 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11204 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11206 #ifndef HAVE_ZLIB_H
11209 dwarf_size_type compressed_size
= *size
;
11210 unsigned char * compressed_buffer
= *buffer
;
11211 dwarf_size_type uncompressed_size
;
11212 unsigned char * uncompressed_buffer
;
11215 dwarf_size_type header_size
= 12;
11217 /* Read the zlib header. In this case, it should be "ZLIB" followed
11218 by the uncompressed section size, 8 bytes in big-endian order. */
11219 if (compressed_size
< header_size
11220 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11223 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11224 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11225 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11226 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11227 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11228 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11229 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11230 uncompressed_size
+= compressed_buffer
[11];
11232 /* It is possible the section consists of several compressed
11233 buffers concatenated together, so we uncompress in a loop. */
11234 strm
.zalloc
= NULL
;
11236 strm
.opaque
= NULL
;
11237 strm
.avail_in
= compressed_size
- header_size
;
11238 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11239 strm
.avail_out
= uncompressed_size
;
11240 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11242 rc
= inflateInit (& strm
);
11243 while (strm
.avail_in
> 0)
11247 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11248 + (uncompressed_size
- strm
.avail_out
));
11249 rc
= inflate (&strm
, Z_FINISH
);
11250 if (rc
!= Z_STREAM_END
)
11252 rc
= inflateReset (& strm
);
11254 rc
= inflateEnd (& strm
);
11256 || strm
.avail_out
!= 0)
11259 free (compressed_buffer
);
11260 *buffer
= uncompressed_buffer
;
11261 *size
= uncompressed_size
;
11265 free (uncompressed_buffer
);
11266 /* Indicate decompression failure. */
11269 #endif /* HAVE_ZLIB_H */
11273 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11274 Elf_Internal_Shdr
* sec
, void * file
)
11276 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11279 /* If it is already loaded, do nothing. */
11280 if (section
->start
!= NULL
)
11283 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11284 section
->address
= sec
->sh_addr
;
11285 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11287 sec
->sh_size
, buf
);
11288 if (section
->start
== NULL
)
11292 section
->size
= sec
->sh_size
;
11293 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11294 sec
->sh_size
= section
->size
;
11297 if (section
->start
== NULL
)
11300 if (debug_displays
[debug
].relocate
)
11301 apply_relocations ((FILE *) file
, sec
, section
->start
);
11306 /* If this is not NULL, load_debug_section will only look for sections
11307 within the list of sections given here. */
11308 unsigned int *section_subset
= NULL
;
11311 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11313 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11314 Elf_Internal_Shdr
* sec
;
11316 /* Locate the debug section. */
11317 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11319 section
->name
= section
->uncompressed_name
;
11322 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11324 section
->name
= section
->compressed_name
;
11329 /* If we're loading from a subset of sections, and we've loaded
11330 a section matching this name before, it's likely that it's a
11332 if (section_subset
!= NULL
)
11333 free_debug_section (debug
);
11335 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11339 free_debug_section (enum dwarf_section_display_enum debug
)
11341 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11343 if (section
->start
== NULL
)
11346 free ((char *) section
->start
);
11347 section
->start
= NULL
;
11348 section
->address
= 0;
11353 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11355 char * name
= SECTION_NAME (section
);
11356 bfd_size_type length
;
11360 length
= section
->sh_size
;
11363 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11366 if (section
->sh_type
== SHT_NOBITS
)
11368 /* There is no point in dumping the contents of a debugging section
11369 which has the NOBITS type - the bits in the file will be random.
11370 This can happen when a file containing a .eh_frame section is
11371 stripped with the --only-keep-debug command line option. */
11372 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11376 if (const_strneq (name
, ".gnu.linkonce.wi."))
11377 name
= ".debug_info";
11379 /* See if we know how to display the contents of this section. */
11380 for (i
= 0; i
< max
; i
++)
11381 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11382 || (i
== line
&& const_strneq (name
, ".debug_line."))
11383 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11385 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11386 int secondary
= (section
!= find_section (name
));
11389 free_debug_section ((enum dwarf_section_display_enum
) i
);
11391 if (i
== line
&& const_strneq (name
, ".debug_line."))
11393 else if (streq (sec
->uncompressed_name
, name
))
11394 sec
->name
= sec
->uncompressed_name
;
11396 sec
->name
= sec
->compressed_name
;
11397 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11400 /* If this debug section is part of a CU/TU set in a .dwp file,
11401 restrict load_debug_section to the sections in that set. */
11402 section_subset
= find_cu_tu_set (file
, shndx
);
11404 result
&= debug_displays
[i
].display (sec
, file
);
11406 section_subset
= NULL
;
11408 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11409 free_debug_section ((enum dwarf_section_display_enum
) i
);
11417 printf (_("Unrecognized debug section: %s\n"), name
);
11424 /* Set DUMP_SECTS for all sections where dumps were requested
11425 based on section name. */
11428 initialise_dumps_byname (void)
11430 struct dump_list_entry
* cur
;
11432 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11437 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11438 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11440 request_dump_bynumber (i
, cur
->type
);
11445 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11451 process_section_contents (FILE * file
)
11453 Elf_Internal_Shdr
* section
;
11459 initialise_dumps_byname ();
11461 for (i
= 0, section
= section_headers
;
11462 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11465 #ifdef SUPPORT_DISASSEMBLY
11466 if (dump_sects
[i
] & DISASS_DUMP
)
11467 disassemble_section (section
, file
);
11469 if (dump_sects
[i
] & HEX_DUMP
)
11470 dump_section_as_bytes (section
, file
, FALSE
);
11472 if (dump_sects
[i
] & RELOC_DUMP
)
11473 dump_section_as_bytes (section
, file
, TRUE
);
11475 if (dump_sects
[i
] & STRING_DUMP
)
11476 dump_section_as_strings (section
, file
);
11478 if (dump_sects
[i
] & DEBUG_DUMP
)
11479 display_debug_section (i
, section
, file
);
11482 /* Check to see if the user requested a
11483 dump of a section that does not exist. */
11484 while (i
++ < num_dump_sects
)
11486 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11490 process_mips_fpe_exception (int mask
)
11495 if (mask
& OEX_FPU_INEX
)
11496 fputs ("INEX", stdout
), first
= 0;
11497 if (mask
& OEX_FPU_UFLO
)
11498 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11499 if (mask
& OEX_FPU_OFLO
)
11500 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11501 if (mask
& OEX_FPU_DIV0
)
11502 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11503 if (mask
& OEX_FPU_INVAL
)
11504 printf ("%sINVAL", first
? "" : "|");
11507 fputs ("0", stdout
);
11510 /* Display's the value of TAG at location P. If TAG is
11511 greater than 0 it is assumed to be an unknown tag, and
11512 a message is printed to this effect. Otherwise it is
11513 assumed that a message has already been printed.
11515 If the bottom bit of TAG is set it assumed to have a
11516 string value, otherwise it is assumed to have an integer
11519 Returns an updated P pointing to the first unread byte
11520 beyond the end of TAG's value.
11522 Reads at or beyond END will not be made. */
11524 static unsigned char *
11525 display_tag_value (int tag
,
11527 const unsigned char * const end
)
11532 printf (" Tag_unknown_%d: ", tag
);
11536 warn (_("corrupt tag\n"));
11540 /* FIXME: we could read beyond END here. */
11541 printf ("\"%s\"\n", p
);
11542 p
+= strlen ((char *) p
) + 1;
11548 val
= read_uleb128 (p
, &len
, end
);
11550 printf ("%ld (0x%lx)\n", val
, val
);
11556 /* ARM EABI attributes section. */
11561 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11563 const char ** table
;
11564 } arm_attr_public_tag
;
11566 static const char * arm_attr_tag_CPU_arch
[] =
11567 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11568 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11569 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11570 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11571 {"No", "Thumb-1", "Thumb-2"};
11572 static const char * arm_attr_tag_FP_arch
[] =
11573 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11575 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11576 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11577 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11578 static const char * arm_attr_tag_PCS_config
[] =
11579 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11580 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11581 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11582 {"V6", "SB", "TLS", "Unused"};
11583 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11584 {"Absolute", "PC-relative", "SB-relative", "None"};
11585 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11586 {"Absolute", "PC-relative", "None"};
11587 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11588 {"None", "direct", "GOT-indirect"};
11589 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11590 {"None", "??? 1", "2", "??? 3", "4"};
11591 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11592 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11593 {"Unused", "Needed", "Sign only"};
11594 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11595 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11596 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11597 {"Unused", "Finite", "RTABI", "IEEE 754"};
11598 static const char * arm_attr_tag_ABI_enum_size
[] =
11599 {"Unused", "small", "int", "forced to int"};
11600 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11601 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11602 static const char * arm_attr_tag_ABI_VFP_args
[] =
11603 {"AAPCS", "VFP registers", "custom"};
11604 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11605 {"AAPCS", "WMMX registers", "custom"};
11606 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11607 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11608 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11609 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11610 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11611 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11612 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11613 static const char * arm_attr_tag_FP_HP_extension
[] =
11614 {"Not Allowed", "Allowed"};
11615 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11616 {"None", "IEEE 754", "Alternative Format"};
11617 static const char * arm_attr_tag_MPextension_use
[] =
11618 {"Not Allowed", "Allowed"};
11619 static const char * arm_attr_tag_DIV_use
[] =
11620 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11621 "Allowed in v7-A with integer division extension"};
11622 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11623 static const char * arm_attr_tag_Virtualization_use
[] =
11624 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11625 "TrustZone and Virtualization Extensions"};
11626 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11627 {"Not Allowed", "Allowed"};
11629 #define LOOKUP(id, name) \
11630 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11631 static arm_attr_public_tag arm_attr_public_tags
[] =
11633 {4, "CPU_raw_name", 1, NULL
},
11634 {5, "CPU_name", 1, NULL
},
11635 LOOKUP(6, CPU_arch
),
11636 {7, "CPU_arch_profile", 0, NULL
},
11637 LOOKUP(8, ARM_ISA_use
),
11638 LOOKUP(9, THUMB_ISA_use
),
11639 LOOKUP(10, FP_arch
),
11640 LOOKUP(11, WMMX_arch
),
11641 LOOKUP(12, Advanced_SIMD_arch
),
11642 LOOKUP(13, PCS_config
),
11643 LOOKUP(14, ABI_PCS_R9_use
),
11644 LOOKUP(15, ABI_PCS_RW_data
),
11645 LOOKUP(16, ABI_PCS_RO_data
),
11646 LOOKUP(17, ABI_PCS_GOT_use
),
11647 LOOKUP(18, ABI_PCS_wchar_t
),
11648 LOOKUP(19, ABI_FP_rounding
),
11649 LOOKUP(20, ABI_FP_denormal
),
11650 LOOKUP(21, ABI_FP_exceptions
),
11651 LOOKUP(22, ABI_FP_user_exceptions
),
11652 LOOKUP(23, ABI_FP_number_model
),
11653 {24, "ABI_align_needed", 0, NULL
},
11654 {25, "ABI_align_preserved", 0, NULL
},
11655 LOOKUP(26, ABI_enum_size
),
11656 LOOKUP(27, ABI_HardFP_use
),
11657 LOOKUP(28, ABI_VFP_args
),
11658 LOOKUP(29, ABI_WMMX_args
),
11659 LOOKUP(30, ABI_optimization_goals
),
11660 LOOKUP(31, ABI_FP_optimization_goals
),
11661 {32, "compatibility", 0, NULL
},
11662 LOOKUP(34, CPU_unaligned_access
),
11663 LOOKUP(36, FP_HP_extension
),
11664 LOOKUP(38, ABI_FP_16bit_format
),
11665 LOOKUP(42, MPextension_use
),
11666 LOOKUP(44, DIV_use
),
11667 {64, "nodefaults", 0, NULL
},
11668 {65, "also_compatible_with", 0, NULL
},
11669 LOOKUP(66, T2EE_use
),
11670 {67, "conformance", 1, NULL
},
11671 LOOKUP(68, Virtualization_use
),
11672 LOOKUP(70, MPextension_use_legacy
)
11676 static unsigned char *
11677 display_arm_attribute (unsigned char * p
,
11678 const unsigned char * const end
)
11683 arm_attr_public_tag
* attr
;
11687 tag
= read_uleb128 (p
, &len
, end
);
11690 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11692 if (arm_attr_public_tags
[i
].tag
== tag
)
11694 attr
= &arm_attr_public_tags
[i
];
11701 printf (" Tag_%s: ", attr
->name
);
11702 switch (attr
->type
)
11707 case 7: /* Tag_CPU_arch_profile. */
11708 val
= read_uleb128 (p
, &len
, end
);
11712 case 0: printf (_("None\n")); break;
11713 case 'A': printf (_("Application\n")); break;
11714 case 'R': printf (_("Realtime\n")); break;
11715 case 'M': printf (_("Microcontroller\n")); break;
11716 case 'S': printf (_("Application or Realtime\n")); break;
11717 default: printf ("??? (%d)\n", val
); break;
11721 case 24: /* Tag_align_needed. */
11722 val
= read_uleb128 (p
, &len
, end
);
11726 case 0: printf (_("None\n")); break;
11727 case 1: printf (_("8-byte\n")); break;
11728 case 2: printf (_("4-byte\n")); break;
11729 case 3: printf ("??? 3\n"); break;
11732 printf (_("8-byte and up to %d-byte extended\n"),
11735 printf ("??? (%d)\n", val
);
11740 case 25: /* Tag_align_preserved. */
11741 val
= read_uleb128 (p
, &len
, end
);
11745 case 0: printf (_("None\n")); break;
11746 case 1: printf (_("8-byte, except leaf SP\n")); break;
11747 case 2: printf (_("8-byte\n")); break;
11748 case 3: printf ("??? 3\n"); break;
11751 printf (_("8-byte and up to %d-byte extended\n"),
11754 printf ("??? (%d)\n", val
);
11759 case 32: /* Tag_compatibility. */
11760 val
= read_uleb128 (p
, &len
, end
);
11762 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11763 p
+= strlen ((char *) p
) + 1;
11766 case 64: /* Tag_nodefaults. */
11768 printf (_("True\n"));
11771 case 65: /* Tag_also_compatible_with. */
11772 val
= read_uleb128 (p
, &len
, end
);
11774 if (val
== 6 /* Tag_CPU_arch. */)
11776 val
= read_uleb128 (p
, &len
, end
);
11778 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11779 printf ("??? (%d)\n", val
);
11781 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11785 while (*(p
++) != '\0' /* NUL terminator. */);
11794 return display_tag_value (-1, p
, end
);
11796 return display_tag_value (0, p
, end
);
11799 assert (attr
->type
& 0x80);
11800 val
= read_uleb128 (p
, &len
, end
);
11802 type
= attr
->type
& 0x7f;
11804 printf ("??? (%d)\n", val
);
11806 printf ("%s\n", attr
->table
[val
]);
11811 return display_tag_value (tag
, p
, end
);
11814 static unsigned char *
11815 display_gnu_attribute (unsigned char * p
,
11816 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11817 const unsigned char * const end
)
11823 tag
= read_uleb128 (p
, &len
, end
);
11826 /* Tag_compatibility is the only generic GNU attribute defined at
11830 val
= read_uleb128 (p
, &len
, end
);
11834 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11835 warn (_("corrupt vendor attribute\n"));
11839 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11840 p
+= strlen ((char *) p
) + 1;
11845 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11846 return display_proc_gnu_attribute (p
, tag
, end
);
11848 return display_tag_value (tag
, p
, end
);
11851 static unsigned char *
11852 display_power_gnu_attribute (unsigned char * p
,
11854 const unsigned char * const end
)
11859 if (tag
== Tag_GNU_Power_ABI_FP
)
11861 val
= read_uleb128 (p
, &len
, end
);
11863 printf (" Tag_GNU_Power_ABI_FP: ");
11868 printf (_("Hard or soft float\n"));
11871 printf (_("Hard float\n"));
11874 printf (_("Soft float\n"));
11877 printf (_("Single-precision hard float\n"));
11880 printf ("??? (%d)\n", val
);
11886 if (tag
== Tag_GNU_Power_ABI_Vector
)
11888 val
= read_uleb128 (p
, &len
, end
);
11890 printf (" Tag_GNU_Power_ABI_Vector: ");
11894 printf (_("Any\n"));
11897 printf (_("Generic\n"));
11900 printf ("AltiVec\n");
11906 printf ("??? (%d)\n", val
);
11912 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11916 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11920 val
= read_uleb128 (p
, &len
, end
);
11922 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11926 printf (_("Any\n"));
11929 printf ("r3/r4\n");
11932 printf (_("Memory\n"));
11935 printf ("??? (%d)\n", val
);
11941 return display_tag_value (tag
& 1, p
, end
);
11945 display_sparc_hwcaps (int mask
)
11950 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11951 fputs ("mul32", stdout
), first
= 0;
11952 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11953 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11954 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11955 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11956 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11957 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11958 if (mask
& ELF_SPARC_HWCAP_POPC
)
11959 printf ("%spopc", first
? "" : "|"), first
= 0;
11960 if (mask
& ELF_SPARC_HWCAP_VIS
)
11961 printf ("%svis", first
? "" : "|"), first
= 0;
11962 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11963 printf ("%svis2", first
? "" : "|"), first
= 0;
11964 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11965 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11966 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11967 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11968 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11969 printf ("%svis3", first
? "" : "|"), first
= 0;
11970 if (mask
& ELF_SPARC_HWCAP_HPC
)
11971 printf ("%shpc", first
? "" : "|"), first
= 0;
11972 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11973 printf ("%srandom", first
? "" : "|"), first
= 0;
11974 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11975 printf ("%strans", first
? "" : "|"), first
= 0;
11976 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11977 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11978 if (mask
& ELF_SPARC_HWCAP_IMA
)
11979 printf ("%sima", first
? "" : "|"), first
= 0;
11980 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11981 printf ("%scspare", first
? "" : "|"), first
= 0;
11984 fputc('0', stdout
);
11985 fputc('\n', stdout
);
11989 display_sparc_hwcaps2 (int mask
)
11994 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
11995 fputs ("fjathplus", stdout
), first
= 0;
11996 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
11997 printf ("%svis3b", first
? "" : "|"), first
= 0;
11998 if (mask
& ELF_SPARC_HWCAP2_ADP
)
11999 printf ("%sadp", first
? "" : "|"), first
= 0;
12000 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12001 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12002 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12003 printf ("%smwait", first
? "" : "|"), first
= 0;
12004 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12005 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12006 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12007 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12008 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12009 printf ("%snsec", first
? "" : "|"), first
= 0;
12010 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12011 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12012 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12013 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12014 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12015 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12018 fputc('0', stdout
);
12019 fputc('\n', stdout
);
12022 static unsigned char *
12023 display_sparc_gnu_attribute (unsigned char * p
,
12025 const unsigned char * const end
)
12030 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12032 val
= read_uleb128 (p
, &len
, end
);
12034 printf (" Tag_GNU_Sparc_HWCAPS: ");
12035 display_sparc_hwcaps (val
);
12038 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12040 val
= read_uleb128 (p
, &len
, end
);
12042 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12043 display_sparc_hwcaps2 (val
);
12047 return display_tag_value (tag
, p
, end
);
12051 print_mips_fp_abi_value (int val
)
12055 case Val_GNU_MIPS_ABI_FP_ANY
:
12056 printf (_("Hard or soft float\n"));
12058 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12059 printf (_("Hard float (double precision)\n"));
12061 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12062 printf (_("Hard float (single precision)\n"));
12064 case Val_GNU_MIPS_ABI_FP_SOFT
:
12065 printf (_("Soft float\n"));
12067 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12068 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12070 case Val_GNU_MIPS_ABI_FP_XX
:
12071 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12073 case Val_GNU_MIPS_ABI_FP_64
:
12074 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12076 case Val_GNU_MIPS_ABI_FP_64A
:
12077 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12080 printf ("??? (%d)\n", val
);
12085 static unsigned char *
12086 display_mips_gnu_attribute (unsigned char * p
,
12088 const unsigned char * const end
)
12090 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12095 val
= read_uleb128 (p
, &len
, end
);
12097 printf (" Tag_GNU_MIPS_ABI_FP: ");
12099 print_mips_fp_abi_value (val
);
12104 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12109 val
= read_uleb128 (p
, &len
, end
);
12111 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12115 case Val_GNU_MIPS_ABI_MSA_ANY
:
12116 printf (_("Any MSA or not\n"));
12118 case Val_GNU_MIPS_ABI_MSA_128
:
12119 printf (_("128-bit MSA\n"));
12122 printf ("??? (%d)\n", val
);
12128 return display_tag_value (tag
& 1, p
, end
);
12131 static unsigned char *
12132 display_tic6x_attribute (unsigned char * p
,
12133 const unsigned char * const end
)
12139 tag
= read_uleb128 (p
, &len
, end
);
12145 val
= read_uleb128 (p
, &len
, end
);
12147 printf (" Tag_ISA: ");
12151 case C6XABI_Tag_ISA_none
:
12152 printf (_("None\n"));
12154 case C6XABI_Tag_ISA_C62X
:
12157 case C6XABI_Tag_ISA_C67X
:
12160 case C6XABI_Tag_ISA_C67XP
:
12161 printf ("C67x+\n");
12163 case C6XABI_Tag_ISA_C64X
:
12166 case C6XABI_Tag_ISA_C64XP
:
12167 printf ("C64x+\n");
12169 case C6XABI_Tag_ISA_C674X
:
12170 printf ("C674x\n");
12173 printf ("??? (%d)\n", val
);
12178 case Tag_ABI_wchar_t
:
12179 val
= read_uleb128 (p
, &len
, end
);
12181 printf (" Tag_ABI_wchar_t: ");
12185 printf (_("Not used\n"));
12188 printf (_("2 bytes\n"));
12191 printf (_("4 bytes\n"));
12194 printf ("??? (%d)\n", val
);
12199 case Tag_ABI_stack_align_needed
:
12200 val
= read_uleb128 (p
, &len
, end
);
12202 printf (" Tag_ABI_stack_align_needed: ");
12206 printf (_("8-byte\n"));
12209 printf (_("16-byte\n"));
12212 printf ("??? (%d)\n", val
);
12217 case Tag_ABI_stack_align_preserved
:
12218 val
= read_uleb128 (p
, &len
, end
);
12220 printf (" Tag_ABI_stack_align_preserved: ");
12224 printf (_("8-byte\n"));
12227 printf (_("16-byte\n"));
12230 printf ("??? (%d)\n", val
);
12236 val
= read_uleb128 (p
, &len
, end
);
12238 printf (" Tag_ABI_DSBT: ");
12242 printf (_("DSBT addressing not used\n"));
12245 printf (_("DSBT addressing used\n"));
12248 printf ("??? (%d)\n", val
);
12254 val
= read_uleb128 (p
, &len
, end
);
12256 printf (" Tag_ABI_PID: ");
12260 printf (_("Data addressing position-dependent\n"));
12263 printf (_("Data addressing position-independent, GOT near DP\n"));
12266 printf (_("Data addressing position-independent, GOT far from DP\n"));
12269 printf ("??? (%d)\n", val
);
12275 val
= read_uleb128 (p
, &len
, end
);
12277 printf (" Tag_ABI_PIC: ");
12281 printf (_("Code addressing position-dependent\n"));
12284 printf (_("Code addressing position-independent\n"));
12287 printf ("??? (%d)\n", val
);
12292 case Tag_ABI_array_object_alignment
:
12293 val
= read_uleb128 (p
, &len
, end
);
12295 printf (" Tag_ABI_array_object_alignment: ");
12299 printf (_("8-byte\n"));
12302 printf (_("4-byte\n"));
12305 printf (_("16-byte\n"));
12308 printf ("??? (%d)\n", val
);
12313 case Tag_ABI_array_object_align_expected
:
12314 val
= read_uleb128 (p
, &len
, end
);
12316 printf (" Tag_ABI_array_object_align_expected: ");
12320 printf (_("8-byte\n"));
12323 printf (_("4-byte\n"));
12326 printf (_("16-byte\n"));
12329 printf ("??? (%d)\n", val
);
12334 case Tag_ABI_compatibility
:
12335 val
= read_uleb128 (p
, &len
, end
);
12337 printf (" Tag_ABI_compatibility: ");
12338 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12339 p
+= strlen ((char *) p
) + 1;
12342 case Tag_ABI_conformance
:
12343 printf (" Tag_ABI_conformance: ");
12344 printf ("\"%s\"\n", p
);
12345 p
+= strlen ((char *) p
) + 1;
12349 return display_tag_value (tag
, p
, end
);
12353 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12355 unsigned long addr
= 0;
12356 size_t bytes
= end
- p
;
12362 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12364 printf (" 0x%8.8lx ", addr
);
12366 for (j
= 0; j
< 16; j
++)
12369 printf ("%2.2x", p
[j
]);
12377 for (j
= 0; j
< lbytes
; j
++)
12380 if (k
>= ' ' && k
< 0x7f)
12396 static unsigned char *
12397 display_msp430x_attribute (unsigned char * p
,
12398 const unsigned char * const end
)
12404 tag
= read_uleb128 (p
, & len
, end
);
12409 case OFBA_MSPABI_Tag_ISA
:
12410 val
= read_uleb128 (p
, &len
, end
);
12412 printf (" Tag_ISA: ");
12415 case 0: printf (_("None\n")); break;
12416 case 1: printf (_("MSP430\n")); break;
12417 case 2: printf (_("MSP430X\n")); break;
12418 default: printf ("??? (%d)\n", val
); break;
12422 case OFBA_MSPABI_Tag_Code_Model
:
12423 val
= read_uleb128 (p
, &len
, end
);
12425 printf (" Tag_Code_Model: ");
12428 case 0: printf (_("None\n")); break;
12429 case 1: printf (_("Small\n")); break;
12430 case 2: printf (_("Large\n")); break;
12431 default: printf ("??? (%d)\n", val
); break;
12435 case OFBA_MSPABI_Tag_Data_Model
:
12436 val
= read_uleb128 (p
, &len
, end
);
12438 printf (" Tag_Data_Model: ");
12441 case 0: printf (_("None\n")); break;
12442 case 1: printf (_("Small\n")); break;
12443 case 2: printf (_("Large\n")); break;
12444 case 3: printf (_("Restricted Large\n")); break;
12445 default: printf ("??? (%d)\n", val
); break;
12450 printf (_(" <unknown tag %d>: "), tag
);
12454 printf ("\"%s\"\n", p
);
12455 p
+= strlen ((char *) p
) + 1;
12459 val
= read_uleb128 (p
, &len
, end
);
12461 printf ("%d (0x%x)\n", val
, val
);
12470 process_attributes (FILE * file
,
12471 const char * public_name
,
12472 unsigned int proc_type
,
12473 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12474 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12476 Elf_Internal_Shdr
* sect
;
12477 unsigned char * contents
;
12479 unsigned char * end
;
12480 bfd_vma section_len
;
12484 /* Find the section header so that we get the size. */
12485 for (i
= 0, sect
= section_headers
;
12486 i
< elf_header
.e_shnum
;
12489 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12492 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12493 sect
->sh_size
, _("attributes"));
12494 if (contents
== NULL
)
12500 len
= sect
->sh_size
- 1;
12505 unsigned int namelen
;
12506 bfd_boolean public_section
;
12507 bfd_boolean gnu_section
;
12509 section_len
= byte_get (p
, 4);
12512 if (section_len
> len
)
12514 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12515 (unsigned) section_len
, (unsigned) len
);
12519 len
-= section_len
;
12522 namelen
= strnlen ((char *) p
, section_len
) + 1;
12523 if (namelen
== 0 || namelen
>= section_len
)
12525 error (_("Corrupt attribute section name\n"));
12529 printf (_("Attribute Section: %s\n"), p
);
12531 if (public_name
&& streq ((char *) p
, public_name
))
12532 public_section
= TRUE
;
12534 public_section
= FALSE
;
12536 if (streq ((char *) p
, "gnu"))
12537 gnu_section
= TRUE
;
12539 gnu_section
= FALSE
;
12542 section_len
-= namelen
;
12543 while (section_len
> 0)
12549 size
= byte_get (p
, 4);
12550 if (size
> section_len
)
12552 error (_("Bad subsection length (%u > %u)\n"),
12553 (unsigned) size
, (unsigned) section_len
);
12554 size
= section_len
;
12557 section_len
-= size
;
12558 end
= p
+ size
- 1;
12564 printf (_("File Attributes\n"));
12567 printf (_("Section Attributes:"));
12570 printf (_("Symbol Attributes:"));
12576 val
= read_uleb128 (p
, &j
, end
);
12580 printf (" %d", val
);
12585 printf (_("Unknown tag: %d\n"), tag
);
12586 public_section
= FALSE
;
12590 if (public_section
)
12593 p
= display_pub_attribute (p
, end
);
12595 else if (gnu_section
)
12598 p
= display_gnu_attribute (p
,
12599 display_proc_gnu_attribute
,
12604 printf (_(" Unknown section contexts\n"));
12605 display_raw_attribute (p
, end
);
12612 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12620 process_arm_specific (FILE * file
)
12622 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12623 display_arm_attribute
, NULL
);
12627 process_power_specific (FILE * file
)
12629 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12630 display_power_gnu_attribute
);
12634 process_sparc_specific (FILE * file
)
12636 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12637 display_sparc_gnu_attribute
);
12641 process_tic6x_specific (FILE * file
)
12643 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12644 display_tic6x_attribute
, NULL
);
12648 process_msp430x_specific (FILE * file
)
12650 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12651 display_msp430x_attribute
, NULL
);
12654 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12655 Print the Address, Access and Initial fields of an entry at VMA ADDR
12656 and return the VMA of the next entry. */
12659 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12662 print_vma (addr
, LONG_HEX
);
12664 if (addr
< pltgot
+ 0xfff0)
12665 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12667 printf ("%10s", "");
12670 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12675 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12676 print_vma (entry
, LONG_HEX
);
12678 return addr
+ (is_32bit_elf
? 4 : 8);
12681 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12682 PLTGOT. Print the Address and Initial fields of an entry at VMA
12683 ADDR and return the VMA of the next entry. */
12686 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12689 print_vma (addr
, LONG_HEX
);
12692 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12697 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12698 print_vma (entry
, LONG_HEX
);
12700 return addr
+ (is_32bit_elf
? 4 : 8);
12704 print_mips_ases (unsigned int mask
)
12706 if (mask
& AFL_ASE_DSP
)
12707 fputs ("\n\tDSP ASE", stdout
);
12708 if (mask
& AFL_ASE_DSPR2
)
12709 fputs ("\n\tDSP R2 ASE", stdout
);
12710 if (mask
& AFL_ASE_EVA
)
12711 fputs ("\n\tEnhanced VA Scheme", stdout
);
12712 if (mask
& AFL_ASE_MCU
)
12713 fputs ("\n\tMCU (MicroController) ASE", stdout
);
12714 if (mask
& AFL_ASE_MDMX
)
12715 fputs ("\n\tMDMX ASE", stdout
);
12716 if (mask
& AFL_ASE_MIPS3D
)
12717 fputs ("\n\tMIPS-3D ASE", stdout
);
12718 if (mask
& AFL_ASE_MT
)
12719 fputs ("\n\tMT ASE", stdout
);
12720 if (mask
& AFL_ASE_SMARTMIPS
)
12721 fputs ("\n\tSmartMIPS ASE", stdout
);
12722 if (mask
& AFL_ASE_VIRT
)
12723 fputs ("\n\tVZ ASE", stdout
);
12724 if (mask
& AFL_ASE_MSA
)
12725 fputs ("\n\tMSA ASE", stdout
);
12726 if (mask
& AFL_ASE_MIPS16
)
12727 fputs ("\n\tMIPS16 ASE", stdout
);
12728 if (mask
& AFL_ASE_MICROMIPS
)
12729 fputs ("\n\tMICROMIPS ASE", stdout
);
12730 if (mask
& AFL_ASE_XPA
)
12731 fputs ("\n\tXPA ASE", stdout
);
12733 fprintf (stdout
, "\n\t%s", _("None"));
12734 else if ((mask
& ~AFL_ASE_MASK
) != 0)
12735 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
12739 print_mips_isa_ext (unsigned int isa_ext
)
12744 fputs (_("None"), stdout
);
12747 fputs ("RMI XLR", stdout
);
12749 case AFL_EXT_OCTEON2
:
12750 fputs ("Cavium Networks Octeon2", stdout
);
12752 case AFL_EXT_OCTEONP
:
12753 fputs ("Cavium Networks OcteonP", stdout
);
12755 case AFL_EXT_LOONGSON_3A
:
12756 fputs ("Loongson 3A", stdout
);
12758 case AFL_EXT_OCTEON
:
12759 fputs ("Cavium Networks Octeon", stdout
);
12762 fputs ("Toshiba R5900", stdout
);
12765 fputs ("MIPS R4650", stdout
);
12768 fputs ("LSI R4010", stdout
);
12771 fputs ("NEC VR4100", stdout
);
12774 fputs ("Toshiba R3900", stdout
);
12776 case AFL_EXT_10000
:
12777 fputs ("MIPS R10000", stdout
);
12780 fputs ("Broadcom SB-1", stdout
);
12783 fputs ("NEC VR4111/VR4181", stdout
);
12786 fputs ("NEC VR4120", stdout
);
12789 fputs ("NEC VR5400", stdout
);
12792 fputs ("NEC VR5500", stdout
);
12794 case AFL_EXT_LOONGSON_2E
:
12795 fputs ("ST Microelectronics Loongson 2E", stdout
);
12797 case AFL_EXT_LOONGSON_2F
:
12798 fputs ("ST Microelectronics Loongson 2F", stdout
);
12801 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
12806 get_mips_reg_size (int reg_size
)
12808 return (reg_size
== AFL_REG_NONE
) ? 0
12809 : (reg_size
== AFL_REG_32
) ? 32
12810 : (reg_size
== AFL_REG_64
) ? 64
12811 : (reg_size
== AFL_REG_128
) ? 128
12816 process_mips_specific (FILE * file
)
12818 Elf_Internal_Dyn
* entry
;
12819 Elf_Internal_Shdr
*sect
= NULL
;
12820 size_t liblist_offset
= 0;
12821 size_t liblistno
= 0;
12822 size_t conflictsno
= 0;
12823 size_t options_offset
= 0;
12824 size_t conflicts_offset
= 0;
12825 size_t pltrelsz
= 0;
12827 bfd_vma pltgot
= 0;
12828 bfd_vma mips_pltgot
= 0;
12829 bfd_vma jmprel
= 0;
12830 bfd_vma local_gotno
= 0;
12831 bfd_vma gotsym
= 0;
12832 bfd_vma symtabno
= 0;
12834 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12835 display_mips_gnu_attribute
);
12837 sect
= find_section (".MIPS.abiflags");
12841 Elf_External_ABIFlags_v0
*abiflags_ext
;
12842 Elf_Internal_ABIFlags_v0 abiflags_in
;
12844 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
12845 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
12848 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
12849 sect
->sh_size
, _("MIPS ABI Flags section"));
12852 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
12853 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
12854 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
12855 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
12856 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
12857 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
12858 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
12859 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
12860 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
12861 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
12862 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
12864 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
12865 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
12866 if (abiflags_in
.isa_rev
> 1)
12867 printf ("r%d", abiflags_in
.isa_rev
);
12868 printf ("\nGPR size: %d",
12869 get_mips_reg_size (abiflags_in
.gpr_size
));
12870 printf ("\nCPR1 size: %d",
12871 get_mips_reg_size (abiflags_in
.cpr1_size
));
12872 printf ("\nCPR2 size: %d",
12873 get_mips_reg_size (abiflags_in
.cpr2_size
));
12874 fputs ("\nFP ABI: ", stdout
);
12875 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
12876 fputs ("ISA Extension: ", stdout
);
12877 print_mips_isa_ext (abiflags_in
.isa_ext
);
12878 fputs ("\nASEs:", stdout
);
12879 print_mips_ases (abiflags_in
.ases
);
12880 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
12881 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
12882 fputc ('\n', stdout
);
12883 free (abiflags_ext
);
12888 /* We have a lot of special sections. Thanks SGI! */
12889 if (dynamic_section
== NULL
)
12890 /* No information available. */
12893 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12894 switch (entry
->d_tag
)
12896 case DT_MIPS_LIBLIST
:
12898 = offset_from_vma (file
, entry
->d_un
.d_val
,
12899 liblistno
* sizeof (Elf32_External_Lib
));
12901 case DT_MIPS_LIBLISTNO
:
12902 liblistno
= entry
->d_un
.d_val
;
12904 case DT_MIPS_OPTIONS
:
12905 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12907 case DT_MIPS_CONFLICT
:
12909 = offset_from_vma (file
, entry
->d_un
.d_val
,
12910 conflictsno
* sizeof (Elf32_External_Conflict
));
12912 case DT_MIPS_CONFLICTNO
:
12913 conflictsno
= entry
->d_un
.d_val
;
12916 pltgot
= entry
->d_un
.d_ptr
;
12918 case DT_MIPS_LOCAL_GOTNO
:
12919 local_gotno
= entry
->d_un
.d_val
;
12921 case DT_MIPS_GOTSYM
:
12922 gotsym
= entry
->d_un
.d_val
;
12924 case DT_MIPS_SYMTABNO
:
12925 symtabno
= entry
->d_un
.d_val
;
12927 case DT_MIPS_PLTGOT
:
12928 mips_pltgot
= entry
->d_un
.d_ptr
;
12931 pltrel
= entry
->d_un
.d_val
;
12934 pltrelsz
= entry
->d_un
.d_val
;
12937 jmprel
= entry
->d_un
.d_ptr
;
12943 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12945 Elf32_External_Lib
* elib
;
12948 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12950 sizeof (Elf32_External_Lib
),
12951 _("liblist section data"));
12954 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12955 (unsigned long) liblistno
);
12956 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12959 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12966 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12967 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12968 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12969 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12970 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12972 tmp
= gmtime (&atime
);
12973 snprintf (timebuf
, sizeof (timebuf
),
12974 "%04u-%02u-%02uT%02u:%02u:%02u",
12975 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12976 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12978 printf ("%3lu: ", (unsigned long) cnt
);
12979 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12980 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12982 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12983 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12984 liblist
.l_version
);
12986 if (liblist
.l_flags
== 0)
12990 static const struct
12997 { " EXACT_MATCH", LL_EXACT_MATCH
},
12998 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12999 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13000 { " EXPORTS", LL_EXPORTS
},
13001 { " DELAY_LOAD", LL_DELAY_LOAD
},
13002 { " DELTA", LL_DELTA
}
13004 int flags
= liblist
.l_flags
;
13007 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13008 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13010 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13011 flags
^= l_flags_vals
[fcnt
].bit
;
13014 printf (" %#x", (unsigned int) flags
);
13024 if (options_offset
!= 0)
13026 Elf_External_Options
* eopt
;
13027 Elf_Internal_Options
* iopt
;
13028 Elf_Internal_Options
* option
;
13031 sect
= section_headers
;
13033 /* Find the section header so that we get the size. */
13034 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
13037 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13038 sect
->sh_size
, _("options"));
13041 iopt
= (Elf_Internal_Options
*)
13042 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13045 error (_("Out of memory\n"));
13052 while (offset
< sect
->sh_size
)
13054 Elf_External_Options
* eoption
;
13056 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13058 option
->kind
= BYTE_GET (eoption
->kind
);
13059 option
->size
= BYTE_GET (eoption
->size
);
13060 option
->section
= BYTE_GET (eoption
->section
);
13061 option
->info
= BYTE_GET (eoption
->info
);
13063 offset
+= option
->size
;
13069 printf (_("\nSection '%s' contains %d entries:\n"),
13070 SECTION_NAME (sect
), cnt
);
13078 switch (option
->kind
)
13081 /* This shouldn't happen. */
13082 printf (" NULL %d %lx", option
->section
, option
->info
);
13085 printf (" REGINFO ");
13086 if (elf_header
.e_machine
== EM_MIPS
)
13089 Elf32_External_RegInfo
* ereg
;
13090 Elf32_RegInfo reginfo
;
13092 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13093 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13094 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13095 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13096 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13097 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13098 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13100 printf ("GPR %08lx GP 0x%lx\n",
13101 reginfo
.ri_gprmask
,
13102 (unsigned long) reginfo
.ri_gp_value
);
13103 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13104 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13105 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13110 Elf64_External_RegInfo
* ereg
;
13111 Elf64_Internal_RegInfo reginfo
;
13113 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13114 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13115 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13116 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13117 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13118 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13119 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13121 printf ("GPR %08lx GP 0x",
13122 reginfo
.ri_gprmask
);
13123 printf_vma (reginfo
.ri_gp_value
);
13126 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13127 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13128 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13132 case ODK_EXCEPTIONS
:
13133 fputs (" EXCEPTIONS fpe_min(", stdout
);
13134 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13135 fputs (") fpe_max(", stdout
);
13136 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13137 fputs (")", stdout
);
13139 if (option
->info
& OEX_PAGE0
)
13140 fputs (" PAGE0", stdout
);
13141 if (option
->info
& OEX_SMM
)
13142 fputs (" SMM", stdout
);
13143 if (option
->info
& OEX_FPDBUG
)
13144 fputs (" FPDBUG", stdout
);
13145 if (option
->info
& OEX_DISMISS
)
13146 fputs (" DISMISS", stdout
);
13149 fputs (" PAD ", stdout
);
13150 if (option
->info
& OPAD_PREFIX
)
13151 fputs (" PREFIX", stdout
);
13152 if (option
->info
& OPAD_POSTFIX
)
13153 fputs (" POSTFIX", stdout
);
13154 if (option
->info
& OPAD_SYMBOL
)
13155 fputs (" SYMBOL", stdout
);
13158 fputs (" HWPATCH ", stdout
);
13159 if (option
->info
& OHW_R4KEOP
)
13160 fputs (" R4KEOP", stdout
);
13161 if (option
->info
& OHW_R8KPFETCH
)
13162 fputs (" R8KPFETCH", stdout
);
13163 if (option
->info
& OHW_R5KEOP
)
13164 fputs (" R5KEOP", stdout
);
13165 if (option
->info
& OHW_R5KCVTL
)
13166 fputs (" R5KCVTL", stdout
);
13169 fputs (" FILL ", stdout
);
13170 /* XXX Print content of info word? */
13173 fputs (" TAGS ", stdout
);
13174 /* XXX Print content of info word? */
13177 fputs (" HWAND ", stdout
);
13178 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13179 fputs (" R4KEOP_CHECKED", stdout
);
13180 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13181 fputs (" R4KEOP_CLEAN", stdout
);
13184 fputs (" HWOR ", stdout
);
13185 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13186 fputs (" R4KEOP_CHECKED", stdout
);
13187 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13188 fputs (" R4KEOP_CLEAN", stdout
);
13191 printf (" GP_GROUP %#06lx self-contained %#06lx",
13192 option
->info
& OGP_GROUP
,
13193 (option
->info
& OGP_SELF
) >> 16);
13196 printf (" IDENT %#06lx self-contained %#06lx",
13197 option
->info
& OGP_GROUP
,
13198 (option
->info
& OGP_SELF
) >> 16);
13201 /* This shouldn't happen. */
13202 printf (" %3d ??? %d %lx",
13203 option
->kind
, option
->section
, option
->info
);
13207 len
= sizeof (* eopt
);
13208 while (len
< option
->size
)
13209 if (((char *) option
)[len
] >= ' '
13210 && ((char *) option
)[len
] < 0x7f)
13211 printf ("%c", ((char *) option
)[len
++]);
13213 printf ("\\%03o", ((char *) option
)[len
++]);
13215 fputs ("\n", stdout
);
13223 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13225 Elf32_Conflict
* iconf
;
13228 if (dynamic_symbols
== NULL
)
13230 error (_("conflict list found without a dynamic symbol table\n"));
13234 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13237 error (_("Out of memory\n"));
13243 Elf32_External_Conflict
* econf32
;
13245 econf32
= (Elf32_External_Conflict
*)
13246 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13247 sizeof (* econf32
), _("conflict"));
13251 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13252 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13258 Elf64_External_Conflict
* econf64
;
13260 econf64
= (Elf64_External_Conflict
*)
13261 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13262 sizeof (* econf64
), _("conflict"));
13266 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13267 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13272 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13273 (unsigned long) conflictsno
);
13274 puts (_(" Num: Index Value Name"));
13276 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13278 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13280 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13281 print_vma (psym
->st_value
, FULL_HEX
);
13283 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13284 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13286 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13293 if (pltgot
!= 0 && local_gotno
!= 0)
13295 bfd_vma ent
, local_end
, global_end
;
13297 unsigned char * data
;
13301 addr_size
= (is_32bit_elf
? 4 : 8);
13302 local_end
= pltgot
+ local_gotno
* addr_size
;
13303 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13305 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13306 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13307 global_end
- pltgot
, 1,
13308 _("Global Offset Table data"));
13312 printf (_("\nPrimary GOT:\n"));
13313 printf (_(" Canonical gp value: "));
13314 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13317 printf (_(" Reserved entries:\n"));
13318 printf (_(" %*s %10s %*s Purpose\n"),
13319 addr_size
* 2, _("Address"), _("Access"),
13320 addr_size
* 2, _("Initial"));
13321 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13322 printf (_(" Lazy resolver\n"));
13324 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13325 >> (addr_size
* 8 - 1)) != 0)
13327 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13328 printf (_(" Module pointer (GNU extension)\n"));
13332 if (ent
< local_end
)
13334 printf (_(" Local entries:\n"));
13335 printf (" %*s %10s %*s\n",
13336 addr_size
* 2, _("Address"), _("Access"),
13337 addr_size
* 2, _("Initial"));
13338 while (ent
< local_end
)
13340 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13346 if (gotsym
< symtabno
)
13350 printf (_(" Global entries:\n"));
13351 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13352 addr_size
* 2, _("Address"),
13354 addr_size
* 2, _("Initial"),
13355 addr_size
* 2, _("Sym.Val."),
13357 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13358 _("Ndx"), _("Name"));
13360 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13361 for (i
= gotsym
; i
< symtabno
; i
++)
13363 Elf_Internal_Sym
* psym
;
13365 psym
= dynamic_symbols
+ i
;
13366 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13368 print_vma (psym
->st_value
, LONG_HEX
);
13369 printf (" %-7s %3s ",
13370 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13371 get_symbol_index_type (psym
->st_shndx
));
13372 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13373 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13375 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13385 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13388 size_t offset
, rel_offset
;
13389 unsigned long count
, i
;
13390 unsigned char * data
;
13391 int addr_size
, sym_width
;
13392 Elf_Internal_Rela
* rels
;
13394 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13395 if (pltrel
== DT_RELA
)
13397 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13402 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13407 addr_size
= (is_32bit_elf
? 4 : 8);
13408 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13410 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13411 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13412 1, _("Procedure Linkage Table data"));
13416 printf ("\nPLT GOT:\n\n");
13417 printf (_(" Reserved entries:\n"));
13418 printf (_(" %*s %*s Purpose\n"),
13419 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13420 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13421 printf (_(" PLT lazy resolver\n"));
13422 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13423 printf (_(" Module pointer\n"));
13426 printf (_(" Entries:\n"));
13427 printf (" %*s %*s %*s %-7s %3s %s\n",
13428 addr_size
* 2, _("Address"),
13429 addr_size
* 2, _("Initial"),
13430 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13431 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13432 for (i
= 0; i
< count
; i
++)
13434 Elf_Internal_Sym
* psym
;
13436 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13437 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13439 print_vma (psym
->st_value
, LONG_HEX
);
13440 printf (" %-7s %3s ",
13441 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13442 get_symbol_index_type (psym
->st_shndx
));
13443 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13444 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13446 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13460 process_nds32_specific (FILE * file
)
13462 Elf_Internal_Shdr
*sect
= NULL
;
13464 sect
= find_section (".nds32_e_flags");
13467 unsigned int *flag
;
13469 printf ("\nNDS32 elf flags section:\n");
13470 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13471 sect
->sh_size
, _("NDS32 elf flags section"));
13473 switch ((*flag
) & 0x3)
13476 printf ("(VEC_SIZE):\tNo entry.\n");
13479 printf ("(VEC_SIZE):\t4 bytes\n");
13482 printf ("(VEC_SIZE):\t16 bytes\n");
13485 printf ("(VEC_SIZE):\treserved\n");
13494 process_gnu_liblist (FILE * file
)
13496 Elf_Internal_Shdr
* section
;
13497 Elf_Internal_Shdr
* string_sec
;
13498 Elf32_External_Lib
* elib
;
13500 size_t strtab_size
;
13507 for (i
= 0, section
= section_headers
;
13508 i
< elf_header
.e_shnum
;
13511 switch (section
->sh_type
)
13513 case SHT_GNU_LIBLIST
:
13514 if (section
->sh_link
>= elf_header
.e_shnum
)
13517 elib
= (Elf32_External_Lib
*)
13518 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13519 _("liblist section data"));
13523 string_sec
= section_headers
+ section
->sh_link
;
13525 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13526 string_sec
->sh_size
,
13527 _("liblist string table"));
13529 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13535 strtab_size
= string_sec
->sh_size
;
13537 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13538 SECTION_NAME (section
),
13539 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13541 puts (_(" Library Time Stamp Checksum Version Flags"));
13543 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13551 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13552 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13553 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13554 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13555 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13557 tmp
= gmtime (&atime
);
13558 snprintf (timebuf
, sizeof (timebuf
),
13559 "%04u-%02u-%02uT%02u:%02u:%02u",
13560 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13561 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13563 printf ("%3lu: ", (unsigned long) cnt
);
13565 printf ("%-20s", liblist
.l_name
< strtab_size
13566 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13568 printf ("%-20.20s", liblist
.l_name
< strtab_size
13569 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13570 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13571 liblist
.l_version
, liblist
.l_flags
);
13582 static const char *
13583 get_note_type (unsigned e_type
)
13585 static char buff
[64];
13587 if (elf_header
.e_type
== ET_CORE
)
13591 return _("NT_AUXV (auxiliary vector)");
13593 return _("NT_PRSTATUS (prstatus structure)");
13595 return _("NT_FPREGSET (floating point registers)");
13597 return _("NT_PRPSINFO (prpsinfo structure)");
13598 case NT_TASKSTRUCT
:
13599 return _("NT_TASKSTRUCT (task structure)");
13601 return _("NT_PRXFPREG (user_xfpregs structure)");
13603 return _("NT_PPC_VMX (ppc Altivec registers)");
13605 return _("NT_PPC_VSX (ppc VSX registers)");
13607 return _("NT_386_TLS (x86 TLS information)");
13608 case NT_386_IOPERM
:
13609 return _("NT_386_IOPERM (x86 I/O permissions)");
13610 case NT_X86_XSTATE
:
13611 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13612 case NT_S390_HIGH_GPRS
:
13613 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13614 case NT_S390_TIMER
:
13615 return _("NT_S390_TIMER (s390 timer register)");
13616 case NT_S390_TODCMP
:
13617 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13618 case NT_S390_TODPREG
:
13619 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13621 return _("NT_S390_CTRS (s390 control registers)");
13622 case NT_S390_PREFIX
:
13623 return _("NT_S390_PREFIX (s390 prefix register)");
13624 case NT_S390_LAST_BREAK
:
13625 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13626 case NT_S390_SYSTEM_CALL
:
13627 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13629 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13631 return _("NT_ARM_VFP (arm VFP registers)");
13633 return _("NT_ARM_TLS (AArch TLS registers)");
13634 case NT_ARM_HW_BREAK
:
13635 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13636 case NT_ARM_HW_WATCH
:
13637 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13639 return _("NT_PSTATUS (pstatus structure)");
13641 return _("NT_FPREGS (floating point registers)");
13643 return _("NT_PSINFO (psinfo structure)");
13645 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13647 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13648 case NT_WIN32PSTATUS
:
13649 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13651 return _("NT_SIGINFO (siginfo_t data)");
13653 return _("NT_FILE (mapped files)");
13661 return _("NT_VERSION (version)");
13663 return _("NT_ARCH (architecture)");
13668 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13673 print_core_note (Elf_Internal_Note
*pnote
)
13675 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13676 bfd_vma count
, page_size
;
13677 unsigned char *descdata
, *filenames
, *descend
;
13679 if (pnote
->type
!= NT_FILE
)
13685 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13686 /* Still "successful". */
13691 if (pnote
->descsz
< 2 * addr_size
)
13693 printf (_(" Malformed note - too short for header\n"));
13697 descdata
= (unsigned char *) pnote
->descdata
;
13698 descend
= descdata
+ pnote
->descsz
;
13700 if (descdata
[pnote
->descsz
- 1] != '\0')
13702 printf (_(" Malformed note - does not end with \\0\n"));
13706 count
= byte_get (descdata
, addr_size
);
13707 descdata
+= addr_size
;
13709 page_size
= byte_get (descdata
, addr_size
);
13710 descdata
+= addr_size
;
13712 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13714 printf (_(" Malformed note - too short for supplied file count\n"));
13718 printf (_(" Page size: "));
13719 print_vma (page_size
, DEC
);
13722 printf (_(" %*s%*s%*s\n"),
13723 (int) (2 + 2 * addr_size
), _("Start"),
13724 (int) (4 + 2 * addr_size
), _("End"),
13725 (int) (4 + 2 * addr_size
), _("Page Offset"));
13726 filenames
= descdata
+ count
* 3 * addr_size
;
13727 while (--count
> 0)
13729 bfd_vma start
, end
, file_ofs
;
13731 if (filenames
== descend
)
13733 printf (_(" Malformed note - filenames end too early\n"));
13737 start
= byte_get (descdata
, addr_size
);
13738 descdata
+= addr_size
;
13739 end
= byte_get (descdata
, addr_size
);
13740 descdata
+= addr_size
;
13741 file_ofs
= byte_get (descdata
, addr_size
);
13742 descdata
+= addr_size
;
13745 print_vma (start
, FULL_HEX
);
13747 print_vma (end
, FULL_HEX
);
13749 print_vma (file_ofs
, FULL_HEX
);
13750 printf ("\n %s\n", filenames
);
13752 filenames
+= 1 + strlen ((char *) filenames
);
13758 static const char *
13759 get_gnu_elf_note_type (unsigned e_type
)
13761 static char buff
[64];
13765 case NT_GNU_ABI_TAG
:
13766 return _("NT_GNU_ABI_TAG (ABI version tag)");
13768 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13769 case NT_GNU_BUILD_ID
:
13770 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13771 case NT_GNU_GOLD_VERSION
:
13772 return _("NT_GNU_GOLD_VERSION (gold version)");
13777 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13782 print_gnu_note (Elf_Internal_Note
*pnote
)
13784 switch (pnote
->type
)
13786 case NT_GNU_BUILD_ID
:
13790 printf (_(" Build ID: "));
13791 for (i
= 0; i
< pnote
->descsz
; ++i
)
13792 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13797 case NT_GNU_ABI_TAG
:
13799 unsigned long os
, major
, minor
, subminor
;
13800 const char *osname
;
13802 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13803 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13804 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13805 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13809 case GNU_ABI_TAG_LINUX
:
13812 case GNU_ABI_TAG_HURD
:
13815 case GNU_ABI_TAG_SOLARIS
:
13816 osname
= "Solaris";
13818 case GNU_ABI_TAG_FREEBSD
:
13819 osname
= "FreeBSD";
13821 case GNU_ABI_TAG_NETBSD
:
13825 osname
= "Unknown";
13829 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13830 major
, minor
, subminor
);
13834 case NT_GNU_GOLD_VERSION
:
13838 printf (_(" Version: "));
13839 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13840 printf ("%c", pnote
->descdata
[i
]);
13849 static const char *
13850 get_netbsd_elfcore_note_type (unsigned e_type
)
13852 static char buff
[64];
13854 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13856 /* NetBSD core "procinfo" structure. */
13857 return _("NetBSD procinfo structure");
13860 /* As of Jan 2002 there are no other machine-independent notes
13861 defined for NetBSD core files. If the note type is less
13862 than the start of the machine-dependent note types, we don't
13865 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13867 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13871 switch (elf_header
.e_machine
)
13873 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13874 and PT_GETFPREGS == mach+2. */
13879 case EM_SPARC32PLUS
:
13883 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13884 return _("PT_GETREGS (reg structure)");
13885 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13886 return _("PT_GETFPREGS (fpreg structure)");
13892 /* On all other arch's, PT_GETREGS == mach+1 and
13893 PT_GETFPREGS == mach+3. */
13897 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13898 return _("PT_GETREGS (reg structure)");
13899 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13900 return _("PT_GETFPREGS (fpreg structure)");
13906 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13907 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13911 static const char *
13912 get_stapsdt_note_type (unsigned e_type
)
13914 static char buff
[64];
13919 return _("NT_STAPSDT (SystemTap probe descriptors)");
13925 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13930 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13932 int addr_size
= is_32bit_elf
? 4 : 8;
13933 char *data
= pnote
->descdata
;
13934 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13935 bfd_vma pc
, base_addr
, semaphore
;
13936 char *provider
, *probe
, *arg_fmt
;
13938 pc
= byte_get ((unsigned char *) data
, addr_size
);
13940 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13942 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13946 data
+= strlen (data
) + 1;
13948 data
+= strlen (data
) + 1;
13950 data
+= strlen (data
) + 1;
13952 printf (_(" Provider: %s\n"), provider
);
13953 printf (_(" Name: %s\n"), probe
);
13954 printf (_(" Location: "));
13955 print_vma (pc
, FULL_HEX
);
13956 printf (_(", Base: "));
13957 print_vma (base_addr
, FULL_HEX
);
13958 printf (_(", Semaphore: "));
13959 print_vma (semaphore
, FULL_HEX
);
13961 printf (_(" Arguments: %s\n"), arg_fmt
);
13963 return data
== data_end
;
13966 static const char *
13967 get_ia64_vms_note_type (unsigned e_type
)
13969 static char buff
[64];
13974 return _("NT_VMS_MHD (module header)");
13976 return _("NT_VMS_LNM (language name)");
13978 return _("NT_VMS_SRC (source files)");
13980 return "NT_VMS_TITLE";
13982 return _("NT_VMS_EIDC (consistency check)");
13983 case NT_VMS_FPMODE
:
13984 return _("NT_VMS_FPMODE (FP mode)");
13985 case NT_VMS_LINKTIME
:
13986 return "NT_VMS_LINKTIME";
13987 case NT_VMS_IMGNAM
:
13988 return _("NT_VMS_IMGNAM (image name)");
13990 return _("NT_VMS_IMGID (image id)");
13991 case NT_VMS_LINKID
:
13992 return _("NT_VMS_LINKID (link id)");
13993 case NT_VMS_IMGBID
:
13994 return _("NT_VMS_IMGBID (build id)");
13995 case NT_VMS_GSTNAM
:
13996 return _("NT_VMS_GSTNAM (sym table name)");
13997 case NT_VMS_ORIG_DYN
:
13998 return "NT_VMS_ORIG_DYN";
13999 case NT_VMS_PATCHTIME
:
14000 return "NT_VMS_PATCHTIME";
14002 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14008 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14010 switch (pnote
->type
)
14013 if (pnote
->descsz
> 36)
14015 size_t l
= strlen (pnote
->descdata
+ 34);
14016 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14017 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14018 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14019 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14022 printf (_(" Invalid size\n"));
14025 printf (_(" Language: %s\n"), pnote
->descdata
);
14028 case NT_VMS_FPMODE
:
14029 printf (_(" Floating Point mode: "));
14030 printf ("0x%016" BFD_VMA_FMT
"x\n",
14031 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14033 case NT_VMS_LINKTIME
:
14034 printf (_(" Link time: "));
14036 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14039 case NT_VMS_PATCHTIME
:
14040 printf (_(" Patch time: "));
14042 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14045 case NT_VMS_ORIG_DYN
:
14046 printf (_(" Major id: %u, minor id: %u\n"),
14047 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14048 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14049 printf (_(" Last modified : "));
14051 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14052 printf (_("\n Link flags : "));
14053 printf ("0x%016" BFD_VMA_FMT
"x\n",
14054 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14055 printf (_(" Header flags: 0x%08x\n"),
14056 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14057 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14060 case NT_VMS_IMGNAM
:
14061 printf (_(" Image name: %s\n"), pnote
->descdata
);
14063 case NT_VMS_GSTNAM
:
14064 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14067 printf (_(" Image id: %s\n"), pnote
->descdata
);
14069 case NT_VMS_LINKID
:
14070 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14078 /* Note that by the ELF standard, the name field is already null byte
14079 terminated, and namesz includes the terminating null byte.
14080 I.E. the value of namesz for the name "FSF" is 4.
14082 If the value of namesz is zero, there is no name present. */
14084 process_note (Elf_Internal_Note
* pnote
)
14086 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14089 if (pnote
->namesz
== 0)
14090 /* If there is no note name, then use the default set of
14091 note type strings. */
14092 nt
= get_note_type (pnote
->type
);
14094 else if (const_strneq (pnote
->namedata
, "GNU"))
14095 /* GNU-specific object file notes. */
14096 nt
= get_gnu_elf_note_type (pnote
->type
);
14098 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14099 /* NetBSD-specific core file notes. */
14100 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14102 else if (strneq (pnote
->namedata
, "SPU/", 4))
14104 /* SPU-specific core file notes. */
14105 nt
= pnote
->namedata
+ 4;
14109 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14110 /* VMS/ia64-specific file notes. */
14111 nt
= get_ia64_vms_note_type (pnote
->type
);
14113 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14114 nt
= get_stapsdt_note_type (pnote
->type
);
14117 /* Don't recognize this note name; just use the default set of
14118 note type strings. */
14119 nt
= get_note_type (pnote
->type
);
14121 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14123 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14124 return print_ia64_vms_note (pnote
);
14125 else if (const_strneq (pnote
->namedata
, "GNU"))
14126 return print_gnu_note (pnote
);
14127 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14128 return print_stapsdt_note (pnote
);
14129 else if (const_strneq (pnote
->namedata
, "CORE"))
14130 return print_core_note (pnote
);
14137 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14139 Elf_External_Note
* pnotes
;
14140 Elf_External_Note
* external
;
14146 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14148 if (pnotes
== NULL
)
14153 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14154 (unsigned long) offset
, (unsigned long) length
);
14155 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14157 while ((char *) external
< (char *) pnotes
+ length
)
14159 Elf_Internal_Note inote
;
14162 char * temp
= NULL
;
14163 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14165 if (!is_ia64_vms ())
14167 /* PR binutils/15191
14168 Make sure that there is enough data to read. */
14169 min_notesz
= offsetof (Elf_External_Note
, name
);
14170 if (data_remaining
< min_notesz
)
14172 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14173 (int) data_remaining
);
14176 inote
.type
= BYTE_GET (external
->type
);
14177 inote
.namesz
= BYTE_GET (external
->namesz
);
14178 inote
.namedata
= external
->name
;
14179 inote
.descsz
= BYTE_GET (external
->descsz
);
14180 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14181 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14182 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14186 Elf64_External_VMS_Note
*vms_external
;
14188 /* PR binutils/15191
14189 Make sure that there is enough data to read. */
14190 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14191 if (data_remaining
< min_notesz
)
14193 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14194 (int) data_remaining
);
14198 vms_external
= (Elf64_External_VMS_Note
*) external
;
14199 inote
.type
= BYTE_GET (vms_external
->type
);
14200 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14201 inote
.namedata
= vms_external
->name
;
14202 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14203 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14204 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14205 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14208 if (inote
.descdata
< (char *) external
+ min_notesz
14209 || next
< (char *) external
+ min_notesz
14210 || data_remaining
< (size_t)(next
- (char *) external
))
14212 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14213 (unsigned long) ((char *) external
- (char *) pnotes
));
14214 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14215 inote
.type
, inote
.namesz
, inote
.descsz
);
14219 external
= (Elf_External_Note
*) next
;
14221 /* Verify that name is null terminated. It appears that at least
14222 one version of Linux (RedHat 6.0) generates corefiles that don't
14223 comply with the ELF spec by failing to include the null byte in
14225 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14227 temp
= (char *) malloc (inote
.namesz
+ 1);
14231 error (_("Out of memory\n"));
14236 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14237 temp
[inote
.namesz
] = 0;
14239 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14240 inote
.namedata
= temp
;
14243 res
&= process_note (& inote
);
14258 process_corefile_note_segments (FILE * file
)
14260 Elf_Internal_Phdr
* segment
;
14264 if (! get_program_headers (file
))
14267 for (i
= 0, segment
= program_headers
;
14268 i
< elf_header
.e_phnum
;
14271 if (segment
->p_type
== PT_NOTE
)
14272 res
&= process_corefile_note_segment (file
,
14273 (bfd_vma
) segment
->p_offset
,
14274 (bfd_vma
) segment
->p_filesz
);
14281 process_note_sections (FILE * file
)
14283 Elf_Internal_Shdr
* section
;
14288 for (i
= 0, section
= section_headers
;
14289 i
< elf_header
.e_shnum
&& section
!= NULL
;
14291 if (section
->sh_type
== SHT_NOTE
)
14293 res
&= process_corefile_note_segment (file
,
14294 (bfd_vma
) section
->sh_offset
,
14295 (bfd_vma
) section
->sh_size
);
14300 /* Try processing NOTE segments instead. */
14301 return process_corefile_note_segments (file
);
14307 process_notes (FILE * file
)
14309 /* If we have not been asked to display the notes then do nothing. */
14313 if (elf_header
.e_type
!= ET_CORE
)
14314 return process_note_sections (file
);
14316 /* No program headers means no NOTE segment. */
14317 if (elf_header
.e_phnum
> 0)
14318 return process_corefile_note_segments (file
);
14320 printf (_("No note segments present in the core file.\n"));
14325 process_arch_specific (FILE * file
)
14330 switch (elf_header
.e_machine
)
14333 return process_arm_specific (file
);
14335 case EM_MIPS_RS3_LE
:
14336 return process_mips_specific (file
);
14339 return process_nds32_specific (file
);
14342 return process_power_specific (file
);
14345 case EM_SPARC32PLUS
:
14347 return process_sparc_specific (file
);
14350 return process_tic6x_specific (file
);
14353 return process_msp430x_specific (file
);
14361 get_file_header (FILE * file
)
14363 /* Read in the identity array. */
14364 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14367 /* Determine how to read the rest of the header. */
14368 switch (elf_header
.e_ident
[EI_DATA
])
14370 default: /* fall through */
14371 case ELFDATANONE
: /* fall through */
14373 byte_get
= byte_get_little_endian
;
14374 byte_put
= byte_put_little_endian
;
14377 byte_get
= byte_get_big_endian
;
14378 byte_put
= byte_put_big_endian
;
14382 /* For now we only support 32 bit and 64 bit ELF files. */
14383 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14385 /* Read in the rest of the header. */
14388 Elf32_External_Ehdr ehdr32
;
14390 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14393 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14394 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14395 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14396 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14397 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14398 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14399 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14400 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14401 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14402 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14403 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14404 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14405 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14409 Elf64_External_Ehdr ehdr64
;
14411 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14412 we will not be able to cope with the 64bit data found in
14413 64 ELF files. Detect this now and abort before we start
14414 overwriting things. */
14415 if (sizeof (bfd_vma
) < 8)
14417 error (_("This instance of readelf has been built without support for a\n\
14418 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14422 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14425 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14426 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14427 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14428 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14429 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14430 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14431 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14432 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14433 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14434 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14435 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14436 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14437 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14440 if (elf_header
.e_shoff
)
14442 /* There may be some extensions in the first section header. Don't
14443 bomb if we can't read it. */
14445 get_32bit_section_headers (file
, 1);
14447 get_64bit_section_headers (file
, 1);
14453 /* Process one ELF object file according to the command line options.
14454 This file may actually be stored in an archive. The file is
14455 positioned at the start of the ELF object. */
14458 process_object (char * file_name
, FILE * file
)
14462 if (! get_file_header (file
))
14464 error (_("%s: Failed to read file header\n"), file_name
);
14468 /* Initialise per file variables. */
14469 for (i
= ARRAY_SIZE (version_info
); i
--;)
14470 version_info
[i
] = 0;
14472 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14473 dynamic_info
[i
] = 0;
14474 dynamic_info_DT_GNU_HASH
= 0;
14476 /* Process the file. */
14478 printf (_("\nFile: %s\n"), file_name
);
14480 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14481 Note we do this even if cmdline_dump_sects is empty because we
14482 must make sure that the dump_sets array is zeroed out before each
14483 object file is processed. */
14484 if (num_dump_sects
> num_cmdline_dump_sects
)
14485 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14487 if (num_cmdline_dump_sects
> 0)
14489 if (num_dump_sects
== 0)
14490 /* A sneaky way of allocating the dump_sects array. */
14491 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14493 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14494 memcpy (dump_sects
, cmdline_dump_sects
,
14495 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14498 if (! process_file_header ())
14501 if (! process_section_headers (file
))
14503 /* Without loaded section headers we cannot process lots of
14505 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14507 if (! do_using_dynamic
)
14508 do_syms
= do_dyn_syms
= do_reloc
= 0;
14511 if (! process_section_groups (file
))
14513 /* Without loaded section groups we cannot process unwind. */
14517 if (process_program_headers (file
))
14518 process_dynamic_section (file
);
14520 process_relocs (file
);
14522 process_unwind (file
);
14524 process_symbol_table (file
);
14526 process_syminfo (file
);
14528 process_version_sections (file
);
14530 process_section_contents (file
);
14532 process_notes (file
);
14534 process_gnu_liblist (file
);
14536 process_arch_specific (file
);
14538 if (program_headers
)
14540 free (program_headers
);
14541 program_headers
= NULL
;
14544 if (section_headers
)
14546 free (section_headers
);
14547 section_headers
= NULL
;
14552 free (string_table
);
14553 string_table
= NULL
;
14554 string_table_length
= 0;
14557 if (dynamic_strings
)
14559 free (dynamic_strings
);
14560 dynamic_strings
= NULL
;
14561 dynamic_strings_length
= 0;
14564 if (dynamic_symbols
)
14566 free (dynamic_symbols
);
14567 dynamic_symbols
= NULL
;
14568 num_dynamic_syms
= 0;
14571 if (dynamic_syminfo
)
14573 free (dynamic_syminfo
);
14574 dynamic_syminfo
= NULL
;
14577 if (dynamic_section
)
14579 free (dynamic_section
);
14580 dynamic_section
= NULL
;
14583 if (section_headers_groups
)
14585 free (section_headers_groups
);
14586 section_headers_groups
= NULL
;
14589 if (section_groups
)
14591 struct group_list
* g
;
14592 struct group_list
* next
;
14594 for (i
= 0; i
< group_count
; i
++)
14596 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14603 free (section_groups
);
14604 section_groups
= NULL
;
14607 free_debug_memory ();
14612 /* Process an ELF archive.
14613 On entry the file is positioned just after the ARMAG string. */
14616 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14618 struct archive_info arch
;
14619 struct archive_info nested_arch
;
14625 /* The ARCH structure is used to hold information about this archive. */
14626 arch
.file_name
= NULL
;
14628 arch
.index_array
= NULL
;
14629 arch
.sym_table
= NULL
;
14630 arch
.longnames
= NULL
;
14632 /* The NESTED_ARCH structure is used as a single-item cache of information
14633 about a nested archive (when members of a thin archive reside within
14634 another regular archive file). */
14635 nested_arch
.file_name
= NULL
;
14636 nested_arch
.file
= NULL
;
14637 nested_arch
.index_array
= NULL
;
14638 nested_arch
.sym_table
= NULL
;
14639 nested_arch
.longnames
= NULL
;
14641 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14647 if (do_archive_index
)
14649 if (arch
.sym_table
== NULL
)
14650 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14654 unsigned long current_pos
;
14656 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14657 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14658 current_pos
= ftell (file
);
14660 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14662 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14664 char * member_name
;
14666 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14668 if (member_name
!= NULL
)
14670 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14672 if (qualified_name
!= NULL
)
14674 printf (_("Contents of binary %s at offset "), qualified_name
);
14675 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14677 free (qualified_name
);
14682 if (l
>= arch
.sym_size
)
14684 error (_("%s: end of the symbol table reached before the end of the index\n"),
14688 printf ("\t%s\n", arch
.sym_table
+ l
);
14689 l
+= strlen (arch
.sym_table
+ l
) + 1;
14692 if (arch
.uses_64bit_indicies
)
14697 if (l
< arch
.sym_size
)
14698 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14699 file_name
, arch
.sym_size
- l
);
14701 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14703 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14709 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14710 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14711 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14712 && !do_section_groups
&& !do_dyn_syms
)
14714 ret
= 0; /* Archive index only. */
14725 char * qualified_name
;
14727 /* Read the next archive header. */
14728 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14730 error (_("%s: failed to seek to next archive header\n"), file_name
);
14733 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14734 if (got
!= sizeof arch
.arhdr
)
14738 error (_("%s: failed to read archive header\n"), file_name
);
14742 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14744 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14749 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14751 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14752 if (archive_file_size
& 01)
14753 ++archive_file_size
;
14755 name
= get_archive_member_name (&arch
, &nested_arch
);
14758 error (_("%s: bad archive file name\n"), file_name
);
14762 namelen
= strlen (name
);
14764 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14765 if (qualified_name
== NULL
)
14767 error (_("%s: bad archive file name\n"), file_name
);
14772 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14774 /* This is a proxy for an external member of a thin archive. */
14775 FILE * member_file
;
14776 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14777 if (member_file_name
== NULL
)
14783 member_file
= fopen (member_file_name
, "rb");
14784 if (member_file
== NULL
)
14786 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14787 free (member_file_name
);
14792 archive_file_offset
= arch
.nested_member_origin
;
14794 ret
|= process_object (qualified_name
, member_file
);
14796 fclose (member_file
);
14797 free (member_file_name
);
14799 else if (is_thin_archive
)
14801 /* PR 15140: Allow for corrupt thin archives. */
14802 if (nested_arch
.file
== NULL
)
14804 error (_("%s: contains corrupt thin archive: %s\n"),
14810 /* This is a proxy for a member of a nested archive. */
14811 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14813 /* The nested archive file will have been opened and setup by
14814 get_archive_member_name. */
14815 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14817 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14822 ret
|= process_object (qualified_name
, nested_arch
.file
);
14826 archive_file_offset
= arch
.next_arhdr_offset
;
14827 arch
.next_arhdr_offset
+= archive_file_size
;
14829 ret
|= process_object (qualified_name
, file
);
14832 if (dump_sects
!= NULL
)
14836 num_dump_sects
= 0;
14839 free (qualified_name
);
14843 if (nested_arch
.file
!= NULL
)
14844 fclose (nested_arch
.file
);
14845 release_archive (&nested_arch
);
14846 release_archive (&arch
);
14852 process_file (char * file_name
)
14855 struct stat statbuf
;
14856 char armag
[SARMAG
];
14859 if (stat (file_name
, &statbuf
) < 0)
14861 if (errno
== ENOENT
)
14862 error (_("'%s': No such file\n"), file_name
);
14864 error (_("Could not locate '%s'. System error message: %s\n"),
14865 file_name
, strerror (errno
));
14869 if (! S_ISREG (statbuf
.st_mode
))
14871 error (_("'%s' is not an ordinary file\n"), file_name
);
14875 file
= fopen (file_name
, "rb");
14878 error (_("Input file '%s' is not readable.\n"), file_name
);
14882 if (fread (armag
, SARMAG
, 1, file
) != 1)
14884 error (_("%s: Failed to read file's magic number\n"), file_name
);
14889 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14890 ret
= process_archive (file_name
, file
, FALSE
);
14891 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14892 ret
= process_archive (file_name
, file
, TRUE
);
14895 if (do_archive_index
)
14896 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14900 archive_file_size
= archive_file_offset
= 0;
14901 ret
= process_object (file_name
, file
);
14909 #ifdef SUPPORT_DISASSEMBLY
14910 /* Needed by the i386 disassembler. For extra credit, someone could
14911 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14915 print_address (unsigned int addr
, FILE * outfile
)
14917 fprintf (outfile
,"0x%8.8x", addr
);
14920 /* Needed by the i386 disassembler. */
14922 db_task_printsym (unsigned int addr
)
14924 print_address (addr
, stderr
);
14929 main (int argc
, char ** argv
)
14933 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14934 setlocale (LC_MESSAGES
, "");
14936 #if defined (HAVE_SETLOCALE)
14937 setlocale (LC_CTYPE
, "");
14939 bindtextdomain (PACKAGE
, LOCALEDIR
);
14940 textdomain (PACKAGE
);
14942 expandargv (&argc
, &argv
);
14944 parse_args (argc
, argv
);
14946 if (num_dump_sects
> 0)
14948 /* Make a copy of the dump_sects array. */
14949 cmdline_dump_sects
= (dump_type
*)
14950 malloc (num_dump_sects
* sizeof (* dump_sects
));
14951 if (cmdline_dump_sects
== NULL
)
14952 error (_("Out of memory allocating dump request table.\n"));
14955 memcpy (cmdline_dump_sects
, dump_sects
,
14956 num_dump_sects
* sizeof (* dump_sects
));
14957 num_cmdline_dump_sects
= num_dump_sects
;
14961 if (optind
< (argc
- 1))
14965 while (optind
< argc
)
14966 err
|= process_file (argv
[optind
++]);
14968 if (dump_sects
!= NULL
)
14970 if (cmdline_dump_sects
!= NULL
)
14971 free (cmdline_dump_sects
);