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
);
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) \
5063 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5064 i, section->sh_entsize); \
5065 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5066 (int) expected_entsize); \
5067 section->sh_entsize = expected_entsize; \
5072 #define CHECK_ENTSIZE(section, i, type) \
5073 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5074 sizeof (Elf64_External_##type))
5076 for (i
= 0, section
= section_headers
;
5077 i
< elf_header
.e_shnum
;
5080 char * name
= SECTION_NAME (section
);
5082 if (section
->sh_type
== SHT_DYNSYM
)
5084 if (dynamic_symbols
!= NULL
)
5086 error (_("File contains multiple dynamic symbol tables\n"));
5090 CHECK_ENTSIZE (section
, i
, Sym
);
5091 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5093 else if (section
->sh_type
== SHT_STRTAB
5094 && streq (name
, ".dynstr"))
5096 if (dynamic_strings
!= NULL
)
5098 error (_("File contains multiple dynamic string tables\n"));
5102 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5103 1, section
->sh_size
,
5104 _("dynamic strings"));
5105 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5107 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5109 if (symtab_shndx_hdr
!= NULL
)
5111 error (_("File contains multiple symtab shndx tables\n"));
5114 symtab_shndx_hdr
= section
;
5116 else if (section
->sh_type
== SHT_SYMTAB
)
5117 CHECK_ENTSIZE (section
, i
, Sym
);
5118 else if (section
->sh_type
== SHT_GROUP
)
5119 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5120 else if (section
->sh_type
== SHT_REL
)
5121 CHECK_ENTSIZE (section
, i
, Rel
);
5122 else if (section
->sh_type
== SHT_RELA
)
5123 CHECK_ENTSIZE (section
, i
, Rela
);
5124 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5125 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5126 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5127 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5128 || do_debug_addr
|| do_debug_cu_index
)
5129 && (const_strneq (name
, ".debug_")
5130 || const_strneq (name
, ".zdebug_")))
5133 name
+= sizeof (".zdebug_") - 1;
5135 name
+= sizeof (".debug_") - 1;
5138 || (do_debug_info
&& const_strneq (name
, "info"))
5139 || (do_debug_info
&& const_strneq (name
, "types"))
5140 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5141 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5142 || (do_debug_lines
&& const_strneq (name
, "line."))
5143 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5144 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5145 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5146 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5147 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5148 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5149 || (do_debug_frames
&& const_strneq (name
, "frame"))
5150 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5151 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5152 || (do_debug_str
&& const_strneq (name
, "str"))
5153 || (do_debug_loc
&& const_strneq (name
, "loc"))
5154 || (do_debug_addr
&& const_strneq (name
, "addr"))
5155 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5156 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5158 request_dump_bynumber (i
, DEBUG_DUMP
);
5160 /* Linkonce section to be combined with .debug_info at link time. */
5161 else if ((do_debugging
|| do_debug_info
)
5162 && const_strneq (name
, ".gnu.linkonce.wi."))
5163 request_dump_bynumber (i
, DEBUG_DUMP
);
5164 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5165 request_dump_bynumber (i
, DEBUG_DUMP
);
5166 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5167 request_dump_bynumber (i
, DEBUG_DUMP
);
5168 /* Trace sections for Itanium VMS. */
5169 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5170 || do_trace_aranges
)
5171 && const_strneq (name
, ".trace_"))
5173 name
+= sizeof (".trace_") - 1;
5176 || (do_trace_info
&& streq (name
, "info"))
5177 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5178 || (do_trace_aranges
&& streq (name
, "aranges"))
5180 request_dump_bynumber (i
, DEBUG_DUMP
);
5188 if (elf_header
.e_shnum
> 1)
5189 printf (_("\nSection Headers:\n"));
5191 printf (_("\nSection Header:\n"));
5195 if (do_section_details
)
5197 printf (_(" [Nr] Name\n"));
5198 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5202 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5206 if (do_section_details
)
5208 printf (_(" [Nr] Name\n"));
5209 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5213 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5217 if (do_section_details
)
5219 printf (_(" [Nr] Name\n"));
5220 printf (_(" Type Address Offset Link\n"));
5221 printf (_(" Size EntSize Info Align\n"));
5225 printf (_(" [Nr] Name Type Address Offset\n"));
5226 printf (_(" Size EntSize Flags Link Info Align\n"));
5230 if (do_section_details
)
5231 printf (_(" Flags\n"));
5233 for (i
= 0, section
= section_headers
;
5234 i
< elf_header
.e_shnum
;
5237 printf (" [%2u] ", i
);
5238 if (do_section_details
)
5240 print_symbol (INT_MAX
, SECTION_NAME (section
));
5245 print_symbol (-17, SECTION_NAME (section
));
5248 printf (do_wide
? " %-15s " : " %-15.15s ",
5249 get_section_type_name (section
->sh_type
));
5253 const char * link_too_big
= NULL
;
5255 print_vma (section
->sh_addr
, LONG_HEX
);
5257 printf ( " %6.6lx %6.6lx %2.2lx",
5258 (unsigned long) section
->sh_offset
,
5259 (unsigned long) section
->sh_size
,
5260 (unsigned long) section
->sh_entsize
);
5262 if (do_section_details
)
5263 fputs (" ", stdout
);
5265 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5267 if (section
->sh_link
>= elf_header
.e_shnum
)
5270 /* The sh_link value is out of range. Normally this indicates
5271 an error but it can have special values in Solaris binaries. */
5272 switch (elf_header
.e_machine
)
5279 case EM_OLD_SPARCV9
:
5280 case EM_SPARC32PLUS
:
5283 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5284 link_too_big
= "BEFORE";
5285 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5286 link_too_big
= "AFTER";
5293 if (do_section_details
)
5295 if (link_too_big
!= NULL
&& * link_too_big
)
5296 printf ("<%s> ", link_too_big
);
5298 printf ("%2u ", section
->sh_link
);
5299 printf ("%3u %2lu\n", section
->sh_info
,
5300 (unsigned long) section
->sh_addralign
);
5303 printf ("%2u %3u %2lu\n",
5306 (unsigned long) section
->sh_addralign
);
5308 if (link_too_big
&& ! * link_too_big
)
5309 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5310 i
, section
->sh_link
);
5314 print_vma (section
->sh_addr
, LONG_HEX
);
5316 if ((long) section
->sh_offset
== section
->sh_offset
)
5317 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5321 print_vma (section
->sh_offset
, LONG_HEX
);
5324 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5325 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5329 print_vma (section
->sh_size
, LONG_HEX
);
5332 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5333 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5337 print_vma (section
->sh_entsize
, LONG_HEX
);
5340 if (do_section_details
)
5341 fputs (" ", stdout
);
5343 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5345 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5347 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5348 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5351 print_vma (section
->sh_addralign
, DEC
);
5355 else if (do_section_details
)
5357 printf (" %-15.15s ",
5358 get_section_type_name (section
->sh_type
));
5359 print_vma (section
->sh_addr
, LONG_HEX
);
5360 if ((long) section
->sh_offset
== section
->sh_offset
)
5361 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5365 print_vma (section
->sh_offset
, LONG_HEX
);
5367 printf (" %u\n ", section
->sh_link
);
5368 print_vma (section
->sh_size
, LONG_HEX
);
5370 print_vma (section
->sh_entsize
, LONG_HEX
);
5372 printf (" %-16u %lu\n",
5374 (unsigned long) section
->sh_addralign
);
5379 print_vma (section
->sh_addr
, LONG_HEX
);
5380 if ((long) section
->sh_offset
== section
->sh_offset
)
5381 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5385 print_vma (section
->sh_offset
, LONG_HEX
);
5388 print_vma (section
->sh_size
, LONG_HEX
);
5390 print_vma (section
->sh_entsize
, LONG_HEX
);
5392 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5394 printf (" %2u %3u %lu\n",
5397 (unsigned long) section
->sh_addralign
);
5400 if (do_section_details
)
5401 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5404 if (!do_section_details
)
5406 if (elf_header
.e_machine
== EM_X86_64
5407 || elf_header
.e_machine
== EM_L1OM
5408 || elf_header
.e_machine
== EM_K1OM
)
5409 printf (_("Key to Flags:\n\
5410 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5411 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5412 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5414 printf (_("Key to Flags:\n\
5415 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5416 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5417 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5424 get_group_flags (unsigned int flags
)
5426 static char buff
[32];
5436 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5443 process_section_groups (FILE * file
)
5445 Elf_Internal_Shdr
* section
;
5447 struct group
* group
;
5448 Elf_Internal_Shdr
* symtab_sec
;
5449 Elf_Internal_Shdr
* strtab_sec
;
5450 Elf_Internal_Sym
* symtab
;
5451 unsigned long num_syms
;
5455 /* Don't process section groups unless needed. */
5456 if (!do_unwind
&& !do_section_groups
)
5459 if (elf_header
.e_shnum
== 0)
5461 if (do_section_groups
)
5462 printf (_("\nThere are no sections to group in this file.\n"));
5467 if (section_headers
== NULL
)
5469 error (_("Section headers are not available!\n"));
5470 /* PR 13622: This can happen with a corrupt ELF header. */
5474 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5475 sizeof (struct group
*));
5477 if (section_headers_groups
== NULL
)
5479 error (_("Out of memory\n"));
5483 /* Scan the sections for the group section. */
5485 for (i
= 0, section
= section_headers
;
5486 i
< elf_header
.e_shnum
;
5488 if (section
->sh_type
== SHT_GROUP
)
5491 if (group_count
== 0)
5493 if (do_section_groups
)
5494 printf (_("\nThere are no section groups in this file.\n"));
5499 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5501 if (section_groups
== NULL
)
5503 error (_("Out of memory\n"));
5513 for (i
= 0, section
= section_headers
, group
= section_groups
;
5514 i
< elf_header
.e_shnum
;
5517 if (section
->sh_type
== SHT_GROUP
)
5519 char * name
= SECTION_NAME (section
);
5521 unsigned char * start
;
5522 unsigned char * indices
;
5523 unsigned int entry
, j
, size
;
5524 Elf_Internal_Shdr
* sec
;
5525 Elf_Internal_Sym
* sym
;
5527 /* Get the symbol table. */
5528 if (section
->sh_link
>= elf_header
.e_shnum
5529 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5532 error (_("Bad sh_link in group section `%s'\n"), name
);
5536 if (symtab_sec
!= sec
)
5541 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5546 error (_("Corrupt header in group section `%s'\n"), name
);
5550 if (section
->sh_info
>= num_syms
)
5552 error (_("Bad sh_info in group section `%s'\n"), name
);
5556 sym
= symtab
+ section
->sh_info
;
5558 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5560 if (sym
->st_shndx
== 0
5561 || sym
->st_shndx
>= elf_header
.e_shnum
)
5563 error (_("Bad sh_info in group section `%s'\n"), name
);
5567 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5576 /* Get the string table. */
5577 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5586 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5591 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5592 1, strtab_sec
->sh_size
,
5594 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5596 group_name
= sym
->st_name
< strtab_size
5597 ? strtab
+ sym
->st_name
: _("<corrupt>");
5600 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5601 1, section
->sh_size
,
5607 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5608 entry
= byte_get (indices
, 4);
5611 if (do_section_groups
)
5613 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5614 get_group_flags (entry
), i
, name
, group_name
, size
);
5616 printf (_(" [Index] Name\n"));
5619 group
->group_index
= i
;
5621 for (j
= 0; j
< size
; j
++)
5623 struct group_list
* g
;
5625 entry
= byte_get (indices
, 4);
5628 if (entry
>= elf_header
.e_shnum
)
5630 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5631 entry
, i
, elf_header
.e_shnum
- 1);
5635 if (section_headers_groups
[entry
] != NULL
)
5639 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5641 section_headers_groups
[entry
]->group_index
);
5646 /* Intel C/C++ compiler may put section 0 in a
5647 section group. We just warn it the first time
5648 and ignore it afterwards. */
5649 static int warned
= 0;
5652 error (_("section 0 in group section [%5u]\n"),
5653 section_headers_groups
[entry
]->group_index
);
5659 section_headers_groups
[entry
] = group
;
5661 if (do_section_groups
)
5663 sec
= section_headers
+ entry
;
5664 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5667 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5668 g
->section_index
= entry
;
5669 g
->next
= group
->root
;
5687 /* Data used to display dynamic fixups. */
5689 struct ia64_vms_dynfixup
5691 bfd_vma needed_ident
; /* Library ident number. */
5692 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5693 bfd_vma fixup_needed
; /* Index of the library. */
5694 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5695 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5698 /* Data used to display dynamic relocations. */
5700 struct ia64_vms_dynimgrela
5702 bfd_vma img_rela_cnt
; /* Number of relocations. */
5703 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5706 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5710 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5711 const char *strtab
, unsigned int strtab_sz
)
5713 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5715 const char *lib_name
;
5717 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5718 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5719 _("dynamic section image fixups"));
5723 if (fixup
->needed
< strtab_sz
)
5724 lib_name
= strtab
+ fixup
->needed
;
5727 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5728 (unsigned long) fixup
->needed
);
5731 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5732 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5734 (_("Seg Offset Type SymVec DataType\n"));
5736 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5741 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5742 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5743 type
= BYTE_GET (imfs
[i
].type
);
5744 rtype
= elf_ia64_reloc_type (type
);
5746 printf (" 0x%08x ", type
);
5748 printf (" %-32s ", rtype
);
5749 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5750 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5756 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5759 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5761 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5764 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5765 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5766 _("dynamic section image relocations"));
5770 printf (_("\nImage relocs\n"));
5772 (_("Seg Offset Type Addend Seg Sym Off\n"));
5774 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5779 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5780 printf ("%08" BFD_VMA_FMT
"x ",
5781 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5782 type
= BYTE_GET (imrs
[i
].type
);
5783 rtype
= elf_ia64_reloc_type (type
);
5785 printf ("0x%08x ", type
);
5787 printf ("%-31s ", rtype
);
5788 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5789 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5790 printf ("%08" BFD_VMA_FMT
"x\n",
5791 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5797 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5800 process_ia64_vms_dynamic_relocs (FILE *file
)
5802 struct ia64_vms_dynfixup fixup
;
5803 struct ia64_vms_dynimgrela imgrela
;
5804 Elf_Internal_Dyn
*entry
;
5806 bfd_vma strtab_off
= 0;
5807 bfd_vma strtab_sz
= 0;
5808 char *strtab
= NULL
;
5810 memset (&fixup
, 0, sizeof (fixup
));
5811 memset (&imgrela
, 0, sizeof (imgrela
));
5813 /* Note: the order of the entries is specified by the OpenVMS specs. */
5814 for (entry
= dynamic_section
;
5815 entry
< dynamic_section
+ dynamic_nent
;
5818 switch (entry
->d_tag
)
5820 case DT_IA_64_VMS_STRTAB_OFFSET
:
5821 strtab_off
= entry
->d_un
.d_val
;
5824 strtab_sz
= entry
->d_un
.d_val
;
5826 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5827 1, strtab_sz
, _("dynamic string section"));
5830 case DT_IA_64_VMS_NEEDED_IDENT
:
5831 fixup
.needed_ident
= entry
->d_un
.d_val
;
5834 fixup
.needed
= entry
->d_un
.d_val
;
5836 case DT_IA_64_VMS_FIXUP_NEEDED
:
5837 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5839 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5840 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5842 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5843 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5845 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5848 case DT_IA_64_VMS_IMG_RELA_CNT
:
5849 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5851 case DT_IA_64_VMS_IMG_RELA_OFF
:
5852 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5854 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5874 } dynamic_relocations
[] =
5876 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5877 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5878 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5881 /* Process the reloc section. */
5884 process_relocs (FILE * file
)
5886 unsigned long rel_size
;
5887 unsigned long rel_offset
;
5893 if (do_using_dynamic
)
5897 int has_dynamic_reloc
;
5900 has_dynamic_reloc
= 0;
5902 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5904 is_rela
= dynamic_relocations
[i
].rela
;
5905 name
= dynamic_relocations
[i
].name
;
5906 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5907 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5909 has_dynamic_reloc
|= rel_size
;
5911 if (is_rela
== UNKNOWN
)
5913 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5914 switch (dynamic_info
[DT_PLTREL
])
5928 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5929 name
, rel_offset
, rel_size
);
5931 dump_relocations (file
,
5932 offset_from_vma (file
, rel_offset
, rel_size
),
5934 dynamic_symbols
, num_dynamic_syms
,
5935 dynamic_strings
, dynamic_strings_length
, is_rela
);
5940 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5942 if (! has_dynamic_reloc
)
5943 printf (_("\nThere are no dynamic relocations in this file.\n"));
5947 Elf_Internal_Shdr
* section
;
5951 for (i
= 0, section
= section_headers
;
5952 i
< elf_header
.e_shnum
;
5955 if ( section
->sh_type
!= SHT_RELA
5956 && section
->sh_type
!= SHT_REL
)
5959 rel_offset
= section
->sh_offset
;
5960 rel_size
= section
->sh_size
;
5964 Elf_Internal_Shdr
* strsec
;
5967 printf (_("\nRelocation section "));
5969 if (string_table
== NULL
)
5970 printf ("%d", section
->sh_name
);
5972 printf ("'%s'", SECTION_NAME (section
));
5974 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5975 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5977 is_rela
= section
->sh_type
== SHT_RELA
;
5979 if (section
->sh_link
!= 0
5980 && section
->sh_link
< elf_header
.e_shnum
)
5982 Elf_Internal_Shdr
* symsec
;
5983 Elf_Internal_Sym
* symtab
;
5984 unsigned long nsyms
;
5985 unsigned long strtablen
= 0;
5986 char * strtab
= NULL
;
5988 symsec
= section_headers
+ section
->sh_link
;
5989 if (symsec
->sh_type
!= SHT_SYMTAB
5990 && symsec
->sh_type
!= SHT_DYNSYM
)
5993 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5998 if (symsec
->sh_link
!= 0
5999 && symsec
->sh_link
< elf_header
.e_shnum
)
6001 strsec
= section_headers
+ symsec
->sh_link
;
6003 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6006 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6009 dump_relocations (file
, rel_offset
, rel_size
,
6010 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6016 dump_relocations (file
, rel_offset
, rel_size
,
6017 NULL
, 0, NULL
, 0, is_rela
);
6024 printf (_("\nThere are no relocations in this file.\n"));
6030 /* Process the unwind section. */
6032 #include "unwind-ia64.h"
6034 /* An absolute address consists of a section and an offset. If the
6035 section is NULL, the offset itself is the address, otherwise, the
6036 address equals to LOAD_ADDRESS(section) + offset. */
6040 unsigned short section
;
6044 #define ABSADDR(a) \
6046 ? section_headers [(a).section].sh_addr + (a).offset \
6049 struct ia64_unw_table_entry
6051 struct absaddr start
;
6053 struct absaddr info
;
6056 struct ia64_unw_aux_info
6059 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6060 unsigned long table_len
; /* Length of unwind table. */
6061 unsigned char * info
; /* Unwind info. */
6062 unsigned long info_size
; /* Size of unwind info. */
6063 bfd_vma info_addr
; /* starting address of unwind info. */
6064 bfd_vma seg_base
; /* Starting address of segment. */
6065 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6066 unsigned long nsyms
; /* Number of symbols. */
6067 char * strtab
; /* The string table. */
6068 unsigned long strtab_size
; /* Size of string table. */
6072 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6073 unsigned long nsyms
,
6074 const char * strtab
,
6075 unsigned long strtab_size
,
6076 struct absaddr addr
,
6077 const char ** symname
,
6080 bfd_vma dist
= 0x100000;
6081 Elf_Internal_Sym
* sym
;
6082 Elf_Internal_Sym
* best
= NULL
;
6085 REMOVE_ARCH_BITS (addr
.offset
);
6087 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6089 bfd_vma value
= sym
->st_value
;
6091 REMOVE_ARCH_BITS (value
);
6093 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6094 && sym
->st_name
!= 0
6095 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6096 && addr
.offset
>= value
6097 && addr
.offset
- value
< dist
)
6100 dist
= addr
.offset
- value
;
6108 *symname
= (best
->st_name
>= strtab_size
6109 ? _("<corrupt>") : strtab
+ best
->st_name
);
6115 *offset
= addr
.offset
;
6119 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6121 struct ia64_unw_table_entry
* tp
;
6124 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6128 const unsigned char * dp
;
6129 const unsigned char * head
;
6130 const char * procname
;
6132 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6133 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6135 fputs ("\n<", stdout
);
6139 fputs (procname
, stdout
);
6142 printf ("+%lx", (unsigned long) offset
);
6145 fputs (">: [", stdout
);
6146 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6147 fputc ('-', stdout
);
6148 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6149 printf ("], info at +0x%lx\n",
6150 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6152 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6153 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6155 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6156 (unsigned) UNW_VER (stamp
),
6157 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6158 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6159 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6160 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6162 if (UNW_VER (stamp
) != 1)
6164 printf (_("\tUnknown version.\n"));
6169 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6170 dp
= unw_decode (dp
, in_body
, & in_body
);
6175 slurp_ia64_unwind_table (FILE * file
,
6176 struct ia64_unw_aux_info
* aux
,
6177 Elf_Internal_Shdr
* sec
)
6179 unsigned long size
, nrelas
, i
;
6180 Elf_Internal_Phdr
* seg
;
6181 struct ia64_unw_table_entry
* tep
;
6182 Elf_Internal_Shdr
* relsec
;
6183 Elf_Internal_Rela
* rela
;
6184 Elf_Internal_Rela
* rp
;
6185 unsigned char * table
;
6187 Elf_Internal_Sym
* sym
;
6188 const char * relname
;
6190 /* First, find the starting address of the segment that includes
6193 if (elf_header
.e_phnum
)
6195 if (! get_program_headers (file
))
6198 for (seg
= program_headers
;
6199 seg
< program_headers
+ elf_header
.e_phnum
;
6202 if (seg
->p_type
!= PT_LOAD
)
6205 if (sec
->sh_addr
>= seg
->p_vaddr
6206 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6208 aux
->seg_base
= seg
->p_vaddr
;
6214 /* Second, build the unwind table from the contents of the unwind section: */
6215 size
= sec
->sh_size
;
6216 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6221 aux
->table
= (struct ia64_unw_table_entry
*)
6222 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6224 for (tp
= table
; tp
< table
+ size
; ++tep
)
6226 tep
->start
.section
= SHN_UNDEF
;
6227 tep
->end
.section
= SHN_UNDEF
;
6228 tep
->info
.section
= SHN_UNDEF
;
6229 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6230 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6231 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6232 tep
->start
.offset
+= aux
->seg_base
;
6233 tep
->end
.offset
+= aux
->seg_base
;
6234 tep
->info
.offset
+= aux
->seg_base
;
6238 /* Third, apply any relocations to the unwind table: */
6239 for (relsec
= section_headers
;
6240 relsec
< section_headers
+ elf_header
.e_shnum
;
6243 if (relsec
->sh_type
!= SHT_RELA
6244 || relsec
->sh_info
>= elf_header
.e_shnum
6245 || section_headers
+ relsec
->sh_info
!= sec
)
6248 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6252 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6254 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6255 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6257 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6259 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6263 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6265 switch (rp
->r_offset
/eh_addr_size
% 3)
6268 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6269 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6272 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6273 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6276 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6277 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6287 aux
->table_len
= size
/ (3 * eh_addr_size
);
6292 ia64_process_unwind (FILE * file
)
6294 Elf_Internal_Shdr
* sec
;
6295 Elf_Internal_Shdr
* unwsec
= NULL
;
6296 Elf_Internal_Shdr
* strsec
;
6297 unsigned long i
, unwcount
= 0, unwstart
= 0;
6298 struct ia64_unw_aux_info aux
;
6300 memset (& aux
, 0, sizeof (aux
));
6302 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6304 if (sec
->sh_type
== SHT_SYMTAB
6305 && sec
->sh_link
< elf_header
.e_shnum
)
6307 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6309 strsec
= section_headers
+ sec
->sh_link
;
6310 assert (aux
.strtab
== NULL
);
6311 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6314 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6316 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6321 printf (_("\nThere are no unwind sections in this file.\n"));
6323 while (unwcount
-- > 0)
6328 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6329 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6330 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6337 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6339 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6341 /* We need to find which section group it is in. */
6342 struct group_list
* g
= section_headers_groups
[i
]->root
;
6344 for (; g
!= NULL
; g
= g
->next
)
6346 sec
= section_headers
+ g
->section_index
;
6348 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6353 i
= elf_header
.e_shnum
;
6355 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6357 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6358 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6359 suffix
= SECTION_NAME (unwsec
) + len
;
6360 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6362 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6363 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6368 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6369 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6370 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6371 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6373 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6374 suffix
= SECTION_NAME (unwsec
) + len
;
6375 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6377 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6378 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6382 if (i
== elf_header
.e_shnum
)
6384 printf (_("\nCould not find unwind info section for "));
6386 if (string_table
== NULL
)
6387 printf ("%d", unwsec
->sh_name
);
6389 printf (_("'%s'"), SECTION_NAME (unwsec
));
6393 aux
.info_addr
= sec
->sh_addr
;
6394 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6397 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6399 printf (_("\nUnwind section "));
6401 if (string_table
== NULL
)
6402 printf ("%d", unwsec
->sh_name
);
6404 printf (_("'%s'"), SECTION_NAME (unwsec
));
6406 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6407 (unsigned long) unwsec
->sh_offset
,
6408 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6410 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6412 if (aux
.table_len
> 0)
6413 dump_ia64_unwind (& aux
);
6416 free ((char *) aux
.table
);
6418 free ((char *) aux
.info
);
6427 free ((char *) aux
.strtab
);
6430 struct hppa_unw_table_entry
6432 struct absaddr start
;
6434 unsigned int Cannot_unwind
:1; /* 0 */
6435 unsigned int Millicode
:1; /* 1 */
6436 unsigned int Millicode_save_sr0
:1; /* 2 */
6437 unsigned int Region_description
:2; /* 3..4 */
6438 unsigned int reserved1
:1; /* 5 */
6439 unsigned int Entry_SR
:1; /* 6 */
6440 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6441 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6442 unsigned int Args_stored
:1; /* 16 */
6443 unsigned int Variable_Frame
:1; /* 17 */
6444 unsigned int Separate_Package_Body
:1; /* 18 */
6445 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6446 unsigned int Stack_Overflow_Check
:1; /* 20 */
6447 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6448 unsigned int Ada_Region
:1; /* 22 */
6449 unsigned int cxx_info
:1; /* 23 */
6450 unsigned int cxx_try_catch
:1; /* 24 */
6451 unsigned int sched_entry_seq
:1; /* 25 */
6452 unsigned int reserved2
:1; /* 26 */
6453 unsigned int Save_SP
:1; /* 27 */
6454 unsigned int Save_RP
:1; /* 28 */
6455 unsigned int Save_MRP_in_frame
:1; /* 29 */
6456 unsigned int extn_ptr_defined
:1; /* 30 */
6457 unsigned int Cleanup_defined
:1; /* 31 */
6459 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6460 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6461 unsigned int Large_frame
:1; /* 2 */
6462 unsigned int Pseudo_SP_Set
:1; /* 3 */
6463 unsigned int reserved4
:1; /* 4 */
6464 unsigned int Total_frame_size
:27; /* 5..31 */
6467 struct hppa_unw_aux_info
6469 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6470 unsigned long table_len
; /* Length of unwind table. */
6471 bfd_vma seg_base
; /* Starting address of segment. */
6472 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6473 unsigned long nsyms
; /* Number of symbols. */
6474 char * strtab
; /* The string table. */
6475 unsigned long strtab_size
; /* Size of string table. */
6479 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6481 struct hppa_unw_table_entry
* tp
;
6483 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6486 const char * procname
;
6488 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6489 aux
->strtab_size
, tp
->start
, &procname
,
6492 fputs ("\n<", stdout
);
6496 fputs (procname
, stdout
);
6499 printf ("+%lx", (unsigned long) offset
);
6502 fputs (">: [", stdout
);
6503 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6504 fputc ('-', stdout
);
6505 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6508 #define PF(_m) if (tp->_m) printf (#_m " ");
6509 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6512 PF(Millicode_save_sr0
);
6513 /* PV(Region_description); */
6519 PF(Separate_Package_Body
);
6520 PF(Frame_Extension_Millicode
);
6521 PF(Stack_Overflow_Check
);
6522 PF(Two_Instruction_SP_Increment
);
6526 PF(sched_entry_seq
);
6529 PF(Save_MRP_in_frame
);
6530 PF(extn_ptr_defined
);
6531 PF(Cleanup_defined
);
6532 PF(MPE_XL_interrupt_marker
);
6533 PF(HP_UX_interrupt_marker
);
6536 PV(Total_frame_size
);
6545 slurp_hppa_unwind_table (FILE * file
,
6546 struct hppa_unw_aux_info
* aux
,
6547 Elf_Internal_Shdr
* sec
)
6549 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6550 Elf_Internal_Phdr
* seg
;
6551 struct hppa_unw_table_entry
* tep
;
6552 Elf_Internal_Shdr
* relsec
;
6553 Elf_Internal_Rela
* rela
;
6554 Elf_Internal_Rela
* rp
;
6555 unsigned char * table
;
6557 Elf_Internal_Sym
* sym
;
6558 const char * relname
;
6560 /* First, find the starting address of the segment that includes
6563 if (elf_header
.e_phnum
)
6565 if (! get_program_headers (file
))
6568 for (seg
= program_headers
;
6569 seg
< program_headers
+ elf_header
.e_phnum
;
6572 if (seg
->p_type
!= PT_LOAD
)
6575 if (sec
->sh_addr
>= seg
->p_vaddr
6576 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6578 aux
->seg_base
= seg
->p_vaddr
;
6584 /* Second, build the unwind table from the contents of the unwind
6586 size
= sec
->sh_size
;
6587 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6593 nentries
= size
/ unw_ent_size
;
6594 size
= unw_ent_size
* nentries
;
6596 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6597 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6599 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6601 unsigned int tmp1
, tmp2
;
6603 tep
->start
.section
= SHN_UNDEF
;
6604 tep
->end
.section
= SHN_UNDEF
;
6606 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6607 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6608 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6609 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6611 tep
->start
.offset
+= aux
->seg_base
;
6612 tep
->end
.offset
+= aux
->seg_base
;
6614 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6615 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6616 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6617 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6618 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6619 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6620 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6621 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6622 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6623 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6624 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6625 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6626 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6627 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6628 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6629 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6630 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6631 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6632 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6633 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6634 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6635 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6636 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6637 tep
->Cleanup_defined
= tmp1
& 0x1;
6639 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6640 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6641 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6642 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6643 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6644 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6648 /* Third, apply any relocations to the unwind table. */
6649 for (relsec
= section_headers
;
6650 relsec
< section_headers
+ elf_header
.e_shnum
;
6653 if (relsec
->sh_type
!= SHT_RELA
6654 || relsec
->sh_info
>= elf_header
.e_shnum
6655 || section_headers
+ relsec
->sh_info
!= sec
)
6658 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6662 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6664 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6665 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6667 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6668 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6670 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6674 i
= rp
->r_offset
/ unw_ent_size
;
6676 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6679 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6680 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6683 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6684 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6694 aux
->table_len
= nentries
;
6700 hppa_process_unwind (FILE * file
)
6702 struct hppa_unw_aux_info aux
;
6703 Elf_Internal_Shdr
* unwsec
= NULL
;
6704 Elf_Internal_Shdr
* strsec
;
6705 Elf_Internal_Shdr
* sec
;
6708 if (string_table
== NULL
)
6711 memset (& aux
, 0, sizeof (aux
));
6713 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6715 if (sec
->sh_type
== SHT_SYMTAB
6716 && sec
->sh_link
< elf_header
.e_shnum
)
6718 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6720 strsec
= section_headers
+ sec
->sh_link
;
6721 assert (aux
.strtab
== NULL
);
6722 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6725 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6727 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6732 printf (_("\nThere are no unwind sections in this file.\n"));
6734 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6736 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6738 printf (_("\nUnwind section "));
6739 printf (_("'%s'"), SECTION_NAME (sec
));
6741 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6742 (unsigned long) sec
->sh_offset
,
6743 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6745 slurp_hppa_unwind_table (file
, &aux
, sec
);
6746 if (aux
.table_len
> 0)
6747 dump_hppa_unwind (&aux
);
6750 free ((char *) aux
.table
);
6758 free ((char *) aux
.strtab
);
6763 unsigned char * data
; /* The unwind data. */
6764 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6765 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6766 unsigned long nrelas
; /* The number of relocations. */
6767 unsigned int rel_type
; /* REL or RELA ? */
6768 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6771 struct arm_unw_aux_info
6773 FILE * file
; /* The file containing the unwind sections. */
6774 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6775 unsigned long nsyms
; /* Number of symbols. */
6776 char * strtab
; /* The file's string table. */
6777 unsigned long strtab_size
; /* Size of string table. */
6781 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6782 bfd_vma fn
, struct absaddr addr
)
6784 const char *procname
;
6787 if (addr
.section
== SHN_UNDEF
)
6790 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6791 aux
->strtab_size
, addr
, &procname
,
6794 print_vma (fn
, PREFIX_HEX
);
6798 fputs (" <", stdout
);
6799 fputs (procname
, stdout
);
6802 printf ("+0x%lx", (unsigned long) sym_offset
);
6803 fputc ('>', stdout
);
6810 arm_free_section (struct arm_section
*arm_sec
)
6812 if (arm_sec
->data
!= NULL
)
6813 free (arm_sec
->data
);
6815 if (arm_sec
->rela
!= NULL
)
6816 free (arm_sec
->rela
);
6819 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6820 cached section and install SEC instead.
6821 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6822 and return its valued in * WORDP, relocating if necessary.
6823 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6824 relocation's offset in ADDR.
6825 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6826 into the string table of the symbol associated with the reloc. If no
6827 reloc was applied store -1 there.
6828 5) Return TRUE upon success, FALSE otherwise. */
6831 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6832 struct arm_section
* arm_sec
,
6833 Elf_Internal_Shdr
* sec
,
6834 bfd_vma word_offset
,
6835 unsigned int * wordp
,
6836 struct absaddr
* addr
,
6839 Elf_Internal_Rela
*rp
;
6840 Elf_Internal_Sym
*sym
;
6841 const char * relname
;
6843 bfd_boolean wrapped
;
6845 addr
->section
= SHN_UNDEF
;
6848 if (sym_name
!= NULL
)
6849 *sym_name
= (bfd_vma
) -1;
6851 /* If necessary, update the section cache. */
6852 if (sec
!= arm_sec
->sec
)
6854 Elf_Internal_Shdr
*relsec
;
6856 arm_free_section (arm_sec
);
6859 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6860 sec
->sh_size
, _("unwind data"));
6861 arm_sec
->rela
= NULL
;
6862 arm_sec
->nrelas
= 0;
6864 for (relsec
= section_headers
;
6865 relsec
< section_headers
+ elf_header
.e_shnum
;
6868 if (relsec
->sh_info
>= elf_header
.e_shnum
6869 || section_headers
+ relsec
->sh_info
!= sec
6870 /* PR 15745: Check the section type as well. */
6871 || (relsec
->sh_type
!= SHT_REL
6872 && relsec
->sh_type
!= SHT_RELA
))
6875 arm_sec
->rel_type
= relsec
->sh_type
;
6876 if (relsec
->sh_type
== SHT_REL
)
6878 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6880 & arm_sec
->rela
, & arm_sec
->nrelas
))
6883 else /* relsec->sh_type == SHT_RELA */
6885 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6887 & arm_sec
->rela
, & arm_sec
->nrelas
))
6893 arm_sec
->next_rela
= arm_sec
->rela
;
6896 /* If there is no unwind data we can do nothing. */
6897 if (arm_sec
->data
== NULL
)
6900 /* Get the word at the required offset. */
6901 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6903 /* Look through the relocs to find the one that applies to the provided offset. */
6905 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6907 bfd_vma prelval
, offset
;
6909 if (rp
->r_offset
> word_offset
&& !wrapped
)
6914 if (rp
->r_offset
> word_offset
)
6917 if (rp
->r_offset
& 3)
6919 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6920 (unsigned long) rp
->r_offset
);
6924 if (rp
->r_offset
< word_offset
)
6927 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6929 if (arm_sec
->rel_type
== SHT_REL
)
6931 offset
= word
& 0x7fffffff;
6932 if (offset
& 0x40000000)
6933 offset
|= ~ (bfd_vma
) 0x7fffffff;
6935 else if (arm_sec
->rel_type
== SHT_RELA
)
6936 offset
= rp
->r_addend
;
6940 offset
+= sym
->st_value
;
6941 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6943 /* Check that we are processing the expected reloc type. */
6944 if (elf_header
.e_machine
== EM_ARM
)
6946 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6948 if (streq (relname
, "R_ARM_NONE"))
6951 if (! streq (relname
, "R_ARM_PREL31"))
6953 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6957 else if (elf_header
.e_machine
== EM_TI_C6000
)
6959 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6961 if (streq (relname
, "R_C6000_NONE"))
6964 if (! streq (relname
, "R_C6000_PREL31"))
6966 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6973 /* This function currently only supports ARM and TI unwinders. */
6976 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6977 addr
->section
= sym
->st_shndx
;
6978 addr
->offset
= offset
;
6980 * sym_name
= sym
->st_name
;
6985 arm_sec
->next_rela
= rp
;
6990 static const char *tic6x_unwind_regnames
[16] =
6992 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6993 "A14", "A13", "A12", "A11", "A10",
6994 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6998 decode_tic6x_unwind_regmask (unsigned int mask
)
7002 for (i
= 12; mask
; mask
>>= 1, i
--)
7006 fputs (tic6x_unwind_regnames
[i
], stdout
);
7008 fputs (", ", stdout
);
7014 if (remaining == 0 && more_words) \
7017 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7018 data_offset, & word, & addr, NULL)) \
7024 #define GET_OP(OP) \
7029 (OP) = word >> 24; \
7034 printf (_("[Truncated opcode]\n")); \
7037 printf ("0x%02x ", OP)
7040 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7041 unsigned int word
, unsigned int remaining
,
7042 unsigned int more_words
,
7043 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7044 struct arm_section
*data_arm_sec
)
7046 struct absaddr addr
;
7048 /* Decode the unwinding instructions. */
7051 unsigned int op
, op2
;
7060 printf (" 0x%02x ", op
);
7062 if ((op
& 0xc0) == 0x00)
7064 int offset
= ((op
& 0x3f) << 2) + 4;
7066 printf (" vsp = vsp + %d", offset
);
7068 else if ((op
& 0xc0) == 0x40)
7070 int offset
= ((op
& 0x3f) << 2) + 4;
7072 printf (" vsp = vsp - %d", offset
);
7074 else if ((op
& 0xf0) == 0x80)
7077 if (op
== 0x80 && op2
== 0)
7078 printf (_("Refuse to unwind"));
7081 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7086 for (i
= 0; i
< 12; i
++)
7087 if (mask
& (1 << i
))
7093 printf ("r%d", 4 + i
);
7098 else if ((op
& 0xf0) == 0x90)
7100 if (op
== 0x9d || op
== 0x9f)
7101 printf (_(" [Reserved]"));
7103 printf (" vsp = r%d", op
& 0x0f);
7105 else if ((op
& 0xf0) == 0xa0)
7107 int end
= 4 + (op
& 0x07);
7112 for (i
= 4; i
<= end
; i
++)
7128 else if (op
== 0xb0)
7129 printf (_(" finish"));
7130 else if (op
== 0xb1)
7133 if (op2
== 0 || (op2
& 0xf0) != 0)
7134 printf (_("[Spare]"));
7137 unsigned int mask
= op2
& 0x0f;
7142 for (i
= 0; i
< 12; i
++)
7143 if (mask
& (1 << i
))
7154 else if (op
== 0xb2)
7156 unsigned char buf
[9];
7157 unsigned int i
, len
;
7158 unsigned long offset
;
7160 for (i
= 0; i
< sizeof (buf
); i
++)
7163 if ((buf
[i
] & 0x80) == 0)
7166 assert (i
< sizeof (buf
));
7167 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7168 assert (len
== i
+ 1);
7169 offset
= offset
* 4 + 0x204;
7170 printf ("vsp = vsp + %ld", offset
);
7172 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7174 unsigned int first
, last
;
7181 printf ("pop {D%d", first
);
7183 printf ("-D%d", first
+ last
);
7186 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7188 unsigned int count
= op
& 0x07;
7192 printf ("-D%d", 8 + count
);
7195 else if (op
>= 0xc0 && op
<= 0xc5)
7197 unsigned int count
= op
& 0x07;
7199 printf (" pop {wR10");
7201 printf ("-wR%d", 10 + count
);
7204 else if (op
== 0xc6)
7206 unsigned int first
, last
;
7211 printf ("pop {wR%d", first
);
7213 printf ("-wR%d", first
+ last
);
7216 else if (op
== 0xc7)
7219 if (op2
== 0 || (op2
& 0xf0) != 0)
7220 printf (_("[Spare]"));
7223 unsigned int mask
= op2
& 0x0f;
7228 for (i
= 0; i
< 4; i
++)
7229 if (mask
& (1 << i
))
7235 printf ("wCGR%d", i
);
7241 printf (_(" [unsupported opcode]"));
7247 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7248 unsigned int word
, unsigned int remaining
,
7249 unsigned int more_words
,
7250 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7251 struct arm_section
*data_arm_sec
)
7253 struct absaddr addr
;
7255 /* Decode the unwinding instructions. */
7258 unsigned int op
, op2
;
7267 printf (" 0x%02x ", op
);
7269 if ((op
& 0xc0) == 0x00)
7271 int offset
= ((op
& 0x3f) << 3) + 8;
7272 printf (" sp = sp + %d", offset
);
7274 else if ((op
& 0xc0) == 0x80)
7277 if (op
== 0x80 && op2
== 0)
7278 printf (_("Refuse to unwind"));
7281 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7283 printf ("pop compact {");
7287 decode_tic6x_unwind_regmask (mask
);
7291 else if ((op
& 0xf0) == 0xc0)
7299 unsigned int offset
;
7303 /* Scan entire instruction first so that GET_OP output is not
7304 interleaved with disassembly. */
7306 for (i
= 0; nregs
< (op
& 0xf); i
++)
7312 regpos
[nregs
].offset
= i
* 2;
7313 regpos
[nregs
].reg
= reg
;
7320 regpos
[nregs
].offset
= i
* 2 + 1;
7321 regpos
[nregs
].reg
= reg
;
7326 printf (_("pop frame {"));
7328 for (i
= i
* 2; i
> 0; i
--)
7330 if (regpos
[reg
].offset
== i
- 1)
7332 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7339 fputs (name
, stdout
);
7346 else if (op
== 0xd0)
7347 printf (" MOV FP, SP");
7348 else if (op
== 0xd1)
7349 printf (" __c6xabi_pop_rts");
7350 else if (op
== 0xd2)
7352 unsigned char buf
[9];
7353 unsigned int i
, len
;
7354 unsigned long offset
;
7356 for (i
= 0; i
< sizeof (buf
); i
++)
7359 if ((buf
[i
] & 0x80) == 0)
7362 assert (i
< sizeof (buf
));
7363 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7364 assert (len
== i
+ 1);
7365 offset
= offset
* 8 + 0x408;
7366 printf (_("sp = sp + %ld"), offset
);
7368 else if ((op
& 0xf0) == 0xe0)
7370 if ((op
& 0x0f) == 7)
7373 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7377 printf (_(" [unsupported opcode]"));
7384 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7388 offset
= word
& 0x7fffffff;
7389 if (offset
& 0x40000000)
7390 offset
|= ~ (bfd_vma
) 0x7fffffff;
7392 if (elf_header
.e_machine
== EM_TI_C6000
)
7395 return offset
+ where
;
7399 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7401 unsigned int remaining
,
7402 bfd_vma data_offset
,
7403 Elf_Internal_Shdr
* data_sec
,
7404 struct arm_section
* data_arm_sec
)
7407 unsigned int more_words
= 0;
7408 struct absaddr addr
;
7409 bfd_vma sym_name
= (bfd_vma
) -1;
7413 /* Fetch the first word.
7414 Note - when decoding an object file the address extracted
7415 here will always be 0. So we also pass in the sym_name
7416 parameter so that we can find the symbol associated with
7417 the personality routine. */
7418 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7419 & word
, & addr
, & sym_name
))
7425 if ((word
& 0x80000000) == 0)
7427 /* Expand prel31 for personality routine. */
7429 const char *procname
;
7431 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7432 printf (_(" Personality routine: "));
7434 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7435 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7437 procname
= aux
->strtab
+ sym_name
;
7438 print_vma (fn
, PREFIX_HEX
);
7441 fputs (" <", stdout
);
7442 fputs (procname
, stdout
);
7443 fputc ('>', stdout
);
7447 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7448 fputc ('\n', stdout
);
7450 /* The GCC personality routines use the standard compact
7451 encoding, starting with one byte giving the number of
7453 if (procname
!= NULL
7454 && (const_strneq (procname
, "__gcc_personality_v0")
7455 || const_strneq (procname
, "__gxx_personality_v0")
7456 || const_strneq (procname
, "__gcj_personality_v0")
7457 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7464 printf (_(" [Truncated data]\n"));
7467 more_words
= word
>> 24;
7477 /* ARM EHABI Section 6.3:
7479 An exception-handling table entry for the compact model looks like:
7483 1 0 index Data for personalityRoutine[index] */
7485 if (elf_header
.e_machine
== EM_ARM
7486 && (word
& 0x70000000))
7487 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7489 per_index
= (word
>> 24) & 0x7f;
7490 printf (_(" Compact model index: %d\n"), per_index
);
7497 else if (per_index
< 3)
7499 more_words
= (word
>> 16) & 0xff;
7505 switch (elf_header
.e_machine
)
7510 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7511 data_offset
, data_sec
, data_arm_sec
);
7515 warn (_("Unknown ARM compact model index encountered\n"));
7516 printf (_(" [reserved]\n"));
7523 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7524 data_offset
, data_sec
, data_arm_sec
);
7526 else if (per_index
< 5)
7528 if (((word
>> 17) & 0x7f) == 0x7f)
7529 printf (_(" Restore stack from frame pointer\n"));
7531 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7532 printf (_(" Registers restored: "));
7534 printf (" (compact) ");
7535 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7537 printf (_(" Return register: %s\n"),
7538 tic6x_unwind_regnames
[word
& 0xf]);
7541 printf (_(" [reserved (%d)]\n"), per_index
);
7545 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7546 elf_header
.e_machine
);
7549 /* Decode the descriptors. Not implemented. */
7553 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7555 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7556 unsigned int i
, exidx_len
;
7558 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7559 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7560 exidx_len
= exidx_sec
->sh_size
/ 8;
7562 for (i
= 0; i
< exidx_len
; i
++)
7564 unsigned int exidx_fn
, exidx_entry
;
7565 struct absaddr fn_addr
, entry_addr
;
7568 fputc ('\n', stdout
);
7570 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7571 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7572 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7573 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7575 arm_free_section (& exidx_arm_sec
);
7576 arm_free_section (& extab_arm_sec
);
7580 /* ARM EHABI, Section 5:
7581 An index table entry consists of 2 words.
7582 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7583 if (exidx_fn
& 0x80000000)
7584 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7586 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7588 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7589 fputs (": ", stdout
);
7591 if (exidx_entry
== 1)
7593 print_vma (exidx_entry
, PREFIX_HEX
);
7594 fputs (" [cantunwind]\n", stdout
);
7596 else if (exidx_entry
& 0x80000000)
7598 print_vma (exidx_entry
, PREFIX_HEX
);
7599 fputc ('\n', stdout
);
7600 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7604 bfd_vma table
, table_offset
= 0;
7605 Elf_Internal_Shdr
*table_sec
;
7607 fputs ("@", stdout
);
7608 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7609 print_vma (table
, PREFIX_HEX
);
7612 /* Locate the matching .ARM.extab. */
7613 if (entry_addr
.section
!= SHN_UNDEF
7614 && entry_addr
.section
< elf_header
.e_shnum
)
7616 table_sec
= section_headers
+ entry_addr
.section
;
7617 table_offset
= entry_addr
.offset
;
7621 table_sec
= find_section_by_address (table
);
7622 if (table_sec
!= NULL
)
7623 table_offset
= table
- table_sec
->sh_addr
;
7625 if (table_sec
== NULL
)
7627 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7628 (unsigned long) table
);
7631 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7638 arm_free_section (&exidx_arm_sec
);
7639 arm_free_section (&extab_arm_sec
);
7642 /* Used for both ARM and C6X unwinding tables. */
7645 arm_process_unwind (FILE *file
)
7647 struct arm_unw_aux_info aux
;
7648 Elf_Internal_Shdr
*unwsec
= NULL
;
7649 Elf_Internal_Shdr
*strsec
;
7650 Elf_Internal_Shdr
*sec
;
7652 unsigned int sec_type
;
7654 switch (elf_header
.e_machine
)
7657 sec_type
= SHT_ARM_EXIDX
;
7661 sec_type
= SHT_C6000_UNWIND
;
7665 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7666 elf_header
.e_machine
);
7670 if (string_table
== NULL
)
7673 memset (& aux
, 0, sizeof (aux
));
7676 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7678 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7680 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7682 strsec
= section_headers
+ sec
->sh_link
;
7683 assert (aux
.strtab
== NULL
);
7684 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7685 1, strsec
->sh_size
, _("string table"));
7686 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7688 else if (sec
->sh_type
== sec_type
)
7693 printf (_("\nThere are no unwind sections in this file.\n"));
7695 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7697 if (sec
->sh_type
== sec_type
)
7699 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7701 (unsigned long) sec
->sh_offset
,
7702 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7704 dump_arm_unwind (&aux
, sec
);
7711 free ((char *) aux
.strtab
);
7715 process_unwind (FILE * file
)
7717 struct unwind_handler
7720 void (* handler
)(FILE *);
7723 { EM_ARM
, arm_process_unwind
},
7724 { EM_IA_64
, ia64_process_unwind
},
7725 { EM_PARISC
, hppa_process_unwind
},
7726 { EM_TI_C6000
, arm_process_unwind
},
7734 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7735 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7737 handlers
[i
].handler (file
);
7741 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7742 get_machine_name (elf_header
.e_machine
));
7746 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7748 switch (entry
->d_tag
)
7751 if (entry
->d_un
.d_val
== 0)
7755 static const char * opts
[] =
7757 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7758 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7759 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7760 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7766 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7767 if (entry
->d_un
.d_val
& (1 << cnt
))
7769 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7775 case DT_MIPS_IVERSION
:
7776 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7777 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7779 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7782 case DT_MIPS_TIME_STAMP
:
7787 time_t atime
= entry
->d_un
.d_val
;
7788 tmp
= gmtime (&atime
);
7789 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7790 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7791 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7792 printf (_("Time Stamp: %s"), timebuf
);
7796 case DT_MIPS_RLD_VERSION
:
7797 case DT_MIPS_LOCAL_GOTNO
:
7798 case DT_MIPS_CONFLICTNO
:
7799 case DT_MIPS_LIBLISTNO
:
7800 case DT_MIPS_SYMTABNO
:
7801 case DT_MIPS_UNREFEXTNO
:
7802 case DT_MIPS_HIPAGENO
:
7803 case DT_MIPS_DELTA_CLASS_NO
:
7804 case DT_MIPS_DELTA_INSTANCE_NO
:
7805 case DT_MIPS_DELTA_RELOC_NO
:
7806 case DT_MIPS_DELTA_SYM_NO
:
7807 case DT_MIPS_DELTA_CLASSSYM_NO
:
7808 case DT_MIPS_COMPACT_SIZE
:
7809 print_vma (entry
->d_un
.d_ptr
, DEC
);
7813 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7819 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7821 switch (entry
->d_tag
)
7823 case DT_HP_DLD_FLAGS
:
7832 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7833 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7834 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7835 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7836 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7837 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7838 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7839 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7840 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7841 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7842 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7843 { DT_HP_GST
, "HP_GST" },
7844 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7845 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7846 { DT_HP_NODELETE
, "HP_NODELETE" },
7847 { DT_HP_GROUP
, "HP_GROUP" },
7848 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7852 bfd_vma val
= entry
->d_un
.d_val
;
7854 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7855 if (val
& flags
[cnt
].bit
)
7859 fputs (flags
[cnt
].str
, stdout
);
7861 val
^= flags
[cnt
].bit
;
7864 if (val
!= 0 || first
)
7868 print_vma (val
, HEX
);
7874 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7882 /* VMS vs Unix time offset and factor. */
7884 #define VMS_EPOCH_OFFSET 35067168000000000LL
7885 #define VMS_GRANULARITY_FACTOR 10000000
7887 /* Display a VMS time in a human readable format. */
7890 print_vms_time (bfd_int64_t vmstime
)
7895 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7896 tm
= gmtime (&unxtime
);
7897 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7898 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7899 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7904 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7906 switch (entry
->d_tag
)
7908 case DT_IA_64_PLT_RESERVE
:
7909 /* First 3 slots reserved. */
7910 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7912 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7915 case DT_IA_64_VMS_LINKTIME
:
7917 print_vms_time (entry
->d_un
.d_val
);
7921 case DT_IA_64_VMS_LNKFLAGS
:
7922 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7923 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7924 printf (" CALL_DEBUG");
7925 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7926 printf (" NOP0BUFS");
7927 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7928 printf (" P0IMAGE");
7929 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7930 printf (" MKTHREADS");
7931 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7932 printf (" UPCALLS");
7933 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7935 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7936 printf (" INITIALIZE");
7937 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7939 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7940 printf (" EXE_INIT");
7941 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7942 printf (" TBK_IN_IMG");
7943 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7944 printf (" DBG_IN_IMG");
7945 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7946 printf (" TBK_IN_DSF");
7947 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7948 printf (" DBG_IN_DSF");
7949 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7950 printf (" SIGNATURES");
7951 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7952 printf (" REL_SEG_OFF");
7956 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7963 get_32bit_dynamic_section (FILE * file
)
7965 Elf32_External_Dyn
* edyn
;
7966 Elf32_External_Dyn
* ext
;
7967 Elf_Internal_Dyn
* entry
;
7969 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7970 dynamic_size
, _("dynamic section"));
7974 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7975 might not have the luxury of section headers. Look for the DT_NULL
7976 terminator to determine the number of entries. */
7977 for (ext
= edyn
, dynamic_nent
= 0;
7978 (char *) ext
< (char *) edyn
+ dynamic_size
;
7982 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7986 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7988 if (dynamic_section
== NULL
)
7990 error (_("Out of memory\n"));
7995 for (ext
= edyn
, entry
= dynamic_section
;
7996 entry
< dynamic_section
+ dynamic_nent
;
7999 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8000 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8009 get_64bit_dynamic_section (FILE * file
)
8011 Elf64_External_Dyn
* edyn
;
8012 Elf64_External_Dyn
* ext
;
8013 Elf_Internal_Dyn
* entry
;
8015 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8016 dynamic_size
, _("dynamic section"));
8020 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8021 might not have the luxury of section headers. Look for the DT_NULL
8022 terminator to determine the number of entries. */
8023 for (ext
= edyn
, dynamic_nent
= 0;
8024 (char *) ext
< (char *) edyn
+ dynamic_size
;
8028 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8032 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8034 if (dynamic_section
== NULL
)
8036 error (_("Out of memory\n"));
8041 for (ext
= edyn
, entry
= dynamic_section
;
8042 entry
< dynamic_section
+ dynamic_nent
;
8045 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8046 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8055 print_dynamic_flags (bfd_vma flags
)
8063 flag
= flags
& - flags
;
8073 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8074 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8075 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8076 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8077 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8078 default: fputs (_("unknown"), stdout
); break;
8084 /* Parse and display the contents of the dynamic section. */
8087 process_dynamic_section (FILE * file
)
8089 Elf_Internal_Dyn
* entry
;
8091 if (dynamic_size
== 0)
8094 printf (_("\nThere is no dynamic section in this file.\n"));
8101 if (! get_32bit_dynamic_section (file
))
8104 else if (! get_64bit_dynamic_section (file
))
8107 /* Find the appropriate symbol table. */
8108 if (dynamic_symbols
== NULL
)
8110 for (entry
= dynamic_section
;
8111 entry
< dynamic_section
+ dynamic_nent
;
8114 Elf_Internal_Shdr section
;
8116 if (entry
->d_tag
!= DT_SYMTAB
)
8119 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8121 /* Since we do not know how big the symbol table is,
8122 we default to reading in the entire file (!) and
8123 processing that. This is overkill, I know, but it
8125 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8127 if (archive_file_offset
!= 0)
8128 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8131 if (fseek (file
, 0, SEEK_END
))
8132 error (_("Unable to seek to end of file!\n"));
8134 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8138 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8140 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8142 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8143 if (num_dynamic_syms
< 1)
8145 error (_("Unable to determine the number of symbols to load\n"));
8151 /* Similarly find a string table. */
8152 if (dynamic_strings
== NULL
)
8154 for (entry
= dynamic_section
;
8155 entry
< dynamic_section
+ dynamic_nent
;
8158 unsigned long offset
;
8161 if (entry
->d_tag
!= DT_STRTAB
)
8164 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8166 /* Since we do not know how big the string table is,
8167 we default to reading in the entire file (!) and
8168 processing that. This is overkill, I know, but it
8171 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8173 if (archive_file_offset
!= 0)
8174 str_tab_len
= archive_file_size
- offset
;
8177 if (fseek (file
, 0, SEEK_END
))
8178 error (_("Unable to seek to end of file\n"));
8179 str_tab_len
= ftell (file
) - offset
;
8182 if (str_tab_len
< 1)
8185 (_("Unable to determine the length of the dynamic string table\n"));
8189 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8191 _("dynamic string table"));
8192 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8197 /* And find the syminfo section if available. */
8198 if (dynamic_syminfo
== NULL
)
8200 unsigned long syminsz
= 0;
8202 for (entry
= dynamic_section
;
8203 entry
< dynamic_section
+ dynamic_nent
;
8206 if (entry
->d_tag
== DT_SYMINENT
)
8208 /* Note: these braces are necessary to avoid a syntax
8209 error from the SunOS4 C compiler. */
8210 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
8212 else if (entry
->d_tag
== DT_SYMINSZ
)
8213 syminsz
= entry
->d_un
.d_val
;
8214 else if (entry
->d_tag
== DT_SYMINFO
)
8215 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8219 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8221 Elf_External_Syminfo
* extsyminfo
;
8222 Elf_External_Syminfo
* extsym
;
8223 Elf_Internal_Syminfo
* syminfo
;
8225 /* There is a syminfo section. Read the data. */
8226 extsyminfo
= (Elf_External_Syminfo
*)
8227 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8228 _("symbol information"));
8232 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8233 if (dynamic_syminfo
== NULL
)
8235 error (_("Out of memory\n"));
8239 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8240 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8241 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8242 ++syminfo
, ++extsym
)
8244 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8245 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8252 if (do_dynamic
&& dynamic_addr
)
8253 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8254 dynamic_addr
, dynamic_nent
);
8256 printf (_(" Tag Type Name/Value\n"));
8258 for (entry
= dynamic_section
;
8259 entry
< dynamic_section
+ dynamic_nent
;
8267 print_vma (entry
->d_tag
, FULL_HEX
);
8268 dtype
= get_dynamic_type (entry
->d_tag
);
8269 printf (" (%s)%*s", dtype
,
8270 ((is_32bit_elf
? 27 : 19)
8271 - (int) strlen (dtype
)),
8275 switch (entry
->d_tag
)
8279 print_dynamic_flags (entry
->d_un
.d_val
);
8289 switch (entry
->d_tag
)
8292 printf (_("Auxiliary library"));
8296 printf (_("Filter library"));
8300 printf (_("Configuration file"));
8304 printf (_("Dependency audit library"));
8308 printf (_("Audit library"));
8312 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8313 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8317 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8326 printf (_("Flags:"));
8328 if (entry
->d_un
.d_val
== 0)
8329 printf (_(" None\n"));
8332 unsigned long int val
= entry
->d_un
.d_val
;
8334 if (val
& DTF_1_PARINIT
)
8336 printf (" PARINIT");
8337 val
^= DTF_1_PARINIT
;
8339 if (val
& DTF_1_CONFEXP
)
8341 printf (" CONFEXP");
8342 val
^= DTF_1_CONFEXP
;
8345 printf (" %lx", val
);
8354 printf (_("Flags:"));
8356 if (entry
->d_un
.d_val
== 0)
8357 printf (_(" None\n"));
8360 unsigned long int val
= entry
->d_un
.d_val
;
8362 if (val
& DF_P1_LAZYLOAD
)
8364 printf (" LAZYLOAD");
8365 val
^= DF_P1_LAZYLOAD
;
8367 if (val
& DF_P1_GROUPPERM
)
8369 printf (" GROUPPERM");
8370 val
^= DF_P1_GROUPPERM
;
8373 printf (" %lx", val
);
8382 printf (_("Flags:"));
8383 if (entry
->d_un
.d_val
== 0)
8384 printf (_(" None\n"));
8387 unsigned long int val
= entry
->d_un
.d_val
;
8394 if (val
& DF_1_GLOBAL
)
8399 if (val
& DF_1_GROUP
)
8404 if (val
& DF_1_NODELETE
)
8406 printf (" NODELETE");
8407 val
^= DF_1_NODELETE
;
8409 if (val
& DF_1_LOADFLTR
)
8411 printf (" LOADFLTR");
8412 val
^= DF_1_LOADFLTR
;
8414 if (val
& DF_1_INITFIRST
)
8416 printf (" INITFIRST");
8417 val
^= DF_1_INITFIRST
;
8419 if (val
& DF_1_NOOPEN
)
8424 if (val
& DF_1_ORIGIN
)
8429 if (val
& DF_1_DIRECT
)
8434 if (val
& DF_1_TRANS
)
8439 if (val
& DF_1_INTERPOSE
)
8441 printf (" INTERPOSE");
8442 val
^= DF_1_INTERPOSE
;
8444 if (val
& DF_1_NODEFLIB
)
8446 printf (" NODEFLIB");
8447 val
^= DF_1_NODEFLIB
;
8449 if (val
& DF_1_NODUMP
)
8454 if (val
& DF_1_CONFALT
)
8456 printf (" CONFALT");
8457 val
^= DF_1_CONFALT
;
8459 if (val
& DF_1_ENDFILTEE
)
8461 printf (" ENDFILTEE");
8462 val
^= DF_1_ENDFILTEE
;
8464 if (val
& DF_1_DISPRELDNE
)
8466 printf (" DISPRELDNE");
8467 val
^= DF_1_DISPRELDNE
;
8469 if (val
& DF_1_DISPRELPND
)
8471 printf (" DISPRELPND");
8472 val
^= DF_1_DISPRELPND
;
8474 if (val
& DF_1_NODIRECT
)
8476 printf (" NODIRECT");
8477 val
^= DF_1_NODIRECT
;
8479 if (val
& DF_1_IGNMULDEF
)
8481 printf (" IGNMULDEF");
8482 val
^= DF_1_IGNMULDEF
;
8484 if (val
& DF_1_NOKSYMS
)
8486 printf (" NOKSYMS");
8487 val
^= DF_1_NOKSYMS
;
8489 if (val
& DF_1_NOHDR
)
8494 if (val
& DF_1_EDITED
)
8499 if (val
& DF_1_NORELOC
)
8501 printf (" NORELOC");
8502 val
^= DF_1_NORELOC
;
8504 if (val
& DF_1_SYMINTPOSE
)
8506 printf (" SYMINTPOSE");
8507 val
^= DF_1_SYMINTPOSE
;
8509 if (val
& DF_1_GLOBAUDIT
)
8511 printf (" GLOBAUDIT");
8512 val
^= DF_1_GLOBAUDIT
;
8514 if (val
& DF_1_SINGLETON
)
8516 printf (" SINGLETON");
8517 val
^= DF_1_SINGLETON
;
8520 printf (" %lx", val
);
8527 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8529 puts (get_dynamic_type (entry
->d_un
.d_val
));
8549 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8555 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8556 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8562 switch (entry
->d_tag
)
8565 printf (_("Shared library: [%s]"), name
);
8567 if (streq (name
, program_interpreter
))
8568 printf (_(" program interpreter"));
8572 printf (_("Library soname: [%s]"), name
);
8576 printf (_("Library rpath: [%s]"), name
);
8580 printf (_("Library runpath: [%s]"), name
);
8584 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8589 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8602 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8606 case DT_INIT_ARRAYSZ
:
8607 case DT_FINI_ARRAYSZ
:
8608 case DT_GNU_CONFLICTSZ
:
8609 case DT_GNU_LIBLISTSZ
:
8612 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8613 printf (_(" (bytes)\n"));
8623 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8636 if (entry
->d_tag
== DT_USED
8637 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8639 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8643 printf (_("Not needed object: [%s]\n"), name
);
8648 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8654 /* The value of this entry is ignored. */
8659 case DT_GNU_PRELINKED
:
8663 time_t atime
= entry
->d_un
.d_val
;
8665 tmp
= gmtime (&atime
);
8666 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8667 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8668 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8674 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8677 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8683 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8684 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8689 switch (elf_header
.e_machine
)
8692 case EM_MIPS_RS3_LE
:
8693 dynamic_section_mips_val (entry
);
8696 dynamic_section_parisc_val (entry
);
8699 dynamic_section_ia64_val (entry
);
8702 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8714 get_ver_flags (unsigned int flags
)
8716 static char buff
[32];
8723 if (flags
& VER_FLG_BASE
)
8724 strcat (buff
, "BASE ");
8726 if (flags
& VER_FLG_WEAK
)
8728 if (flags
& VER_FLG_BASE
)
8729 strcat (buff
, "| ");
8731 strcat (buff
, "WEAK ");
8734 if (flags
& VER_FLG_INFO
)
8736 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8737 strcat (buff
, "| ");
8739 strcat (buff
, "INFO ");
8742 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8743 strcat (buff
, _("| <unknown>"));
8748 /* Display the contents of the version sections. */
8751 process_version_sections (FILE * file
)
8753 Elf_Internal_Shdr
* section
;
8760 for (i
= 0, section
= section_headers
;
8761 i
< elf_header
.e_shnum
;
8764 switch (section
->sh_type
)
8766 case SHT_GNU_verdef
:
8768 Elf_External_Verdef
* edefs
;
8776 (_("\nVersion definition section '%s' contains %u entries:\n"),
8777 SECTION_NAME (section
), section
->sh_info
);
8779 printf (_(" Addr: 0x"));
8780 printf_vma (section
->sh_addr
);
8781 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8782 (unsigned long) section
->sh_offset
, section
->sh_link
,
8783 section
->sh_link
< elf_header
.e_shnum
8784 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8787 edefs
= (Elf_External_Verdef
*)
8788 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8789 _("version definition section"));
8792 endbuf
= (char *) edefs
+ section
->sh_size
;
8794 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8797 Elf_External_Verdef
* edef
;
8798 Elf_Internal_Verdef ent
;
8799 Elf_External_Verdaux
* eaux
;
8800 Elf_Internal_Verdaux aux
;
8804 /* Check for very large indicies. */
8805 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8808 vstart
= ((char *) edefs
) + idx
;
8809 if (vstart
+ sizeof (*edef
) > endbuf
)
8812 edef
= (Elf_External_Verdef
*) vstart
;
8814 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8815 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8816 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8817 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8818 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8819 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8820 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8822 printf (_(" %#06x: Rev: %d Flags: %s"),
8823 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8825 printf (_(" Index: %d Cnt: %d "),
8826 ent
.vd_ndx
, ent
.vd_cnt
);
8828 /* Check for overflow. */
8829 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8832 vstart
+= ent
.vd_aux
;
8834 eaux
= (Elf_External_Verdaux
*) vstart
;
8836 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8837 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8839 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8840 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8842 printf (_("Name index: %ld\n"), aux
.vda_name
);
8844 isum
= idx
+ ent
.vd_aux
;
8846 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8848 /* Check for overflow. */
8849 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8852 isum
+= aux
.vda_next
;
8853 vstart
+= aux
.vda_next
;
8855 eaux
= (Elf_External_Verdaux
*) vstart
;
8856 if (vstart
+ sizeof (*eaux
) > endbuf
)
8859 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8860 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8862 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8863 printf (_(" %#06x: Parent %d: %s\n"),
8864 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8866 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8867 isum
, j
, aux
.vda_name
);
8871 printf (_(" Version def aux past end of section\n"));
8876 if (cnt
< section
->sh_info
)
8877 printf (_(" Version definition past end of section\n"));
8883 case SHT_GNU_verneed
:
8885 Elf_External_Verneed
* eneed
;
8892 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8893 SECTION_NAME (section
), section
->sh_info
);
8895 printf (_(" Addr: 0x"));
8896 printf_vma (section
->sh_addr
);
8897 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8898 (unsigned long) section
->sh_offset
, section
->sh_link
,
8899 section
->sh_link
< elf_header
.e_shnum
8900 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8903 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8904 section
->sh_offset
, 1,
8906 _("Version Needs section"));
8909 endbuf
= (char *) eneed
+ section
->sh_size
;
8911 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8913 Elf_External_Verneed
* entry
;
8914 Elf_Internal_Verneed ent
;
8919 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8922 vstart
= ((char *) eneed
) + idx
;
8923 if (vstart
+ sizeof (*entry
) > endbuf
)
8926 entry
= (Elf_External_Verneed
*) vstart
;
8928 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8929 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8930 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8931 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8932 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8934 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8936 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8937 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8939 printf (_(" File: %lx"), ent
.vn_file
);
8941 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8943 /* Check for overflow. */
8944 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8947 vstart
+= ent
.vn_aux
;
8949 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8951 Elf_External_Vernaux
* eaux
;
8952 Elf_Internal_Vernaux aux
;
8954 if (vstart
+ sizeof (*eaux
) > endbuf
)
8956 eaux
= (Elf_External_Vernaux
*) vstart
;
8958 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8959 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8960 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8961 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8962 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8964 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8965 printf (_(" %#06x: Name: %s"),
8966 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8968 printf (_(" %#06x: Name index: %lx"),
8969 isum
, aux
.vna_name
);
8971 printf (_(" Flags: %s Version: %d\n"),
8972 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8974 /* Check for overflow. */
8975 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8978 isum
+= aux
.vna_next
;
8979 vstart
+= aux
.vna_next
;
8983 warn (_("Missing Version Needs auxillary information\n"));
8985 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
8987 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8988 cnt
= section
->sh_info
;
8994 if (cnt
< section
->sh_info
)
8995 warn (_("Missing Version Needs information\n"));
9001 case SHT_GNU_versym
:
9003 Elf_Internal_Shdr
* link_section
;
9006 unsigned char * edata
;
9007 unsigned short * data
;
9009 Elf_Internal_Sym
* symbols
;
9010 Elf_Internal_Shdr
* string_sec
;
9011 unsigned long num_syms
;
9014 if (section
->sh_link
>= elf_header
.e_shnum
)
9017 link_section
= section_headers
+ section
->sh_link
;
9018 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9020 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9025 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9026 if (symbols
== NULL
)
9029 string_sec
= section_headers
+ link_section
->sh_link
;
9031 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9032 string_sec
->sh_size
,
9033 _("version string table"));
9040 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9041 SECTION_NAME (section
), total
);
9043 printf (_(" Addr: "));
9044 printf_vma (section
->sh_addr
);
9045 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9046 (unsigned long) section
->sh_offset
, section
->sh_link
,
9047 SECTION_NAME (link_section
));
9049 off
= offset_from_vma (file
,
9050 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9051 total
* sizeof (short));
9052 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9054 _("version symbol data"));
9062 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9064 for (cnt
= total
; cnt
--;)
9065 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9070 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9073 int check_def
, check_need
;
9076 printf (" %03x:", cnt
);
9078 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9079 switch (data
[cnt
+ j
])
9082 fputs (_(" 0 (*local*) "), stdout
);
9086 fputs (_(" 1 (*global*) "), stdout
);
9090 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9091 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9093 /* If this index value is greater than the size of the symbols
9094 array, break to avoid an out-of-bounds read. */
9095 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9097 warn (_("invalid index into symbol array\n"));
9103 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9104 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9107 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9114 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9116 Elf_Internal_Verneed ivn
;
9117 unsigned long offset
;
9119 offset
= offset_from_vma
9120 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9121 sizeof (Elf_External_Verneed
));
9125 Elf_Internal_Vernaux ivna
;
9126 Elf_External_Verneed evn
;
9127 Elf_External_Vernaux evna
;
9128 unsigned long a_off
;
9130 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9131 _("version need")) == NULL
)
9134 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9135 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9137 a_off
= offset
+ ivn
.vn_aux
;
9141 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9142 1, _("version need aux (2)")) == NULL
)
9149 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9150 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9153 a_off
+= ivna
.vna_next
;
9155 while (ivna
.vna_other
!= data
[cnt
+ j
]
9156 && ivna
.vna_next
!= 0);
9158 if (ivna
.vna_other
== data
[cnt
+ j
])
9160 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9162 if (ivna
.vna_name
>= string_sec
->sh_size
)
9163 name
= _("*invalid*");
9165 name
= strtab
+ ivna
.vna_name
;
9166 nn
+= printf ("(%s%-*s",
9168 12 - (int) strlen (name
),
9174 offset
+= ivn
.vn_next
;
9176 while (ivn
.vn_next
);
9179 if (check_def
&& data
[cnt
+ j
] != 0x8001
9180 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9182 Elf_Internal_Verdef ivd
;
9183 Elf_External_Verdef evd
;
9184 unsigned long offset
;
9186 offset
= offset_from_vma
9187 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9192 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9193 _("version def")) == NULL
)
9200 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9201 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9204 offset
+= ivd
.vd_next
;
9206 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9207 && ivd
.vd_next
!= 0);
9209 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9211 Elf_External_Verdaux evda
;
9212 Elf_Internal_Verdaux ivda
;
9214 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9216 if (get_data (&evda
, file
,
9217 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9219 _("version def aux")) == NULL
)
9222 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9224 if (ivda
.vda_name
>= string_sec
->sh_size
)
9225 name
= _("*invalid*");
9227 name
= strtab
+ ivda
.vda_name
;
9228 nn
+= printf ("(%s%-*s",
9230 12 - (int) strlen (name
),
9236 printf ("%*c", 18 - nn
, ' ');
9254 printf (_("\nNo version information found in this file.\n"));
9260 get_symbol_binding (unsigned int binding
)
9262 static char buff
[32];
9266 case STB_LOCAL
: return "LOCAL";
9267 case STB_GLOBAL
: return "GLOBAL";
9268 case STB_WEAK
: return "WEAK";
9270 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9271 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9273 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9275 if (binding
== STB_GNU_UNIQUE
9276 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9277 /* GNU is still using the default value 0. */
9278 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9280 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9283 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9289 get_symbol_type (unsigned int type
)
9291 static char buff
[32];
9295 case STT_NOTYPE
: return "NOTYPE";
9296 case STT_OBJECT
: return "OBJECT";
9297 case STT_FUNC
: return "FUNC";
9298 case STT_SECTION
: return "SECTION";
9299 case STT_FILE
: return "FILE";
9300 case STT_COMMON
: return "COMMON";
9301 case STT_TLS
: return "TLS";
9302 case STT_RELC
: return "RELC";
9303 case STT_SRELC
: return "SRELC";
9305 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9307 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9308 return "THUMB_FUNC";
9310 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9313 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9314 return "PARISC_MILLI";
9316 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9318 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9320 if (elf_header
.e_machine
== EM_PARISC
)
9322 if (type
== STT_HP_OPAQUE
)
9324 if (type
== STT_HP_STUB
)
9328 if (type
== STT_GNU_IFUNC
9329 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9330 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9331 /* GNU is still using the default value 0. */
9332 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9335 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9338 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9344 get_symbol_visibility (unsigned int visibility
)
9348 case STV_DEFAULT
: return "DEFAULT";
9349 case STV_INTERNAL
: return "INTERNAL";
9350 case STV_HIDDEN
: return "HIDDEN";
9351 case STV_PROTECTED
: return "PROTECTED";
9357 get_mips_symbol_other (unsigned int other
)
9369 case STO_MICROMIPS
| STO_MIPS_PIC
:
9370 return "MICROMIPS, MIPS PIC";
9379 get_ia64_symbol_other (unsigned int other
)
9383 static char res
[32];
9387 /* Function types is for images and .STB files only. */
9388 switch (elf_header
.e_type
)
9392 switch (VMS_ST_FUNC_TYPE (other
))
9394 case VMS_SFT_CODE_ADDR
:
9395 strcat (res
, " CA");
9397 case VMS_SFT_SYMV_IDX
:
9398 strcat (res
, " VEC");
9401 strcat (res
, " FD");
9403 case VMS_SFT_RESERVE
:
9404 strcat (res
, " RSV");
9413 switch (VMS_ST_LINKAGE (other
))
9415 case VMS_STL_IGNORE
:
9416 strcat (res
, " IGN");
9418 case VMS_STL_RESERVE
:
9419 strcat (res
, " RSV");
9422 strcat (res
, " STD");
9425 strcat (res
, " LNK");
9440 get_ppc64_symbol_other (unsigned int other
)
9442 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9444 static char buf
[32];
9445 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9446 PPC64_LOCAL_ENTRY_OFFSET (other
));
9453 get_symbol_other (unsigned int other
)
9455 const char * result
= NULL
;
9456 static char buff
[32];
9461 switch (elf_header
.e_machine
)
9464 result
= get_mips_symbol_other (other
);
9467 result
= get_ia64_symbol_other (other
);
9470 result
= get_ppc64_symbol_other (other
);
9479 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9484 get_symbol_index_type (unsigned int type
)
9486 static char buff
[32];
9490 case SHN_UNDEF
: return "UND";
9491 case SHN_ABS
: return "ABS";
9492 case SHN_COMMON
: return "COM";
9494 if (type
== SHN_IA_64_ANSI_COMMON
9495 && elf_header
.e_machine
== EM_IA_64
9496 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9498 else if ((elf_header
.e_machine
== EM_X86_64
9499 || elf_header
.e_machine
== EM_L1OM
9500 || elf_header
.e_machine
== EM_K1OM
)
9501 && type
== SHN_X86_64_LCOMMON
)
9503 else if ((type
== SHN_MIPS_SCOMMON
9504 && elf_header
.e_machine
== EM_MIPS
)
9505 || (type
== SHN_TIC6X_SCOMMON
9506 && elf_header
.e_machine
== EM_TI_C6000
))
9508 else if (type
== SHN_MIPS_SUNDEFINED
9509 && elf_header
.e_machine
== EM_MIPS
)
9511 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9512 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9513 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9514 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9515 else if (type
>= SHN_LORESERVE
)
9516 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9517 else if (type
>= elf_header
.e_shnum
)
9518 sprintf (buff
, "bad section index[%3d]", type
);
9520 sprintf (buff
, "%3d", type
);
9528 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9530 unsigned char * e_data
;
9533 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9537 error (_("Out of memory\n"));
9541 if (fread (e_data
, ent_size
, number
, file
) != number
)
9543 error (_("Unable to read in dynamic data\n"));
9547 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9551 error (_("Out of memory\n"));
9557 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9565 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9567 Elf_Internal_Sym
* psym
;
9570 psym
= dynamic_symbols
+ si
;
9572 n
= print_vma (si
, DEC_5
);
9574 fputs (&" "[n
], stdout
);
9575 printf (" %3lu: ", hn
);
9576 print_vma (psym
->st_value
, LONG_HEX
);
9578 print_vma (psym
->st_size
, DEC_5
);
9580 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9581 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9582 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9583 /* Check to see if any other bits in the st_other field are set.
9584 Note - displaying this information disrupts the layout of the
9585 table being generated, but for the moment this case is very
9587 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9588 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9589 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9590 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9591 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9593 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9597 /* Dump the symbol table. */
9599 process_symbol_table (FILE * file
)
9601 Elf_Internal_Shdr
* section
;
9602 bfd_vma nbuckets
= 0;
9603 bfd_vma nchains
= 0;
9604 bfd_vma
* buckets
= NULL
;
9605 bfd_vma
* chains
= NULL
;
9606 bfd_vma ngnubuckets
= 0;
9607 bfd_vma
* gnubuckets
= NULL
;
9608 bfd_vma
* gnuchains
= NULL
;
9609 bfd_vma gnusymidx
= 0;
9611 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9614 if (dynamic_info
[DT_HASH
]
9616 || (do_using_dynamic
9618 && dynamic_strings
!= NULL
)))
9620 unsigned char nb
[8];
9621 unsigned char nc
[8];
9622 int hash_ent_size
= 4;
9624 if ((elf_header
.e_machine
== EM_ALPHA
9625 || elf_header
.e_machine
== EM_S390
9626 || elf_header
.e_machine
== EM_S390_OLD
)
9627 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9631 (archive_file_offset
9632 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9633 sizeof nb
+ sizeof nc
)),
9636 error (_("Unable to seek to start of dynamic information\n"));
9640 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9642 error (_("Failed to read in number of buckets\n"));
9646 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9648 error (_("Failed to read in number of chains\n"));
9652 nbuckets
= byte_get (nb
, hash_ent_size
);
9653 nchains
= byte_get (nc
, hash_ent_size
);
9655 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9656 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9659 if (buckets
== NULL
|| chains
== NULL
)
9661 if (do_using_dynamic
)
9672 if (dynamic_info_DT_GNU_HASH
9674 || (do_using_dynamic
9676 && dynamic_strings
!= NULL
)))
9678 unsigned char nb
[16];
9679 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9680 bfd_vma buckets_vma
;
9683 (archive_file_offset
9684 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9688 error (_("Unable to seek to start of dynamic information\n"));
9692 if (fread (nb
, 16, 1, file
) != 1)
9694 error (_("Failed to read in number of buckets\n"));
9698 ngnubuckets
= byte_get (nb
, 4);
9699 gnusymidx
= byte_get (nb
+ 4, 4);
9700 bitmaskwords
= byte_get (nb
+ 8, 4);
9701 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9703 buckets_vma
+= bitmaskwords
* 4;
9705 buckets_vma
+= bitmaskwords
* 8;
9708 (archive_file_offset
9709 + offset_from_vma (file
, buckets_vma
, 4)),
9712 error (_("Unable to seek to start of dynamic information\n"));
9716 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9718 if (gnubuckets
== NULL
)
9721 for (i
= 0; i
< ngnubuckets
; i
++)
9722 if (gnubuckets
[i
] != 0)
9724 if (gnubuckets
[i
] < gnusymidx
)
9727 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9728 maxchain
= gnubuckets
[i
];
9731 if (maxchain
== 0xffffffff)
9734 maxchain
-= gnusymidx
;
9737 (archive_file_offset
9738 + offset_from_vma (file
, buckets_vma
9739 + 4 * (ngnubuckets
+ maxchain
), 4)),
9742 error (_("Unable to seek to start of dynamic information\n"));
9748 if (fread (nb
, 4, 1, file
) != 1)
9750 error (_("Failed to determine last chain length\n"));
9754 if (maxchain
+ 1 == 0)
9759 while ((byte_get (nb
, 4) & 1) == 0);
9762 (archive_file_offset
9763 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9766 error (_("Unable to seek to start of dynamic information\n"));
9770 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9773 if (gnuchains
== NULL
)
9778 if (do_using_dynamic
)
9783 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9786 && dynamic_strings
!= NULL
)
9790 if (dynamic_info
[DT_HASH
])
9794 printf (_("\nSymbol table for image:\n"));
9796 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9798 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9800 for (hn
= 0; hn
< nbuckets
; hn
++)
9805 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9806 print_dynamic_symbol (si
, hn
);
9810 if (dynamic_info_DT_GNU_HASH
)
9812 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9814 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9816 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9818 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9819 if (gnubuckets
[hn
] != 0)
9821 bfd_vma si
= gnubuckets
[hn
];
9822 bfd_vma off
= si
- gnusymidx
;
9826 print_dynamic_symbol (si
, hn
);
9829 while ((gnuchains
[off
++] & 1) == 0);
9833 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9837 for (i
= 0, section
= section_headers
;
9838 i
< elf_header
.e_shnum
;
9842 char * strtab
= NULL
;
9843 unsigned long int strtab_size
= 0;
9844 Elf_Internal_Sym
* symtab
;
9845 Elf_Internal_Sym
* psym
;
9846 unsigned long num_syms
;
9848 if ((section
->sh_type
!= SHT_SYMTAB
9849 && section
->sh_type
!= SHT_DYNSYM
)
9851 && section
->sh_type
== SHT_SYMTAB
))
9854 if (section
->sh_entsize
== 0)
9856 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9857 SECTION_NAME (section
));
9861 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9862 SECTION_NAME (section
),
9863 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9866 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9868 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9870 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9874 if (section
->sh_link
== elf_header
.e_shstrndx
)
9876 strtab
= string_table
;
9877 strtab_size
= string_table_length
;
9879 else if (section
->sh_link
< elf_header
.e_shnum
)
9881 Elf_Internal_Shdr
* string_sec
;
9883 string_sec
= section_headers
+ section
->sh_link
;
9885 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9886 1, string_sec
->sh_size
,
9888 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9891 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9893 printf ("%6d: ", si
);
9894 print_vma (psym
->st_value
, LONG_HEX
);
9896 print_vma (psym
->st_size
, DEC_5
);
9897 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9898 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9899 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9900 /* Check to see if any other bits in the st_other field are set.
9901 Note - displaying this information disrupts the layout of the
9902 table being generated, but for the moment this case is very rare. */
9903 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9904 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9905 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9906 print_symbol (25, psym
->st_name
< strtab_size
9907 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9909 if (section
->sh_type
== SHT_DYNSYM
9910 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9912 unsigned char data
[2];
9913 unsigned short vers_data
;
9914 unsigned long offset
;
9918 offset
= offset_from_vma
9919 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9920 sizeof data
+ si
* sizeof (vers_data
));
9922 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9923 sizeof (data
), 1, _("version data")) == NULL
)
9926 vers_data
= byte_get (data
, 2);
9928 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9929 && section_headers
[psym
->st_shndx
].sh_type
9932 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9934 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9936 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9937 && (is_nobits
|| ! check_def
))
9939 Elf_External_Verneed evn
;
9940 Elf_Internal_Verneed ivn
;
9941 Elf_Internal_Vernaux ivna
;
9943 /* We must test both. */
9944 offset
= offset_from_vma
9945 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9950 unsigned long vna_off
;
9952 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9953 _("version need")) == NULL
)
9961 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9962 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9964 vna_off
= offset
+ ivn
.vn_aux
;
9968 Elf_External_Vernaux evna
;
9970 if (get_data (&evna
, file
, vna_off
,
9972 _("version need aux (3)")) == NULL
)
9980 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9981 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9982 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9985 vna_off
+= ivna
.vna_next
;
9987 while (ivna
.vna_other
!= vers_data
9988 && ivna
.vna_next
!= 0);
9990 if (ivna
.vna_other
== vers_data
)
9993 offset
+= ivn
.vn_next
;
9995 while (ivn
.vn_next
!= 0);
9997 if (ivna
.vna_other
== vers_data
)
10000 ivna
.vna_name
< strtab_size
10001 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10005 else if (! is_nobits
)
10006 error (_("bad dynamic symbol\n"));
10013 if (vers_data
!= 0x8001
10014 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10016 Elf_Internal_Verdef ivd
;
10017 Elf_Internal_Verdaux ivda
;
10018 Elf_External_Verdaux evda
;
10021 off
= offset_from_vma
10023 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10024 sizeof (Elf_External_Verdef
));
10028 Elf_External_Verdef evd
;
10030 if (get_data (&evd
, file
, off
, sizeof (evd
),
10031 1, _("version def")) == NULL
)
10039 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10040 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10041 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10044 off
+= ivd
.vd_next
;
10046 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10047 && ivd
.vd_next
!= 0);
10049 off
-= ivd
.vd_next
;
10052 if (get_data (&evda
, file
, off
, sizeof (evda
),
10053 1, _("version def aux")) == NULL
)
10056 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10058 if (psym
->st_name
!= ivda
.vda_name
)
10059 printf ((vers_data
& VERSYM_HIDDEN
)
10061 ivda
.vda_name
< strtab_size
10062 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10072 if (strtab
!= string_table
)
10078 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10080 if (do_histogram
&& buckets
!= NULL
)
10082 unsigned long * lengths
;
10083 unsigned long * counts
;
10086 unsigned long maxlength
= 0;
10087 unsigned long nzero_counts
= 0;
10088 unsigned long nsyms
= 0;
10090 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10091 (unsigned long) nbuckets
);
10092 printf (_(" Length Number %% of total Coverage\n"));
10094 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10095 if (lengths
== NULL
)
10097 error (_("Out of memory\n"));
10100 for (hn
= 0; hn
< nbuckets
; ++hn
)
10102 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10105 if (maxlength
< ++lengths
[hn
])
10110 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10111 if (counts
== NULL
)
10114 error (_("Out of memory\n"));
10118 for (hn
= 0; hn
< nbuckets
; ++hn
)
10119 ++counts
[lengths
[hn
]];
10124 printf (" 0 %-10lu (%5.1f%%)\n",
10125 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10126 for (i
= 1; i
<= maxlength
; ++i
)
10128 nzero_counts
+= counts
[i
] * i
;
10129 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10130 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10131 (nzero_counts
* 100.0) / nsyms
);
10139 if (buckets
!= NULL
)
10145 if (do_histogram
&& gnubuckets
!= NULL
)
10147 unsigned long * lengths
;
10148 unsigned long * counts
;
10150 unsigned long maxlength
= 0;
10151 unsigned long nzero_counts
= 0;
10152 unsigned long nsyms
= 0;
10154 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10155 if (lengths
== NULL
)
10157 error (_("Out of memory\n"));
10161 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10162 (unsigned long) ngnubuckets
);
10163 printf (_(" Length Number %% of total Coverage\n"));
10165 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10166 if (gnubuckets
[hn
] != 0)
10168 bfd_vma off
, length
= 1;
10170 for (off
= gnubuckets
[hn
] - gnusymidx
;
10171 (gnuchains
[off
] & 1) == 0; ++off
)
10173 lengths
[hn
] = length
;
10174 if (length
> maxlength
)
10175 maxlength
= length
;
10179 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10180 if (counts
== NULL
)
10183 error (_("Out of memory\n"));
10187 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10188 ++counts
[lengths
[hn
]];
10190 if (ngnubuckets
> 0)
10193 printf (" 0 %-10lu (%5.1f%%)\n",
10194 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10195 for (j
= 1; j
<= maxlength
; ++j
)
10197 nzero_counts
+= counts
[j
] * j
;
10198 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10199 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10200 (nzero_counts
* 100.0) / nsyms
);
10214 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10218 if (dynamic_syminfo
== NULL
10220 /* No syminfo, this is ok. */
10223 /* There better should be a dynamic symbol section. */
10224 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10228 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10229 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10231 printf (_(" Num: Name BoundTo Flags\n"));
10232 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10234 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10236 printf ("%4d: ", i
);
10237 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10238 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10240 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10243 switch (dynamic_syminfo
[i
].si_boundto
)
10245 case SYMINFO_BT_SELF
:
10246 fputs ("SELF ", stdout
);
10248 case SYMINFO_BT_PARENT
:
10249 fputs ("PARENT ", stdout
);
10252 if (dynamic_syminfo
[i
].si_boundto
> 0
10253 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10254 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10256 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10260 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10264 if (flags
& SYMINFO_FLG_DIRECT
)
10265 printf (" DIRECT");
10266 if (flags
& SYMINFO_FLG_PASSTHRU
)
10267 printf (" PASSTHRU");
10268 if (flags
& SYMINFO_FLG_COPY
)
10270 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10271 printf (" LAZYLOAD");
10279 /* Check to see if the given reloc needs to be handled in a target specific
10280 manner. If so then process the reloc and return TRUE otherwise return
10284 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10285 unsigned char * start
,
10286 Elf_Internal_Sym
* symtab
)
10288 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10290 switch (elf_header
.e_machine
)
10293 case EM_MSP430_OLD
:
10295 static Elf_Internal_Sym
* saved_sym
= NULL
;
10297 switch (reloc_type
)
10299 case 10: /* R_MSP430_SYM_DIFF */
10300 if (uses_msp430x_relocs ())
10302 case 21: /* R_MSP430X_SYM_DIFF */
10303 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10306 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10307 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10308 goto handle_sym_diff
;
10310 case 5: /* R_MSP430_16_BYTE */
10311 case 9: /* R_MSP430_8 */
10312 if (uses_msp430x_relocs ())
10314 goto handle_sym_diff
;
10316 case 2: /* R_MSP430_ABS16 */
10317 case 15: /* R_MSP430X_ABS16 */
10318 if (! uses_msp430x_relocs ())
10320 goto handle_sym_diff
;
10323 if (saved_sym
!= NULL
)
10327 value
= reloc
->r_addend
10328 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10329 - saved_sym
->st_value
);
10331 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10339 if (saved_sym
!= NULL
)
10340 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10347 case EM_CYGNUS_MN10300
:
10349 static Elf_Internal_Sym
* saved_sym
= NULL
;
10351 switch (reloc_type
)
10353 case 34: /* R_MN10300_ALIGN */
10355 case 33: /* R_MN10300_SYM_DIFF */
10356 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10358 case 1: /* R_MN10300_32 */
10359 case 2: /* R_MN10300_16 */
10360 if (saved_sym
!= NULL
)
10364 value
= reloc
->r_addend
10365 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10366 - saved_sym
->st_value
);
10368 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10375 if (saved_sym
!= NULL
)
10376 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10386 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10387 DWARF debug sections. This is a target specific test. Note - we do not
10388 go through the whole including-target-headers-multiple-times route, (as
10389 we have already done with <elf/h8.h>) because this would become very
10390 messy and even then this function would have to contain target specific
10391 information (the names of the relocs instead of their numeric values).
10392 FIXME: This is not the correct way to solve this problem. The proper way
10393 is to have target specific reloc sizing and typing functions created by
10394 the reloc-macros.h header, in the same way that it already creates the
10395 reloc naming functions. */
10398 is_32bit_abs_reloc (unsigned int reloc_type
)
10400 switch (elf_header
.e_machine
)
10404 return reloc_type
== 1; /* R_386_32. */
10406 return reloc_type
== 1; /* R_68K_32. */
10408 return reloc_type
== 1; /* R_860_32. */
10410 return reloc_type
== 2; /* R_960_32. */
10412 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10414 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10416 return reloc_type
== 1; /* R_ARC_32. */
10418 return reloc_type
== 2; /* R_ARM_ABS32 */
10421 return reloc_type
== 1;
10422 case EM_ADAPTEVA_EPIPHANY
:
10423 return reloc_type
== 3;
10425 return reloc_type
== 0x12; /* R_byte4_data. */
10427 return reloc_type
== 3; /* R_CRIS_32. */
10429 return reloc_type
== 3; /* R_CR16_NUM32. */
10431 return reloc_type
== 15; /* R_CRX_NUM32. */
10432 case EM_CYGNUS_FRV
:
10433 return reloc_type
== 1;
10434 case EM_CYGNUS_D10V
:
10436 return reloc_type
== 6; /* R_D10V_32. */
10437 case EM_CYGNUS_D30V
:
10439 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10441 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10442 case EM_CYGNUS_FR30
:
10444 return reloc_type
== 3; /* R_FR30_32. */
10448 return reloc_type
== 1; /* R_H8_DIR32. */
10450 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10453 return reloc_type
== 2; /* R_IP2K_32. */
10455 return reloc_type
== 2; /* R_IQ2000_32. */
10456 case EM_LATTICEMICO32
:
10457 return reloc_type
== 3; /* R_LM32_32. */
10460 return reloc_type
== 3; /* R_M32C_32. */
10462 return reloc_type
== 34; /* R_M32R_32_RELA. */
10464 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10465 case EM_CYGNUS_MEP
:
10466 return reloc_type
== 4; /* R_MEP_32. */
10468 return reloc_type
== 2; /* R_METAG_ADDR32. */
10469 case EM_MICROBLAZE
:
10470 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10472 return reloc_type
== 2; /* R_MIPS_32. */
10474 return reloc_type
== 4; /* R_MMIX_32. */
10475 case EM_CYGNUS_MN10200
:
10477 return reloc_type
== 1; /* R_MN10200_32. */
10478 case EM_CYGNUS_MN10300
:
10480 return reloc_type
== 1; /* R_MN10300_32. */
10482 return reloc_type
== 1; /* R_MOXIE_32. */
10483 case EM_MSP430_OLD
:
10485 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10487 return reloc_type
== 2; /* R_MT_32. */
10489 return reloc_type
== 20; /* R_NDS32_RELA. */
10490 case EM_ALTERA_NIOS2
:
10491 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10493 return reloc_type
== 1; /* R_NIOS_32. */
10495 return reloc_type
== 1; /* R_OR1K_32. */
10497 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10498 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10501 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10503 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10505 return reloc_type
== 1; /* R_PPC_ADDR32. */
10507 return reloc_type
== 1; /* R_RL78_DIR32. */
10509 return reloc_type
== 1; /* R_RX_DIR32. */
10511 return reloc_type
== 1; /* R_I370_ADDR31. */
10514 return reloc_type
== 4; /* R_S390_32. */
10516 return reloc_type
== 8; /* R_SCORE_ABS32. */
10518 return reloc_type
== 1; /* R_SH_DIR32. */
10519 case EM_SPARC32PLUS
:
10522 return reloc_type
== 3 /* R_SPARC_32. */
10523 || reloc_type
== 23; /* R_SPARC_UA32. */
10525 return reloc_type
== 6; /* R_SPU_ADDR32 */
10527 return reloc_type
== 1; /* R_C6000_ABS32. */
10529 return reloc_type
== 2; /* R_TILEGX_32. */
10531 return reloc_type
== 1; /* R_TILEPRO_32. */
10532 case EM_CYGNUS_V850
:
10534 return reloc_type
== 6; /* R_V850_ABS32. */
10536 return reloc_type
== 0x33; /* R_V810_WORD. */
10538 return reloc_type
== 1; /* R_VAX_32. */
10542 return reloc_type
== 10; /* R_X86_64_32. */
10545 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10547 return reloc_type
== 4; /* R_XGATE_32. */
10549 return reloc_type
== 1; /* R_XSTROMY16_32. */
10550 case EM_XTENSA_OLD
:
10552 return reloc_type
== 1; /* R_XTENSA_32. */
10554 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10555 elf_header
.e_machine
);
10560 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10561 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10564 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10566 switch (elf_header
.e_machine
)
10570 return reloc_type
== 2; /* R_386_PC32. */
10572 return reloc_type
== 4; /* R_68K_PC32. */
10574 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10575 case EM_ADAPTEVA_EPIPHANY
:
10576 return reloc_type
== 6;
10578 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10580 return reloc_type
== 3; /* R_ARM_REL32 */
10581 case EM_MICROBLAZE
:
10582 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10584 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10586 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10588 return reloc_type
== 26; /* R_PPC_REL32. */
10590 return reloc_type
== 26; /* R_PPC64_REL32. */
10593 return reloc_type
== 5; /* R_390_PC32. */
10595 return reloc_type
== 2; /* R_SH_REL32. */
10596 case EM_SPARC32PLUS
:
10599 return reloc_type
== 6; /* R_SPARC_DISP32. */
10601 return reloc_type
== 13; /* R_SPU_REL32. */
10603 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10605 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10609 return reloc_type
== 2; /* R_X86_64_PC32. */
10610 case EM_XTENSA_OLD
:
10612 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10614 /* Do not abort or issue an error message here. Not all targets use
10615 pc-relative 32-bit relocs in their DWARF debug information and we
10616 have already tested for target coverage in is_32bit_abs_reloc. A
10617 more helpful warning message will be generated by apply_relocations
10618 anyway, so just return. */
10623 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10624 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10627 is_64bit_abs_reloc (unsigned int reloc_type
)
10629 switch (elf_header
.e_machine
)
10632 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10634 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10636 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10638 return reloc_type
== 80; /* R_PARISC_DIR64. */
10640 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10641 case EM_SPARC32PLUS
:
10644 return reloc_type
== 54; /* R_SPARC_UA64. */
10648 return reloc_type
== 1; /* R_X86_64_64. */
10651 return reloc_type
== 22; /* R_S390_64. */
10653 return reloc_type
== 1; /* R_TILEGX_64. */
10655 return reloc_type
== 18; /* R_MIPS_64. */
10661 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10662 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10665 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10667 switch (elf_header
.e_machine
)
10670 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10672 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10674 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10676 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10678 return reloc_type
== 44; /* R_PPC64_REL64. */
10679 case EM_SPARC32PLUS
:
10682 return reloc_type
== 46; /* R_SPARC_DISP64. */
10686 return reloc_type
== 24; /* R_X86_64_PC64. */
10689 return reloc_type
== 23; /* R_S390_PC64. */
10691 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10697 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10698 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10701 is_24bit_abs_reloc (unsigned int reloc_type
)
10703 switch (elf_header
.e_machine
)
10705 case EM_CYGNUS_MN10200
:
10707 return reloc_type
== 4; /* R_MN10200_24. */
10713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10714 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10717 is_16bit_abs_reloc (unsigned int reloc_type
)
10719 switch (elf_header
.e_machine
)
10723 return reloc_type
== 4; /* R_AVR_16. */
10724 case EM_ADAPTEVA_EPIPHANY
:
10725 return reloc_type
== 5;
10726 case EM_CYGNUS_D10V
:
10728 return reloc_type
== 3; /* R_D10V_16. */
10732 return reloc_type
== R_H8_DIR16
;
10735 return reloc_type
== 1; /* R_IP2K_16. */
10738 return reloc_type
== 1; /* R_M32C_16 */
10740 if (uses_msp430x_relocs ())
10741 return reloc_type
== 2; /* R_MSP430_ABS16. */
10742 case EM_MSP430_OLD
:
10743 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10745 return reloc_type
== 19; /* R_NDS32_RELA. */
10746 case EM_ALTERA_NIOS2
:
10747 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10749 return reloc_type
== 9; /* R_NIOS_16. */
10751 return reloc_type
== 2; /* R_OR1K_16. */
10753 return reloc_type
== 2; /* R_C6000_ABS16. */
10756 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10757 case EM_CYGNUS_MN10200
:
10759 return reloc_type
== 2; /* R_MN10200_16. */
10760 case EM_CYGNUS_MN10300
:
10762 return reloc_type
== 2; /* R_MN10300_16. */
10764 return reloc_type
== 3; /* R_XGATE_16. */
10770 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10771 relocation entries (possibly formerly used for SHT_GROUP sections). */
10774 is_none_reloc (unsigned int reloc_type
)
10776 switch (elf_header
.e_machine
)
10778 case EM_68K
: /* R_68K_NONE. */
10779 case EM_386
: /* R_386_NONE. */
10780 case EM_SPARC32PLUS
:
10782 case EM_SPARC
: /* R_SPARC_NONE. */
10783 case EM_MIPS
: /* R_MIPS_NONE. */
10784 case EM_PARISC
: /* R_PARISC_NONE. */
10785 case EM_ALPHA
: /* R_ALPHA_NONE. */
10786 case EM_ADAPTEVA_EPIPHANY
:
10787 case EM_PPC
: /* R_PPC_NONE. */
10788 case EM_PPC64
: /* R_PPC64_NONE. */
10789 case EM_ARM
: /* R_ARM_NONE. */
10790 case EM_IA_64
: /* R_IA64_NONE. */
10791 case EM_SH
: /* R_SH_NONE. */
10793 case EM_S390
: /* R_390_NONE. */
10794 case EM_CRIS
: /* R_CRIS_NONE. */
10795 case EM_X86_64
: /* R_X86_64_NONE. */
10796 case EM_L1OM
: /* R_X86_64_NONE. */
10797 case EM_K1OM
: /* R_X86_64_NONE. */
10798 case EM_MN10300
: /* R_MN10300_NONE. */
10799 case EM_MOXIE
: /* R_MOXIE_NONE. */
10800 case EM_M32R
: /* R_M32R_NONE. */
10801 case EM_TI_C6000
:/* R_C6000_NONE. */
10802 case EM_TILEGX
: /* R_TILEGX_NONE. */
10803 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10805 case EM_C166
: /* R_XC16X_NONE. */
10806 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10807 case EM_NIOS32
: /* R_NIOS_NONE. */
10808 case EM_OR1K
: /* R_OR1K_NONE. */
10809 return reloc_type
== 0;
10811 return reloc_type
== 0 || reloc_type
== 256;
10813 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10814 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10815 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10816 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10817 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10818 case EM_XTENSA_OLD
:
10820 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10821 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10822 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10823 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10825 return reloc_type
== 3; /* R_METAG_NONE. */
10830 /* Apply relocations to a section.
10831 Note: So far support has been added only for those relocations
10832 which can be found in debug sections.
10833 FIXME: Add support for more relocations ? */
10836 apply_relocations (void * file
,
10837 Elf_Internal_Shdr
* section
,
10838 unsigned char * start
)
10840 Elf_Internal_Shdr
* relsec
;
10841 unsigned char * end
= start
+ section
->sh_size
;
10843 if (elf_header
.e_type
!= ET_REL
)
10846 /* Find the reloc section associated with the section. */
10847 for (relsec
= section_headers
;
10848 relsec
< section_headers
+ elf_header
.e_shnum
;
10851 bfd_boolean is_rela
;
10852 unsigned long num_relocs
;
10853 Elf_Internal_Rela
* relocs
;
10854 Elf_Internal_Rela
* rp
;
10855 Elf_Internal_Shdr
* symsec
;
10856 Elf_Internal_Sym
* symtab
;
10857 unsigned long num_syms
;
10858 Elf_Internal_Sym
* sym
;
10860 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10861 || relsec
->sh_info
>= elf_header
.e_shnum
10862 || section_headers
+ relsec
->sh_info
!= section
10863 || relsec
->sh_size
== 0
10864 || relsec
->sh_link
>= elf_header
.e_shnum
)
10867 is_rela
= relsec
->sh_type
== SHT_RELA
;
10871 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10872 relsec
->sh_size
, & relocs
, & num_relocs
))
10877 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10878 relsec
->sh_size
, & relocs
, & num_relocs
))
10882 /* SH uses RELA but uses in place value instead of the addend field. */
10883 if (elf_header
.e_machine
== EM_SH
)
10886 symsec
= section_headers
+ relsec
->sh_link
;
10887 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10889 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10892 unsigned int reloc_type
;
10893 unsigned int reloc_size
;
10894 unsigned char * rloc
;
10895 unsigned long sym_index
;
10897 reloc_type
= get_reloc_type (rp
->r_info
);
10899 if (target_specific_reloc_handling (rp
, start
, symtab
))
10901 else if (is_none_reloc (reloc_type
))
10903 else if (is_32bit_abs_reloc (reloc_type
)
10904 || is_32bit_pcrel_reloc (reloc_type
))
10906 else if (is_64bit_abs_reloc (reloc_type
)
10907 || is_64bit_pcrel_reloc (reloc_type
))
10909 else if (is_24bit_abs_reloc (reloc_type
))
10911 else if (is_16bit_abs_reloc (reloc_type
))
10915 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10916 reloc_type
, SECTION_NAME (section
));
10920 rloc
= start
+ rp
->r_offset
;
10921 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10923 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10924 (unsigned long) rp
->r_offset
,
10925 SECTION_NAME (section
));
10929 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10930 if (sym_index
>= num_syms
)
10932 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10933 sym_index
, SECTION_NAME (section
));
10936 sym
= symtab
+ sym_index
;
10938 /* If the reloc has a symbol associated with it,
10939 make sure that it is of an appropriate type.
10941 Relocations against symbols without type can happen.
10942 Gcc -feliminate-dwarf2-dups may generate symbols
10943 without type for debug info.
10945 Icc generates relocations against function symbols
10946 instead of local labels.
10948 Relocations against object symbols can happen, eg when
10949 referencing a global array. For an example of this see
10950 the _clz.o binary in libgcc.a. */
10952 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10954 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10955 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10956 (long int)(rp
- relocs
),
10957 SECTION_NAME (relsec
));
10963 addend
+= rp
->r_addend
;
10964 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10965 partial_inplace. */
10967 || (elf_header
.e_machine
== EM_XTENSA
10968 && reloc_type
== 1)
10969 || ((elf_header
.e_machine
== EM_PJ
10970 || elf_header
.e_machine
== EM_PJ_OLD
)
10971 && reloc_type
== 1)
10972 || ((elf_header
.e_machine
== EM_D30V
10973 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10974 && reloc_type
== 12))
10975 addend
+= byte_get (rloc
, reloc_size
);
10977 if (is_32bit_pcrel_reloc (reloc_type
)
10978 || is_64bit_pcrel_reloc (reloc_type
))
10980 /* On HPPA, all pc-relative relocations are biased by 8. */
10981 if (elf_header
.e_machine
== EM_PARISC
)
10983 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10987 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10996 #ifdef SUPPORT_DISASSEMBLY
10998 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11000 printf (_("\nAssembly dump of section %s\n"),
11001 SECTION_NAME (section
));
11003 /* XXX -- to be done --- XXX */
11009 /* Reads in the contents of SECTION from FILE, returning a pointer
11010 to a malloc'ed buffer or NULL if something went wrong. */
11013 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11015 bfd_size_type num_bytes
;
11017 num_bytes
= section
->sh_size
;
11019 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11021 printf (_("\nSection '%s' has no data to dump.\n"),
11022 SECTION_NAME (section
));
11026 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11027 _("section contents"));
11032 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11034 Elf_Internal_Shdr
* relsec
;
11035 bfd_size_type num_bytes
;
11039 char * name
= SECTION_NAME (section
);
11040 bfd_boolean some_strings_shown
;
11042 start
= get_section_contents (section
, file
);
11046 printf (_("\nString dump of section '%s':\n"), name
);
11048 /* If the section being dumped has relocations against it the user might
11049 be expecting these relocations to have been applied. Check for this
11050 case and issue a warning message in order to avoid confusion.
11051 FIXME: Maybe we ought to have an option that dumps a section with
11052 relocs applied ? */
11053 for (relsec
= section_headers
;
11054 relsec
< section_headers
+ elf_header
.e_shnum
;
11057 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11058 || relsec
->sh_info
>= elf_header
.e_shnum
11059 || section_headers
+ relsec
->sh_info
!= section
11060 || relsec
->sh_size
== 0
11061 || relsec
->sh_link
>= elf_header
.e_shnum
)
11064 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11068 num_bytes
= section
->sh_size
;
11070 end
= start
+ num_bytes
;
11071 some_strings_shown
= FALSE
;
11075 while (!ISPRINT (* data
))
11076 if (++ data
>= end
)
11082 /* PR 11128: Use two separate invocations in order to work
11083 around bugs in the Solaris 8 implementation of printf. */
11084 printf (" [%6tx] ", data
- start
);
11085 printf ("%s\n", data
);
11087 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11089 data
+= strlen (data
);
11090 some_strings_shown
= TRUE
;
11094 if (! some_strings_shown
)
11095 printf (_(" No strings found in this section."));
11103 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11105 bfd_boolean relocate
)
11107 Elf_Internal_Shdr
* relsec
;
11108 bfd_size_type bytes
;
11110 unsigned char * data
;
11111 unsigned char * start
;
11113 start
= (unsigned char *) get_section_contents (section
, file
);
11117 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11121 apply_relocations (file
, section
, start
);
11125 /* If the section being dumped has relocations against it the user might
11126 be expecting these relocations to have been applied. Check for this
11127 case and issue a warning message in order to avoid confusion.
11128 FIXME: Maybe we ought to have an option that dumps a section with
11129 relocs applied ? */
11130 for (relsec
= section_headers
;
11131 relsec
< section_headers
+ elf_header
.e_shnum
;
11134 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11135 || relsec
->sh_info
>= elf_header
.e_shnum
11136 || section_headers
+ relsec
->sh_info
!= section
11137 || relsec
->sh_size
== 0
11138 || relsec
->sh_link
>= elf_header
.e_shnum
)
11141 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11146 addr
= section
->sh_addr
;
11147 bytes
= section
->sh_size
;
11156 lbytes
= (bytes
> 16 ? 16 : bytes
);
11158 printf (" 0x%8.8lx ", (unsigned long) addr
);
11160 for (j
= 0; j
< 16; j
++)
11163 printf ("%2.2x", data
[j
]);
11171 for (j
= 0; j
< lbytes
; j
++)
11174 if (k
>= ' ' && k
< 0x7f)
11192 /* Uncompresses a section that was compressed using zlib, in place. */
11195 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11196 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11198 #ifndef HAVE_ZLIB_H
11201 dwarf_size_type compressed_size
= *size
;
11202 unsigned char * compressed_buffer
= *buffer
;
11203 dwarf_size_type uncompressed_size
;
11204 unsigned char * uncompressed_buffer
;
11207 dwarf_size_type header_size
= 12;
11209 /* Read the zlib header. In this case, it should be "ZLIB" followed
11210 by the uncompressed section size, 8 bytes in big-endian order. */
11211 if (compressed_size
< header_size
11212 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11215 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11216 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11217 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11218 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11219 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11220 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11221 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11222 uncompressed_size
+= compressed_buffer
[11];
11224 /* It is possible the section consists of several compressed
11225 buffers concatenated together, so we uncompress in a loop. */
11226 strm
.zalloc
= NULL
;
11228 strm
.opaque
= NULL
;
11229 strm
.avail_in
= compressed_size
- header_size
;
11230 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11231 strm
.avail_out
= uncompressed_size
;
11232 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11234 rc
= inflateInit (& strm
);
11235 while (strm
.avail_in
> 0)
11239 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11240 + (uncompressed_size
- strm
.avail_out
));
11241 rc
= inflate (&strm
, Z_FINISH
);
11242 if (rc
!= Z_STREAM_END
)
11244 rc
= inflateReset (& strm
);
11246 rc
= inflateEnd (& strm
);
11248 || strm
.avail_out
!= 0)
11251 free (compressed_buffer
);
11252 *buffer
= uncompressed_buffer
;
11253 *size
= uncompressed_size
;
11257 free (uncompressed_buffer
);
11258 /* Indicate decompression failure. */
11261 #endif /* HAVE_ZLIB_H */
11265 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11266 Elf_Internal_Shdr
* sec
, void * file
)
11268 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11271 /* If it is already loaded, do nothing. */
11272 if (section
->start
!= NULL
)
11275 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11276 section
->address
= sec
->sh_addr
;
11277 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11279 sec
->sh_size
, buf
);
11280 if (section
->start
== NULL
)
11284 section
->size
= sec
->sh_size
;
11285 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11286 sec
->sh_size
= section
->size
;
11289 if (section
->start
== NULL
)
11292 if (debug_displays
[debug
].relocate
)
11293 apply_relocations ((FILE *) file
, sec
, section
->start
);
11298 /* If this is not NULL, load_debug_section will only look for sections
11299 within the list of sections given here. */
11300 unsigned int *section_subset
= NULL
;
11303 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11305 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11306 Elf_Internal_Shdr
* sec
;
11308 /* Locate the debug section. */
11309 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11311 section
->name
= section
->uncompressed_name
;
11314 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11316 section
->name
= section
->compressed_name
;
11321 /* If we're loading from a subset of sections, and we've loaded
11322 a section matching this name before, it's likely that it's a
11324 if (section_subset
!= NULL
)
11325 free_debug_section (debug
);
11327 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11331 free_debug_section (enum dwarf_section_display_enum debug
)
11333 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11335 if (section
->start
== NULL
)
11338 free ((char *) section
->start
);
11339 section
->start
= NULL
;
11340 section
->address
= 0;
11345 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11347 char * name
= SECTION_NAME (section
);
11348 bfd_size_type length
;
11352 length
= section
->sh_size
;
11355 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11358 if (section
->sh_type
== SHT_NOBITS
)
11360 /* There is no point in dumping the contents of a debugging section
11361 which has the NOBITS type - the bits in the file will be random.
11362 This can happen when a file containing a .eh_frame section is
11363 stripped with the --only-keep-debug command line option. */
11364 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11368 if (const_strneq (name
, ".gnu.linkonce.wi."))
11369 name
= ".debug_info";
11371 /* See if we know how to display the contents of this section. */
11372 for (i
= 0; i
< max
; i
++)
11373 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11374 || (i
== line
&& const_strneq (name
, ".debug_line."))
11375 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11377 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11378 int secondary
= (section
!= find_section (name
));
11381 free_debug_section ((enum dwarf_section_display_enum
) i
);
11383 if (i
== line
&& const_strneq (name
, ".debug_line."))
11385 else if (streq (sec
->uncompressed_name
, name
))
11386 sec
->name
= sec
->uncompressed_name
;
11388 sec
->name
= sec
->compressed_name
;
11389 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11392 /* If this debug section is part of a CU/TU set in a .dwp file,
11393 restrict load_debug_section to the sections in that set. */
11394 section_subset
= find_cu_tu_set (file
, shndx
);
11396 result
&= debug_displays
[i
].display (sec
, file
);
11398 section_subset
= NULL
;
11400 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11401 free_debug_section ((enum dwarf_section_display_enum
) i
);
11409 printf (_("Unrecognized debug section: %s\n"), name
);
11416 /* Set DUMP_SECTS for all sections where dumps were requested
11417 based on section name. */
11420 initialise_dumps_byname (void)
11422 struct dump_list_entry
* cur
;
11424 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11429 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11430 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11432 request_dump_bynumber (i
, cur
->type
);
11437 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11443 process_section_contents (FILE * file
)
11445 Elf_Internal_Shdr
* section
;
11451 initialise_dumps_byname ();
11453 for (i
= 0, section
= section_headers
;
11454 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11457 #ifdef SUPPORT_DISASSEMBLY
11458 if (dump_sects
[i
] & DISASS_DUMP
)
11459 disassemble_section (section
, file
);
11461 if (dump_sects
[i
] & HEX_DUMP
)
11462 dump_section_as_bytes (section
, file
, FALSE
);
11464 if (dump_sects
[i
] & RELOC_DUMP
)
11465 dump_section_as_bytes (section
, file
, TRUE
);
11467 if (dump_sects
[i
] & STRING_DUMP
)
11468 dump_section_as_strings (section
, file
);
11470 if (dump_sects
[i
] & DEBUG_DUMP
)
11471 display_debug_section (i
, section
, file
);
11474 /* Check to see if the user requested a
11475 dump of a section that does not exist. */
11476 while (i
++ < num_dump_sects
)
11478 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11482 process_mips_fpe_exception (int mask
)
11487 if (mask
& OEX_FPU_INEX
)
11488 fputs ("INEX", stdout
), first
= 0;
11489 if (mask
& OEX_FPU_UFLO
)
11490 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11491 if (mask
& OEX_FPU_OFLO
)
11492 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11493 if (mask
& OEX_FPU_DIV0
)
11494 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11495 if (mask
& OEX_FPU_INVAL
)
11496 printf ("%sINVAL", first
? "" : "|");
11499 fputs ("0", stdout
);
11502 /* Display's the value of TAG at location P. If TAG is
11503 greater than 0 it is assumed to be an unknown tag, and
11504 a message is printed to this effect. Otherwise it is
11505 assumed that a message has already been printed.
11507 If the bottom bit of TAG is set it assumed to have a
11508 string value, otherwise it is assumed to have an integer
11511 Returns an updated P pointing to the first unread byte
11512 beyond the end of TAG's value.
11514 Reads at or beyond END will not be made. */
11516 static unsigned char *
11517 display_tag_value (int tag
,
11519 const unsigned char * const end
)
11524 printf (" Tag_unknown_%d: ", tag
);
11528 warn (_("corrupt tag\n"));
11532 /* FIXME: we could read beyond END here. */
11533 printf ("\"%s\"\n", p
);
11534 p
+= strlen ((char *) p
) + 1;
11540 val
= read_uleb128 (p
, &len
, end
);
11542 printf ("%ld (0x%lx)\n", val
, val
);
11548 /* ARM EABI attributes section. */
11553 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11555 const char ** table
;
11556 } arm_attr_public_tag
;
11558 static const char * arm_attr_tag_CPU_arch
[] =
11559 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11560 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11561 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11562 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11563 {"No", "Thumb-1", "Thumb-2"};
11564 static const char * arm_attr_tag_FP_arch
[] =
11565 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11567 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11568 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11569 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11570 static const char * arm_attr_tag_PCS_config
[] =
11571 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11572 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11573 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11574 {"V6", "SB", "TLS", "Unused"};
11575 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11576 {"Absolute", "PC-relative", "SB-relative", "None"};
11577 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11578 {"Absolute", "PC-relative", "None"};
11579 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11580 {"None", "direct", "GOT-indirect"};
11581 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11582 {"None", "??? 1", "2", "??? 3", "4"};
11583 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11584 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11585 {"Unused", "Needed", "Sign only"};
11586 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11587 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11588 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11589 {"Unused", "Finite", "RTABI", "IEEE 754"};
11590 static const char * arm_attr_tag_ABI_enum_size
[] =
11591 {"Unused", "small", "int", "forced to int"};
11592 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11593 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11594 static const char * arm_attr_tag_ABI_VFP_args
[] =
11595 {"AAPCS", "VFP registers", "custom"};
11596 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11597 {"AAPCS", "WMMX registers", "custom"};
11598 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11599 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11600 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11601 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11602 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11603 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11604 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11605 static const char * arm_attr_tag_FP_HP_extension
[] =
11606 {"Not Allowed", "Allowed"};
11607 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11608 {"None", "IEEE 754", "Alternative Format"};
11609 static const char * arm_attr_tag_MPextension_use
[] =
11610 {"Not Allowed", "Allowed"};
11611 static const char * arm_attr_tag_DIV_use
[] =
11612 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11613 "Allowed in v7-A with integer division extension"};
11614 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11615 static const char * arm_attr_tag_Virtualization_use
[] =
11616 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11617 "TrustZone and Virtualization Extensions"};
11618 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11619 {"Not Allowed", "Allowed"};
11621 #define LOOKUP(id, name) \
11622 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11623 static arm_attr_public_tag arm_attr_public_tags
[] =
11625 {4, "CPU_raw_name", 1, NULL
},
11626 {5, "CPU_name", 1, NULL
},
11627 LOOKUP(6, CPU_arch
),
11628 {7, "CPU_arch_profile", 0, NULL
},
11629 LOOKUP(8, ARM_ISA_use
),
11630 LOOKUP(9, THUMB_ISA_use
),
11631 LOOKUP(10, FP_arch
),
11632 LOOKUP(11, WMMX_arch
),
11633 LOOKUP(12, Advanced_SIMD_arch
),
11634 LOOKUP(13, PCS_config
),
11635 LOOKUP(14, ABI_PCS_R9_use
),
11636 LOOKUP(15, ABI_PCS_RW_data
),
11637 LOOKUP(16, ABI_PCS_RO_data
),
11638 LOOKUP(17, ABI_PCS_GOT_use
),
11639 LOOKUP(18, ABI_PCS_wchar_t
),
11640 LOOKUP(19, ABI_FP_rounding
),
11641 LOOKUP(20, ABI_FP_denormal
),
11642 LOOKUP(21, ABI_FP_exceptions
),
11643 LOOKUP(22, ABI_FP_user_exceptions
),
11644 LOOKUP(23, ABI_FP_number_model
),
11645 {24, "ABI_align_needed", 0, NULL
},
11646 {25, "ABI_align_preserved", 0, NULL
},
11647 LOOKUP(26, ABI_enum_size
),
11648 LOOKUP(27, ABI_HardFP_use
),
11649 LOOKUP(28, ABI_VFP_args
),
11650 LOOKUP(29, ABI_WMMX_args
),
11651 LOOKUP(30, ABI_optimization_goals
),
11652 LOOKUP(31, ABI_FP_optimization_goals
),
11653 {32, "compatibility", 0, NULL
},
11654 LOOKUP(34, CPU_unaligned_access
),
11655 LOOKUP(36, FP_HP_extension
),
11656 LOOKUP(38, ABI_FP_16bit_format
),
11657 LOOKUP(42, MPextension_use
),
11658 LOOKUP(44, DIV_use
),
11659 {64, "nodefaults", 0, NULL
},
11660 {65, "also_compatible_with", 0, NULL
},
11661 LOOKUP(66, T2EE_use
),
11662 {67, "conformance", 1, NULL
},
11663 LOOKUP(68, Virtualization_use
),
11664 LOOKUP(70, MPextension_use_legacy
)
11668 static unsigned char *
11669 display_arm_attribute (unsigned char * p
,
11670 const unsigned char * const end
)
11675 arm_attr_public_tag
* attr
;
11679 tag
= read_uleb128 (p
, &len
, end
);
11682 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11684 if (arm_attr_public_tags
[i
].tag
== tag
)
11686 attr
= &arm_attr_public_tags
[i
];
11693 printf (" Tag_%s: ", attr
->name
);
11694 switch (attr
->type
)
11699 case 7: /* Tag_CPU_arch_profile. */
11700 val
= read_uleb128 (p
, &len
, end
);
11704 case 0: printf (_("None\n")); break;
11705 case 'A': printf (_("Application\n")); break;
11706 case 'R': printf (_("Realtime\n")); break;
11707 case 'M': printf (_("Microcontroller\n")); break;
11708 case 'S': printf (_("Application or Realtime\n")); break;
11709 default: printf ("??? (%d)\n", val
); break;
11713 case 24: /* Tag_align_needed. */
11714 val
= read_uleb128 (p
, &len
, end
);
11718 case 0: printf (_("None\n")); break;
11719 case 1: printf (_("8-byte\n")); break;
11720 case 2: printf (_("4-byte\n")); break;
11721 case 3: printf ("??? 3\n"); break;
11724 printf (_("8-byte and up to %d-byte extended\n"),
11727 printf ("??? (%d)\n", val
);
11732 case 25: /* Tag_align_preserved. */
11733 val
= read_uleb128 (p
, &len
, end
);
11737 case 0: printf (_("None\n")); break;
11738 case 1: printf (_("8-byte, except leaf SP\n")); break;
11739 case 2: printf (_("8-byte\n")); break;
11740 case 3: printf ("??? 3\n"); break;
11743 printf (_("8-byte and up to %d-byte extended\n"),
11746 printf ("??? (%d)\n", val
);
11751 case 32: /* Tag_compatibility. */
11752 val
= read_uleb128 (p
, &len
, end
);
11754 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11755 p
+= strlen ((char *) p
) + 1;
11758 case 64: /* Tag_nodefaults. */
11760 printf (_("True\n"));
11763 case 65: /* Tag_also_compatible_with. */
11764 val
= read_uleb128 (p
, &len
, end
);
11766 if (val
== 6 /* Tag_CPU_arch. */)
11768 val
= read_uleb128 (p
, &len
, end
);
11770 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11771 printf ("??? (%d)\n", val
);
11773 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11777 while (*(p
++) != '\0' /* NUL terminator. */);
11786 return display_tag_value (-1, p
, end
);
11788 return display_tag_value (0, p
, end
);
11791 assert (attr
->type
& 0x80);
11792 val
= read_uleb128 (p
, &len
, end
);
11794 type
= attr
->type
& 0x7f;
11796 printf ("??? (%d)\n", val
);
11798 printf ("%s\n", attr
->table
[val
]);
11803 return display_tag_value (tag
, p
, end
);
11806 static unsigned char *
11807 display_gnu_attribute (unsigned char * p
,
11808 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11809 const unsigned char * const end
)
11815 tag
= read_uleb128 (p
, &len
, end
);
11818 /* Tag_compatibility is the only generic GNU attribute defined at
11822 val
= read_uleb128 (p
, &len
, end
);
11826 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11827 warn (_("corrupt vendor attribute\n"));
11831 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11832 p
+= strlen ((char *) p
) + 1;
11837 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11838 return display_proc_gnu_attribute (p
, tag
, end
);
11840 return display_tag_value (tag
, p
, end
);
11843 static unsigned char *
11844 display_power_gnu_attribute (unsigned char * p
,
11846 const unsigned char * const end
)
11851 if (tag
== Tag_GNU_Power_ABI_FP
)
11853 val
= read_uleb128 (p
, &len
, end
);
11855 printf (" Tag_GNU_Power_ABI_FP: ");
11860 printf (_("Hard or soft float\n"));
11863 printf (_("Hard float\n"));
11866 printf (_("Soft float\n"));
11869 printf (_("Single-precision hard float\n"));
11872 printf ("??? (%d)\n", val
);
11878 if (tag
== Tag_GNU_Power_ABI_Vector
)
11880 val
= read_uleb128 (p
, &len
, end
);
11882 printf (" Tag_GNU_Power_ABI_Vector: ");
11886 printf (_("Any\n"));
11889 printf (_("Generic\n"));
11892 printf ("AltiVec\n");
11898 printf ("??? (%d)\n", val
);
11904 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11908 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11912 val
= read_uleb128 (p
, &len
, end
);
11914 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11918 printf (_("Any\n"));
11921 printf ("r3/r4\n");
11924 printf (_("Memory\n"));
11927 printf ("??? (%d)\n", val
);
11933 return display_tag_value (tag
& 1, p
, end
);
11937 display_sparc_hwcaps (int mask
)
11942 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11943 fputs ("mul32", stdout
), first
= 0;
11944 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11945 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11946 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11947 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11948 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11949 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11950 if (mask
& ELF_SPARC_HWCAP_POPC
)
11951 printf ("%spopc", first
? "" : "|"), first
= 0;
11952 if (mask
& ELF_SPARC_HWCAP_VIS
)
11953 printf ("%svis", first
? "" : "|"), first
= 0;
11954 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11955 printf ("%svis2", first
? "" : "|"), first
= 0;
11956 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11957 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11958 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11959 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11960 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11961 printf ("%svis3", first
? "" : "|"), first
= 0;
11962 if (mask
& ELF_SPARC_HWCAP_HPC
)
11963 printf ("%shpc", first
? "" : "|"), first
= 0;
11964 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11965 printf ("%srandom", first
? "" : "|"), first
= 0;
11966 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11967 printf ("%strans", first
? "" : "|"), first
= 0;
11968 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11969 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11970 if (mask
& ELF_SPARC_HWCAP_IMA
)
11971 printf ("%sima", first
? "" : "|"), first
= 0;
11972 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11973 printf ("%scspare", first
? "" : "|"), first
= 0;
11976 fputc('0', stdout
);
11977 fputc('\n', stdout
);
11980 static unsigned char *
11981 display_sparc_gnu_attribute (unsigned char * p
,
11983 const unsigned char * const end
)
11985 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11990 val
= read_uleb128 (p
, &len
, end
);
11992 printf (" Tag_GNU_Sparc_HWCAPS: ");
11993 display_sparc_hwcaps (val
);
11997 return display_tag_value (tag
, p
, end
);
12001 print_mips_fp_abi_value (int val
)
12005 case Val_GNU_MIPS_ABI_FP_ANY
:
12006 printf (_("Hard or soft float\n"));
12008 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12009 printf (_("Hard float (double precision)\n"));
12011 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12012 printf (_("Hard float (single precision)\n"));
12014 case Val_GNU_MIPS_ABI_FP_SOFT
:
12015 printf (_("Soft float\n"));
12017 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12018 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12020 case Val_GNU_MIPS_ABI_FP_XX
:
12021 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12023 case Val_GNU_MIPS_ABI_FP_64
:
12024 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12026 case Val_GNU_MIPS_ABI_FP_64A
:
12027 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12030 printf ("??? (%d)\n", val
);
12035 static unsigned char *
12036 display_mips_gnu_attribute (unsigned char * p
,
12038 const unsigned char * const end
)
12040 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12045 val
= read_uleb128 (p
, &len
, end
);
12047 printf (" Tag_GNU_MIPS_ABI_FP: ");
12049 print_mips_fp_abi_value (val
);
12054 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12059 val
= read_uleb128 (p
, &len
, end
);
12061 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12065 case Val_GNU_MIPS_ABI_MSA_ANY
:
12066 printf (_("Any MSA or not\n"));
12068 case Val_GNU_MIPS_ABI_MSA_128
:
12069 printf (_("128-bit MSA\n"));
12072 printf ("??? (%d)\n", val
);
12078 return display_tag_value (tag
& 1, p
, end
);
12081 static unsigned char *
12082 display_tic6x_attribute (unsigned char * p
,
12083 const unsigned char * const end
)
12089 tag
= read_uleb128 (p
, &len
, end
);
12095 val
= read_uleb128 (p
, &len
, end
);
12097 printf (" Tag_ISA: ");
12101 case C6XABI_Tag_ISA_none
:
12102 printf (_("None\n"));
12104 case C6XABI_Tag_ISA_C62X
:
12107 case C6XABI_Tag_ISA_C67X
:
12110 case C6XABI_Tag_ISA_C67XP
:
12111 printf ("C67x+\n");
12113 case C6XABI_Tag_ISA_C64X
:
12116 case C6XABI_Tag_ISA_C64XP
:
12117 printf ("C64x+\n");
12119 case C6XABI_Tag_ISA_C674X
:
12120 printf ("C674x\n");
12123 printf ("??? (%d)\n", val
);
12128 case Tag_ABI_wchar_t
:
12129 val
= read_uleb128 (p
, &len
, end
);
12131 printf (" Tag_ABI_wchar_t: ");
12135 printf (_("Not used\n"));
12138 printf (_("2 bytes\n"));
12141 printf (_("4 bytes\n"));
12144 printf ("??? (%d)\n", val
);
12149 case Tag_ABI_stack_align_needed
:
12150 val
= read_uleb128 (p
, &len
, end
);
12152 printf (" Tag_ABI_stack_align_needed: ");
12156 printf (_("8-byte\n"));
12159 printf (_("16-byte\n"));
12162 printf ("??? (%d)\n", val
);
12167 case Tag_ABI_stack_align_preserved
:
12168 val
= read_uleb128 (p
, &len
, end
);
12170 printf (" Tag_ABI_stack_align_preserved: ");
12174 printf (_("8-byte\n"));
12177 printf (_("16-byte\n"));
12180 printf ("??? (%d)\n", val
);
12186 val
= read_uleb128 (p
, &len
, end
);
12188 printf (" Tag_ABI_DSBT: ");
12192 printf (_("DSBT addressing not used\n"));
12195 printf (_("DSBT addressing used\n"));
12198 printf ("??? (%d)\n", val
);
12204 val
= read_uleb128 (p
, &len
, end
);
12206 printf (" Tag_ABI_PID: ");
12210 printf (_("Data addressing position-dependent\n"));
12213 printf (_("Data addressing position-independent, GOT near DP\n"));
12216 printf (_("Data addressing position-independent, GOT far from DP\n"));
12219 printf ("??? (%d)\n", val
);
12225 val
= read_uleb128 (p
, &len
, end
);
12227 printf (" Tag_ABI_PIC: ");
12231 printf (_("Code addressing position-dependent\n"));
12234 printf (_("Code addressing position-independent\n"));
12237 printf ("??? (%d)\n", val
);
12242 case Tag_ABI_array_object_alignment
:
12243 val
= read_uleb128 (p
, &len
, end
);
12245 printf (" Tag_ABI_array_object_alignment: ");
12249 printf (_("8-byte\n"));
12252 printf (_("4-byte\n"));
12255 printf (_("16-byte\n"));
12258 printf ("??? (%d)\n", val
);
12263 case Tag_ABI_array_object_align_expected
:
12264 val
= read_uleb128 (p
, &len
, end
);
12266 printf (" Tag_ABI_array_object_align_expected: ");
12270 printf (_("8-byte\n"));
12273 printf (_("4-byte\n"));
12276 printf (_("16-byte\n"));
12279 printf ("??? (%d)\n", val
);
12284 case Tag_ABI_compatibility
:
12285 val
= read_uleb128 (p
, &len
, end
);
12287 printf (" Tag_ABI_compatibility: ");
12288 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12289 p
+= strlen ((char *) p
) + 1;
12292 case Tag_ABI_conformance
:
12293 printf (" Tag_ABI_conformance: ");
12294 printf ("\"%s\"\n", p
);
12295 p
+= strlen ((char *) p
) + 1;
12299 return display_tag_value (tag
, p
, end
);
12303 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12305 unsigned long addr
= 0;
12306 size_t bytes
= end
- p
;
12312 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12314 printf (" 0x%8.8lx ", addr
);
12316 for (j
= 0; j
< 16; j
++)
12319 printf ("%2.2x", p
[j
]);
12327 for (j
= 0; j
< lbytes
; j
++)
12330 if (k
>= ' ' && k
< 0x7f)
12346 static unsigned char *
12347 display_msp430x_attribute (unsigned char * p
,
12348 const unsigned char * const end
)
12354 tag
= read_uleb128 (p
, & len
, end
);
12359 case OFBA_MSPABI_Tag_ISA
:
12360 val
= read_uleb128 (p
, &len
, end
);
12362 printf (" Tag_ISA: ");
12365 case 0: printf (_("None\n")); break;
12366 case 1: printf (_("MSP430\n")); break;
12367 case 2: printf (_("MSP430X\n")); break;
12368 default: printf ("??? (%d)\n", val
); break;
12372 case OFBA_MSPABI_Tag_Code_Model
:
12373 val
= read_uleb128 (p
, &len
, end
);
12375 printf (" Tag_Code_Model: ");
12378 case 0: printf (_("None\n")); break;
12379 case 1: printf (_("Small\n")); break;
12380 case 2: printf (_("Large\n")); break;
12381 default: printf ("??? (%d)\n", val
); break;
12385 case OFBA_MSPABI_Tag_Data_Model
:
12386 val
= read_uleb128 (p
, &len
, end
);
12388 printf (" Tag_Data_Model: ");
12391 case 0: printf (_("None\n")); break;
12392 case 1: printf (_("Small\n")); break;
12393 case 2: printf (_("Large\n")); break;
12394 case 3: printf (_("Restricted Large\n")); break;
12395 default: printf ("??? (%d)\n", val
); break;
12400 printf (_(" <unknown tag %d>: "), tag
);
12404 printf ("\"%s\"\n", p
);
12405 p
+= strlen ((char *) p
) + 1;
12409 val
= read_uleb128 (p
, &len
, end
);
12411 printf ("%d (0x%x)\n", val
, val
);
12420 process_attributes (FILE * file
,
12421 const char * public_name
,
12422 unsigned int proc_type
,
12423 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12424 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12426 Elf_Internal_Shdr
* sect
;
12427 unsigned char * contents
;
12429 unsigned char * end
;
12430 bfd_vma section_len
;
12434 /* Find the section header so that we get the size. */
12435 for (i
= 0, sect
= section_headers
;
12436 i
< elf_header
.e_shnum
;
12439 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12442 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12443 sect
->sh_size
, _("attributes"));
12444 if (contents
== NULL
)
12450 len
= sect
->sh_size
- 1;
12455 unsigned int namelen
;
12456 bfd_boolean public_section
;
12457 bfd_boolean gnu_section
;
12459 section_len
= byte_get (p
, 4);
12462 if (section_len
> len
)
12464 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12465 (unsigned) section_len
, (unsigned) len
);
12469 len
-= section_len
;
12472 namelen
= strnlen ((char *) p
, section_len
) + 1;
12473 if (namelen
== 0 || namelen
>= section_len
)
12475 error (_("Corrupt attribute section name\n"));
12479 printf (_("Attribute Section: %s\n"), p
);
12481 if (public_name
&& streq ((char *) p
, public_name
))
12482 public_section
= TRUE
;
12484 public_section
= FALSE
;
12486 if (streq ((char *) p
, "gnu"))
12487 gnu_section
= TRUE
;
12489 gnu_section
= FALSE
;
12492 section_len
-= namelen
;
12493 while (section_len
> 0)
12499 size
= byte_get (p
, 4);
12500 if (size
> section_len
)
12502 error (_("Bad subsection length (%u > %u)\n"),
12503 (unsigned) size
, (unsigned) section_len
);
12504 size
= section_len
;
12507 section_len
-= size
;
12508 end
= p
+ size
- 1;
12514 printf (_("File Attributes\n"));
12517 printf (_("Section Attributes:"));
12520 printf (_("Symbol Attributes:"));
12526 val
= read_uleb128 (p
, &j
, end
);
12530 printf (" %d", val
);
12535 printf (_("Unknown tag: %d\n"), tag
);
12536 public_section
= FALSE
;
12540 if (public_section
)
12543 p
= display_pub_attribute (p
, end
);
12545 else if (gnu_section
)
12548 p
= display_gnu_attribute (p
,
12549 display_proc_gnu_attribute
,
12554 printf (_(" Unknown section contexts\n"));
12555 display_raw_attribute (p
, end
);
12562 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12570 process_arm_specific (FILE * file
)
12572 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12573 display_arm_attribute
, NULL
);
12577 process_power_specific (FILE * file
)
12579 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12580 display_power_gnu_attribute
);
12584 process_sparc_specific (FILE * file
)
12586 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12587 display_sparc_gnu_attribute
);
12591 process_tic6x_specific (FILE * file
)
12593 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12594 display_tic6x_attribute
, NULL
);
12598 process_msp430x_specific (FILE * file
)
12600 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12601 display_msp430x_attribute
, NULL
);
12604 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12605 Print the Address, Access and Initial fields of an entry at VMA ADDR
12606 and return the VMA of the next entry. */
12609 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12612 print_vma (addr
, LONG_HEX
);
12614 if (addr
< pltgot
+ 0xfff0)
12615 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12617 printf ("%10s", "");
12620 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12625 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12626 print_vma (entry
, LONG_HEX
);
12628 return addr
+ (is_32bit_elf
? 4 : 8);
12631 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12632 PLTGOT. Print the Address and Initial fields of an entry at VMA
12633 ADDR and return the VMA of the next entry. */
12636 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12639 print_vma (addr
, LONG_HEX
);
12642 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12647 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12648 print_vma (entry
, LONG_HEX
);
12650 return addr
+ (is_32bit_elf
? 4 : 8);
12654 print_mips_ases (unsigned int mask
)
12656 if (mask
& AFL_ASE_DSP
)
12657 fputs ("\n\tDSP ASE", stdout
);
12658 if (mask
& AFL_ASE_DSPR2
)
12659 fputs ("\n\tDSP R2 ASE", stdout
);
12660 if (mask
& AFL_ASE_EVA
)
12661 fputs ("\n\tEnhanced VA Scheme", stdout
);
12662 if (mask
& AFL_ASE_MCU
)
12663 fputs ("\n\tMCU (MicroController) ASE", stdout
);
12664 if (mask
& AFL_ASE_MDMX
)
12665 fputs ("\n\tMDMX ASE", stdout
);
12666 if (mask
& AFL_ASE_MIPS3D
)
12667 fputs ("\n\tMIPS-3D ASE", stdout
);
12668 if (mask
& AFL_ASE_MT
)
12669 fputs ("\n\tMT ASE", stdout
);
12670 if (mask
& AFL_ASE_SMARTMIPS
)
12671 fputs ("\n\tSmartMIPS ASE", stdout
);
12672 if (mask
& AFL_ASE_VIRT
)
12673 fputs ("\n\tVZ ASE", stdout
);
12674 if (mask
& AFL_ASE_MSA
)
12675 fputs ("\n\tMSA ASE", stdout
);
12676 if (mask
& AFL_ASE_MIPS16
)
12677 fputs ("\n\tMIPS16 ASE", stdout
);
12678 if (mask
& AFL_ASE_MICROMIPS
)
12679 fputs ("\n\tMICROMIPS ASE", stdout
);
12680 if (mask
& AFL_ASE_XPA
)
12681 fputs ("\n\tXPA ASE", stdout
);
12683 fprintf (stdout
, "\n\t%s", _("None"));
12687 print_mips_isa_ext (unsigned int isa_ext
)
12692 fputs (_("None"), stdout
);
12695 fputs ("RMI XLR", stdout
);
12697 case AFL_EXT_OCTEON2
:
12698 fputs ("Cavium Networks Octeon2", stdout
);
12700 case AFL_EXT_OCTEONP
:
12701 fputs ("Cavium Networks OcteonP", stdout
);
12703 case AFL_EXT_LOONGSON_3A
:
12704 fputs ("Loongson 3A", stdout
);
12706 case AFL_EXT_OCTEON
:
12707 fputs ("Cavium Networks Octeon", stdout
);
12710 fputs ("Toshiba R5900", stdout
);
12713 fputs ("MIPS R4650", stdout
);
12716 fputs ("LSI R4010", stdout
);
12719 fputs ("NEC VR4100", stdout
);
12722 fputs ("Toshiba R3900", stdout
);
12724 case AFL_EXT_10000
:
12725 fputs ("MIPS R10000", stdout
);
12728 fputs ("Broadcom SB-1", stdout
);
12731 fputs ("NEC VR4111/VR4181", stdout
);
12734 fputs ("NEC VR4120", stdout
);
12737 fputs ("NEC VR5400", stdout
);
12740 fputs ("NEC VR5500", stdout
);
12742 case AFL_EXT_LOONGSON_2E
:
12743 fputs ("ST Microelectronics Loongson 2E", stdout
);
12745 case AFL_EXT_LOONGSON_2F
:
12746 fputs ("ST Microelectronics Loongson 2F", stdout
);
12749 fputs (_("Unknown"), stdout
);
12754 get_mips_reg_size (int reg_size
)
12756 return (reg_size
== AFL_REG_NONE
) ? 0
12757 : (reg_size
== AFL_REG_32
) ? 32
12758 : (reg_size
== AFL_REG_64
) ? 64
12759 : (reg_size
== AFL_REG_128
) ? 128
12764 process_mips_specific (FILE * file
)
12766 Elf_Internal_Dyn
* entry
;
12767 Elf_Internal_Shdr
*sect
= NULL
;
12768 size_t liblist_offset
= 0;
12769 size_t liblistno
= 0;
12770 size_t conflictsno
= 0;
12771 size_t options_offset
= 0;
12772 size_t conflicts_offset
= 0;
12773 size_t pltrelsz
= 0;
12775 bfd_vma pltgot
= 0;
12776 bfd_vma mips_pltgot
= 0;
12777 bfd_vma jmprel
= 0;
12778 bfd_vma local_gotno
= 0;
12779 bfd_vma gotsym
= 0;
12780 bfd_vma symtabno
= 0;
12782 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12783 display_mips_gnu_attribute
);
12785 sect
= find_section (".MIPS.abiflags");
12789 Elf_External_ABIFlags_v0
*abiflags_ext
;
12790 Elf_Internal_ABIFlags_v0 abiflags_in
;
12792 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
12793 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
12796 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
12797 sect
->sh_size
, _("MIPS ABI Flags section"));
12800 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
12801 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
12802 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
12803 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
12804 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
12805 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
12806 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
12807 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
12808 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
12809 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
12810 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
12812 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
12813 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
12814 if (abiflags_in
.isa_rev
> 1)
12815 printf ("r%d", abiflags_in
.isa_rev
);
12816 printf ("\nGPR size: %d",
12817 get_mips_reg_size (abiflags_in
.gpr_size
));
12818 printf ("\nCPR1 size: %d",
12819 get_mips_reg_size (abiflags_in
.cpr1_size
));
12820 printf ("\nCPR2 size: %d",
12821 get_mips_reg_size (abiflags_in
.cpr2_size
));
12822 fputs ("\nFP ABI: ", stdout
);
12823 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
12824 fputs ("ISA Extension: ", stdout
);
12825 print_mips_isa_ext (abiflags_in
.isa_ext
);
12826 fputs ("\nASEs:", stdout
);
12827 print_mips_ases (abiflags_in
.ases
);
12828 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
12829 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
12830 fputc ('\n', stdout
);
12831 free (abiflags_ext
);
12836 /* We have a lot of special sections. Thanks SGI! */
12837 if (dynamic_section
== NULL
)
12838 /* No information available. */
12841 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12842 switch (entry
->d_tag
)
12844 case DT_MIPS_LIBLIST
:
12846 = offset_from_vma (file
, entry
->d_un
.d_val
,
12847 liblistno
* sizeof (Elf32_External_Lib
));
12849 case DT_MIPS_LIBLISTNO
:
12850 liblistno
= entry
->d_un
.d_val
;
12852 case DT_MIPS_OPTIONS
:
12853 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12855 case DT_MIPS_CONFLICT
:
12857 = offset_from_vma (file
, entry
->d_un
.d_val
,
12858 conflictsno
* sizeof (Elf32_External_Conflict
));
12860 case DT_MIPS_CONFLICTNO
:
12861 conflictsno
= entry
->d_un
.d_val
;
12864 pltgot
= entry
->d_un
.d_ptr
;
12866 case DT_MIPS_LOCAL_GOTNO
:
12867 local_gotno
= entry
->d_un
.d_val
;
12869 case DT_MIPS_GOTSYM
:
12870 gotsym
= entry
->d_un
.d_val
;
12872 case DT_MIPS_SYMTABNO
:
12873 symtabno
= entry
->d_un
.d_val
;
12875 case DT_MIPS_PLTGOT
:
12876 mips_pltgot
= entry
->d_un
.d_ptr
;
12879 pltrel
= entry
->d_un
.d_val
;
12882 pltrelsz
= entry
->d_un
.d_val
;
12885 jmprel
= entry
->d_un
.d_ptr
;
12891 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12893 Elf32_External_Lib
* elib
;
12896 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12898 sizeof (Elf32_External_Lib
),
12899 _("liblist section data"));
12902 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12903 (unsigned long) liblistno
);
12904 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12907 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12914 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12915 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12916 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12917 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12918 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12920 tmp
= gmtime (&atime
);
12921 snprintf (timebuf
, sizeof (timebuf
),
12922 "%04u-%02u-%02uT%02u:%02u:%02u",
12923 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12924 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12926 printf ("%3lu: ", (unsigned long) cnt
);
12927 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12928 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12930 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12931 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12932 liblist
.l_version
);
12934 if (liblist
.l_flags
== 0)
12938 static const struct
12945 { " EXACT_MATCH", LL_EXACT_MATCH
},
12946 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12947 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12948 { " EXPORTS", LL_EXPORTS
},
12949 { " DELAY_LOAD", LL_DELAY_LOAD
},
12950 { " DELTA", LL_DELTA
}
12952 int flags
= liblist
.l_flags
;
12955 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12956 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12958 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12959 flags
^= l_flags_vals
[fcnt
].bit
;
12962 printf (" %#x", (unsigned int) flags
);
12972 if (options_offset
!= 0)
12974 Elf_External_Options
* eopt
;
12975 Elf_Internal_Options
* iopt
;
12976 Elf_Internal_Options
* option
;
12979 sect
= section_headers
;
12981 /* Find the section header so that we get the size. */
12982 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12985 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12986 sect
->sh_size
, _("options"));
12989 iopt
= (Elf_Internal_Options
*)
12990 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12993 error (_("Out of memory\n"));
13000 while (offset
< sect
->sh_size
)
13002 Elf_External_Options
* eoption
;
13004 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13006 option
->kind
= BYTE_GET (eoption
->kind
);
13007 option
->size
= BYTE_GET (eoption
->size
);
13008 option
->section
= BYTE_GET (eoption
->section
);
13009 option
->info
= BYTE_GET (eoption
->info
);
13011 offset
+= option
->size
;
13017 printf (_("\nSection '%s' contains %d entries:\n"),
13018 SECTION_NAME (sect
), cnt
);
13026 switch (option
->kind
)
13029 /* This shouldn't happen. */
13030 printf (" NULL %d %lx", option
->section
, option
->info
);
13033 printf (" REGINFO ");
13034 if (elf_header
.e_machine
== EM_MIPS
)
13037 Elf32_External_RegInfo
* ereg
;
13038 Elf32_RegInfo reginfo
;
13040 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13041 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13042 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13043 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13044 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13045 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13046 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13048 printf ("GPR %08lx GP 0x%lx\n",
13049 reginfo
.ri_gprmask
,
13050 (unsigned long) reginfo
.ri_gp_value
);
13051 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13052 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13053 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13058 Elf64_External_RegInfo
* ereg
;
13059 Elf64_Internal_RegInfo reginfo
;
13061 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13062 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13063 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13064 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13065 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13066 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13067 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13069 printf ("GPR %08lx GP 0x",
13070 reginfo
.ri_gprmask
);
13071 printf_vma (reginfo
.ri_gp_value
);
13074 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13075 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13076 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13080 case ODK_EXCEPTIONS
:
13081 fputs (" EXCEPTIONS fpe_min(", stdout
);
13082 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13083 fputs (") fpe_max(", stdout
);
13084 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13085 fputs (")", stdout
);
13087 if (option
->info
& OEX_PAGE0
)
13088 fputs (" PAGE0", stdout
);
13089 if (option
->info
& OEX_SMM
)
13090 fputs (" SMM", stdout
);
13091 if (option
->info
& OEX_FPDBUG
)
13092 fputs (" FPDBUG", stdout
);
13093 if (option
->info
& OEX_DISMISS
)
13094 fputs (" DISMISS", stdout
);
13097 fputs (" PAD ", stdout
);
13098 if (option
->info
& OPAD_PREFIX
)
13099 fputs (" PREFIX", stdout
);
13100 if (option
->info
& OPAD_POSTFIX
)
13101 fputs (" POSTFIX", stdout
);
13102 if (option
->info
& OPAD_SYMBOL
)
13103 fputs (" SYMBOL", stdout
);
13106 fputs (" HWPATCH ", stdout
);
13107 if (option
->info
& OHW_R4KEOP
)
13108 fputs (" R4KEOP", stdout
);
13109 if (option
->info
& OHW_R8KPFETCH
)
13110 fputs (" R8KPFETCH", stdout
);
13111 if (option
->info
& OHW_R5KEOP
)
13112 fputs (" R5KEOP", stdout
);
13113 if (option
->info
& OHW_R5KCVTL
)
13114 fputs (" R5KCVTL", stdout
);
13117 fputs (" FILL ", stdout
);
13118 /* XXX Print content of info word? */
13121 fputs (" TAGS ", stdout
);
13122 /* XXX Print content of info word? */
13125 fputs (" HWAND ", stdout
);
13126 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13127 fputs (" R4KEOP_CHECKED", stdout
);
13128 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13129 fputs (" R4KEOP_CLEAN", stdout
);
13132 fputs (" HWOR ", stdout
);
13133 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13134 fputs (" R4KEOP_CHECKED", stdout
);
13135 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13136 fputs (" R4KEOP_CLEAN", stdout
);
13139 printf (" GP_GROUP %#06lx self-contained %#06lx",
13140 option
->info
& OGP_GROUP
,
13141 (option
->info
& OGP_SELF
) >> 16);
13144 printf (" IDENT %#06lx self-contained %#06lx",
13145 option
->info
& OGP_GROUP
,
13146 (option
->info
& OGP_SELF
) >> 16);
13149 /* This shouldn't happen. */
13150 printf (" %3d ??? %d %lx",
13151 option
->kind
, option
->section
, option
->info
);
13155 len
= sizeof (* eopt
);
13156 while (len
< option
->size
)
13157 if (((char *) option
)[len
] >= ' '
13158 && ((char *) option
)[len
] < 0x7f)
13159 printf ("%c", ((char *) option
)[len
++]);
13161 printf ("\\%03o", ((char *) option
)[len
++]);
13163 fputs ("\n", stdout
);
13171 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13173 Elf32_Conflict
* iconf
;
13176 if (dynamic_symbols
== NULL
)
13178 error (_("conflict list found without a dynamic symbol table\n"));
13182 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13185 error (_("Out of memory\n"));
13191 Elf32_External_Conflict
* econf32
;
13193 econf32
= (Elf32_External_Conflict
*)
13194 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13195 sizeof (* econf32
), _("conflict"));
13199 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13200 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13206 Elf64_External_Conflict
* econf64
;
13208 econf64
= (Elf64_External_Conflict
*)
13209 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13210 sizeof (* econf64
), _("conflict"));
13214 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13215 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13220 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13221 (unsigned long) conflictsno
);
13222 puts (_(" Num: Index Value Name"));
13224 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13226 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13228 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13229 print_vma (psym
->st_value
, FULL_HEX
);
13231 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13232 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13234 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13241 if (pltgot
!= 0 && local_gotno
!= 0)
13243 bfd_vma ent
, local_end
, global_end
;
13245 unsigned char * data
;
13249 addr_size
= (is_32bit_elf
? 4 : 8);
13250 local_end
= pltgot
+ local_gotno
* addr_size
;
13251 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13253 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13254 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13255 global_end
- pltgot
, 1,
13256 _("Global Offset Table data"));
13260 printf (_("\nPrimary GOT:\n"));
13261 printf (_(" Canonical gp value: "));
13262 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13265 printf (_(" Reserved entries:\n"));
13266 printf (_(" %*s %10s %*s Purpose\n"),
13267 addr_size
* 2, _("Address"), _("Access"),
13268 addr_size
* 2, _("Initial"));
13269 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13270 printf (_(" Lazy resolver\n"));
13272 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13273 >> (addr_size
* 8 - 1)) != 0)
13275 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13276 printf (_(" Module pointer (GNU extension)\n"));
13280 if (ent
< local_end
)
13282 printf (_(" Local entries:\n"));
13283 printf (" %*s %10s %*s\n",
13284 addr_size
* 2, _("Address"), _("Access"),
13285 addr_size
* 2, _("Initial"));
13286 while (ent
< local_end
)
13288 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13294 if (gotsym
< symtabno
)
13298 printf (_(" Global entries:\n"));
13299 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13300 addr_size
* 2, _("Address"),
13302 addr_size
* 2, _("Initial"),
13303 addr_size
* 2, _("Sym.Val."),
13305 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13306 _("Ndx"), _("Name"));
13308 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13309 for (i
= gotsym
; i
< symtabno
; i
++)
13311 Elf_Internal_Sym
* psym
;
13313 psym
= dynamic_symbols
+ i
;
13314 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13316 print_vma (psym
->st_value
, LONG_HEX
);
13317 printf (" %-7s %3s ",
13318 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13319 get_symbol_index_type (psym
->st_shndx
));
13320 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13321 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13323 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13333 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13336 size_t offset
, rel_offset
;
13337 unsigned long count
, i
;
13338 unsigned char * data
;
13339 int addr_size
, sym_width
;
13340 Elf_Internal_Rela
* rels
;
13342 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13343 if (pltrel
== DT_RELA
)
13345 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13350 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13355 addr_size
= (is_32bit_elf
? 4 : 8);
13356 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13358 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13359 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13360 1, _("Procedure Linkage Table data"));
13364 printf ("\nPLT GOT:\n\n");
13365 printf (_(" Reserved entries:\n"));
13366 printf (_(" %*s %*s Purpose\n"),
13367 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13368 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13369 printf (_(" PLT lazy resolver\n"));
13370 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13371 printf (_(" Module pointer\n"));
13374 printf (_(" Entries:\n"));
13375 printf (" %*s %*s %*s %-7s %3s %s\n",
13376 addr_size
* 2, _("Address"),
13377 addr_size
* 2, _("Initial"),
13378 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13379 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13380 for (i
= 0; i
< count
; i
++)
13382 Elf_Internal_Sym
* psym
;
13384 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13385 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13387 print_vma (psym
->st_value
, LONG_HEX
);
13388 printf (" %-7s %3s ",
13389 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13390 get_symbol_index_type (psym
->st_shndx
));
13391 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13392 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13394 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13408 process_nds32_specific (FILE * file
)
13410 Elf_Internal_Shdr
*sect
= NULL
;
13412 sect
= find_section (".nds32_e_flags");
13415 unsigned int *flag
;
13417 printf ("\nNDS32 elf flags section:\n");
13418 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13419 sect
->sh_size
, _("NDS32 elf flags section"));
13421 switch ((*flag
) & 0x3)
13424 printf ("(VEC_SIZE):\tNo entry.\n");
13427 printf ("(VEC_SIZE):\t4 bytes\n");
13430 printf ("(VEC_SIZE):\t16 bytes\n");
13433 printf ("(VEC_SIZE):\treserved\n");
13442 process_gnu_liblist (FILE * file
)
13444 Elf_Internal_Shdr
* section
;
13445 Elf_Internal_Shdr
* string_sec
;
13446 Elf32_External_Lib
* elib
;
13448 size_t strtab_size
;
13455 for (i
= 0, section
= section_headers
;
13456 i
< elf_header
.e_shnum
;
13459 switch (section
->sh_type
)
13461 case SHT_GNU_LIBLIST
:
13462 if (section
->sh_link
>= elf_header
.e_shnum
)
13465 elib
= (Elf32_External_Lib
*)
13466 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13467 _("liblist section data"));
13471 string_sec
= section_headers
+ section
->sh_link
;
13473 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13474 string_sec
->sh_size
,
13475 _("liblist string table"));
13477 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13483 strtab_size
= string_sec
->sh_size
;
13485 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13486 SECTION_NAME (section
),
13487 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13489 puts (_(" Library Time Stamp Checksum Version Flags"));
13491 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13499 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13500 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13501 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13502 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13503 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13505 tmp
= gmtime (&atime
);
13506 snprintf (timebuf
, sizeof (timebuf
),
13507 "%04u-%02u-%02uT%02u:%02u:%02u",
13508 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13509 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13511 printf ("%3lu: ", (unsigned long) cnt
);
13513 printf ("%-20s", liblist
.l_name
< strtab_size
13514 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13516 printf ("%-20.20s", liblist
.l_name
< strtab_size
13517 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13518 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13519 liblist
.l_version
, liblist
.l_flags
);
13530 static const char *
13531 get_note_type (unsigned e_type
)
13533 static char buff
[64];
13535 if (elf_header
.e_type
== ET_CORE
)
13539 return _("NT_AUXV (auxiliary vector)");
13541 return _("NT_PRSTATUS (prstatus structure)");
13543 return _("NT_FPREGSET (floating point registers)");
13545 return _("NT_PRPSINFO (prpsinfo structure)");
13546 case NT_TASKSTRUCT
:
13547 return _("NT_TASKSTRUCT (task structure)");
13549 return _("NT_PRXFPREG (user_xfpregs structure)");
13551 return _("NT_PPC_VMX (ppc Altivec registers)");
13553 return _("NT_PPC_VSX (ppc VSX registers)");
13555 return _("NT_386_TLS (x86 TLS information)");
13556 case NT_386_IOPERM
:
13557 return _("NT_386_IOPERM (x86 I/O permissions)");
13558 case NT_X86_XSTATE
:
13559 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13560 case NT_S390_HIGH_GPRS
:
13561 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13562 case NT_S390_TIMER
:
13563 return _("NT_S390_TIMER (s390 timer register)");
13564 case NT_S390_TODCMP
:
13565 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13566 case NT_S390_TODPREG
:
13567 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13569 return _("NT_S390_CTRS (s390 control registers)");
13570 case NT_S390_PREFIX
:
13571 return _("NT_S390_PREFIX (s390 prefix register)");
13572 case NT_S390_LAST_BREAK
:
13573 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13574 case NT_S390_SYSTEM_CALL
:
13575 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13577 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13579 return _("NT_ARM_VFP (arm VFP registers)");
13581 return _("NT_ARM_TLS (AArch TLS registers)");
13582 case NT_ARM_HW_BREAK
:
13583 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13584 case NT_ARM_HW_WATCH
:
13585 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13587 return _("NT_PSTATUS (pstatus structure)");
13589 return _("NT_FPREGS (floating point registers)");
13591 return _("NT_PSINFO (psinfo structure)");
13593 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13595 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13596 case NT_WIN32PSTATUS
:
13597 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13599 return _("NT_SIGINFO (siginfo_t data)");
13601 return _("NT_FILE (mapped files)");
13609 return _("NT_VERSION (version)");
13611 return _("NT_ARCH (architecture)");
13616 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13621 print_core_note (Elf_Internal_Note
*pnote
)
13623 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13624 bfd_vma count
, page_size
;
13625 unsigned char *descdata
, *filenames
, *descend
;
13627 if (pnote
->type
!= NT_FILE
)
13633 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13634 /* Still "successful". */
13639 if (pnote
->descsz
< 2 * addr_size
)
13641 printf (_(" Malformed note - too short for header\n"));
13645 descdata
= (unsigned char *) pnote
->descdata
;
13646 descend
= descdata
+ pnote
->descsz
;
13648 if (descdata
[pnote
->descsz
- 1] != '\0')
13650 printf (_(" Malformed note - does not end with \\0\n"));
13654 count
= byte_get (descdata
, addr_size
);
13655 descdata
+= addr_size
;
13657 page_size
= byte_get (descdata
, addr_size
);
13658 descdata
+= addr_size
;
13660 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13662 printf (_(" Malformed note - too short for supplied file count\n"));
13666 printf (_(" Page size: "));
13667 print_vma (page_size
, DEC
);
13670 printf (_(" %*s%*s%*s\n"),
13671 (int) (2 + 2 * addr_size
), _("Start"),
13672 (int) (4 + 2 * addr_size
), _("End"),
13673 (int) (4 + 2 * addr_size
), _("Page Offset"));
13674 filenames
= descdata
+ count
* 3 * addr_size
;
13675 while (--count
> 0)
13677 bfd_vma start
, end
, file_ofs
;
13679 if (filenames
== descend
)
13681 printf (_(" Malformed note - filenames end too early\n"));
13685 start
= byte_get (descdata
, addr_size
);
13686 descdata
+= addr_size
;
13687 end
= byte_get (descdata
, addr_size
);
13688 descdata
+= addr_size
;
13689 file_ofs
= byte_get (descdata
, addr_size
);
13690 descdata
+= addr_size
;
13693 print_vma (start
, FULL_HEX
);
13695 print_vma (end
, FULL_HEX
);
13697 print_vma (file_ofs
, FULL_HEX
);
13698 printf ("\n %s\n", filenames
);
13700 filenames
+= 1 + strlen ((char *) filenames
);
13706 static const char *
13707 get_gnu_elf_note_type (unsigned e_type
)
13709 static char buff
[64];
13713 case NT_GNU_ABI_TAG
:
13714 return _("NT_GNU_ABI_TAG (ABI version tag)");
13716 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13717 case NT_GNU_BUILD_ID
:
13718 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13719 case NT_GNU_GOLD_VERSION
:
13720 return _("NT_GNU_GOLD_VERSION (gold version)");
13725 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13730 print_gnu_note (Elf_Internal_Note
*pnote
)
13732 switch (pnote
->type
)
13734 case NT_GNU_BUILD_ID
:
13738 printf (_(" Build ID: "));
13739 for (i
= 0; i
< pnote
->descsz
; ++i
)
13740 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13745 case NT_GNU_ABI_TAG
:
13747 unsigned long os
, major
, minor
, subminor
;
13748 const char *osname
;
13750 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13751 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13752 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13753 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13757 case GNU_ABI_TAG_LINUX
:
13760 case GNU_ABI_TAG_HURD
:
13763 case GNU_ABI_TAG_SOLARIS
:
13764 osname
= "Solaris";
13766 case GNU_ABI_TAG_FREEBSD
:
13767 osname
= "FreeBSD";
13769 case GNU_ABI_TAG_NETBSD
:
13773 osname
= "Unknown";
13777 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13778 major
, minor
, subminor
);
13782 case NT_GNU_GOLD_VERSION
:
13786 printf (_(" Version: "));
13787 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13788 printf ("%c", pnote
->descdata
[i
]);
13797 static const char *
13798 get_netbsd_elfcore_note_type (unsigned e_type
)
13800 static char buff
[64];
13802 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13804 /* NetBSD core "procinfo" structure. */
13805 return _("NetBSD procinfo structure");
13808 /* As of Jan 2002 there are no other machine-independent notes
13809 defined for NetBSD core files. If the note type is less
13810 than the start of the machine-dependent note types, we don't
13813 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13815 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13819 switch (elf_header
.e_machine
)
13821 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13822 and PT_GETFPREGS == mach+2. */
13827 case EM_SPARC32PLUS
:
13831 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13832 return _("PT_GETREGS (reg structure)");
13833 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13834 return _("PT_GETFPREGS (fpreg structure)");
13840 /* On all other arch's, PT_GETREGS == mach+1 and
13841 PT_GETFPREGS == mach+3. */
13845 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13846 return _("PT_GETREGS (reg structure)");
13847 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13848 return _("PT_GETFPREGS (fpreg structure)");
13854 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13855 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13859 static const char *
13860 get_stapsdt_note_type (unsigned e_type
)
13862 static char buff
[64];
13867 return _("NT_STAPSDT (SystemTap probe descriptors)");
13873 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13878 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13880 int addr_size
= is_32bit_elf
? 4 : 8;
13881 char *data
= pnote
->descdata
;
13882 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13883 bfd_vma pc
, base_addr
, semaphore
;
13884 char *provider
, *probe
, *arg_fmt
;
13886 pc
= byte_get ((unsigned char *) data
, addr_size
);
13888 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13890 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13894 data
+= strlen (data
) + 1;
13896 data
+= strlen (data
) + 1;
13898 data
+= strlen (data
) + 1;
13900 printf (_(" Provider: %s\n"), provider
);
13901 printf (_(" Name: %s\n"), probe
);
13902 printf (_(" Location: "));
13903 print_vma (pc
, FULL_HEX
);
13904 printf (_(", Base: "));
13905 print_vma (base_addr
, FULL_HEX
);
13906 printf (_(", Semaphore: "));
13907 print_vma (semaphore
, FULL_HEX
);
13909 printf (_(" Arguments: %s\n"), arg_fmt
);
13911 return data
== data_end
;
13914 static const char *
13915 get_ia64_vms_note_type (unsigned e_type
)
13917 static char buff
[64];
13922 return _("NT_VMS_MHD (module header)");
13924 return _("NT_VMS_LNM (language name)");
13926 return _("NT_VMS_SRC (source files)");
13928 return "NT_VMS_TITLE";
13930 return _("NT_VMS_EIDC (consistency check)");
13931 case NT_VMS_FPMODE
:
13932 return _("NT_VMS_FPMODE (FP mode)");
13933 case NT_VMS_LINKTIME
:
13934 return "NT_VMS_LINKTIME";
13935 case NT_VMS_IMGNAM
:
13936 return _("NT_VMS_IMGNAM (image name)");
13938 return _("NT_VMS_IMGID (image id)");
13939 case NT_VMS_LINKID
:
13940 return _("NT_VMS_LINKID (link id)");
13941 case NT_VMS_IMGBID
:
13942 return _("NT_VMS_IMGBID (build id)");
13943 case NT_VMS_GSTNAM
:
13944 return _("NT_VMS_GSTNAM (sym table name)");
13945 case NT_VMS_ORIG_DYN
:
13946 return "NT_VMS_ORIG_DYN";
13947 case NT_VMS_PATCHTIME
:
13948 return "NT_VMS_PATCHTIME";
13950 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13956 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13958 switch (pnote
->type
)
13961 if (pnote
->descsz
> 36)
13963 size_t l
= strlen (pnote
->descdata
+ 34);
13964 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13965 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13966 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13967 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13970 printf (_(" Invalid size\n"));
13973 printf (_(" Language: %s\n"), pnote
->descdata
);
13976 case NT_VMS_FPMODE
:
13977 printf (_(" Floating Point mode: "));
13978 printf ("0x%016" BFD_VMA_FMT
"x\n",
13979 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13981 case NT_VMS_LINKTIME
:
13982 printf (_(" Link time: "));
13984 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13987 case NT_VMS_PATCHTIME
:
13988 printf (_(" Patch time: "));
13990 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13993 case NT_VMS_ORIG_DYN
:
13994 printf (_(" Major id: %u, minor id: %u\n"),
13995 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13996 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13997 printf (_(" Last modified : "));
13999 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14000 printf (_("\n Link flags : "));
14001 printf ("0x%016" BFD_VMA_FMT
"x\n",
14002 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14003 printf (_(" Header flags: 0x%08x\n"),
14004 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14005 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14008 case NT_VMS_IMGNAM
:
14009 printf (_(" Image name: %s\n"), pnote
->descdata
);
14011 case NT_VMS_GSTNAM
:
14012 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14015 printf (_(" Image id: %s\n"), pnote
->descdata
);
14017 case NT_VMS_LINKID
:
14018 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14026 /* Note that by the ELF standard, the name field is already null byte
14027 terminated, and namesz includes the terminating null byte.
14028 I.E. the value of namesz for the name "FSF" is 4.
14030 If the value of namesz is zero, there is no name present. */
14032 process_note (Elf_Internal_Note
* pnote
)
14034 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14037 if (pnote
->namesz
== 0)
14038 /* If there is no note name, then use the default set of
14039 note type strings. */
14040 nt
= get_note_type (pnote
->type
);
14042 else if (const_strneq (pnote
->namedata
, "GNU"))
14043 /* GNU-specific object file notes. */
14044 nt
= get_gnu_elf_note_type (pnote
->type
);
14046 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14047 /* NetBSD-specific core file notes. */
14048 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14050 else if (strneq (pnote
->namedata
, "SPU/", 4))
14052 /* SPU-specific core file notes. */
14053 nt
= pnote
->namedata
+ 4;
14057 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14058 /* VMS/ia64-specific file notes. */
14059 nt
= get_ia64_vms_note_type (pnote
->type
);
14061 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14062 nt
= get_stapsdt_note_type (pnote
->type
);
14065 /* Don't recognize this note name; just use the default set of
14066 note type strings. */
14067 nt
= get_note_type (pnote
->type
);
14069 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14071 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14072 return print_ia64_vms_note (pnote
);
14073 else if (const_strneq (pnote
->namedata
, "GNU"))
14074 return print_gnu_note (pnote
);
14075 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14076 return print_stapsdt_note (pnote
);
14077 else if (const_strneq (pnote
->namedata
, "CORE"))
14078 return print_core_note (pnote
);
14085 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14087 Elf_External_Note
* pnotes
;
14088 Elf_External_Note
* external
;
14094 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14096 if (pnotes
== NULL
)
14101 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14102 (unsigned long) offset
, (unsigned long) length
);
14103 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14105 while ((char *) external
< (char *) pnotes
+ length
)
14107 Elf_Internal_Note inote
;
14110 char * temp
= NULL
;
14111 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14113 if (!is_ia64_vms ())
14115 /* PR binutils/15191
14116 Make sure that there is enough data to read. */
14117 min_notesz
= offsetof (Elf_External_Note
, name
);
14118 if (data_remaining
< min_notesz
)
14120 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14121 (int) data_remaining
);
14124 inote
.type
= BYTE_GET (external
->type
);
14125 inote
.namesz
= BYTE_GET (external
->namesz
);
14126 inote
.namedata
= external
->name
;
14127 inote
.descsz
= BYTE_GET (external
->descsz
);
14128 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14129 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14130 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14134 Elf64_External_VMS_Note
*vms_external
;
14136 /* PR binutils/15191
14137 Make sure that there is enough data to read. */
14138 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14139 if (data_remaining
< min_notesz
)
14141 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14142 (int) data_remaining
);
14146 vms_external
= (Elf64_External_VMS_Note
*) external
;
14147 inote
.type
= BYTE_GET (vms_external
->type
);
14148 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14149 inote
.namedata
= vms_external
->name
;
14150 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14151 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14152 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14153 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14156 if (inote
.descdata
< (char *) external
+ min_notesz
14157 || next
< (char *) external
+ min_notesz
14158 || data_remaining
< (size_t)(next
- (char *) external
))
14160 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14161 (unsigned long) ((char *) external
- (char *) pnotes
));
14162 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14163 inote
.type
, inote
.namesz
, inote
.descsz
);
14167 external
= (Elf_External_Note
*) next
;
14169 /* Verify that name is null terminated. It appears that at least
14170 one version of Linux (RedHat 6.0) generates corefiles that don't
14171 comply with the ELF spec by failing to include the null byte in
14173 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14175 temp
= (char *) malloc (inote
.namesz
+ 1);
14179 error (_("Out of memory\n"));
14184 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14185 temp
[inote
.namesz
] = 0;
14187 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14188 inote
.namedata
= temp
;
14191 res
&= process_note (& inote
);
14206 process_corefile_note_segments (FILE * file
)
14208 Elf_Internal_Phdr
* segment
;
14212 if (! get_program_headers (file
))
14215 for (i
= 0, segment
= program_headers
;
14216 i
< elf_header
.e_phnum
;
14219 if (segment
->p_type
== PT_NOTE
)
14220 res
&= process_corefile_note_segment (file
,
14221 (bfd_vma
) segment
->p_offset
,
14222 (bfd_vma
) segment
->p_filesz
);
14229 process_note_sections (FILE * file
)
14231 Elf_Internal_Shdr
* section
;
14236 for (i
= 0, section
= section_headers
;
14237 i
< elf_header
.e_shnum
&& section
!= NULL
;
14239 if (section
->sh_type
== SHT_NOTE
)
14241 res
&= process_corefile_note_segment (file
,
14242 (bfd_vma
) section
->sh_offset
,
14243 (bfd_vma
) section
->sh_size
);
14248 /* Try processing NOTE segments instead. */
14249 return process_corefile_note_segments (file
);
14255 process_notes (FILE * file
)
14257 /* If we have not been asked to display the notes then do nothing. */
14261 if (elf_header
.e_type
!= ET_CORE
)
14262 return process_note_sections (file
);
14264 /* No program headers means no NOTE segment. */
14265 if (elf_header
.e_phnum
> 0)
14266 return process_corefile_note_segments (file
);
14268 printf (_("No note segments present in the core file.\n"));
14273 process_arch_specific (FILE * file
)
14278 switch (elf_header
.e_machine
)
14281 return process_arm_specific (file
);
14283 case EM_MIPS_RS3_LE
:
14284 return process_mips_specific (file
);
14287 return process_nds32_specific (file
);
14290 return process_power_specific (file
);
14293 case EM_SPARC32PLUS
:
14295 return process_sparc_specific (file
);
14298 return process_tic6x_specific (file
);
14301 return process_msp430x_specific (file
);
14309 get_file_header (FILE * file
)
14311 /* Read in the identity array. */
14312 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14315 /* Determine how to read the rest of the header. */
14316 switch (elf_header
.e_ident
[EI_DATA
])
14318 default: /* fall through */
14319 case ELFDATANONE
: /* fall through */
14321 byte_get
= byte_get_little_endian
;
14322 byte_put
= byte_put_little_endian
;
14325 byte_get
= byte_get_big_endian
;
14326 byte_put
= byte_put_big_endian
;
14330 /* For now we only support 32 bit and 64 bit ELF files. */
14331 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14333 /* Read in the rest of the header. */
14336 Elf32_External_Ehdr ehdr32
;
14338 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14341 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14342 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14343 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14344 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14345 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14346 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14347 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14348 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14349 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14350 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14351 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14352 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14353 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14357 Elf64_External_Ehdr ehdr64
;
14359 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14360 we will not be able to cope with the 64bit data found in
14361 64 ELF files. Detect this now and abort before we start
14362 overwriting things. */
14363 if (sizeof (bfd_vma
) < 8)
14365 error (_("This instance of readelf has been built without support for a\n\
14366 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14370 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14373 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14374 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14375 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14376 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14377 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14378 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14379 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14380 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14381 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14382 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14383 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14384 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14385 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14388 if (elf_header
.e_shoff
)
14390 /* There may be some extensions in the first section header. Don't
14391 bomb if we can't read it. */
14393 get_32bit_section_headers (file
, 1);
14395 get_64bit_section_headers (file
, 1);
14401 /* Process one ELF object file according to the command line options.
14402 This file may actually be stored in an archive. The file is
14403 positioned at the start of the ELF object. */
14406 process_object (char * file_name
, FILE * file
)
14410 if (! get_file_header (file
))
14412 error (_("%s: Failed to read file header\n"), file_name
);
14416 /* Initialise per file variables. */
14417 for (i
= ARRAY_SIZE (version_info
); i
--;)
14418 version_info
[i
] = 0;
14420 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14421 dynamic_info
[i
] = 0;
14422 dynamic_info_DT_GNU_HASH
= 0;
14424 /* Process the file. */
14426 printf (_("\nFile: %s\n"), file_name
);
14428 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14429 Note we do this even if cmdline_dump_sects is empty because we
14430 must make sure that the dump_sets array is zeroed out before each
14431 object file is processed. */
14432 if (num_dump_sects
> num_cmdline_dump_sects
)
14433 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14435 if (num_cmdline_dump_sects
> 0)
14437 if (num_dump_sects
== 0)
14438 /* A sneaky way of allocating the dump_sects array. */
14439 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14441 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14442 memcpy (dump_sects
, cmdline_dump_sects
,
14443 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14446 if (! process_file_header ())
14449 if (! process_section_headers (file
))
14451 /* Without loaded section headers we cannot process lots of
14453 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14455 if (! do_using_dynamic
)
14456 do_syms
= do_dyn_syms
= do_reloc
= 0;
14459 if (! process_section_groups (file
))
14461 /* Without loaded section groups we cannot process unwind. */
14465 if (process_program_headers (file
))
14466 process_dynamic_section (file
);
14468 process_relocs (file
);
14470 process_unwind (file
);
14472 process_symbol_table (file
);
14474 process_syminfo (file
);
14476 process_version_sections (file
);
14478 process_section_contents (file
);
14480 process_notes (file
);
14482 process_gnu_liblist (file
);
14484 process_arch_specific (file
);
14486 if (program_headers
)
14488 free (program_headers
);
14489 program_headers
= NULL
;
14492 if (section_headers
)
14494 free (section_headers
);
14495 section_headers
= NULL
;
14500 free (string_table
);
14501 string_table
= NULL
;
14502 string_table_length
= 0;
14505 if (dynamic_strings
)
14507 free (dynamic_strings
);
14508 dynamic_strings
= NULL
;
14509 dynamic_strings_length
= 0;
14512 if (dynamic_symbols
)
14514 free (dynamic_symbols
);
14515 dynamic_symbols
= NULL
;
14516 num_dynamic_syms
= 0;
14519 if (dynamic_syminfo
)
14521 free (dynamic_syminfo
);
14522 dynamic_syminfo
= NULL
;
14525 if (dynamic_section
)
14527 free (dynamic_section
);
14528 dynamic_section
= NULL
;
14531 if (section_headers_groups
)
14533 free (section_headers_groups
);
14534 section_headers_groups
= NULL
;
14537 if (section_groups
)
14539 struct group_list
* g
;
14540 struct group_list
* next
;
14542 for (i
= 0; i
< group_count
; i
++)
14544 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14551 free (section_groups
);
14552 section_groups
= NULL
;
14555 free_debug_memory ();
14560 /* Process an ELF archive.
14561 On entry the file is positioned just after the ARMAG string. */
14564 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14566 struct archive_info arch
;
14567 struct archive_info nested_arch
;
14573 /* The ARCH structure is used to hold information about this archive. */
14574 arch
.file_name
= NULL
;
14576 arch
.index_array
= NULL
;
14577 arch
.sym_table
= NULL
;
14578 arch
.longnames
= NULL
;
14580 /* The NESTED_ARCH structure is used as a single-item cache of information
14581 about a nested archive (when members of a thin archive reside within
14582 another regular archive file). */
14583 nested_arch
.file_name
= NULL
;
14584 nested_arch
.file
= NULL
;
14585 nested_arch
.index_array
= NULL
;
14586 nested_arch
.sym_table
= NULL
;
14587 nested_arch
.longnames
= NULL
;
14589 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14595 if (do_archive_index
)
14597 if (arch
.sym_table
== NULL
)
14598 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14602 unsigned long current_pos
;
14604 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14605 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14606 current_pos
= ftell (file
);
14608 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14610 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14612 char * member_name
;
14614 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14616 if (member_name
!= NULL
)
14618 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14620 if (qualified_name
!= NULL
)
14622 printf (_("Contents of binary %s at offset "), qualified_name
);
14623 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14625 free (qualified_name
);
14630 if (l
>= arch
.sym_size
)
14632 error (_("%s: end of the symbol table reached before the end of the index\n"),
14636 printf ("\t%s\n", arch
.sym_table
+ l
);
14637 l
+= strlen (arch
.sym_table
+ l
) + 1;
14640 if (arch
.uses_64bit_indicies
)
14645 if (l
< arch
.sym_size
)
14646 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14647 file_name
, arch
.sym_size
- l
);
14649 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14651 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14657 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14658 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14659 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14660 && !do_section_groups
&& !do_dyn_syms
)
14662 ret
= 0; /* Archive index only. */
14673 char * qualified_name
;
14675 /* Read the next archive header. */
14676 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14678 error (_("%s: failed to seek to next archive header\n"), file_name
);
14681 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14682 if (got
!= sizeof arch
.arhdr
)
14686 error (_("%s: failed to read archive header\n"), file_name
);
14690 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14692 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14697 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14699 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14700 if (archive_file_size
& 01)
14701 ++archive_file_size
;
14703 name
= get_archive_member_name (&arch
, &nested_arch
);
14706 error (_("%s: bad archive file name\n"), file_name
);
14710 namelen
= strlen (name
);
14712 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14713 if (qualified_name
== NULL
)
14715 error (_("%s: bad archive file name\n"), file_name
);
14720 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14722 /* This is a proxy for an external member of a thin archive. */
14723 FILE * member_file
;
14724 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14725 if (member_file_name
== NULL
)
14731 member_file
= fopen (member_file_name
, "rb");
14732 if (member_file
== NULL
)
14734 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14735 free (member_file_name
);
14740 archive_file_offset
= arch
.nested_member_origin
;
14742 ret
|= process_object (qualified_name
, member_file
);
14744 fclose (member_file
);
14745 free (member_file_name
);
14747 else if (is_thin_archive
)
14749 /* PR 15140: Allow for corrupt thin archives. */
14750 if (nested_arch
.file
== NULL
)
14752 error (_("%s: contains corrupt thin archive: %s\n"),
14758 /* This is a proxy for a member of a nested archive. */
14759 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14761 /* The nested archive file will have been opened and setup by
14762 get_archive_member_name. */
14763 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14765 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14770 ret
|= process_object (qualified_name
, nested_arch
.file
);
14774 archive_file_offset
= arch
.next_arhdr_offset
;
14775 arch
.next_arhdr_offset
+= archive_file_size
;
14777 ret
|= process_object (qualified_name
, file
);
14780 if (dump_sects
!= NULL
)
14784 num_dump_sects
= 0;
14787 free (qualified_name
);
14791 if (nested_arch
.file
!= NULL
)
14792 fclose (nested_arch
.file
);
14793 release_archive (&nested_arch
);
14794 release_archive (&arch
);
14800 process_file (char * file_name
)
14803 struct stat statbuf
;
14804 char armag
[SARMAG
];
14807 if (stat (file_name
, &statbuf
) < 0)
14809 if (errno
== ENOENT
)
14810 error (_("'%s': No such file\n"), file_name
);
14812 error (_("Could not locate '%s'. System error message: %s\n"),
14813 file_name
, strerror (errno
));
14817 if (! S_ISREG (statbuf
.st_mode
))
14819 error (_("'%s' is not an ordinary file\n"), file_name
);
14823 file
= fopen (file_name
, "rb");
14826 error (_("Input file '%s' is not readable.\n"), file_name
);
14830 if (fread (armag
, SARMAG
, 1, file
) != 1)
14832 error (_("%s: Failed to read file's magic number\n"), file_name
);
14837 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14838 ret
= process_archive (file_name
, file
, FALSE
);
14839 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14840 ret
= process_archive (file_name
, file
, TRUE
);
14843 if (do_archive_index
)
14844 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14848 archive_file_size
= archive_file_offset
= 0;
14849 ret
= process_object (file_name
, file
);
14857 #ifdef SUPPORT_DISASSEMBLY
14858 /* Needed by the i386 disassembler. For extra credit, someone could
14859 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14863 print_address (unsigned int addr
, FILE * outfile
)
14865 fprintf (outfile
,"0x%8.8x", addr
);
14868 /* Needed by the i386 disassembler. */
14870 db_task_printsym (unsigned int addr
)
14872 print_address (addr
, stderr
);
14877 main (int argc
, char ** argv
)
14881 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14882 setlocale (LC_MESSAGES
, "");
14884 #if defined (HAVE_SETLOCALE)
14885 setlocale (LC_CTYPE
, "");
14887 bindtextdomain (PACKAGE
, LOCALEDIR
);
14888 textdomain (PACKAGE
);
14890 expandargv (&argc
, &argv
);
14892 parse_args (argc
, argv
);
14894 if (num_dump_sects
> 0)
14896 /* Make a copy of the dump_sects array. */
14897 cmdline_dump_sects
= (dump_type
*)
14898 malloc (num_dump_sects
* sizeof (* dump_sects
));
14899 if (cmdline_dump_sects
== NULL
)
14900 error (_("Out of memory allocating dump request table.\n"));
14903 memcpy (cmdline_dump_sects
, dump_sects
,
14904 num_dump_sects
* sizeof (* dump_sects
));
14905 num_cmdline_dump_sects
= num_dump_sects
;
14909 if (optind
< (argc
- 1))
14913 while (optind
< argc
)
14914 err
|= process_file (argv
[optind
++]);
14916 if (dump_sects
!= NULL
)
14918 if (cmdline_dump_sects
!= NULL
)
14919 free (cmdline_dump_sects
);