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/or32.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. */
589 /* Targets that use RELA relocations. */
593 case EM_ADAPTEVA_EPIPHANY
:
595 case EM_ALTERA_NIOS2
:
614 case EM_LATTICEMICO32
:
623 case EM_CYGNUS_MN10200
:
625 case EM_CYGNUS_MN10300
:
657 case EM_MICROBLAZE_OLD
:
678 warn (_("Don't know about relocations on this machine architecture\n"));
684 slurp_rela_relocs (FILE * file
,
685 unsigned long rel_offset
,
686 unsigned long rel_size
,
687 Elf_Internal_Rela
** relasp
,
688 unsigned long * nrelasp
)
690 Elf_Internal_Rela
* relas
;
691 unsigned long nrelas
;
696 Elf32_External_Rela
* erelas
;
698 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
699 rel_size
, _("32-bit relocation data"));
703 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
705 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
706 sizeof (Elf_Internal_Rela
));
711 error (_("out of memory parsing relocs\n"));
715 for (i
= 0; i
< nrelas
; i
++)
717 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
718 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
719 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
726 Elf64_External_Rela
* erelas
;
728 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
729 rel_size
, _("64-bit relocation data"));
733 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
735 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
736 sizeof (Elf_Internal_Rela
));
741 error (_("out of memory parsing relocs\n"));
745 for (i
= 0; i
< nrelas
; i
++)
747 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
748 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
749 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
751 /* The #ifdef BFD64 below is to prevent a compile time
752 warning. We know that if we do not have a 64 bit data
753 type that we will never execute this code anyway. */
755 if (elf_header
.e_machine
== EM_MIPS
756 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
758 /* In little-endian objects, r_info isn't really a
759 64-bit little-endian value: it has a 32-bit
760 little-endian symbol index followed by four
761 individual byte fields. Reorder INFO
763 bfd_vma inf
= relas
[i
].r_info
;
764 inf
= (((inf
& 0xffffffff) << 32)
765 | ((inf
>> 56) & 0xff)
766 | ((inf
>> 40) & 0xff00)
767 | ((inf
>> 24) & 0xff0000)
768 | ((inf
>> 8) & 0xff000000));
769 relas
[i
].r_info
= inf
;
782 slurp_rel_relocs (FILE * file
,
783 unsigned long rel_offset
,
784 unsigned long rel_size
,
785 Elf_Internal_Rela
** relsp
,
786 unsigned long * nrelsp
)
788 Elf_Internal_Rela
* rels
;
794 Elf32_External_Rel
* erels
;
796 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
797 rel_size
, _("32-bit relocation data"));
801 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
803 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
808 error (_("out of memory parsing relocs\n"));
812 for (i
= 0; i
< nrels
; i
++)
814 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
815 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
816 rels
[i
].r_addend
= 0;
823 Elf64_External_Rel
* erels
;
825 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
826 rel_size
, _("64-bit relocation data"));
830 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
832 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
837 error (_("out of memory parsing relocs\n"));
841 for (i
= 0; i
< nrels
; i
++)
843 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
844 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
845 rels
[i
].r_addend
= 0;
847 /* The #ifdef BFD64 below is to prevent a compile time
848 warning. We know that if we do not have a 64 bit data
849 type that we will never execute this code anyway. */
851 if (elf_header
.e_machine
== EM_MIPS
852 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
854 /* In little-endian objects, r_info isn't really a
855 64-bit little-endian value: it has a 32-bit
856 little-endian symbol index followed by four
857 individual byte fields. Reorder INFO
859 bfd_vma inf
= rels
[i
].r_info
;
860 inf
= (((inf
& 0xffffffff) << 32)
861 | ((inf
>> 56) & 0xff)
862 | ((inf
>> 40) & 0xff00)
863 | ((inf
>> 24) & 0xff0000)
864 | ((inf
>> 8) & 0xff000000));
865 rels
[i
].r_info
= inf
;
877 /* Returns the reloc type extracted from the reloc info field. */
880 get_reloc_type (bfd_vma reloc_info
)
883 return ELF32_R_TYPE (reloc_info
);
885 switch (elf_header
.e_machine
)
888 /* Note: We assume that reloc_info has already been adjusted for us. */
889 return ELF64_MIPS_R_TYPE (reloc_info
);
892 return ELF64_R_TYPE_ID (reloc_info
);
895 return ELF64_R_TYPE (reloc_info
);
899 /* Return the symbol index extracted from the reloc info field. */
902 get_reloc_symindex (bfd_vma reloc_info
)
904 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
907 static inline bfd_boolean
908 uses_msp430x_relocs (void)
911 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
912 /* GCC uses osabi == ELFOSBI_STANDALONE. */
913 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
914 /* TI compiler uses ELFOSABI_NONE. */
915 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
918 /* Display the contents of the relocation data found at the specified
922 dump_relocations (FILE * file
,
923 unsigned long rel_offset
,
924 unsigned long rel_size
,
925 Elf_Internal_Sym
* symtab
,
928 unsigned long strtablen
,
932 Elf_Internal_Rela
* rels
;
934 if (is_rela
== UNKNOWN
)
935 is_rela
= guess_is_rela (elf_header
.e_machine
);
939 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
944 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
953 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
955 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
960 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
962 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
970 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
972 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
977 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
979 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
983 for (i
= 0; i
< rel_size
; i
++)
988 bfd_vma symtab_index
;
991 offset
= rels
[i
].r_offset
;
992 inf
= rels
[i
].r_info
;
994 type
= get_reloc_type (inf
);
995 symtab_index
= get_reloc_symindex (inf
);
999 printf ("%8.8lx %8.8lx ",
1000 (unsigned long) offset
& 0xffffffff,
1001 (unsigned long) inf
& 0xffffffff);
1005 #if BFD_HOST_64BIT_LONG
1007 ? "%16.16lx %16.16lx "
1008 : "%12.12lx %12.12lx ",
1010 #elif BFD_HOST_64BIT_LONG_LONG
1013 ? "%16.16llx %16.16llx "
1014 : "%12.12llx %12.12llx ",
1018 ? "%16.16I64x %16.16I64x "
1019 : "%12.12I64x %12.12I64x ",
1024 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1025 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1026 _bfd_int64_high (offset
),
1027 _bfd_int64_low (offset
),
1028 _bfd_int64_high (inf
),
1029 _bfd_int64_low (inf
));
1033 switch (elf_header
.e_machine
)
1040 rtype
= elf_aarch64_reloc_type (type
);
1044 case EM_CYGNUS_M32R
:
1045 rtype
= elf_m32r_reloc_type (type
);
1050 rtype
= elf_i386_reloc_type (type
);
1055 rtype
= elf_m68hc11_reloc_type (type
);
1059 rtype
= elf_m68k_reloc_type (type
);
1063 rtype
= elf_i960_reloc_type (type
);
1068 rtype
= elf_avr_reloc_type (type
);
1071 case EM_OLD_SPARCV9
:
1072 case EM_SPARC32PLUS
:
1075 rtype
= elf_sparc_reloc_type (type
);
1079 rtype
= elf_spu_reloc_type (type
);
1083 rtype
= v800_reloc_type (type
);
1086 case EM_CYGNUS_V850
:
1087 rtype
= v850_reloc_type (type
);
1091 case EM_CYGNUS_D10V
:
1092 rtype
= elf_d10v_reloc_type (type
);
1096 case EM_CYGNUS_D30V
:
1097 rtype
= elf_d30v_reloc_type (type
);
1101 rtype
= elf_dlx_reloc_type (type
);
1105 rtype
= elf_sh_reloc_type (type
);
1109 case EM_CYGNUS_MN10300
:
1110 rtype
= elf_mn10300_reloc_type (type
);
1114 case EM_CYGNUS_MN10200
:
1115 rtype
= elf_mn10200_reloc_type (type
);
1119 case EM_CYGNUS_FR30
:
1120 rtype
= elf_fr30_reloc_type (type
);
1124 rtype
= elf_frv_reloc_type (type
);
1128 rtype
= elf_mcore_reloc_type (type
);
1132 rtype
= elf_mmix_reloc_type (type
);
1136 rtype
= elf_moxie_reloc_type (type
);
1140 if (uses_msp430x_relocs ())
1142 rtype
= elf_msp430x_reloc_type (type
);
1146 rtype
= elf_msp430_reloc_type (type
);
1150 rtype
= elf_nds32_reloc_type (type
);
1154 rtype
= elf_ppc_reloc_type (type
);
1158 rtype
= elf_ppc64_reloc_type (type
);
1162 case EM_MIPS_RS3_LE
:
1163 rtype
= elf_mips_reloc_type (type
);
1167 rtype
= elf_alpha_reloc_type (type
);
1171 rtype
= elf_arm_reloc_type (type
);
1175 rtype
= elf_arc_reloc_type (type
);
1179 rtype
= elf_hppa_reloc_type (type
);
1185 rtype
= elf_h8_reloc_type (type
);
1190 rtype
= elf_or32_reloc_type (type
);
1195 rtype
= elf_pj_reloc_type (type
);
1198 rtype
= elf_ia64_reloc_type (type
);
1202 rtype
= elf_cris_reloc_type (type
);
1206 rtype
= elf_i860_reloc_type (type
);
1212 rtype
= elf_x86_64_reloc_type (type
);
1216 rtype
= i370_reloc_type (type
);
1221 rtype
= elf_s390_reloc_type (type
);
1225 rtype
= elf_score_reloc_type (type
);
1229 rtype
= elf_xstormy16_reloc_type (type
);
1233 rtype
= elf_crx_reloc_type (type
);
1237 rtype
= elf_vax_reloc_type (type
);
1240 case EM_ADAPTEVA_EPIPHANY
:
1241 rtype
= elf_epiphany_reloc_type (type
);
1246 rtype
= elf_ip2k_reloc_type (type
);
1250 rtype
= elf_iq2000_reloc_type (type
);
1255 rtype
= elf_xtensa_reloc_type (type
);
1258 case EM_LATTICEMICO32
:
1259 rtype
= elf_lm32_reloc_type (type
);
1264 rtype
= elf_m32c_reloc_type (type
);
1268 rtype
= elf_mt_reloc_type (type
);
1272 rtype
= elf_bfin_reloc_type (type
);
1276 rtype
= elf_mep_reloc_type (type
);
1280 rtype
= elf_cr16_reloc_type (type
);
1284 case EM_MICROBLAZE_OLD
:
1285 rtype
= elf_microblaze_reloc_type (type
);
1289 rtype
= elf_rl78_reloc_type (type
);
1293 rtype
= elf_rx_reloc_type (type
);
1297 rtype
= elf_metag_reloc_type (type
);
1302 rtype
= elf_xc16x_reloc_type (type
);
1306 rtype
= elf_tic6x_reloc_type (type
);
1310 rtype
= elf_tilegx_reloc_type (type
);
1314 rtype
= elf_tilepro_reloc_type (type
);
1318 rtype
= elf_xgate_reloc_type (type
);
1321 case EM_ALTERA_NIOS2
:
1322 rtype
= elf_nios2_reloc_type (type
);
1327 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1329 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1331 if (elf_header
.e_machine
== EM_ALPHA
1333 && streq (rtype
, "R_ALPHA_LITUSE")
1336 switch (rels
[i
].r_addend
)
1338 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1339 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1340 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1341 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1342 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1343 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1344 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1345 default: rtype
= NULL
;
1348 printf (" (%s)", rtype
);
1352 printf (_("<unknown addend: %lx>"),
1353 (unsigned long) rels
[i
].r_addend
);
1356 else if (symtab_index
)
1358 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1359 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1362 Elf_Internal_Sym
* psym
;
1364 psym
= symtab
+ symtab_index
;
1368 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1372 unsigned int width
= is_32bit_elf
? 8 : 14;
1374 /* Relocations against GNU_IFUNC symbols do not use the value
1375 of the symbol as the address to relocate against. Instead
1376 they invoke the function named by the symbol and use its
1377 result as the address for relocation.
1379 To indicate this to the user, do not display the value of
1380 the symbol in the "Symbols's Value" field. Instead show
1381 its name followed by () as a hint that the symbol is
1385 || psym
->st_name
== 0
1386 || psym
->st_name
>= strtablen
)
1389 name
= strtab
+ psym
->st_name
;
1391 len
= print_symbol (width
, name
);
1392 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1396 print_vma (psym
->st_value
, LONG_HEX
);
1398 printf (is_32bit_elf
? " " : " ");
1401 if (psym
->st_name
== 0)
1403 const char * sec_name
= "<null>";
1406 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1408 if (psym
->st_shndx
< elf_header
.e_shnum
)
1410 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1411 else if (psym
->st_shndx
== SHN_ABS
)
1413 else if (psym
->st_shndx
== SHN_COMMON
)
1414 sec_name
= "COMMON";
1415 else if ((elf_header
.e_machine
== EM_MIPS
1416 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1417 || (elf_header
.e_machine
== EM_TI_C6000
1418 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1419 sec_name
= "SCOMMON";
1420 else if (elf_header
.e_machine
== EM_MIPS
1421 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1422 sec_name
= "SUNDEF";
1423 else if ((elf_header
.e_machine
== EM_X86_64
1424 || elf_header
.e_machine
== EM_L1OM
1425 || elf_header
.e_machine
== EM_K1OM
)
1426 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1427 sec_name
= "LARGE_COMMON";
1428 else if (elf_header
.e_machine
== EM_IA_64
1429 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1430 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1431 sec_name
= "ANSI_COM";
1432 else if (is_ia64_vms ()
1433 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1434 sec_name
= "VMS_SYMVEC";
1437 sprintf (name_buf
, "<section 0x%x>",
1438 (unsigned int) psym
->st_shndx
);
1439 sec_name
= name_buf
;
1442 print_symbol (22, sec_name
);
1444 else if (strtab
== NULL
)
1445 printf (_("<string table index: %3ld>"), psym
->st_name
);
1446 else if (psym
->st_name
>= strtablen
)
1447 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1449 print_symbol (22, strtab
+ psym
->st_name
);
1453 bfd_signed_vma off
= rels
[i
].r_addend
;
1456 printf (" - %" BFD_VMA_FMT
"x", - off
);
1458 printf (" + %" BFD_VMA_FMT
"x", off
);
1464 bfd_signed_vma off
= rels
[i
].r_addend
;
1466 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1468 printf ("-%" BFD_VMA_FMT
"x", - off
);
1470 printf ("%" BFD_VMA_FMT
"x", off
);
1473 if (elf_header
.e_machine
== EM_SPARCV9
1475 && streq (rtype
, "R_SPARC_OLO10"))
1476 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1481 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1483 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1484 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1485 const char * rtype2
= elf_mips_reloc_type (type2
);
1486 const char * rtype3
= elf_mips_reloc_type (type3
);
1488 printf (" Type2: ");
1491 printf (_("unrecognized: %-7lx"),
1492 (unsigned long) type2
& 0xffffffff);
1494 printf ("%-17.17s", rtype2
);
1496 printf ("\n Type3: ");
1499 printf (_("unrecognized: %-7lx"),
1500 (unsigned long) type3
& 0xffffffff);
1502 printf ("%-17.17s", rtype3
);
1513 get_mips_dynamic_type (unsigned long type
)
1517 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1518 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1519 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1520 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1521 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1522 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1523 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1524 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1525 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1526 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1527 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1528 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1529 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1530 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1531 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1532 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1533 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1534 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1535 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1536 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1537 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1538 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1539 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1540 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1541 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1542 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1543 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1544 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1545 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1546 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1547 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1548 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1549 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1550 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1551 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1552 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1553 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1554 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1555 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1556 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1557 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1558 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1559 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1560 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1561 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1568 get_sparc64_dynamic_type (unsigned long type
)
1572 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1579 get_ppc_dynamic_type (unsigned long type
)
1583 case DT_PPC_GOT
: return "PPC_GOT";
1584 case DT_PPC_OPT
: return "PPC_OPT";
1591 get_ppc64_dynamic_type (unsigned long type
)
1595 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1596 case DT_PPC64_OPD
: return "PPC64_OPD";
1597 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1598 case DT_PPC64_OPT
: return "PPC64_OPT";
1605 get_parisc_dynamic_type (unsigned long type
)
1609 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1610 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1611 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1612 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1613 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1614 case DT_HP_PREINIT
: return "HP_PREINIT";
1615 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1616 case DT_HP_NEEDED
: return "HP_NEEDED";
1617 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1618 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1619 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1620 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1621 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1622 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1623 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1624 case DT_HP_FILTERED
: return "HP_FILTERED";
1625 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1626 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1627 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1628 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1629 case DT_PLT
: return "PLT";
1630 case DT_PLT_SIZE
: return "PLT_SIZE";
1631 case DT_DLT
: return "DLT";
1632 case DT_DLT_SIZE
: return "DLT_SIZE";
1639 get_ia64_dynamic_type (unsigned long type
)
1643 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1644 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1645 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1646 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1647 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1648 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1649 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1650 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1651 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1652 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1653 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1654 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1655 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1656 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1657 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1658 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1659 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1660 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1661 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1662 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1663 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1664 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1665 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1666 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1667 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1668 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1669 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1670 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1671 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1672 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1673 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1680 get_alpha_dynamic_type (unsigned long type
)
1684 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1691 get_score_dynamic_type (unsigned long type
)
1695 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1696 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1697 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1698 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1699 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1700 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1707 get_tic6x_dynamic_type (unsigned long type
)
1711 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1712 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1713 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1714 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1715 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1716 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1723 get_nios2_dynamic_type (unsigned long type
)
1727 case DT_NIOS2_GP
: return "NIOS2_GP";
1734 get_dynamic_type (unsigned long type
)
1736 static char buff
[64];
1740 case DT_NULL
: return "NULL";
1741 case DT_NEEDED
: return "NEEDED";
1742 case DT_PLTRELSZ
: return "PLTRELSZ";
1743 case DT_PLTGOT
: return "PLTGOT";
1744 case DT_HASH
: return "HASH";
1745 case DT_STRTAB
: return "STRTAB";
1746 case DT_SYMTAB
: return "SYMTAB";
1747 case DT_RELA
: return "RELA";
1748 case DT_RELASZ
: return "RELASZ";
1749 case DT_RELAENT
: return "RELAENT";
1750 case DT_STRSZ
: return "STRSZ";
1751 case DT_SYMENT
: return "SYMENT";
1752 case DT_INIT
: return "INIT";
1753 case DT_FINI
: return "FINI";
1754 case DT_SONAME
: return "SONAME";
1755 case DT_RPATH
: return "RPATH";
1756 case DT_SYMBOLIC
: return "SYMBOLIC";
1757 case DT_REL
: return "REL";
1758 case DT_RELSZ
: return "RELSZ";
1759 case DT_RELENT
: return "RELENT";
1760 case DT_PLTREL
: return "PLTREL";
1761 case DT_DEBUG
: return "DEBUG";
1762 case DT_TEXTREL
: return "TEXTREL";
1763 case DT_JMPREL
: return "JMPREL";
1764 case DT_BIND_NOW
: return "BIND_NOW";
1765 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1766 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1767 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1768 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1769 case DT_RUNPATH
: return "RUNPATH";
1770 case DT_FLAGS
: return "FLAGS";
1772 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1773 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1775 case DT_CHECKSUM
: return "CHECKSUM";
1776 case DT_PLTPADSZ
: return "PLTPADSZ";
1777 case DT_MOVEENT
: return "MOVEENT";
1778 case DT_MOVESZ
: return "MOVESZ";
1779 case DT_FEATURE
: return "FEATURE";
1780 case DT_POSFLAG_1
: return "POSFLAG_1";
1781 case DT_SYMINSZ
: return "SYMINSZ";
1782 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1784 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1785 case DT_CONFIG
: return "CONFIG";
1786 case DT_DEPAUDIT
: return "DEPAUDIT";
1787 case DT_AUDIT
: return "AUDIT";
1788 case DT_PLTPAD
: return "PLTPAD";
1789 case DT_MOVETAB
: return "MOVETAB";
1790 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1792 case DT_VERSYM
: return "VERSYM";
1794 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1795 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1796 case DT_RELACOUNT
: return "RELACOUNT";
1797 case DT_RELCOUNT
: return "RELCOUNT";
1798 case DT_FLAGS_1
: return "FLAGS_1";
1799 case DT_VERDEF
: return "VERDEF";
1800 case DT_VERDEFNUM
: return "VERDEFNUM";
1801 case DT_VERNEED
: return "VERNEED";
1802 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1804 case DT_AUXILIARY
: return "AUXILIARY";
1805 case DT_USED
: return "USED";
1806 case DT_FILTER
: return "FILTER";
1808 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1809 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1810 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1811 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1812 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1813 case DT_GNU_HASH
: return "GNU_HASH";
1816 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1818 const char * result
;
1820 switch (elf_header
.e_machine
)
1823 case EM_MIPS_RS3_LE
:
1824 result
= get_mips_dynamic_type (type
);
1827 result
= get_sparc64_dynamic_type (type
);
1830 result
= get_ppc_dynamic_type (type
);
1833 result
= get_ppc64_dynamic_type (type
);
1836 result
= get_ia64_dynamic_type (type
);
1839 result
= get_alpha_dynamic_type (type
);
1842 result
= get_score_dynamic_type (type
);
1845 result
= get_tic6x_dynamic_type (type
);
1847 case EM_ALTERA_NIOS2
:
1848 result
= get_nios2_dynamic_type (type
);
1858 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1860 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1861 || (elf_header
.e_machine
== EM_PARISC
1862 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1864 const char * result
;
1866 switch (elf_header
.e_machine
)
1869 result
= get_parisc_dynamic_type (type
);
1872 result
= get_ia64_dynamic_type (type
);
1882 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1886 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1893 get_file_type (unsigned e_type
)
1895 static char buff
[32];
1899 case ET_NONE
: return _("NONE (None)");
1900 case ET_REL
: return _("REL (Relocatable file)");
1901 case ET_EXEC
: return _("EXEC (Executable file)");
1902 case ET_DYN
: return _("DYN (Shared object file)");
1903 case ET_CORE
: return _("CORE (Core file)");
1906 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1907 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1908 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1909 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1911 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1917 get_machine_name (unsigned e_machine
)
1919 static char buff
[64]; /* XXX */
1923 case EM_NONE
: return _("None");
1924 case EM_AARCH64
: return "AArch64";
1925 case EM_M32
: return "WE32100";
1926 case EM_SPARC
: return "Sparc";
1927 case EM_SPU
: return "SPU";
1928 case EM_386
: return "Intel 80386";
1929 case EM_68K
: return "MC68000";
1930 case EM_88K
: return "MC88000";
1931 case EM_486
: return "Intel 80486";
1932 case EM_860
: return "Intel 80860";
1933 case EM_MIPS
: return "MIPS R3000";
1934 case EM_S370
: return "IBM System/370";
1935 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1936 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1937 case EM_PARISC
: return "HPPA";
1938 case EM_PPC_OLD
: return "Power PC (old)";
1939 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1940 case EM_960
: return "Intel 90860";
1941 case EM_PPC
: return "PowerPC";
1942 case EM_PPC64
: return "PowerPC64";
1943 case EM_FR20
: return "Fujitsu FR20";
1944 case EM_RH32
: return "TRW RH32";
1945 case EM_MCORE
: return "MCORE";
1946 case EM_ARM
: return "ARM";
1947 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1948 case EM_SH
: return "Renesas / SuperH SH";
1949 case EM_SPARCV9
: return "Sparc v9";
1950 case EM_TRICORE
: return "Siemens Tricore";
1951 case EM_ARC
: return "ARC";
1952 case EM_H8_300
: return "Renesas H8/300";
1953 case EM_H8_300H
: return "Renesas H8/300H";
1954 case EM_H8S
: return "Renesas H8S";
1955 case EM_H8_500
: return "Renesas H8/500";
1956 case EM_IA_64
: return "Intel IA-64";
1957 case EM_MIPS_X
: return "Stanford MIPS-X";
1958 case EM_COLDFIRE
: return "Motorola Coldfire";
1959 case EM_ALPHA
: return "Alpha";
1960 case EM_CYGNUS_D10V
:
1961 case EM_D10V
: return "d10v";
1962 case EM_CYGNUS_D30V
:
1963 case EM_D30V
: return "d30v";
1964 case EM_CYGNUS_M32R
:
1965 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1966 case EM_CYGNUS_V850
:
1967 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1968 case EM_V850
: return "Renesas V850";
1969 case EM_CYGNUS_MN10300
:
1970 case EM_MN10300
: return "mn10300";
1971 case EM_CYGNUS_MN10200
:
1972 case EM_MN10200
: return "mn10200";
1973 case EM_MOXIE
: return "Moxie";
1974 case EM_CYGNUS_FR30
:
1975 case EM_FR30
: return "Fujitsu FR30";
1976 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1978 case EM_PJ
: return "picoJava";
1979 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1980 case EM_PCP
: return "Siemens PCP";
1981 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1982 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1983 case EM_STARCORE
: return "Motorola Star*Core processor";
1984 case EM_ME16
: return "Toyota ME16 processor";
1985 case EM_ST100
: return "STMicroelectronics ST100 processor";
1986 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1987 case EM_PDSP
: return "Sony DSP processor";
1988 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1989 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1990 case EM_FX66
: return "Siemens FX66 microcontroller";
1991 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1992 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1993 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1994 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1995 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1996 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1997 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1998 case EM_SVX
: return "Silicon Graphics SVx";
1999 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2000 case EM_VAX
: return "Digital VAX";
2002 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2003 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2004 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2005 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2006 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2007 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2008 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2009 case EM_PRISM
: return "Vitesse Prism";
2010 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2011 case EM_L1OM
: return "Intel L1OM";
2012 case EM_K1OM
: return "Intel K1OM";
2014 case EM_S390
: return "IBM S/390";
2015 case EM_SCORE
: return "SUNPLUS S+Core";
2016 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2018 case EM_OR32
: return "OpenRISC";
2019 case EM_ARC_A5
: return "ARC International ARCompact processor";
2020 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2021 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2022 case EM_DLX
: return "OpenDLX";
2024 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2025 case EM_IQ2000
: return "Vitesse IQ2000";
2027 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2028 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2029 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2030 case EM_NS32K
: return "National Semiconductor 32000 series";
2031 case EM_TPC
: return "Tenor Network TPC processor";
2032 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2033 case EM_MAX
: return "MAX Processor";
2034 case EM_CR
: return "National Semiconductor CompactRISC";
2035 case EM_F2MC16
: return "Fujitsu F2MC16";
2036 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2037 case EM_LATTICEMICO32
: return "Lattice Mico32";
2039 case EM_M32C
: return "Renesas M32c";
2040 case EM_MT
: return "Morpho Techologies MT processor";
2041 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2042 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2043 case EM_SEP
: return "Sharp embedded microprocessor";
2044 case EM_ARCA
: return "Arca RISC microprocessor";
2045 case EM_UNICORE
: return "Unicore";
2046 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2047 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2048 case EM_NIOS32
: return "Altera Nios";
2049 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2051 case EM_XC16X
: return "Infineon Technologies xc16x";
2052 case EM_M16C
: return "Renesas M16C series microprocessors";
2053 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2054 case EM_CE
: return "Freescale Communication Engine RISC core";
2055 case EM_TSK3000
: return "Altium TSK3000 core";
2056 case EM_RS08
: return "Freescale RS08 embedded processor";
2057 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2058 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2059 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2060 case EM_SE_C17
: return "Seiko Epson C17 family";
2061 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2062 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2063 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2064 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2065 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2066 case EM_R32C
: return "Renesas R32C series microprocessors";
2067 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2068 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2069 case EM_8051
: return "Intel 8051 and variants";
2070 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2071 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2072 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2073 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2074 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2075 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2076 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2077 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2080 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2081 case EM_RL78
: return "Renesas RL78";
2082 case EM_RX
: return "Renesas RX";
2083 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2084 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2085 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2086 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2087 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2088 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2089 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2090 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2091 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2092 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2093 case EM_CUDA
: return "NVIDIA CUDA architecture";
2094 case EM_XGATE
: return "Motorola XGATE embedded processor";
2096 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2102 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2107 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2108 e_flags
&= ~ EF_ARM_EABIMASK
;
2110 /* Handle "generic" ARM flags. */
2111 if (e_flags
& EF_ARM_RELEXEC
)
2113 strcat (buf
, ", relocatable executable");
2114 e_flags
&= ~ EF_ARM_RELEXEC
;
2117 if (e_flags
& EF_ARM_HASENTRY
)
2119 strcat (buf
, ", has entry point");
2120 e_flags
&= ~ EF_ARM_HASENTRY
;
2123 /* Now handle EABI specific flags. */
2127 strcat (buf
, ", <unrecognized EABI>");
2132 case EF_ARM_EABI_VER1
:
2133 strcat (buf
, ", Version1 EABI");
2138 /* Process flags one bit at a time. */
2139 flag
= e_flags
& - e_flags
;
2144 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2145 strcat (buf
, ", sorted symbol tables");
2155 case EF_ARM_EABI_VER2
:
2156 strcat (buf
, ", Version2 EABI");
2161 /* Process flags one bit at a time. */
2162 flag
= e_flags
& - e_flags
;
2167 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2168 strcat (buf
, ", sorted symbol tables");
2171 case EF_ARM_DYNSYMSUSESEGIDX
:
2172 strcat (buf
, ", dynamic symbols use segment index");
2175 case EF_ARM_MAPSYMSFIRST
:
2176 strcat (buf
, ", mapping symbols precede others");
2186 case EF_ARM_EABI_VER3
:
2187 strcat (buf
, ", Version3 EABI");
2190 case EF_ARM_EABI_VER4
:
2191 strcat (buf
, ", Version4 EABI");
2196 /* Process flags one bit at a time. */
2197 flag
= e_flags
& - e_flags
;
2203 strcat (buf
, ", BE8");
2207 strcat (buf
, ", LE8");
2218 case EF_ARM_EABI_VER5
:
2219 strcat (buf
, ", Version5 EABI");
2224 /* Process flags one bit at a time. */
2225 flag
= e_flags
& - e_flags
;
2231 strcat (buf
, ", BE8");
2235 strcat (buf
, ", LE8");
2238 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2239 strcat (buf
, ", soft-float ABI");
2242 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2243 strcat (buf
, ", hard-float ABI");
2253 case EF_ARM_EABI_UNKNOWN
:
2254 strcat (buf
, ", GNU EABI");
2259 /* Process flags one bit at a time. */
2260 flag
= e_flags
& - e_flags
;
2265 case EF_ARM_INTERWORK
:
2266 strcat (buf
, ", interworking enabled");
2269 case EF_ARM_APCS_26
:
2270 strcat (buf
, ", uses APCS/26");
2273 case EF_ARM_APCS_FLOAT
:
2274 strcat (buf
, ", uses APCS/float");
2278 strcat (buf
, ", position independent");
2282 strcat (buf
, ", 8 bit structure alignment");
2285 case EF_ARM_NEW_ABI
:
2286 strcat (buf
, ", uses new ABI");
2289 case EF_ARM_OLD_ABI
:
2290 strcat (buf
, ", uses old ABI");
2293 case EF_ARM_SOFT_FLOAT
:
2294 strcat (buf
, ", software FP");
2297 case EF_ARM_VFP_FLOAT
:
2298 strcat (buf
, ", VFP");
2301 case EF_ARM_MAVERICK_FLOAT
:
2302 strcat (buf
, ", Maverick FP");
2313 strcat (buf
,_(", <unknown>"));
2317 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2326 static const char *ABI_STRINGS
[] =
2328 "ABI v0", /* use r5 as return register; only used in N1213HC */
2329 "ABI v1", /* use r0 as return register */
2330 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2331 "ABI v2fp", /* for FPU */
2334 static const char *VER_STRINGS
[] =
2336 "Andes ELF V1.3 or older",
2340 static const char *ARCH_STRINGS
[] =
2349 abi
= EF_NDS_ABI
& e_flags
;
2350 arch
= EF_NDS_ARCH
& e_flags
;
2351 config
= EF_NDS_INST
& e_flags
;
2352 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2354 memset (buf
, 0, size
);
2361 case E_NDS_ABI_V2FP
:
2362 case E_NDS_ABI_AABI
:
2363 /* In case there are holes in the array. */
2364 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2368 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2374 case E_NDS32_ELF_VER_1_2
:
2375 case E_NDS32_ELF_VER_1_3
:
2376 case E_NDS32_ELF_VER_1_4
:
2377 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2381 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2385 if (E_NDS_ABI_V0
== abi
)
2387 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2388 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2389 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2390 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2396 case E_NDS_ARCH_STAR_V1_0
:
2397 case E_NDS_ARCH_STAR_V2_0
:
2398 case E_NDS_ARCH_STAR_V3_0
:
2399 case E_NDS_ARCH_STAR_V3_M
:
2400 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2404 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2405 /* ARCH version determines how the e_flags are interpreted.
2406 If it is unknown, we cannot proceed. */
2410 /* Newer ABI; Now handle architecture specific flags. */
2411 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2413 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2414 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2416 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2417 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2419 if (config
& E_NDS32_HAS_DIV_INST
)
2420 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2422 if (config
& E_NDS32_HAS_16BIT_INST
)
2423 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2427 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2429 if (version
<= E_NDS32_ELF_VER_1_3
)
2430 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2432 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2435 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2436 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2438 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2439 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2441 if (config
& E_NDS32_HAS_16BIT_INST
)
2443 if (version
<= E_NDS32_ELF_VER_1_3
)
2444 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2446 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2450 if (config
& E_NDS32_HAS_EXT_INST
)
2451 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2453 if (config
& E_NDS32_HAS_EXT2_INST
)
2454 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2456 if (config
& E_NDS32_HAS_FPU_INST
)
2459 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2462 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2465 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2468 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2471 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2476 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2478 case E_NDS32_FPU_REG_8SP_4DP
:
2479 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2481 case E_NDS32_FPU_REG_16SP_8DP
:
2482 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2484 case E_NDS32_FPU_REG_32SP_16DP
:
2485 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2487 case E_NDS32_FPU_REG_32SP_32DP
:
2488 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2493 if (config
& E_NDS32_HAS_AUDIO_INST
)
2494 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2496 if (config
& E_NDS32_HAS_STRING_INST
)
2497 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2499 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2500 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2502 if (config
& E_NDS32_HAS_VIDEO_INST
)
2504 if (version
<= E_NDS32_ELF_VER_1_3
)
2505 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2507 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2510 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2511 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2513 if (config
& E_NDS32_HAS_L2C_INST
)
2514 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2518 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2520 static char buf
[1024];
2532 decode_ARM_machine_flags (e_flags
, buf
);
2536 if (e_flags
& EF_BFIN_PIC
)
2537 strcat (buf
, ", PIC");
2539 if (e_flags
& EF_BFIN_FDPIC
)
2540 strcat (buf
, ", FDPIC");
2542 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2543 strcat (buf
, ", code in L1");
2545 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2546 strcat (buf
, ", data in L1");
2551 switch (e_flags
& EF_FRV_CPU_MASK
)
2553 case EF_FRV_CPU_GENERIC
:
2557 strcat (buf
, ", fr???");
2560 case EF_FRV_CPU_FR300
:
2561 strcat (buf
, ", fr300");
2564 case EF_FRV_CPU_FR400
:
2565 strcat (buf
, ", fr400");
2567 case EF_FRV_CPU_FR405
:
2568 strcat (buf
, ", fr405");
2571 case EF_FRV_CPU_FR450
:
2572 strcat (buf
, ", fr450");
2575 case EF_FRV_CPU_FR500
:
2576 strcat (buf
, ", fr500");
2578 case EF_FRV_CPU_FR550
:
2579 strcat (buf
, ", fr550");
2582 case EF_FRV_CPU_SIMPLE
:
2583 strcat (buf
, ", simple");
2585 case EF_FRV_CPU_TOMCAT
:
2586 strcat (buf
, ", tomcat");
2592 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2593 strcat (buf
, ", m68000");
2594 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2595 strcat (buf
, ", cpu32");
2596 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2597 strcat (buf
, ", fido_a");
2600 char const * isa
= _("unknown");
2601 char const * mac
= _("unknown mac");
2602 char const * additional
= NULL
;
2604 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2606 case EF_M68K_CF_ISA_A_NODIV
:
2608 additional
= ", nodiv";
2610 case EF_M68K_CF_ISA_A
:
2613 case EF_M68K_CF_ISA_A_PLUS
:
2616 case EF_M68K_CF_ISA_B_NOUSP
:
2618 additional
= ", nousp";
2620 case EF_M68K_CF_ISA_B
:
2623 case EF_M68K_CF_ISA_C
:
2626 case EF_M68K_CF_ISA_C_NODIV
:
2628 additional
= ", nodiv";
2631 strcat (buf
, ", cf, isa ");
2634 strcat (buf
, additional
);
2635 if (e_flags
& EF_M68K_CF_FLOAT
)
2636 strcat (buf
, ", float");
2637 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2642 case EF_M68K_CF_MAC
:
2645 case EF_M68K_CF_EMAC
:
2648 case EF_M68K_CF_EMAC_B
:
2661 if (e_flags
& EF_PPC_EMB
)
2662 strcat (buf
, ", emb");
2664 if (e_flags
& EF_PPC_RELOCATABLE
)
2665 strcat (buf
, _(", relocatable"));
2667 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2668 strcat (buf
, _(", relocatable-lib"));
2672 if (e_flags
& EF_PPC64_ABI
)
2674 char abi
[] = ", abiv0";
2676 abi
[6] += e_flags
& EF_PPC64_ABI
;
2682 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2683 strcat (buf
, ", RH850 ABI");
2685 if (e_flags
& EF_V800_850E3
)
2686 strcat (buf
, ", V3 architecture");
2688 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2689 strcat (buf
, ", FPU not used");
2691 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2692 strcat (buf
, ", regmode: COMMON");
2694 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2695 strcat (buf
, ", r4 not used");
2697 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2698 strcat (buf
, ", r30 not used");
2700 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2701 strcat (buf
, ", r5 not used");
2703 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2704 strcat (buf
, ", r2 not used");
2706 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2708 switch (e_flags
& - e_flags
)
2710 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2711 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2712 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2713 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2714 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2715 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2716 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2717 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2718 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2719 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2720 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2721 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2722 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2723 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2724 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2725 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2732 case EM_CYGNUS_V850
:
2733 switch (e_flags
& EF_V850_ARCH
)
2735 case E_V850E3V5_ARCH
:
2736 strcat (buf
, ", v850e3v5");
2738 case E_V850E2V3_ARCH
:
2739 strcat (buf
, ", v850e2v3");
2742 strcat (buf
, ", v850e2");
2745 strcat (buf
, ", v850e1");
2748 strcat (buf
, ", v850e");
2751 strcat (buf
, ", v850");
2754 strcat (buf
, _(", unknown v850 architecture variant"));
2760 case EM_CYGNUS_M32R
:
2761 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2762 strcat (buf
, ", m32r");
2766 case EM_MIPS_RS3_LE
:
2767 if (e_flags
& EF_MIPS_NOREORDER
)
2768 strcat (buf
, ", noreorder");
2770 if (e_flags
& EF_MIPS_PIC
)
2771 strcat (buf
, ", pic");
2773 if (e_flags
& EF_MIPS_CPIC
)
2774 strcat (buf
, ", cpic");
2776 if (e_flags
& EF_MIPS_UCODE
)
2777 strcat (buf
, ", ugen_reserved");
2779 if (e_flags
& EF_MIPS_ABI2
)
2780 strcat (buf
, ", abi2");
2782 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2783 strcat (buf
, ", odk first");
2785 if (e_flags
& EF_MIPS_32BITMODE
)
2786 strcat (buf
, ", 32bitmode");
2788 if (e_flags
& EF_MIPS_NAN2008
)
2789 strcat (buf
, ", nan2008");
2791 if (e_flags
& EF_MIPS_FP64
)
2792 strcat (buf
, ", fp64");
2794 switch ((e_flags
& EF_MIPS_MACH
))
2796 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2797 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2798 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2799 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2800 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2801 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2802 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2803 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2804 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2805 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2806 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2807 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2808 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2809 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2810 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2811 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2812 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2814 /* We simply ignore the field in this case to avoid confusion:
2815 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2818 default: strcat (buf
, _(", unknown CPU")); break;
2821 switch ((e_flags
& EF_MIPS_ABI
))
2823 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2824 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2825 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2826 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2828 /* We simply ignore the field in this case to avoid confusion:
2829 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2830 This means it is likely to be an o32 file, but not for
2833 default: strcat (buf
, _(", unknown ABI")); break;
2836 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2837 strcat (buf
, ", mdmx");
2839 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2840 strcat (buf
, ", mips16");
2842 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2843 strcat (buf
, ", micromips");
2845 switch ((e_flags
& EF_MIPS_ARCH
))
2847 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2848 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2849 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2850 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2851 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2852 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2853 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2854 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2855 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2856 default: strcat (buf
, _(", unknown ISA")); break;
2861 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2865 switch ((e_flags
& EF_SH_MACH_MASK
))
2867 case EF_SH1
: strcat (buf
, ", sh1"); break;
2868 case EF_SH2
: strcat (buf
, ", sh2"); break;
2869 case EF_SH3
: strcat (buf
, ", sh3"); break;
2870 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2871 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2872 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2873 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2874 case EF_SH4
: strcat (buf
, ", sh4"); break;
2875 case EF_SH5
: strcat (buf
, ", sh5"); break;
2876 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2877 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2878 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2879 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2880 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2881 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2882 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2883 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2884 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2885 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2886 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2887 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2888 default: strcat (buf
, _(", unknown ISA")); break;
2891 if (e_flags
& EF_SH_PIC
)
2892 strcat (buf
, ", pic");
2894 if (e_flags
& EF_SH_FDPIC
)
2895 strcat (buf
, ", fdpic");
2899 if (e_flags
& EF_SPARC_32PLUS
)
2900 strcat (buf
, ", v8+");
2902 if (e_flags
& EF_SPARC_SUN_US1
)
2903 strcat (buf
, ", ultrasparcI");
2905 if (e_flags
& EF_SPARC_SUN_US3
)
2906 strcat (buf
, ", ultrasparcIII");
2908 if (e_flags
& EF_SPARC_HAL_R1
)
2909 strcat (buf
, ", halr1");
2911 if (e_flags
& EF_SPARC_LEDATA
)
2912 strcat (buf
, ", ledata");
2914 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2915 strcat (buf
, ", tso");
2917 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2918 strcat (buf
, ", pso");
2920 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2921 strcat (buf
, ", rmo");
2925 switch (e_flags
& EF_PARISC_ARCH
)
2927 case EFA_PARISC_1_0
:
2928 strcpy (buf
, ", PA-RISC 1.0");
2930 case EFA_PARISC_1_1
:
2931 strcpy (buf
, ", PA-RISC 1.1");
2933 case EFA_PARISC_2_0
:
2934 strcpy (buf
, ", PA-RISC 2.0");
2939 if (e_flags
& EF_PARISC_TRAPNIL
)
2940 strcat (buf
, ", trapnil");
2941 if (e_flags
& EF_PARISC_EXT
)
2942 strcat (buf
, ", ext");
2943 if (e_flags
& EF_PARISC_LSB
)
2944 strcat (buf
, ", lsb");
2945 if (e_flags
& EF_PARISC_WIDE
)
2946 strcat (buf
, ", wide");
2947 if (e_flags
& EF_PARISC_NO_KABP
)
2948 strcat (buf
, ", no kabp");
2949 if (e_flags
& EF_PARISC_LAZYSWAP
)
2950 strcat (buf
, ", lazyswap");
2955 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2956 strcat (buf
, ", new calling convention");
2958 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2959 strcat (buf
, ", gnu calling convention");
2963 if ((e_flags
& EF_IA_64_ABI64
))
2964 strcat (buf
, ", 64-bit");
2966 strcat (buf
, ", 32-bit");
2967 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2968 strcat (buf
, ", reduced fp model");
2969 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2970 strcat (buf
, ", no function descriptors, constant gp");
2971 else if ((e_flags
& EF_IA_64_CONS_GP
))
2972 strcat (buf
, ", constant gp");
2973 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2974 strcat (buf
, ", absolute");
2975 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2977 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2978 strcat (buf
, ", vms_linkages");
2979 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2981 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2983 case EF_IA_64_VMS_COMCOD_WARNING
:
2984 strcat (buf
, ", warning");
2986 case EF_IA_64_VMS_COMCOD_ERROR
:
2987 strcat (buf
, ", error");
2989 case EF_IA_64_VMS_COMCOD_ABORT
:
2990 strcat (buf
, ", abort");
2999 if ((e_flags
& EF_VAX_NONPIC
))
3000 strcat (buf
, ", non-PIC");
3001 if ((e_flags
& EF_VAX_DFLOAT
))
3002 strcat (buf
, ", D-Float");
3003 if ((e_flags
& EF_VAX_GFLOAT
))
3004 strcat (buf
, ", G-Float");
3008 if (e_flags
& E_FLAG_RL78_G10
)
3009 strcat (buf
, ", G10");
3013 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3014 strcat (buf
, ", 64-bit doubles");
3015 if (e_flags
& E_FLAG_RX_DSP
)
3016 strcat (buf
, ", dsp");
3017 if (e_flags
& E_FLAG_RX_PID
)
3018 strcat (buf
, ", pid");
3019 if (e_flags
& E_FLAG_RX_ABI
)
3020 strcat (buf
, ", RX ABI");
3024 if (e_flags
& EF_S390_HIGH_GPRS
)
3025 strcat (buf
, ", highgprs");
3029 if ((e_flags
& EF_C6000_REL
))
3030 strcat (buf
, ", relocatable module");
3034 strcat (buf
, _(": architecture variant: "));
3035 switch (e_flags
& EF_MSP430_MACH
)
3037 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3038 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3039 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3040 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3041 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3042 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3043 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3044 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3045 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3046 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3047 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3048 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3049 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3050 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3051 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3053 strcat (buf
, _(": unknown")); break;
3056 if (e_flags
& ~ EF_MSP430_MACH
)
3057 strcat (buf
, _(": unknown extra flag bits also present"));
3065 get_osabi_name (unsigned int osabi
)
3067 static char buff
[32];
3071 case ELFOSABI_NONE
: return "UNIX - System V";
3072 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3073 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3074 case ELFOSABI_GNU
: return "UNIX - GNU";
3075 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3076 case ELFOSABI_AIX
: return "UNIX - AIX";
3077 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3078 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3079 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3080 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3081 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3082 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3083 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3084 case ELFOSABI_AROS
: return "AROS";
3085 case ELFOSABI_FENIXOS
: return "FenixOS";
3088 switch (elf_header
.e_machine
)
3093 case ELFOSABI_ARM
: return "ARM";
3103 case ELFOSABI_STANDALONE
: return _("Standalone App");
3112 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3113 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3122 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3128 get_aarch64_segment_type (unsigned long type
)
3132 case PT_AARCH64_ARCHEXT
:
3133 return "AARCH64_ARCHEXT";
3142 get_arm_segment_type (unsigned long type
)
3156 get_mips_segment_type (unsigned long type
)
3160 case PT_MIPS_REGINFO
:
3162 case PT_MIPS_RTPROC
:
3164 case PT_MIPS_OPTIONS
:
3174 get_parisc_segment_type (unsigned long type
)
3178 case PT_HP_TLS
: return "HP_TLS";
3179 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3180 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3181 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3182 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3183 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3184 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3185 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3186 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3187 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3188 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3189 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3190 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3191 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3192 case PT_HP_STACK
: return "HP_STACK";
3193 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3194 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3195 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3196 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3205 get_ia64_segment_type (unsigned long type
)
3209 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3210 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3211 case PT_HP_TLS
: return "HP_TLS";
3212 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3213 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3214 case PT_IA_64_HP_STACK
: return "HP_STACK";
3223 get_tic6x_segment_type (unsigned long type
)
3227 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3236 get_segment_type (unsigned long p_type
)
3238 static char buff
[32];
3242 case PT_NULL
: return "NULL";
3243 case PT_LOAD
: return "LOAD";
3244 case PT_DYNAMIC
: return "DYNAMIC";
3245 case PT_INTERP
: return "INTERP";
3246 case PT_NOTE
: return "NOTE";
3247 case PT_SHLIB
: return "SHLIB";
3248 case PT_PHDR
: return "PHDR";
3249 case PT_TLS
: return "TLS";
3251 case PT_GNU_EH_FRAME
:
3252 return "GNU_EH_FRAME";
3253 case PT_GNU_STACK
: return "GNU_STACK";
3254 case PT_GNU_RELRO
: return "GNU_RELRO";
3257 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3259 const char * result
;
3261 switch (elf_header
.e_machine
)
3264 result
= get_aarch64_segment_type (p_type
);
3267 result
= get_arm_segment_type (p_type
);
3270 case EM_MIPS_RS3_LE
:
3271 result
= get_mips_segment_type (p_type
);
3274 result
= get_parisc_segment_type (p_type
);
3277 result
= get_ia64_segment_type (p_type
);
3280 result
= get_tic6x_segment_type (p_type
);
3290 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3292 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3294 const char * result
;
3296 switch (elf_header
.e_machine
)
3299 result
= get_parisc_segment_type (p_type
);
3302 result
= get_ia64_segment_type (p_type
);
3312 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3315 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3322 get_mips_section_type_name (unsigned int sh_type
)
3326 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3327 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3328 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3329 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3330 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3331 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3332 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3333 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3334 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3335 case SHT_MIPS_RELD
: return "MIPS_RELD";
3336 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3337 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3338 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3339 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3340 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3341 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3342 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3343 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3344 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3345 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3346 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3347 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3348 case SHT_MIPS_LINE
: return "MIPS_LINE";
3349 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3350 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3351 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3352 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3353 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3354 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3355 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3356 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3357 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3358 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3359 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3360 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3361 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3362 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3363 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3364 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3372 get_parisc_section_type_name (unsigned int sh_type
)
3376 case SHT_PARISC_EXT
: return "PARISC_EXT";
3377 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3378 case SHT_PARISC_DOC
: return "PARISC_DOC";
3379 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3380 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3381 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3382 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3390 get_ia64_section_type_name (unsigned int sh_type
)
3392 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3393 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3394 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3398 case SHT_IA_64_EXT
: return "IA_64_EXT";
3399 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3400 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3401 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3402 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3403 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3404 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3405 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3406 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3407 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3415 get_x86_64_section_type_name (unsigned int sh_type
)
3419 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3427 get_aarch64_section_type_name (unsigned int sh_type
)
3431 case SHT_AARCH64_ATTRIBUTES
:
3432 return "AARCH64_ATTRIBUTES";
3440 get_arm_section_type_name (unsigned int sh_type
)
3444 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3445 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3446 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3447 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3448 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3456 get_tic6x_section_type_name (unsigned int sh_type
)
3460 case SHT_C6000_UNWIND
:
3461 return "C6000_UNWIND";
3462 case SHT_C6000_PREEMPTMAP
:
3463 return "C6000_PREEMPTMAP";
3464 case SHT_C6000_ATTRIBUTES
:
3465 return "C6000_ATTRIBUTES";
3470 case SHT_TI_HANDLER
:
3471 return "TI_HANDLER";
3472 case SHT_TI_INITINFO
:
3473 return "TI_INITINFO";
3474 case SHT_TI_PHATTRS
:
3475 return "TI_PHATTRS";
3483 get_msp430x_section_type_name (unsigned int sh_type
)
3487 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3488 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3489 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3490 default: return NULL
;
3495 get_section_type_name (unsigned int sh_type
)
3497 static char buff
[32];
3501 case SHT_NULL
: return "NULL";
3502 case SHT_PROGBITS
: return "PROGBITS";
3503 case SHT_SYMTAB
: return "SYMTAB";
3504 case SHT_STRTAB
: return "STRTAB";
3505 case SHT_RELA
: return "RELA";
3506 case SHT_HASH
: return "HASH";
3507 case SHT_DYNAMIC
: return "DYNAMIC";
3508 case SHT_NOTE
: return "NOTE";
3509 case SHT_NOBITS
: return "NOBITS";
3510 case SHT_REL
: return "REL";
3511 case SHT_SHLIB
: return "SHLIB";
3512 case SHT_DYNSYM
: return "DYNSYM";
3513 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3514 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3515 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3516 case SHT_GNU_HASH
: return "GNU_HASH";
3517 case SHT_GROUP
: return "GROUP";
3518 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3519 case SHT_GNU_verdef
: return "VERDEF";
3520 case SHT_GNU_verneed
: return "VERNEED";
3521 case SHT_GNU_versym
: return "VERSYM";
3522 case 0x6ffffff0: return "VERSYM";
3523 case 0x6ffffffc: return "VERDEF";
3524 case 0x7ffffffd: return "AUXILIARY";
3525 case 0x7fffffff: return "FILTER";
3526 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3529 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3531 const char * result
;
3533 switch (elf_header
.e_machine
)
3536 case EM_MIPS_RS3_LE
:
3537 result
= get_mips_section_type_name (sh_type
);
3540 result
= get_parisc_section_type_name (sh_type
);
3543 result
= get_ia64_section_type_name (sh_type
);
3548 result
= get_x86_64_section_type_name (sh_type
);
3551 result
= get_aarch64_section_type_name (sh_type
);
3554 result
= get_arm_section_type_name (sh_type
);
3557 result
= get_tic6x_section_type_name (sh_type
);
3560 result
= get_msp430x_section_type_name (sh_type
);
3570 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3572 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3574 const char * result
;
3576 switch (elf_header
.e_machine
)
3579 result
= get_ia64_section_type_name (sh_type
);
3589 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3591 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3592 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3594 /* This message is probably going to be displayed in a 15
3595 character wide field, so put the hex value first. */
3596 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3602 #define OPTION_DEBUG_DUMP 512
3603 #define OPTION_DYN_SYMS 513
3604 #define OPTION_DWARF_DEPTH 514
3605 #define OPTION_DWARF_START 515
3606 #define OPTION_DWARF_CHECK 516
3608 static struct option options
[] =
3610 {"all", no_argument
, 0, 'a'},
3611 {"file-header", no_argument
, 0, 'h'},
3612 {"program-headers", no_argument
, 0, 'l'},
3613 {"headers", no_argument
, 0, 'e'},
3614 {"histogram", no_argument
, 0, 'I'},
3615 {"segments", no_argument
, 0, 'l'},
3616 {"sections", no_argument
, 0, 'S'},
3617 {"section-headers", no_argument
, 0, 'S'},
3618 {"section-groups", no_argument
, 0, 'g'},
3619 {"section-details", no_argument
, 0, 't'},
3620 {"full-section-name",no_argument
, 0, 'N'},
3621 {"symbols", no_argument
, 0, 's'},
3622 {"syms", no_argument
, 0, 's'},
3623 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3624 {"relocs", no_argument
, 0, 'r'},
3625 {"notes", no_argument
, 0, 'n'},
3626 {"dynamic", no_argument
, 0, 'd'},
3627 {"arch-specific", no_argument
, 0, 'A'},
3628 {"version-info", no_argument
, 0, 'V'},
3629 {"use-dynamic", no_argument
, 0, 'D'},
3630 {"unwind", no_argument
, 0, 'u'},
3631 {"archive-index", no_argument
, 0, 'c'},
3632 {"hex-dump", required_argument
, 0, 'x'},
3633 {"relocated-dump", required_argument
, 0, 'R'},
3634 {"string-dump", required_argument
, 0, 'p'},
3635 #ifdef SUPPORT_DISASSEMBLY
3636 {"instruction-dump", required_argument
, 0, 'i'},
3638 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3640 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3641 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3642 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3644 {"version", no_argument
, 0, 'v'},
3645 {"wide", no_argument
, 0, 'W'},
3646 {"help", no_argument
, 0, 'H'},
3647 {0, no_argument
, 0, 0}
3651 usage (FILE * stream
)
3653 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3654 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3655 fprintf (stream
, _(" Options are:\n\
3656 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3657 -h --file-header Display the ELF file header\n\
3658 -l --program-headers Display the program headers\n\
3659 --segments An alias for --program-headers\n\
3660 -S --section-headers Display the sections' header\n\
3661 --sections An alias for --section-headers\n\
3662 -g --section-groups Display the section groups\n\
3663 -t --section-details Display the section details\n\
3664 -e --headers Equivalent to: -h -l -S\n\
3665 -s --syms Display the symbol table\n\
3666 --symbols An alias for --syms\n\
3667 --dyn-syms Display the dynamic symbol table\n\
3668 -n --notes Display the core notes (if present)\n\
3669 -r --relocs Display the relocations (if present)\n\
3670 -u --unwind Display the unwind info (if present)\n\
3671 -d --dynamic Display the dynamic section (if present)\n\
3672 -V --version-info Display the version sections (if present)\n\
3673 -A --arch-specific Display architecture specific information (if any)\n\
3674 -c --archive-index Display the symbol/file index in an archive\n\
3675 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3676 -x --hex-dump=<number|name>\n\
3677 Dump the contents of section <number|name> as bytes\n\
3678 -p --string-dump=<number|name>\n\
3679 Dump the contents of section <number|name> as strings\n\
3680 -R --relocated-dump=<number|name>\n\
3681 Dump the contents of section <number|name> as relocated bytes\n\
3682 -w[lLiaprmfFsoRt] or\n\
3683 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3684 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3685 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3687 Display the contents of DWARF2 debug sections\n"));
3688 fprintf (stream
, _("\
3689 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3690 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3692 #ifdef SUPPORT_DISASSEMBLY
3693 fprintf (stream
, _("\
3694 -i --instruction-dump=<number|name>\n\
3695 Disassemble the contents of section <number|name>\n"));
3697 fprintf (stream
, _("\
3698 -I --histogram Display histogram of bucket list lengths\n\
3699 -W --wide Allow output width to exceed 80 characters\n\
3700 @<file> Read options from <file>\n\
3701 -H --help Display this information\n\
3702 -v --version Display the version number of readelf\n"));
3704 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3705 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3707 exit (stream
== stdout
? 0 : 1);
3710 /* Record the fact that the user wants the contents of section number
3711 SECTION to be displayed using the method(s) encoded as flags bits
3712 in TYPE. Note, TYPE can be zero if we are creating the array for
3716 request_dump_bynumber (unsigned int section
, dump_type type
)
3718 if (section
>= num_dump_sects
)
3720 dump_type
* new_dump_sects
;
3722 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3723 sizeof (* dump_sects
));
3725 if (new_dump_sects
== NULL
)
3726 error (_("Out of memory allocating dump request table.\n"));
3729 /* Copy current flag settings. */
3730 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3734 dump_sects
= new_dump_sects
;
3735 num_dump_sects
= section
+ 1;
3740 dump_sects
[section
] |= type
;
3745 /* Request a dump by section name. */
3748 request_dump_byname (const char * section
, dump_type type
)
3750 struct dump_list_entry
* new_request
;
3752 new_request
= (struct dump_list_entry
*)
3753 malloc (sizeof (struct dump_list_entry
));
3755 error (_("Out of memory allocating dump request table.\n"));
3757 new_request
->name
= strdup (section
);
3758 if (!new_request
->name
)
3759 error (_("Out of memory allocating dump request table.\n"));
3761 new_request
->type
= type
;
3763 new_request
->next
= dump_sects_byname
;
3764 dump_sects_byname
= new_request
;
3768 request_dump (dump_type type
)
3774 section
= strtoul (optarg
, & cp
, 0);
3776 if (! *cp
&& section
>= 0)
3777 request_dump_bynumber (section
, type
);
3779 request_dump_byname (optarg
, type
);
3784 parse_args (int argc
, char ** argv
)
3791 while ((c
= getopt_long
3792 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3810 do_section_groups
++;
3818 do_section_groups
++;
3823 do_section_details
++;
3867 request_dump (HEX_DUMP
);
3870 request_dump (STRING_DUMP
);
3873 request_dump (RELOC_DUMP
);
3880 dwarf_select_sections_all ();
3885 dwarf_select_sections_by_letters (optarg
);
3888 case OPTION_DEBUG_DUMP
:
3895 dwarf_select_sections_by_names (optarg
);
3898 case OPTION_DWARF_DEPTH
:
3902 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3905 case OPTION_DWARF_START
:
3909 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3912 case OPTION_DWARF_CHECK
:
3915 case OPTION_DYN_SYMS
:
3918 #ifdef SUPPORT_DISASSEMBLY
3920 request_dump (DISASS_DUMP
);
3924 print_version (program_name
);
3933 /* xgettext:c-format */
3934 error (_("Invalid option '-%c'\n"), c
);
3941 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3942 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3943 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3944 && !do_section_groups
&& !do_archive_index
3949 warn (_("Nothing to do.\n"));
3955 get_elf_class (unsigned int elf_class
)
3957 static char buff
[32];
3961 case ELFCLASSNONE
: return _("none");
3962 case ELFCLASS32
: return "ELF32";
3963 case ELFCLASS64
: return "ELF64";
3965 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3971 get_data_encoding (unsigned int encoding
)
3973 static char buff
[32];
3977 case ELFDATANONE
: return _("none");
3978 case ELFDATA2LSB
: return _("2's complement, little endian");
3979 case ELFDATA2MSB
: return _("2's complement, big endian");
3981 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3986 /* Decode the data held in 'elf_header'. */
3989 process_file_header (void)
3991 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3992 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3993 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3994 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3997 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4001 init_dwarf_regnames (elf_header
.e_machine
);
4007 printf (_("ELF Header:\n"));
4008 printf (_(" Magic: "));
4009 for (i
= 0; i
< EI_NIDENT
; i
++)
4010 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4012 printf (_(" Class: %s\n"),
4013 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4014 printf (_(" Data: %s\n"),
4015 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4016 printf (_(" Version: %d %s\n"),
4017 elf_header
.e_ident
[EI_VERSION
],
4018 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4020 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4021 ? _("<unknown: %lx>")
4023 printf (_(" OS/ABI: %s\n"),
4024 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4025 printf (_(" ABI Version: %d\n"),
4026 elf_header
.e_ident
[EI_ABIVERSION
]);
4027 printf (_(" Type: %s\n"),
4028 get_file_type (elf_header
.e_type
));
4029 printf (_(" Machine: %s\n"),
4030 get_machine_name (elf_header
.e_machine
));
4031 printf (_(" Version: 0x%lx\n"),
4032 (unsigned long) elf_header
.e_version
);
4034 printf (_(" Entry point address: "));
4035 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4036 printf (_("\n Start of program headers: "));
4037 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4038 printf (_(" (bytes into file)\n Start of section headers: "));
4039 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4040 printf (_(" (bytes into file)\n"));
4042 printf (_(" Flags: 0x%lx%s\n"),
4043 (unsigned long) elf_header
.e_flags
,
4044 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4045 printf (_(" Size of this header: %ld (bytes)\n"),
4046 (long) elf_header
.e_ehsize
);
4047 printf (_(" Size of program headers: %ld (bytes)\n"),
4048 (long) elf_header
.e_phentsize
);
4049 printf (_(" Number of program headers: %ld"),
4050 (long) elf_header
.e_phnum
);
4051 if (section_headers
!= NULL
4052 && elf_header
.e_phnum
== PN_XNUM
4053 && section_headers
[0].sh_info
!= 0)
4054 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4055 putc ('\n', stdout
);
4056 printf (_(" Size of section headers: %ld (bytes)\n"),
4057 (long) elf_header
.e_shentsize
);
4058 printf (_(" Number of section headers: %ld"),
4059 (long) elf_header
.e_shnum
);
4060 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4061 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4062 putc ('\n', stdout
);
4063 printf (_(" Section header string table index: %ld"),
4064 (long) elf_header
.e_shstrndx
);
4065 if (section_headers
!= NULL
4066 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4067 printf (" (%u)", section_headers
[0].sh_link
);
4068 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4069 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4070 printf (_(" <corrupt: out of range>"));
4071 putc ('\n', stdout
);
4074 if (section_headers
!= NULL
)
4076 if (elf_header
.e_phnum
== PN_XNUM
4077 && section_headers
[0].sh_info
!= 0)
4078 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4079 if (elf_header
.e_shnum
== SHN_UNDEF
)
4080 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4081 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4082 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4083 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4084 elf_header
.e_shstrndx
= SHN_UNDEF
;
4085 free (section_headers
);
4086 section_headers
= NULL
;
4094 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4096 Elf32_External_Phdr
* phdrs
;
4097 Elf32_External_Phdr
* external
;
4098 Elf_Internal_Phdr
* internal
;
4101 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4102 elf_header
.e_phentsize
,
4104 _("program headers"));
4108 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4109 i
< elf_header
.e_phnum
;
4110 i
++, internal
++, external
++)
4112 internal
->p_type
= BYTE_GET (external
->p_type
);
4113 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4114 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4115 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4116 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4117 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4118 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4119 internal
->p_align
= BYTE_GET (external
->p_align
);
4128 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4130 Elf64_External_Phdr
* phdrs
;
4131 Elf64_External_Phdr
* external
;
4132 Elf_Internal_Phdr
* internal
;
4135 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4136 elf_header
.e_phentsize
,
4138 _("program headers"));
4142 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4143 i
< elf_header
.e_phnum
;
4144 i
++, internal
++, external
++)
4146 internal
->p_type
= BYTE_GET (external
->p_type
);
4147 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4148 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4149 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4150 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4151 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4152 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4153 internal
->p_align
= BYTE_GET (external
->p_align
);
4161 /* Returns 1 if the program headers were read into `program_headers'. */
4164 get_program_headers (FILE * file
)
4166 Elf_Internal_Phdr
* phdrs
;
4168 /* Check cache of prior read. */
4169 if (program_headers
!= NULL
)
4172 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4173 sizeof (Elf_Internal_Phdr
));
4177 error (_("Out of memory\n"));
4182 ? get_32bit_program_headers (file
, phdrs
)
4183 : get_64bit_program_headers (file
, phdrs
))
4185 program_headers
= phdrs
;
4193 /* Returns 1 if the program headers were loaded. */
4196 process_program_headers (FILE * file
)
4198 Elf_Internal_Phdr
* segment
;
4201 if (elf_header
.e_phnum
== 0)
4203 /* PR binutils/12467. */
4204 if (elf_header
.e_phoff
!= 0)
4205 warn (_("possibly corrupt ELF header - it has a non-zero program"
4206 " header offset, but no program headers"));
4207 else if (do_segments
)
4208 printf (_("\nThere are no program headers in this file.\n"));
4212 if (do_segments
&& !do_header
)
4214 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4215 printf (_("Entry point "));
4216 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4217 printf (_("\nThere are %d program headers, starting at offset "),
4218 elf_header
.e_phnum
);
4219 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4223 if (! get_program_headers (file
))
4228 if (elf_header
.e_phnum
> 1)
4229 printf (_("\nProgram Headers:\n"));
4231 printf (_("\nProgram Headers:\n"));
4235 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4238 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4242 (_(" Type Offset VirtAddr PhysAddr\n"));
4244 (_(" FileSiz MemSiz Flags Align\n"));
4251 for (i
= 0, segment
= program_headers
;
4252 i
< elf_header
.e_phnum
;
4257 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4261 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4262 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4263 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4264 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4265 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4267 (segment
->p_flags
& PF_R
? 'R' : ' '),
4268 (segment
->p_flags
& PF_W
? 'W' : ' '),
4269 (segment
->p_flags
& PF_X
? 'E' : ' '));
4270 printf ("%#lx", (unsigned long) segment
->p_align
);
4274 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4275 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4278 print_vma (segment
->p_offset
, FULL_HEX
);
4282 print_vma (segment
->p_vaddr
, FULL_HEX
);
4284 print_vma (segment
->p_paddr
, FULL_HEX
);
4287 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4288 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4291 print_vma (segment
->p_filesz
, FULL_HEX
);
4295 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4296 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4299 print_vma (segment
->p_memsz
, FULL_HEX
);
4303 (segment
->p_flags
& PF_R
? 'R' : ' '),
4304 (segment
->p_flags
& PF_W
? 'W' : ' '),
4305 (segment
->p_flags
& PF_X
? 'E' : ' '));
4307 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4308 printf ("%#lx", (unsigned long) segment
->p_align
);
4311 print_vma (segment
->p_align
, PREFIX_HEX
);
4316 print_vma (segment
->p_offset
, FULL_HEX
);
4318 print_vma (segment
->p_vaddr
, FULL_HEX
);
4320 print_vma (segment
->p_paddr
, FULL_HEX
);
4322 print_vma (segment
->p_filesz
, FULL_HEX
);
4324 print_vma (segment
->p_memsz
, FULL_HEX
);
4326 (segment
->p_flags
& PF_R
? 'R' : ' '),
4327 (segment
->p_flags
& PF_W
? 'W' : ' '),
4328 (segment
->p_flags
& PF_X
? 'E' : ' '));
4329 print_vma (segment
->p_align
, HEX
);
4333 switch (segment
->p_type
)
4337 error (_("more than one dynamic segment\n"));
4339 /* By default, assume that the .dynamic section is the first
4340 section in the DYNAMIC segment. */
4341 dynamic_addr
= segment
->p_offset
;
4342 dynamic_size
= segment
->p_filesz
;
4344 /* Try to locate the .dynamic section. If there is
4345 a section header table, we can easily locate it. */
4346 if (section_headers
!= NULL
)
4348 Elf_Internal_Shdr
* sec
;
4350 sec
= find_section (".dynamic");
4351 if (sec
== NULL
|| sec
->sh_size
== 0)
4353 /* A corresponding .dynamic section is expected, but on
4354 IA-64/OpenVMS it is OK for it to be missing. */
4355 if (!is_ia64_vms ())
4356 error (_("no .dynamic section in the dynamic segment\n"));
4360 if (sec
->sh_type
== SHT_NOBITS
)
4366 dynamic_addr
= sec
->sh_offset
;
4367 dynamic_size
= sec
->sh_size
;
4369 if (dynamic_addr
< segment
->p_offset
4370 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4371 warn (_("the .dynamic section is not contained"
4372 " within the dynamic segment\n"));
4373 else if (dynamic_addr
> segment
->p_offset
)
4374 warn (_("the .dynamic section is not the first section"
4375 " in the dynamic segment.\n"));
4380 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4382 error (_("Unable to find program interpreter name\n"));
4386 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4388 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4389 error (_("Internal error: failed to create format string to display program interpreter\n"));
4391 program_interpreter
[0] = 0;
4392 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4393 error (_("Unable to read program interpreter name\n"));
4396 printf (_("\n [Requesting program interpreter: %s]"),
4397 program_interpreter
);
4403 putc ('\n', stdout
);
4406 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4408 printf (_("\n Section to Segment mapping:\n"));
4409 printf (_(" Segment Sections...\n"));
4411 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4414 Elf_Internal_Shdr
* section
;
4416 segment
= program_headers
+ i
;
4417 section
= section_headers
+ 1;
4419 printf (" %2.2d ", i
);
4421 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4423 if (!ELF_TBSS_SPECIAL (section
, segment
)
4424 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4425 printf ("%s ", SECTION_NAME (section
));
4436 /* Find the file offset corresponding to VMA by using the program headers. */
4439 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4441 Elf_Internal_Phdr
* seg
;
4443 if (! get_program_headers (file
))
4445 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4449 for (seg
= program_headers
;
4450 seg
< program_headers
+ elf_header
.e_phnum
;
4453 if (seg
->p_type
!= PT_LOAD
)
4456 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4457 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4458 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4461 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4462 (unsigned long) vma
);
4468 get_32bit_section_headers (FILE * file
, unsigned int num
)
4470 Elf32_External_Shdr
* shdrs
;
4471 Elf_Internal_Shdr
* internal
;
4474 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4475 elf_header
.e_shentsize
, num
,
4476 _("section headers"));
4480 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4481 sizeof (Elf_Internal_Shdr
));
4483 if (section_headers
== NULL
)
4485 error (_("Out of memory\n"));
4489 for (i
= 0, internal
= section_headers
;
4493 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4494 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4495 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4496 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4497 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4498 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4499 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4500 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4501 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4502 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4511 get_64bit_section_headers (FILE * file
, unsigned int num
)
4513 Elf64_External_Shdr
* shdrs
;
4514 Elf_Internal_Shdr
* internal
;
4517 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4518 elf_header
.e_shentsize
, num
,
4519 _("section headers"));
4523 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4524 sizeof (Elf_Internal_Shdr
));
4526 if (section_headers
== NULL
)
4528 error (_("Out of memory\n"));
4532 for (i
= 0, internal
= section_headers
;
4536 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4537 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4538 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4539 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4540 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4541 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4542 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4543 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4544 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4545 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4553 static Elf_Internal_Sym
*
4554 get_32bit_elf_symbols (FILE * file
,
4555 Elf_Internal_Shdr
* section
,
4556 unsigned long * num_syms_return
)
4558 unsigned long number
= 0;
4559 Elf32_External_Sym
* esyms
= NULL
;
4560 Elf_External_Sym_Shndx
* shndx
= NULL
;
4561 Elf_Internal_Sym
* isyms
= NULL
;
4562 Elf_Internal_Sym
* psym
;
4565 /* Run some sanity checks first. */
4566 if (section
->sh_entsize
== 0)
4568 error (_("sh_entsize is zero\n"));
4572 number
= section
->sh_size
/ section
->sh_entsize
;
4574 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4576 error (_("Invalid sh_entsize\n"));
4580 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4581 section
->sh_size
, _("symbols"));
4586 if (symtab_shndx_hdr
!= NULL
4587 && (symtab_shndx_hdr
->sh_link
4588 == (unsigned long) (section
- section_headers
)))
4590 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4591 symtab_shndx_hdr
->sh_offset
,
4592 1, symtab_shndx_hdr
->sh_size
,
4593 _("symbol table section indicies"));
4598 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4602 error (_("Out of memory\n"));
4606 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4608 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4609 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4610 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4611 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4612 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4614 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4615 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4616 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4617 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4618 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4627 if (num_syms_return
!= NULL
)
4628 * num_syms_return
= isyms
== NULL
? 0 : number
;
4633 static Elf_Internal_Sym
*
4634 get_64bit_elf_symbols (FILE * file
,
4635 Elf_Internal_Shdr
* section
,
4636 unsigned long * num_syms_return
)
4638 unsigned long number
= 0;
4639 Elf64_External_Sym
* esyms
= NULL
;
4640 Elf_External_Sym_Shndx
* shndx
= NULL
;
4641 Elf_Internal_Sym
* isyms
= NULL
;
4642 Elf_Internal_Sym
* psym
;
4645 /* Run some sanity checks first. */
4646 if (section
->sh_entsize
== 0)
4648 error (_("sh_entsize is zero\n"));
4652 number
= section
->sh_size
/ section
->sh_entsize
;
4654 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4656 error (_("Invalid sh_entsize\n"));
4660 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4661 section
->sh_size
, _("symbols"));
4665 if (symtab_shndx_hdr
!= NULL
4666 && (symtab_shndx_hdr
->sh_link
4667 == (unsigned long) (section
- section_headers
)))
4669 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4670 symtab_shndx_hdr
->sh_offset
,
4671 1, symtab_shndx_hdr
->sh_size
,
4672 _("symbol table section indicies"));
4677 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4681 error (_("Out of memory\n"));
4685 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4687 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4688 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4689 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4690 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4692 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4694 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4695 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4696 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4698 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4699 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4708 if (num_syms_return
!= NULL
)
4709 * num_syms_return
= isyms
== NULL
? 0 : number
;
4715 get_elf_section_flags (bfd_vma sh_flags
)
4717 static char buff
[1024];
4719 int field_size
= is_32bit_elf
? 8 : 16;
4721 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4722 bfd_vma os_flags
= 0;
4723 bfd_vma proc_flags
= 0;
4724 bfd_vma unknown_flags
= 0;
4732 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4733 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4734 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4735 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4736 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4737 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4738 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4739 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4740 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4741 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4742 /* IA-64 specific. */
4743 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4744 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4745 /* IA-64 OpenVMS specific. */
4746 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4747 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4748 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4749 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4750 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4751 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4753 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4754 /* SPARC specific. */
4755 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4758 if (do_section_details
)
4760 sprintf (buff
, "[%*.*lx]: ",
4761 field_size
, field_size
, (unsigned long) sh_flags
);
4762 p
+= field_size
+ 4;
4769 flag
= sh_flags
& - sh_flags
;
4772 if (do_section_details
)
4776 case SHF_WRITE
: sindex
= 0; break;
4777 case SHF_ALLOC
: sindex
= 1; break;
4778 case SHF_EXECINSTR
: sindex
= 2; break;
4779 case SHF_MERGE
: sindex
= 3; break;
4780 case SHF_STRINGS
: sindex
= 4; break;
4781 case SHF_INFO_LINK
: sindex
= 5; break;
4782 case SHF_LINK_ORDER
: sindex
= 6; break;
4783 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4784 case SHF_GROUP
: sindex
= 8; break;
4785 case SHF_TLS
: sindex
= 9; break;
4786 case SHF_EXCLUDE
: sindex
= 18; break;
4790 switch (elf_header
.e_machine
)
4793 if (flag
== SHF_IA_64_SHORT
)
4795 else if (flag
== SHF_IA_64_NORECOV
)
4798 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4801 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4802 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4803 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4804 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4805 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4806 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4817 case EM_OLD_SPARCV9
:
4818 case EM_SPARC32PLUS
:
4821 if (flag
== SHF_ORDERED
)
4831 if (p
!= buff
+ field_size
+ 4)
4833 if (size
< (10 + 2))
4840 size
-= flags
[sindex
].len
;
4841 p
= stpcpy (p
, flags
[sindex
].str
);
4843 else if (flag
& SHF_MASKOS
)
4845 else if (flag
& SHF_MASKPROC
)
4848 unknown_flags
|= flag
;
4854 case SHF_WRITE
: *p
= 'W'; break;
4855 case SHF_ALLOC
: *p
= 'A'; break;
4856 case SHF_EXECINSTR
: *p
= 'X'; break;
4857 case SHF_MERGE
: *p
= 'M'; break;
4858 case SHF_STRINGS
: *p
= 'S'; break;
4859 case SHF_INFO_LINK
: *p
= 'I'; break;
4860 case SHF_LINK_ORDER
: *p
= 'L'; break;
4861 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4862 case SHF_GROUP
: *p
= 'G'; break;
4863 case SHF_TLS
: *p
= 'T'; break;
4864 case SHF_EXCLUDE
: *p
= 'E'; break;
4867 if ((elf_header
.e_machine
== EM_X86_64
4868 || elf_header
.e_machine
== EM_L1OM
4869 || elf_header
.e_machine
== EM_K1OM
)
4870 && flag
== SHF_X86_64_LARGE
)
4872 else if (flag
& SHF_MASKOS
)
4875 sh_flags
&= ~ SHF_MASKOS
;
4877 else if (flag
& SHF_MASKPROC
)
4880 sh_flags
&= ~ SHF_MASKPROC
;
4890 if (do_section_details
)
4894 size
-= 5 + field_size
;
4895 if (p
!= buff
+ field_size
+ 4)
4903 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4904 (unsigned long) os_flags
);
4905 p
+= 5 + field_size
;
4909 size
-= 7 + field_size
;
4910 if (p
!= buff
+ field_size
+ 4)
4918 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4919 (unsigned long) proc_flags
);
4920 p
+= 7 + field_size
;
4924 size
-= 10 + field_size
;
4925 if (p
!= buff
+ field_size
+ 4)
4933 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4934 (unsigned long) unknown_flags
);
4935 p
+= 10 + field_size
;
4944 process_section_headers (FILE * file
)
4946 Elf_Internal_Shdr
* section
;
4949 section_headers
= NULL
;
4951 if (elf_header
.e_shnum
== 0)
4953 /* PR binutils/12467. */
4954 if (elf_header
.e_shoff
!= 0)
4955 warn (_("possibly corrupt ELF file header - it has a non-zero"
4956 " section header offset, but no section headers\n"));
4957 else if (do_sections
)
4958 printf (_("\nThere are no sections in this file.\n"));
4963 if (do_sections
&& !do_header
)
4964 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4965 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4969 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4972 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4975 /* Read in the string table, so that we have names to display. */
4976 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4977 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4979 section
= section_headers
+ elf_header
.e_shstrndx
;
4981 if (section
->sh_size
!= 0)
4983 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4984 1, section
->sh_size
,
4987 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4991 /* Scan the sections for the dynamic symbol table
4992 and dynamic string table and debug sections. */
4993 dynamic_symbols
= NULL
;
4994 dynamic_strings
= NULL
;
4995 dynamic_syminfo
= NULL
;
4996 symtab_shndx_hdr
= NULL
;
4998 eh_addr_size
= is_32bit_elf
? 4 : 8;
4999 switch (elf_header
.e_machine
)
5002 case EM_MIPS_RS3_LE
:
5003 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5004 FDE addresses. However, the ABI also has a semi-official ILP32
5005 variant for which the normal FDE address size rules apply.
5007 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5008 section, where XX is the size of longs in bits. Unfortunately,
5009 earlier compilers provided no way of distinguishing ILP32 objects
5010 from LP64 objects, so if there's any doubt, we should assume that
5011 the official LP64 form is being used. */
5012 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5013 && find_section (".gcc_compiled_long32") == NULL
)
5019 switch (elf_header
.e_flags
& EF_H8_MACH
)
5021 case E_H8_MACH_H8300
:
5022 case E_H8_MACH_H8300HN
:
5023 case E_H8_MACH_H8300SN
:
5024 case E_H8_MACH_H8300SXN
:
5027 case E_H8_MACH_H8300H
:
5028 case E_H8_MACH_H8300S
:
5029 case E_H8_MACH_H8300SX
:
5037 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5039 case EF_M32C_CPU_M16C
:
5046 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5049 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5050 if (section->sh_entsize != expected_entsize) \
5052 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5053 i, section->sh_entsize); \
5054 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5055 (int) expected_entsize); \
5056 section->sh_entsize = expected_entsize; \
5061 #define CHECK_ENTSIZE(section, i, type) \
5062 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5063 sizeof (Elf64_External_##type))
5065 for (i
= 0, section
= section_headers
;
5066 i
< elf_header
.e_shnum
;
5069 char * name
= SECTION_NAME (section
);
5071 if (section
->sh_type
== SHT_DYNSYM
)
5073 if (dynamic_symbols
!= NULL
)
5075 error (_("File contains multiple dynamic symbol tables\n"));
5079 CHECK_ENTSIZE (section
, i
, Sym
);
5080 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5082 else if (section
->sh_type
== SHT_STRTAB
5083 && streq (name
, ".dynstr"))
5085 if (dynamic_strings
!= NULL
)
5087 error (_("File contains multiple dynamic string tables\n"));
5091 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5092 1, section
->sh_size
,
5093 _("dynamic strings"));
5094 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5096 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5098 if (symtab_shndx_hdr
!= NULL
)
5100 error (_("File contains multiple symtab shndx tables\n"));
5103 symtab_shndx_hdr
= section
;
5105 else if (section
->sh_type
== SHT_SYMTAB
)
5106 CHECK_ENTSIZE (section
, i
, Sym
);
5107 else if (section
->sh_type
== SHT_GROUP
)
5108 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5109 else if (section
->sh_type
== SHT_REL
)
5110 CHECK_ENTSIZE (section
, i
, Rel
);
5111 else if (section
->sh_type
== SHT_RELA
)
5112 CHECK_ENTSIZE (section
, i
, Rela
);
5113 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5114 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5115 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5116 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5117 || do_debug_addr
|| do_debug_cu_index
)
5118 && (const_strneq (name
, ".debug_")
5119 || const_strneq (name
, ".zdebug_")))
5122 name
+= sizeof (".zdebug_") - 1;
5124 name
+= sizeof (".debug_") - 1;
5127 || (do_debug_info
&& const_strneq (name
, "info"))
5128 || (do_debug_info
&& const_strneq (name
, "types"))
5129 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5130 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5131 || (do_debug_lines
&& const_strneq (name
, "line."))
5132 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5133 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5134 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5135 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5136 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5137 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5138 || (do_debug_frames
&& const_strneq (name
, "frame"))
5139 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5140 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5141 || (do_debug_str
&& const_strneq (name
, "str"))
5142 || (do_debug_loc
&& const_strneq (name
, "loc"))
5143 || (do_debug_addr
&& const_strneq (name
, "addr"))
5144 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5145 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5147 request_dump_bynumber (i
, DEBUG_DUMP
);
5149 /* Linkonce section to be combined with .debug_info at link time. */
5150 else if ((do_debugging
|| do_debug_info
)
5151 && const_strneq (name
, ".gnu.linkonce.wi."))
5152 request_dump_bynumber (i
, DEBUG_DUMP
);
5153 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5154 request_dump_bynumber (i
, DEBUG_DUMP
);
5155 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5156 request_dump_bynumber (i
, DEBUG_DUMP
);
5157 /* Trace sections for Itanium VMS. */
5158 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5159 || do_trace_aranges
)
5160 && const_strneq (name
, ".trace_"))
5162 name
+= sizeof (".trace_") - 1;
5165 || (do_trace_info
&& streq (name
, "info"))
5166 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5167 || (do_trace_aranges
&& streq (name
, "aranges"))
5169 request_dump_bynumber (i
, DEBUG_DUMP
);
5177 if (elf_header
.e_shnum
> 1)
5178 printf (_("\nSection Headers:\n"));
5180 printf (_("\nSection Header:\n"));
5184 if (do_section_details
)
5186 printf (_(" [Nr] Name\n"));
5187 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5191 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5195 if (do_section_details
)
5197 printf (_(" [Nr] Name\n"));
5198 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5202 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5206 if (do_section_details
)
5208 printf (_(" [Nr] Name\n"));
5209 printf (_(" Type Address Offset Link\n"));
5210 printf (_(" Size EntSize Info Align\n"));
5214 printf (_(" [Nr] Name Type Address Offset\n"));
5215 printf (_(" Size EntSize Flags Link Info Align\n"));
5219 if (do_section_details
)
5220 printf (_(" Flags\n"));
5222 for (i
= 0, section
= section_headers
;
5223 i
< elf_header
.e_shnum
;
5226 printf (" [%2u] ", i
);
5227 if (do_section_details
)
5229 print_symbol (INT_MAX
, SECTION_NAME (section
));
5234 print_symbol (-17, SECTION_NAME (section
));
5237 printf (do_wide
? " %-15s " : " %-15.15s ",
5238 get_section_type_name (section
->sh_type
));
5242 const char * link_too_big
= NULL
;
5244 print_vma (section
->sh_addr
, LONG_HEX
);
5246 printf ( " %6.6lx %6.6lx %2.2lx",
5247 (unsigned long) section
->sh_offset
,
5248 (unsigned long) section
->sh_size
,
5249 (unsigned long) section
->sh_entsize
);
5251 if (do_section_details
)
5252 fputs (" ", stdout
);
5254 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5256 if (section
->sh_link
>= elf_header
.e_shnum
)
5259 /* The sh_link value is out of range. Normally this indicates
5260 an error but it can have special values in Solaris binaries. */
5261 switch (elf_header
.e_machine
)
5268 case EM_OLD_SPARCV9
:
5269 case EM_SPARC32PLUS
:
5272 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5273 link_too_big
= "BEFORE";
5274 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5275 link_too_big
= "AFTER";
5282 if (do_section_details
)
5284 if (link_too_big
!= NULL
&& * link_too_big
)
5285 printf ("<%s> ", link_too_big
);
5287 printf ("%2u ", section
->sh_link
);
5288 printf ("%3u %2lu\n", section
->sh_info
,
5289 (unsigned long) section
->sh_addralign
);
5292 printf ("%2u %3u %2lu\n",
5295 (unsigned long) section
->sh_addralign
);
5297 if (link_too_big
&& ! * link_too_big
)
5298 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5299 i
, section
->sh_link
);
5303 print_vma (section
->sh_addr
, LONG_HEX
);
5305 if ((long) section
->sh_offset
== section
->sh_offset
)
5306 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5310 print_vma (section
->sh_offset
, LONG_HEX
);
5313 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5314 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5318 print_vma (section
->sh_size
, LONG_HEX
);
5321 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5322 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5326 print_vma (section
->sh_entsize
, LONG_HEX
);
5329 if (do_section_details
)
5330 fputs (" ", stdout
);
5332 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5334 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5336 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5337 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5340 print_vma (section
->sh_addralign
, DEC
);
5344 else if (do_section_details
)
5346 printf (" %-15.15s ",
5347 get_section_type_name (section
->sh_type
));
5348 print_vma (section
->sh_addr
, LONG_HEX
);
5349 if ((long) section
->sh_offset
== section
->sh_offset
)
5350 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5354 print_vma (section
->sh_offset
, LONG_HEX
);
5356 printf (" %u\n ", section
->sh_link
);
5357 print_vma (section
->sh_size
, LONG_HEX
);
5359 print_vma (section
->sh_entsize
, LONG_HEX
);
5361 printf (" %-16u %lu\n",
5363 (unsigned long) section
->sh_addralign
);
5368 print_vma (section
->sh_addr
, LONG_HEX
);
5369 if ((long) section
->sh_offset
== section
->sh_offset
)
5370 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5374 print_vma (section
->sh_offset
, LONG_HEX
);
5377 print_vma (section
->sh_size
, LONG_HEX
);
5379 print_vma (section
->sh_entsize
, LONG_HEX
);
5381 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5383 printf (" %2u %3u %lu\n",
5386 (unsigned long) section
->sh_addralign
);
5389 if (do_section_details
)
5390 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5393 if (!do_section_details
)
5395 if (elf_header
.e_machine
== EM_X86_64
5396 || elf_header
.e_machine
== EM_L1OM
5397 || elf_header
.e_machine
== EM_K1OM
)
5398 printf (_("Key to Flags:\n\
5399 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5400 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5401 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5403 printf (_("Key to Flags:\n\
5404 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5405 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5406 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5413 get_group_flags (unsigned int flags
)
5415 static char buff
[32];
5425 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5432 process_section_groups (FILE * file
)
5434 Elf_Internal_Shdr
* section
;
5436 struct group
* group
;
5437 Elf_Internal_Shdr
* symtab_sec
;
5438 Elf_Internal_Shdr
* strtab_sec
;
5439 Elf_Internal_Sym
* symtab
;
5440 unsigned long num_syms
;
5444 /* Don't process section groups unless needed. */
5445 if (!do_unwind
&& !do_section_groups
)
5448 if (elf_header
.e_shnum
== 0)
5450 if (do_section_groups
)
5451 printf (_("\nThere are no sections to group in this file.\n"));
5456 if (section_headers
== NULL
)
5458 error (_("Section headers are not available!\n"));
5459 /* PR 13622: This can happen with a corrupt ELF header. */
5463 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5464 sizeof (struct group
*));
5466 if (section_headers_groups
== NULL
)
5468 error (_("Out of memory\n"));
5472 /* Scan the sections for the group section. */
5474 for (i
= 0, section
= section_headers
;
5475 i
< elf_header
.e_shnum
;
5477 if (section
->sh_type
== SHT_GROUP
)
5480 if (group_count
== 0)
5482 if (do_section_groups
)
5483 printf (_("\nThere are no section groups in this file.\n"));
5488 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5490 if (section_groups
== NULL
)
5492 error (_("Out of memory\n"));
5502 for (i
= 0, section
= section_headers
, group
= section_groups
;
5503 i
< elf_header
.e_shnum
;
5506 if (section
->sh_type
== SHT_GROUP
)
5508 char * name
= SECTION_NAME (section
);
5510 unsigned char * start
;
5511 unsigned char * indices
;
5512 unsigned int entry
, j
, size
;
5513 Elf_Internal_Shdr
* sec
;
5514 Elf_Internal_Sym
* sym
;
5516 /* Get the symbol table. */
5517 if (section
->sh_link
>= elf_header
.e_shnum
5518 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5521 error (_("Bad sh_link in group section `%s'\n"), name
);
5525 if (symtab_sec
!= sec
)
5530 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5535 error (_("Corrupt header in group section `%s'\n"), name
);
5539 if (section
->sh_info
>= num_syms
)
5541 error (_("Bad sh_info in group section `%s'\n"), name
);
5545 sym
= symtab
+ section
->sh_info
;
5547 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5549 if (sym
->st_shndx
== 0
5550 || sym
->st_shndx
>= elf_header
.e_shnum
)
5552 error (_("Bad sh_info in group section `%s'\n"), name
);
5556 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5565 /* Get the string table. */
5566 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5575 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5580 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5581 1, strtab_sec
->sh_size
,
5583 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5585 group_name
= sym
->st_name
< strtab_size
5586 ? strtab
+ sym
->st_name
: _("<corrupt>");
5589 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5590 1, section
->sh_size
,
5596 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5597 entry
= byte_get (indices
, 4);
5600 if (do_section_groups
)
5602 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5603 get_group_flags (entry
), i
, name
, group_name
, size
);
5605 printf (_(" [Index] Name\n"));
5608 group
->group_index
= i
;
5610 for (j
= 0; j
< size
; j
++)
5612 struct group_list
* g
;
5614 entry
= byte_get (indices
, 4);
5617 if (entry
>= elf_header
.e_shnum
)
5619 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5620 entry
, i
, elf_header
.e_shnum
- 1);
5624 if (section_headers_groups
[entry
] != NULL
)
5628 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5630 section_headers_groups
[entry
]->group_index
);
5635 /* Intel C/C++ compiler may put section 0 in a
5636 section group. We just warn it the first time
5637 and ignore it afterwards. */
5638 static int warned
= 0;
5641 error (_("section 0 in group section [%5u]\n"),
5642 section_headers_groups
[entry
]->group_index
);
5648 section_headers_groups
[entry
] = group
;
5650 if (do_section_groups
)
5652 sec
= section_headers
+ entry
;
5653 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5656 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5657 g
->section_index
= entry
;
5658 g
->next
= group
->root
;
5676 /* Data used to display dynamic fixups. */
5678 struct ia64_vms_dynfixup
5680 bfd_vma needed_ident
; /* Library ident number. */
5681 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5682 bfd_vma fixup_needed
; /* Index of the library. */
5683 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5684 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5687 /* Data used to display dynamic relocations. */
5689 struct ia64_vms_dynimgrela
5691 bfd_vma img_rela_cnt
; /* Number of relocations. */
5692 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5695 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5699 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5700 const char *strtab
, unsigned int strtab_sz
)
5702 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5704 const char *lib_name
;
5706 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5707 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5708 _("dynamic section image fixups"));
5712 if (fixup
->needed
< strtab_sz
)
5713 lib_name
= strtab
+ fixup
->needed
;
5716 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5717 (unsigned long) fixup
->needed
);
5720 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5721 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5723 (_("Seg Offset Type SymVec DataType\n"));
5725 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5730 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5731 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5732 type
= BYTE_GET (imfs
[i
].type
);
5733 rtype
= elf_ia64_reloc_type (type
);
5735 printf (" 0x%08x ", type
);
5737 printf (" %-32s ", rtype
);
5738 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5739 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5745 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5748 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5750 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5753 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5754 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5755 _("dynamic section image relocations"));
5759 printf (_("\nImage relocs\n"));
5761 (_("Seg Offset Type Addend Seg Sym Off\n"));
5763 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5768 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5769 printf ("%08" BFD_VMA_FMT
"x ",
5770 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5771 type
= BYTE_GET (imrs
[i
].type
);
5772 rtype
= elf_ia64_reloc_type (type
);
5774 printf ("0x%08x ", type
);
5776 printf ("%-31s ", rtype
);
5777 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5778 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5779 printf ("%08" BFD_VMA_FMT
"x\n",
5780 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5786 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5789 process_ia64_vms_dynamic_relocs (FILE *file
)
5791 struct ia64_vms_dynfixup fixup
;
5792 struct ia64_vms_dynimgrela imgrela
;
5793 Elf_Internal_Dyn
*entry
;
5795 bfd_vma strtab_off
= 0;
5796 bfd_vma strtab_sz
= 0;
5797 char *strtab
= NULL
;
5799 memset (&fixup
, 0, sizeof (fixup
));
5800 memset (&imgrela
, 0, sizeof (imgrela
));
5802 /* Note: the order of the entries is specified by the OpenVMS specs. */
5803 for (entry
= dynamic_section
;
5804 entry
< dynamic_section
+ dynamic_nent
;
5807 switch (entry
->d_tag
)
5809 case DT_IA_64_VMS_STRTAB_OFFSET
:
5810 strtab_off
= entry
->d_un
.d_val
;
5813 strtab_sz
= entry
->d_un
.d_val
;
5815 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5816 1, strtab_sz
, _("dynamic string section"));
5819 case DT_IA_64_VMS_NEEDED_IDENT
:
5820 fixup
.needed_ident
= entry
->d_un
.d_val
;
5823 fixup
.needed
= entry
->d_un
.d_val
;
5825 case DT_IA_64_VMS_FIXUP_NEEDED
:
5826 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5828 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5829 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5831 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5832 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5834 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5837 case DT_IA_64_VMS_IMG_RELA_CNT
:
5838 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5840 case DT_IA_64_VMS_IMG_RELA_OFF
:
5841 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5843 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5863 } dynamic_relocations
[] =
5865 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5866 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5867 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5870 /* Process the reloc section. */
5873 process_relocs (FILE * file
)
5875 unsigned long rel_size
;
5876 unsigned long rel_offset
;
5882 if (do_using_dynamic
)
5886 int has_dynamic_reloc
;
5889 has_dynamic_reloc
= 0;
5891 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5893 is_rela
= dynamic_relocations
[i
].rela
;
5894 name
= dynamic_relocations
[i
].name
;
5895 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5896 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5898 has_dynamic_reloc
|= rel_size
;
5900 if (is_rela
== UNKNOWN
)
5902 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5903 switch (dynamic_info
[DT_PLTREL
])
5917 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5918 name
, rel_offset
, rel_size
);
5920 dump_relocations (file
,
5921 offset_from_vma (file
, rel_offset
, rel_size
),
5923 dynamic_symbols
, num_dynamic_syms
,
5924 dynamic_strings
, dynamic_strings_length
, is_rela
);
5929 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5931 if (! has_dynamic_reloc
)
5932 printf (_("\nThere are no dynamic relocations in this file.\n"));
5936 Elf_Internal_Shdr
* section
;
5940 for (i
= 0, section
= section_headers
;
5941 i
< elf_header
.e_shnum
;
5944 if ( section
->sh_type
!= SHT_RELA
5945 && section
->sh_type
!= SHT_REL
)
5948 rel_offset
= section
->sh_offset
;
5949 rel_size
= section
->sh_size
;
5953 Elf_Internal_Shdr
* strsec
;
5956 printf (_("\nRelocation section "));
5958 if (string_table
== NULL
)
5959 printf ("%d", section
->sh_name
);
5961 printf ("'%s'", SECTION_NAME (section
));
5963 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5964 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5966 is_rela
= section
->sh_type
== SHT_RELA
;
5968 if (section
->sh_link
!= 0
5969 && section
->sh_link
< elf_header
.e_shnum
)
5971 Elf_Internal_Shdr
* symsec
;
5972 Elf_Internal_Sym
* symtab
;
5973 unsigned long nsyms
;
5974 unsigned long strtablen
= 0;
5975 char * strtab
= NULL
;
5977 symsec
= section_headers
+ section
->sh_link
;
5978 if (symsec
->sh_type
!= SHT_SYMTAB
5979 && symsec
->sh_type
!= SHT_DYNSYM
)
5982 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5987 if (symsec
->sh_link
!= 0
5988 && symsec
->sh_link
< elf_header
.e_shnum
)
5990 strsec
= section_headers
+ symsec
->sh_link
;
5992 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5995 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5998 dump_relocations (file
, rel_offset
, rel_size
,
5999 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6005 dump_relocations (file
, rel_offset
, rel_size
,
6006 NULL
, 0, NULL
, 0, is_rela
);
6013 printf (_("\nThere are no relocations in this file.\n"));
6019 /* Process the unwind section. */
6021 #include "unwind-ia64.h"
6023 /* An absolute address consists of a section and an offset. If the
6024 section is NULL, the offset itself is the address, otherwise, the
6025 address equals to LOAD_ADDRESS(section) + offset. */
6029 unsigned short section
;
6033 #define ABSADDR(a) \
6035 ? section_headers [(a).section].sh_addr + (a).offset \
6038 struct ia64_unw_table_entry
6040 struct absaddr start
;
6042 struct absaddr info
;
6045 struct ia64_unw_aux_info
6048 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6049 unsigned long table_len
; /* Length of unwind table. */
6050 unsigned char * info
; /* Unwind info. */
6051 unsigned long info_size
; /* Size of unwind info. */
6052 bfd_vma info_addr
; /* starting address of unwind info. */
6053 bfd_vma seg_base
; /* Starting address of segment. */
6054 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6055 unsigned long nsyms
; /* Number of symbols. */
6056 char * strtab
; /* The string table. */
6057 unsigned long strtab_size
; /* Size of string table. */
6061 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6062 unsigned long nsyms
,
6063 const char * strtab
,
6064 unsigned long strtab_size
,
6065 struct absaddr addr
,
6066 const char ** symname
,
6069 bfd_vma dist
= 0x100000;
6070 Elf_Internal_Sym
* sym
;
6071 Elf_Internal_Sym
* best
= NULL
;
6074 REMOVE_ARCH_BITS (addr
.offset
);
6076 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6078 bfd_vma value
= sym
->st_value
;
6080 REMOVE_ARCH_BITS (value
);
6082 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6083 && sym
->st_name
!= 0
6084 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6085 && addr
.offset
>= value
6086 && addr
.offset
- value
< dist
)
6089 dist
= addr
.offset
- value
;
6097 *symname
= (best
->st_name
>= strtab_size
6098 ? _("<corrupt>") : strtab
+ best
->st_name
);
6104 *offset
= addr
.offset
;
6108 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6110 struct ia64_unw_table_entry
* tp
;
6113 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6117 const unsigned char * dp
;
6118 const unsigned char * head
;
6119 const char * procname
;
6121 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6122 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6124 fputs ("\n<", stdout
);
6128 fputs (procname
, stdout
);
6131 printf ("+%lx", (unsigned long) offset
);
6134 fputs (">: [", stdout
);
6135 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6136 fputc ('-', stdout
);
6137 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6138 printf ("], info at +0x%lx\n",
6139 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6141 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6142 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6144 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6145 (unsigned) UNW_VER (stamp
),
6146 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6147 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6148 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6149 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6151 if (UNW_VER (stamp
) != 1)
6153 printf (_("\tUnknown version.\n"));
6158 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6159 dp
= unw_decode (dp
, in_body
, & in_body
);
6164 slurp_ia64_unwind_table (FILE * file
,
6165 struct ia64_unw_aux_info
* aux
,
6166 Elf_Internal_Shdr
* sec
)
6168 unsigned long size
, nrelas
, i
;
6169 Elf_Internal_Phdr
* seg
;
6170 struct ia64_unw_table_entry
* tep
;
6171 Elf_Internal_Shdr
* relsec
;
6172 Elf_Internal_Rela
* rela
;
6173 Elf_Internal_Rela
* rp
;
6174 unsigned char * table
;
6176 Elf_Internal_Sym
* sym
;
6177 const char * relname
;
6179 /* First, find the starting address of the segment that includes
6182 if (elf_header
.e_phnum
)
6184 if (! get_program_headers (file
))
6187 for (seg
= program_headers
;
6188 seg
< program_headers
+ elf_header
.e_phnum
;
6191 if (seg
->p_type
!= PT_LOAD
)
6194 if (sec
->sh_addr
>= seg
->p_vaddr
6195 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6197 aux
->seg_base
= seg
->p_vaddr
;
6203 /* Second, build the unwind table from the contents of the unwind section: */
6204 size
= sec
->sh_size
;
6205 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6210 aux
->table
= (struct ia64_unw_table_entry
*)
6211 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6213 for (tp
= table
; tp
< table
+ size
; ++tep
)
6215 tep
->start
.section
= SHN_UNDEF
;
6216 tep
->end
.section
= SHN_UNDEF
;
6217 tep
->info
.section
= SHN_UNDEF
;
6218 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6219 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6220 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6221 tep
->start
.offset
+= aux
->seg_base
;
6222 tep
->end
.offset
+= aux
->seg_base
;
6223 tep
->info
.offset
+= aux
->seg_base
;
6227 /* Third, apply any relocations to the unwind table: */
6228 for (relsec
= section_headers
;
6229 relsec
< section_headers
+ elf_header
.e_shnum
;
6232 if (relsec
->sh_type
!= SHT_RELA
6233 || relsec
->sh_info
>= elf_header
.e_shnum
6234 || section_headers
+ relsec
->sh_info
!= sec
)
6237 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6241 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6243 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6244 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6246 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6248 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6252 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6254 switch (rp
->r_offset
/eh_addr_size
% 3)
6257 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6258 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6261 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6262 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6265 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6266 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6276 aux
->table_len
= size
/ (3 * eh_addr_size
);
6281 ia64_process_unwind (FILE * file
)
6283 Elf_Internal_Shdr
* sec
;
6284 Elf_Internal_Shdr
* unwsec
= NULL
;
6285 Elf_Internal_Shdr
* strsec
;
6286 unsigned long i
, unwcount
= 0, unwstart
= 0;
6287 struct ia64_unw_aux_info aux
;
6289 memset (& aux
, 0, sizeof (aux
));
6291 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6293 if (sec
->sh_type
== SHT_SYMTAB
6294 && sec
->sh_link
< elf_header
.e_shnum
)
6296 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6298 strsec
= section_headers
+ sec
->sh_link
;
6299 assert (aux
.strtab
== NULL
);
6300 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6303 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6305 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6310 printf (_("\nThere are no unwind sections in this file.\n"));
6312 while (unwcount
-- > 0)
6317 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6318 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6319 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6326 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6328 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6330 /* We need to find which section group it is in. */
6331 struct group_list
* g
= section_headers_groups
[i
]->root
;
6333 for (; g
!= NULL
; g
= g
->next
)
6335 sec
= section_headers
+ g
->section_index
;
6337 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6342 i
= elf_header
.e_shnum
;
6344 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6346 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6347 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6348 suffix
= SECTION_NAME (unwsec
) + len
;
6349 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6351 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6352 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6357 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6358 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6359 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6360 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6362 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6363 suffix
= SECTION_NAME (unwsec
) + len
;
6364 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6366 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6367 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6371 if (i
== elf_header
.e_shnum
)
6373 printf (_("\nCould not find unwind info section for "));
6375 if (string_table
== NULL
)
6376 printf ("%d", unwsec
->sh_name
);
6378 printf (_("'%s'"), SECTION_NAME (unwsec
));
6382 aux
.info_addr
= sec
->sh_addr
;
6383 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6386 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6388 printf (_("\nUnwind section "));
6390 if (string_table
== NULL
)
6391 printf ("%d", unwsec
->sh_name
);
6393 printf (_("'%s'"), SECTION_NAME (unwsec
));
6395 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6396 (unsigned long) unwsec
->sh_offset
,
6397 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6399 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6401 if (aux
.table_len
> 0)
6402 dump_ia64_unwind (& aux
);
6405 free ((char *) aux
.table
);
6407 free ((char *) aux
.info
);
6416 free ((char *) aux
.strtab
);
6419 struct hppa_unw_table_entry
6421 struct absaddr start
;
6423 unsigned int Cannot_unwind
:1; /* 0 */
6424 unsigned int Millicode
:1; /* 1 */
6425 unsigned int Millicode_save_sr0
:1; /* 2 */
6426 unsigned int Region_description
:2; /* 3..4 */
6427 unsigned int reserved1
:1; /* 5 */
6428 unsigned int Entry_SR
:1; /* 6 */
6429 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6430 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6431 unsigned int Args_stored
:1; /* 16 */
6432 unsigned int Variable_Frame
:1; /* 17 */
6433 unsigned int Separate_Package_Body
:1; /* 18 */
6434 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6435 unsigned int Stack_Overflow_Check
:1; /* 20 */
6436 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6437 unsigned int Ada_Region
:1; /* 22 */
6438 unsigned int cxx_info
:1; /* 23 */
6439 unsigned int cxx_try_catch
:1; /* 24 */
6440 unsigned int sched_entry_seq
:1; /* 25 */
6441 unsigned int reserved2
:1; /* 26 */
6442 unsigned int Save_SP
:1; /* 27 */
6443 unsigned int Save_RP
:1; /* 28 */
6444 unsigned int Save_MRP_in_frame
:1; /* 29 */
6445 unsigned int extn_ptr_defined
:1; /* 30 */
6446 unsigned int Cleanup_defined
:1; /* 31 */
6448 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6449 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6450 unsigned int Large_frame
:1; /* 2 */
6451 unsigned int Pseudo_SP_Set
:1; /* 3 */
6452 unsigned int reserved4
:1; /* 4 */
6453 unsigned int Total_frame_size
:27; /* 5..31 */
6456 struct hppa_unw_aux_info
6458 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6459 unsigned long table_len
; /* Length of unwind table. */
6460 bfd_vma seg_base
; /* Starting address of segment. */
6461 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6462 unsigned long nsyms
; /* Number of symbols. */
6463 char * strtab
; /* The string table. */
6464 unsigned long strtab_size
; /* Size of string table. */
6468 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6470 struct hppa_unw_table_entry
* tp
;
6472 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6475 const char * procname
;
6477 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6478 aux
->strtab_size
, tp
->start
, &procname
,
6481 fputs ("\n<", stdout
);
6485 fputs (procname
, stdout
);
6488 printf ("+%lx", (unsigned long) offset
);
6491 fputs (">: [", stdout
);
6492 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6493 fputc ('-', stdout
);
6494 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6497 #define PF(_m) if (tp->_m) printf (#_m " ");
6498 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6501 PF(Millicode_save_sr0
);
6502 /* PV(Region_description); */
6508 PF(Separate_Package_Body
);
6509 PF(Frame_Extension_Millicode
);
6510 PF(Stack_Overflow_Check
);
6511 PF(Two_Instruction_SP_Increment
);
6515 PF(sched_entry_seq
);
6518 PF(Save_MRP_in_frame
);
6519 PF(extn_ptr_defined
);
6520 PF(Cleanup_defined
);
6521 PF(MPE_XL_interrupt_marker
);
6522 PF(HP_UX_interrupt_marker
);
6525 PV(Total_frame_size
);
6534 slurp_hppa_unwind_table (FILE * file
,
6535 struct hppa_unw_aux_info
* aux
,
6536 Elf_Internal_Shdr
* sec
)
6538 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6539 Elf_Internal_Phdr
* seg
;
6540 struct hppa_unw_table_entry
* tep
;
6541 Elf_Internal_Shdr
* relsec
;
6542 Elf_Internal_Rela
* rela
;
6543 Elf_Internal_Rela
* rp
;
6544 unsigned char * table
;
6546 Elf_Internal_Sym
* sym
;
6547 const char * relname
;
6549 /* First, find the starting address of the segment that includes
6552 if (elf_header
.e_phnum
)
6554 if (! get_program_headers (file
))
6557 for (seg
= program_headers
;
6558 seg
< program_headers
+ elf_header
.e_phnum
;
6561 if (seg
->p_type
!= PT_LOAD
)
6564 if (sec
->sh_addr
>= seg
->p_vaddr
6565 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6567 aux
->seg_base
= seg
->p_vaddr
;
6573 /* Second, build the unwind table from the contents of the unwind
6575 size
= sec
->sh_size
;
6576 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6582 nentries
= size
/ unw_ent_size
;
6583 size
= unw_ent_size
* nentries
;
6585 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6586 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6588 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6590 unsigned int tmp1
, tmp2
;
6592 tep
->start
.section
= SHN_UNDEF
;
6593 tep
->end
.section
= SHN_UNDEF
;
6595 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6596 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6597 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6598 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6600 tep
->start
.offset
+= aux
->seg_base
;
6601 tep
->end
.offset
+= aux
->seg_base
;
6603 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6604 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6605 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6606 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6607 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6608 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6609 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6610 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6611 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6612 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6613 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6614 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6615 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6616 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6617 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6618 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6619 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6620 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6621 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6622 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6623 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6624 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6625 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6626 tep
->Cleanup_defined
= tmp1
& 0x1;
6628 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6629 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6630 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6631 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6632 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6633 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6637 /* Third, apply any relocations to the unwind table. */
6638 for (relsec
= section_headers
;
6639 relsec
< section_headers
+ elf_header
.e_shnum
;
6642 if (relsec
->sh_type
!= SHT_RELA
6643 || relsec
->sh_info
>= elf_header
.e_shnum
6644 || section_headers
+ relsec
->sh_info
!= sec
)
6647 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6651 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6653 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6654 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6656 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6657 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6659 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6663 i
= rp
->r_offset
/ unw_ent_size
;
6665 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6668 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6669 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6672 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6673 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6683 aux
->table_len
= nentries
;
6689 hppa_process_unwind (FILE * file
)
6691 struct hppa_unw_aux_info aux
;
6692 Elf_Internal_Shdr
* unwsec
= NULL
;
6693 Elf_Internal_Shdr
* strsec
;
6694 Elf_Internal_Shdr
* sec
;
6697 if (string_table
== NULL
)
6700 memset (& aux
, 0, sizeof (aux
));
6702 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6704 if (sec
->sh_type
== SHT_SYMTAB
6705 && sec
->sh_link
< elf_header
.e_shnum
)
6707 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6709 strsec
= section_headers
+ sec
->sh_link
;
6710 assert (aux
.strtab
== NULL
);
6711 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6714 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6716 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6721 printf (_("\nThere are no unwind sections in this file.\n"));
6723 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6725 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6727 printf (_("\nUnwind section "));
6728 printf (_("'%s'"), SECTION_NAME (sec
));
6730 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6731 (unsigned long) sec
->sh_offset
,
6732 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6734 slurp_hppa_unwind_table (file
, &aux
, sec
);
6735 if (aux
.table_len
> 0)
6736 dump_hppa_unwind (&aux
);
6739 free ((char *) aux
.table
);
6747 free ((char *) aux
.strtab
);
6752 unsigned char * data
; /* The unwind data. */
6753 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6754 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6755 unsigned long nrelas
; /* The number of relocations. */
6756 unsigned int rel_type
; /* REL or RELA ? */
6757 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6760 struct arm_unw_aux_info
6762 FILE * file
; /* The file containing the unwind sections. */
6763 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6764 unsigned long nsyms
; /* Number of symbols. */
6765 char * strtab
; /* The file's string table. */
6766 unsigned long strtab_size
; /* Size of string table. */
6770 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6771 bfd_vma fn
, struct absaddr addr
)
6773 const char *procname
;
6776 if (addr
.section
== SHN_UNDEF
)
6779 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6780 aux
->strtab_size
, addr
, &procname
,
6783 print_vma (fn
, PREFIX_HEX
);
6787 fputs (" <", stdout
);
6788 fputs (procname
, stdout
);
6791 printf ("+0x%lx", (unsigned long) sym_offset
);
6792 fputc ('>', stdout
);
6799 arm_free_section (struct arm_section
*arm_sec
)
6801 if (arm_sec
->data
!= NULL
)
6802 free (arm_sec
->data
);
6804 if (arm_sec
->rela
!= NULL
)
6805 free (arm_sec
->rela
);
6808 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6809 cached section and install SEC instead.
6810 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6811 and return its valued in * WORDP, relocating if necessary.
6812 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6813 relocation's offset in ADDR.
6814 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6815 into the string table of the symbol associated with the reloc. If no
6816 reloc was applied store -1 there.
6817 5) Return TRUE upon success, FALSE otherwise. */
6820 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6821 struct arm_section
* arm_sec
,
6822 Elf_Internal_Shdr
* sec
,
6823 bfd_vma word_offset
,
6824 unsigned int * wordp
,
6825 struct absaddr
* addr
,
6828 Elf_Internal_Rela
*rp
;
6829 Elf_Internal_Sym
*sym
;
6830 const char * relname
;
6832 bfd_boolean wrapped
;
6834 addr
->section
= SHN_UNDEF
;
6837 if (sym_name
!= NULL
)
6838 *sym_name
= (bfd_vma
) -1;
6840 /* If necessary, update the section cache. */
6841 if (sec
!= arm_sec
->sec
)
6843 Elf_Internal_Shdr
*relsec
;
6845 arm_free_section (arm_sec
);
6848 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6849 sec
->sh_size
, _("unwind data"));
6850 arm_sec
->rela
= NULL
;
6851 arm_sec
->nrelas
= 0;
6853 for (relsec
= section_headers
;
6854 relsec
< section_headers
+ elf_header
.e_shnum
;
6857 if (relsec
->sh_info
>= elf_header
.e_shnum
6858 || section_headers
+ relsec
->sh_info
!= sec
6859 /* PR 15745: Check the section type as well. */
6860 || (relsec
->sh_type
!= SHT_REL
6861 && relsec
->sh_type
!= SHT_RELA
))
6864 arm_sec
->rel_type
= relsec
->sh_type
;
6865 if (relsec
->sh_type
== SHT_REL
)
6867 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6869 & arm_sec
->rela
, & arm_sec
->nrelas
))
6872 else /* relsec->sh_type == SHT_RELA */
6874 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6876 & arm_sec
->rela
, & arm_sec
->nrelas
))
6882 arm_sec
->next_rela
= arm_sec
->rela
;
6885 /* If there is no unwind data we can do nothing. */
6886 if (arm_sec
->data
== NULL
)
6889 /* Get the word at the required offset. */
6890 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6892 /* Look through the relocs to find the one that applies to the provided offset. */
6894 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6896 bfd_vma prelval
, offset
;
6898 if (rp
->r_offset
> word_offset
&& !wrapped
)
6903 if (rp
->r_offset
> word_offset
)
6906 if (rp
->r_offset
& 3)
6908 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6909 (unsigned long) rp
->r_offset
);
6913 if (rp
->r_offset
< word_offset
)
6916 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6918 if (arm_sec
->rel_type
== SHT_REL
)
6920 offset
= word
& 0x7fffffff;
6921 if (offset
& 0x40000000)
6922 offset
|= ~ (bfd_vma
) 0x7fffffff;
6924 else if (arm_sec
->rel_type
== SHT_RELA
)
6925 offset
= rp
->r_addend
;
6929 offset
+= sym
->st_value
;
6930 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6932 /* Check that we are processing the expected reloc type. */
6933 if (elf_header
.e_machine
== EM_ARM
)
6935 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6937 if (streq (relname
, "R_ARM_NONE"))
6940 if (! streq (relname
, "R_ARM_PREL31"))
6942 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6946 else if (elf_header
.e_machine
== EM_TI_C6000
)
6948 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6950 if (streq (relname
, "R_C6000_NONE"))
6953 if (! streq (relname
, "R_C6000_PREL31"))
6955 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6962 /* This function currently only supports ARM and TI unwinders. */
6965 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6966 addr
->section
= sym
->st_shndx
;
6967 addr
->offset
= offset
;
6969 * sym_name
= sym
->st_name
;
6974 arm_sec
->next_rela
= rp
;
6979 static const char *tic6x_unwind_regnames
[16] =
6981 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6982 "A14", "A13", "A12", "A11", "A10",
6983 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6987 decode_tic6x_unwind_regmask (unsigned int mask
)
6991 for (i
= 12; mask
; mask
>>= 1, i
--)
6995 fputs (tic6x_unwind_regnames
[i
], stdout
);
6997 fputs (", ", stdout
);
7003 if (remaining == 0 && more_words) \
7006 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7007 data_offset, & word, & addr, NULL)) \
7013 #define GET_OP(OP) \
7018 (OP) = word >> 24; \
7023 printf (_("[Truncated opcode]\n")); \
7026 printf ("0x%02x ", OP)
7029 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7030 unsigned int word
, unsigned int remaining
,
7031 unsigned int more_words
,
7032 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7033 struct arm_section
*data_arm_sec
)
7035 struct absaddr addr
;
7037 /* Decode the unwinding instructions. */
7040 unsigned int op
, op2
;
7049 printf (" 0x%02x ", op
);
7051 if ((op
& 0xc0) == 0x00)
7053 int offset
= ((op
& 0x3f) << 2) + 4;
7055 printf (" vsp = vsp + %d", offset
);
7057 else if ((op
& 0xc0) == 0x40)
7059 int offset
= ((op
& 0x3f) << 2) + 4;
7061 printf (" vsp = vsp - %d", offset
);
7063 else if ((op
& 0xf0) == 0x80)
7066 if (op
== 0x80 && op2
== 0)
7067 printf (_("Refuse to unwind"));
7070 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7075 for (i
= 0; i
< 12; i
++)
7076 if (mask
& (1 << i
))
7082 printf ("r%d", 4 + i
);
7087 else if ((op
& 0xf0) == 0x90)
7089 if (op
== 0x9d || op
== 0x9f)
7090 printf (_(" [Reserved]"));
7092 printf (" vsp = r%d", op
& 0x0f);
7094 else if ((op
& 0xf0) == 0xa0)
7096 int end
= 4 + (op
& 0x07);
7101 for (i
= 4; i
<= end
; i
++)
7117 else if (op
== 0xb0)
7118 printf (_(" finish"));
7119 else if (op
== 0xb1)
7122 if (op2
== 0 || (op2
& 0xf0) != 0)
7123 printf (_("[Spare]"));
7126 unsigned int mask
= op2
& 0x0f;
7131 for (i
= 0; i
< 12; i
++)
7132 if (mask
& (1 << i
))
7143 else if (op
== 0xb2)
7145 unsigned char buf
[9];
7146 unsigned int i
, len
;
7147 unsigned long offset
;
7149 for (i
= 0; i
< sizeof (buf
); i
++)
7152 if ((buf
[i
] & 0x80) == 0)
7155 assert (i
< sizeof (buf
));
7156 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7157 assert (len
== i
+ 1);
7158 offset
= offset
* 4 + 0x204;
7159 printf ("vsp = vsp + %ld", offset
);
7161 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7163 unsigned int first
, last
;
7170 printf ("pop {D%d", first
);
7172 printf ("-D%d", first
+ last
);
7175 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7177 unsigned int count
= op
& 0x07;
7181 printf ("-D%d", 8 + count
);
7184 else if (op
>= 0xc0 && op
<= 0xc5)
7186 unsigned int count
= op
& 0x07;
7188 printf (" pop {wR10");
7190 printf ("-wR%d", 10 + count
);
7193 else if (op
== 0xc6)
7195 unsigned int first
, last
;
7200 printf ("pop {wR%d", first
);
7202 printf ("-wR%d", first
+ last
);
7205 else if (op
== 0xc7)
7208 if (op2
== 0 || (op2
& 0xf0) != 0)
7209 printf (_("[Spare]"));
7212 unsigned int mask
= op2
& 0x0f;
7217 for (i
= 0; i
< 4; i
++)
7218 if (mask
& (1 << i
))
7224 printf ("wCGR%d", i
);
7230 printf (_(" [unsupported opcode]"));
7236 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7237 unsigned int word
, unsigned int remaining
,
7238 unsigned int more_words
,
7239 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7240 struct arm_section
*data_arm_sec
)
7242 struct absaddr addr
;
7244 /* Decode the unwinding instructions. */
7247 unsigned int op
, op2
;
7256 printf (" 0x%02x ", op
);
7258 if ((op
& 0xc0) == 0x00)
7260 int offset
= ((op
& 0x3f) << 3) + 8;
7261 printf (" sp = sp + %d", offset
);
7263 else if ((op
& 0xc0) == 0x80)
7266 if (op
== 0x80 && op2
== 0)
7267 printf (_("Refuse to unwind"));
7270 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7272 printf ("pop compact {");
7276 decode_tic6x_unwind_regmask (mask
);
7280 else if ((op
& 0xf0) == 0xc0)
7288 unsigned int offset
;
7292 /* Scan entire instruction first so that GET_OP output is not
7293 interleaved with disassembly. */
7295 for (i
= 0; nregs
< (op
& 0xf); i
++)
7301 regpos
[nregs
].offset
= i
* 2;
7302 regpos
[nregs
].reg
= reg
;
7309 regpos
[nregs
].offset
= i
* 2 + 1;
7310 regpos
[nregs
].reg
= reg
;
7315 printf (_("pop frame {"));
7317 for (i
= i
* 2; i
> 0; i
--)
7319 if (regpos
[reg
].offset
== i
- 1)
7321 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7328 fputs (name
, stdout
);
7335 else if (op
== 0xd0)
7336 printf (" MOV FP, SP");
7337 else if (op
== 0xd1)
7338 printf (" __c6xabi_pop_rts");
7339 else if (op
== 0xd2)
7341 unsigned char buf
[9];
7342 unsigned int i
, len
;
7343 unsigned long offset
;
7345 for (i
= 0; i
< sizeof (buf
); i
++)
7348 if ((buf
[i
] & 0x80) == 0)
7351 assert (i
< sizeof (buf
));
7352 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7353 assert (len
== i
+ 1);
7354 offset
= offset
* 8 + 0x408;
7355 printf (_("sp = sp + %ld"), offset
);
7357 else if ((op
& 0xf0) == 0xe0)
7359 if ((op
& 0x0f) == 7)
7362 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7366 printf (_(" [unsupported opcode]"));
7373 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7377 offset
= word
& 0x7fffffff;
7378 if (offset
& 0x40000000)
7379 offset
|= ~ (bfd_vma
) 0x7fffffff;
7381 if (elf_header
.e_machine
== EM_TI_C6000
)
7384 return offset
+ where
;
7388 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7390 unsigned int remaining
,
7391 bfd_vma data_offset
,
7392 Elf_Internal_Shdr
* data_sec
,
7393 struct arm_section
* data_arm_sec
)
7396 unsigned int more_words
= 0;
7397 struct absaddr addr
;
7398 bfd_vma sym_name
= (bfd_vma
) -1;
7402 /* Fetch the first word.
7403 Note - when decoding an object file the address extracted
7404 here will always be 0. So we also pass in the sym_name
7405 parameter so that we can find the symbol associated with
7406 the personality routine. */
7407 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7408 & word
, & addr
, & sym_name
))
7414 if ((word
& 0x80000000) == 0)
7416 /* Expand prel31 for personality routine. */
7418 const char *procname
;
7420 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7421 printf (_(" Personality routine: "));
7423 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7424 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7426 procname
= aux
->strtab
+ sym_name
;
7427 print_vma (fn
, PREFIX_HEX
);
7430 fputs (" <", stdout
);
7431 fputs (procname
, stdout
);
7432 fputc ('>', stdout
);
7436 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7437 fputc ('\n', stdout
);
7439 /* The GCC personality routines use the standard compact
7440 encoding, starting with one byte giving the number of
7442 if (procname
!= NULL
7443 && (const_strneq (procname
, "__gcc_personality_v0")
7444 || const_strneq (procname
, "__gxx_personality_v0")
7445 || const_strneq (procname
, "__gcj_personality_v0")
7446 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7453 printf (_(" [Truncated data]\n"));
7456 more_words
= word
>> 24;
7466 /* ARM EHABI Section 6.3:
7468 An exception-handling table entry for the compact model looks like:
7472 1 0 index Data for personalityRoutine[index] */
7474 if (elf_header
.e_machine
== EM_ARM
7475 && (word
& 0x70000000))
7476 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7478 per_index
= (word
>> 24) & 0x7f;
7479 printf (_(" Compact model index: %d\n"), per_index
);
7486 else if (per_index
< 3)
7488 more_words
= (word
>> 16) & 0xff;
7494 switch (elf_header
.e_machine
)
7499 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7500 data_offset
, data_sec
, data_arm_sec
);
7504 warn (_("Unknown ARM compact model index encountered\n"));
7505 printf (_(" [reserved]\n"));
7512 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7513 data_offset
, data_sec
, data_arm_sec
);
7515 else if (per_index
< 5)
7517 if (((word
>> 17) & 0x7f) == 0x7f)
7518 printf (_(" Restore stack from frame pointer\n"));
7520 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7521 printf (_(" Registers restored: "));
7523 printf (" (compact) ");
7524 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7526 printf (_(" Return register: %s\n"),
7527 tic6x_unwind_regnames
[word
& 0xf]);
7530 printf (_(" [reserved (%d)]\n"), per_index
);
7534 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7535 elf_header
.e_machine
);
7538 /* Decode the descriptors. Not implemented. */
7542 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7544 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7545 unsigned int i
, exidx_len
;
7547 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7548 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7549 exidx_len
= exidx_sec
->sh_size
/ 8;
7551 for (i
= 0; i
< exidx_len
; i
++)
7553 unsigned int exidx_fn
, exidx_entry
;
7554 struct absaddr fn_addr
, entry_addr
;
7557 fputc ('\n', stdout
);
7559 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7560 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7561 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7562 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7564 arm_free_section (& exidx_arm_sec
);
7565 arm_free_section (& extab_arm_sec
);
7569 /* ARM EHABI, Section 5:
7570 An index table entry consists of 2 words.
7571 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7572 if (exidx_fn
& 0x80000000)
7573 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7575 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7577 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7578 fputs (": ", stdout
);
7580 if (exidx_entry
== 1)
7582 print_vma (exidx_entry
, PREFIX_HEX
);
7583 fputs (" [cantunwind]\n", stdout
);
7585 else if (exidx_entry
& 0x80000000)
7587 print_vma (exidx_entry
, PREFIX_HEX
);
7588 fputc ('\n', stdout
);
7589 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7593 bfd_vma table
, table_offset
= 0;
7594 Elf_Internal_Shdr
*table_sec
;
7596 fputs ("@", stdout
);
7597 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7598 print_vma (table
, PREFIX_HEX
);
7601 /* Locate the matching .ARM.extab. */
7602 if (entry_addr
.section
!= SHN_UNDEF
7603 && entry_addr
.section
< elf_header
.e_shnum
)
7605 table_sec
= section_headers
+ entry_addr
.section
;
7606 table_offset
= entry_addr
.offset
;
7610 table_sec
= find_section_by_address (table
);
7611 if (table_sec
!= NULL
)
7612 table_offset
= table
- table_sec
->sh_addr
;
7614 if (table_sec
== NULL
)
7616 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7617 (unsigned long) table
);
7620 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7627 arm_free_section (&exidx_arm_sec
);
7628 arm_free_section (&extab_arm_sec
);
7631 /* Used for both ARM and C6X unwinding tables. */
7634 arm_process_unwind (FILE *file
)
7636 struct arm_unw_aux_info aux
;
7637 Elf_Internal_Shdr
*unwsec
= NULL
;
7638 Elf_Internal_Shdr
*strsec
;
7639 Elf_Internal_Shdr
*sec
;
7641 unsigned int sec_type
;
7643 switch (elf_header
.e_machine
)
7646 sec_type
= SHT_ARM_EXIDX
;
7650 sec_type
= SHT_C6000_UNWIND
;
7654 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7655 elf_header
.e_machine
);
7659 if (string_table
== NULL
)
7662 memset (& aux
, 0, sizeof (aux
));
7665 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7667 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7669 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7671 strsec
= section_headers
+ sec
->sh_link
;
7672 assert (aux
.strtab
== NULL
);
7673 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7674 1, strsec
->sh_size
, _("string table"));
7675 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7677 else if (sec
->sh_type
== sec_type
)
7682 printf (_("\nThere are no unwind sections in this file.\n"));
7684 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7686 if (sec
->sh_type
== sec_type
)
7688 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7690 (unsigned long) sec
->sh_offset
,
7691 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7693 dump_arm_unwind (&aux
, sec
);
7700 free ((char *) aux
.strtab
);
7704 process_unwind (FILE * file
)
7706 struct unwind_handler
7709 void (* handler
)(FILE *);
7712 { EM_ARM
, arm_process_unwind
},
7713 { EM_IA_64
, ia64_process_unwind
},
7714 { EM_PARISC
, hppa_process_unwind
},
7715 { EM_TI_C6000
, arm_process_unwind
},
7723 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7724 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7726 handlers
[i
].handler (file
);
7730 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7731 get_machine_name (elf_header
.e_machine
));
7735 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7737 switch (entry
->d_tag
)
7740 if (entry
->d_un
.d_val
== 0)
7744 static const char * opts
[] =
7746 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7747 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7748 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7749 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7755 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7756 if (entry
->d_un
.d_val
& (1 << cnt
))
7758 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7764 case DT_MIPS_IVERSION
:
7765 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7766 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7768 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7771 case DT_MIPS_TIME_STAMP
:
7776 time_t atime
= entry
->d_un
.d_val
;
7777 tmp
= gmtime (&atime
);
7778 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7779 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7780 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7781 printf (_("Time Stamp: %s"), timebuf
);
7785 case DT_MIPS_RLD_VERSION
:
7786 case DT_MIPS_LOCAL_GOTNO
:
7787 case DT_MIPS_CONFLICTNO
:
7788 case DT_MIPS_LIBLISTNO
:
7789 case DT_MIPS_SYMTABNO
:
7790 case DT_MIPS_UNREFEXTNO
:
7791 case DT_MIPS_HIPAGENO
:
7792 case DT_MIPS_DELTA_CLASS_NO
:
7793 case DT_MIPS_DELTA_INSTANCE_NO
:
7794 case DT_MIPS_DELTA_RELOC_NO
:
7795 case DT_MIPS_DELTA_SYM_NO
:
7796 case DT_MIPS_DELTA_CLASSSYM_NO
:
7797 case DT_MIPS_COMPACT_SIZE
:
7798 print_vma (entry
->d_un
.d_ptr
, DEC
);
7802 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7808 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7810 switch (entry
->d_tag
)
7812 case DT_HP_DLD_FLAGS
:
7821 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7822 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7823 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7824 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7825 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7826 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7827 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7828 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7829 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7830 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7831 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7832 { DT_HP_GST
, "HP_GST" },
7833 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7834 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7835 { DT_HP_NODELETE
, "HP_NODELETE" },
7836 { DT_HP_GROUP
, "HP_GROUP" },
7837 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7841 bfd_vma val
= entry
->d_un
.d_val
;
7843 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7844 if (val
& flags
[cnt
].bit
)
7848 fputs (flags
[cnt
].str
, stdout
);
7850 val
^= flags
[cnt
].bit
;
7853 if (val
!= 0 || first
)
7857 print_vma (val
, HEX
);
7863 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7871 /* VMS vs Unix time offset and factor. */
7873 #define VMS_EPOCH_OFFSET 35067168000000000LL
7874 #define VMS_GRANULARITY_FACTOR 10000000
7876 /* Display a VMS time in a human readable format. */
7879 print_vms_time (bfd_int64_t vmstime
)
7884 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7885 tm
= gmtime (&unxtime
);
7886 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7887 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7888 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7893 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7895 switch (entry
->d_tag
)
7897 case DT_IA_64_PLT_RESERVE
:
7898 /* First 3 slots reserved. */
7899 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7901 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7904 case DT_IA_64_VMS_LINKTIME
:
7906 print_vms_time (entry
->d_un
.d_val
);
7910 case DT_IA_64_VMS_LNKFLAGS
:
7911 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7912 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7913 printf (" CALL_DEBUG");
7914 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7915 printf (" NOP0BUFS");
7916 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7917 printf (" P0IMAGE");
7918 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7919 printf (" MKTHREADS");
7920 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7921 printf (" UPCALLS");
7922 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7924 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7925 printf (" INITIALIZE");
7926 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7928 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7929 printf (" EXE_INIT");
7930 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7931 printf (" TBK_IN_IMG");
7932 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7933 printf (" DBG_IN_IMG");
7934 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7935 printf (" TBK_IN_DSF");
7936 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7937 printf (" DBG_IN_DSF");
7938 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7939 printf (" SIGNATURES");
7940 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7941 printf (" REL_SEG_OFF");
7945 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7952 get_32bit_dynamic_section (FILE * file
)
7954 Elf32_External_Dyn
* edyn
;
7955 Elf32_External_Dyn
* ext
;
7956 Elf_Internal_Dyn
* entry
;
7958 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7959 dynamic_size
, _("dynamic section"));
7963 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7964 might not have the luxury of section headers. Look for the DT_NULL
7965 terminator to determine the number of entries. */
7966 for (ext
= edyn
, dynamic_nent
= 0;
7967 (char *) ext
< (char *) edyn
+ dynamic_size
;
7971 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7975 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7977 if (dynamic_section
== NULL
)
7979 error (_("Out of memory\n"));
7984 for (ext
= edyn
, entry
= dynamic_section
;
7985 entry
< dynamic_section
+ dynamic_nent
;
7988 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7989 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7998 get_64bit_dynamic_section (FILE * file
)
8000 Elf64_External_Dyn
* edyn
;
8001 Elf64_External_Dyn
* ext
;
8002 Elf_Internal_Dyn
* entry
;
8004 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8005 dynamic_size
, _("dynamic section"));
8009 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8010 might not have the luxury of section headers. Look for the DT_NULL
8011 terminator to determine the number of entries. */
8012 for (ext
= edyn
, dynamic_nent
= 0;
8013 (char *) ext
< (char *) edyn
+ dynamic_size
;
8017 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8021 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8023 if (dynamic_section
== NULL
)
8025 error (_("Out of memory\n"));
8030 for (ext
= edyn
, entry
= dynamic_section
;
8031 entry
< dynamic_section
+ dynamic_nent
;
8034 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8035 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8044 print_dynamic_flags (bfd_vma flags
)
8052 flag
= flags
& - flags
;
8062 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8063 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8064 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8065 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8066 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8067 default: fputs (_("unknown"), stdout
); break;
8073 /* Parse and display the contents of the dynamic section. */
8076 process_dynamic_section (FILE * file
)
8078 Elf_Internal_Dyn
* entry
;
8080 if (dynamic_size
== 0)
8083 printf (_("\nThere is no dynamic section in this file.\n"));
8090 if (! get_32bit_dynamic_section (file
))
8093 else if (! get_64bit_dynamic_section (file
))
8096 /* Find the appropriate symbol table. */
8097 if (dynamic_symbols
== NULL
)
8099 for (entry
= dynamic_section
;
8100 entry
< dynamic_section
+ dynamic_nent
;
8103 Elf_Internal_Shdr section
;
8105 if (entry
->d_tag
!= DT_SYMTAB
)
8108 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8110 /* Since we do not know how big the symbol table is,
8111 we default to reading in the entire file (!) and
8112 processing that. This is overkill, I know, but it
8114 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8116 if (archive_file_offset
!= 0)
8117 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8120 if (fseek (file
, 0, SEEK_END
))
8121 error (_("Unable to seek to end of file!\n"));
8123 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8127 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8129 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8131 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8132 if (num_dynamic_syms
< 1)
8134 error (_("Unable to determine the number of symbols to load\n"));
8140 /* Similarly find a string table. */
8141 if (dynamic_strings
== NULL
)
8143 for (entry
= dynamic_section
;
8144 entry
< dynamic_section
+ dynamic_nent
;
8147 unsigned long offset
;
8150 if (entry
->d_tag
!= DT_STRTAB
)
8153 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8155 /* Since we do not know how big the string table is,
8156 we default to reading in the entire file (!) and
8157 processing that. This is overkill, I know, but it
8160 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8162 if (archive_file_offset
!= 0)
8163 str_tab_len
= archive_file_size
- offset
;
8166 if (fseek (file
, 0, SEEK_END
))
8167 error (_("Unable to seek to end of file\n"));
8168 str_tab_len
= ftell (file
) - offset
;
8171 if (str_tab_len
< 1)
8174 (_("Unable to determine the length of the dynamic string table\n"));
8178 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8180 _("dynamic string table"));
8181 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8186 /* And find the syminfo section if available. */
8187 if (dynamic_syminfo
== NULL
)
8189 unsigned long syminsz
= 0;
8191 for (entry
= dynamic_section
;
8192 entry
< dynamic_section
+ dynamic_nent
;
8195 if (entry
->d_tag
== DT_SYMINENT
)
8197 /* Note: these braces are necessary to avoid a syntax
8198 error from the SunOS4 C compiler. */
8199 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
8201 else if (entry
->d_tag
== DT_SYMINSZ
)
8202 syminsz
= entry
->d_un
.d_val
;
8203 else if (entry
->d_tag
== DT_SYMINFO
)
8204 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8208 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8210 Elf_External_Syminfo
* extsyminfo
;
8211 Elf_External_Syminfo
* extsym
;
8212 Elf_Internal_Syminfo
* syminfo
;
8214 /* There is a syminfo section. Read the data. */
8215 extsyminfo
= (Elf_External_Syminfo
*)
8216 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8217 _("symbol information"));
8221 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8222 if (dynamic_syminfo
== NULL
)
8224 error (_("Out of memory\n"));
8228 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8229 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8230 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8231 ++syminfo
, ++extsym
)
8233 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8234 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8241 if (do_dynamic
&& dynamic_addr
)
8242 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8243 dynamic_addr
, dynamic_nent
);
8245 printf (_(" Tag Type Name/Value\n"));
8247 for (entry
= dynamic_section
;
8248 entry
< dynamic_section
+ dynamic_nent
;
8256 print_vma (entry
->d_tag
, FULL_HEX
);
8257 dtype
= get_dynamic_type (entry
->d_tag
);
8258 printf (" (%s)%*s", dtype
,
8259 ((is_32bit_elf
? 27 : 19)
8260 - (int) strlen (dtype
)),
8264 switch (entry
->d_tag
)
8268 print_dynamic_flags (entry
->d_un
.d_val
);
8278 switch (entry
->d_tag
)
8281 printf (_("Auxiliary library"));
8285 printf (_("Filter library"));
8289 printf (_("Configuration file"));
8293 printf (_("Dependency audit library"));
8297 printf (_("Audit library"));
8301 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8302 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8306 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8315 printf (_("Flags:"));
8317 if (entry
->d_un
.d_val
== 0)
8318 printf (_(" None\n"));
8321 unsigned long int val
= entry
->d_un
.d_val
;
8323 if (val
& DTF_1_PARINIT
)
8325 printf (" PARINIT");
8326 val
^= DTF_1_PARINIT
;
8328 if (val
& DTF_1_CONFEXP
)
8330 printf (" CONFEXP");
8331 val
^= DTF_1_CONFEXP
;
8334 printf (" %lx", val
);
8343 printf (_("Flags:"));
8345 if (entry
->d_un
.d_val
== 0)
8346 printf (_(" None\n"));
8349 unsigned long int val
= entry
->d_un
.d_val
;
8351 if (val
& DF_P1_LAZYLOAD
)
8353 printf (" LAZYLOAD");
8354 val
^= DF_P1_LAZYLOAD
;
8356 if (val
& DF_P1_GROUPPERM
)
8358 printf (" GROUPPERM");
8359 val
^= DF_P1_GROUPPERM
;
8362 printf (" %lx", val
);
8371 printf (_("Flags:"));
8372 if (entry
->d_un
.d_val
== 0)
8373 printf (_(" None\n"));
8376 unsigned long int val
= entry
->d_un
.d_val
;
8383 if (val
& DF_1_GLOBAL
)
8388 if (val
& DF_1_GROUP
)
8393 if (val
& DF_1_NODELETE
)
8395 printf (" NODELETE");
8396 val
^= DF_1_NODELETE
;
8398 if (val
& DF_1_LOADFLTR
)
8400 printf (" LOADFLTR");
8401 val
^= DF_1_LOADFLTR
;
8403 if (val
& DF_1_INITFIRST
)
8405 printf (" INITFIRST");
8406 val
^= DF_1_INITFIRST
;
8408 if (val
& DF_1_NOOPEN
)
8413 if (val
& DF_1_ORIGIN
)
8418 if (val
& DF_1_DIRECT
)
8423 if (val
& DF_1_TRANS
)
8428 if (val
& DF_1_INTERPOSE
)
8430 printf (" INTERPOSE");
8431 val
^= DF_1_INTERPOSE
;
8433 if (val
& DF_1_NODEFLIB
)
8435 printf (" NODEFLIB");
8436 val
^= DF_1_NODEFLIB
;
8438 if (val
& DF_1_NODUMP
)
8443 if (val
& DF_1_CONFALT
)
8445 printf (" CONFALT");
8446 val
^= DF_1_CONFALT
;
8448 if (val
& DF_1_ENDFILTEE
)
8450 printf (" ENDFILTEE");
8451 val
^= DF_1_ENDFILTEE
;
8453 if (val
& DF_1_DISPRELDNE
)
8455 printf (" DISPRELDNE");
8456 val
^= DF_1_DISPRELDNE
;
8458 if (val
& DF_1_DISPRELPND
)
8460 printf (" DISPRELPND");
8461 val
^= DF_1_DISPRELPND
;
8463 if (val
& DF_1_NODIRECT
)
8465 printf (" NODIRECT");
8466 val
^= DF_1_NODIRECT
;
8468 if (val
& DF_1_IGNMULDEF
)
8470 printf (" IGNMULDEF");
8471 val
^= DF_1_IGNMULDEF
;
8473 if (val
& DF_1_NOKSYMS
)
8475 printf (" NOKSYMS");
8476 val
^= DF_1_NOKSYMS
;
8478 if (val
& DF_1_NOHDR
)
8483 if (val
& DF_1_EDITED
)
8488 if (val
& DF_1_NORELOC
)
8490 printf (" NORELOC");
8491 val
^= DF_1_NORELOC
;
8493 if (val
& DF_1_SYMINTPOSE
)
8495 printf (" SYMINTPOSE");
8496 val
^= DF_1_SYMINTPOSE
;
8498 if (val
& DF_1_GLOBAUDIT
)
8500 printf (" GLOBAUDIT");
8501 val
^= DF_1_GLOBAUDIT
;
8503 if (val
& DF_1_SINGLETON
)
8505 printf (" SINGLETON");
8506 val
^= DF_1_SINGLETON
;
8509 printf (" %lx", val
);
8516 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8518 puts (get_dynamic_type (entry
->d_un
.d_val
));
8538 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8544 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8545 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8551 switch (entry
->d_tag
)
8554 printf (_("Shared library: [%s]"), name
);
8556 if (streq (name
, program_interpreter
))
8557 printf (_(" program interpreter"));
8561 printf (_("Library soname: [%s]"), name
);
8565 printf (_("Library rpath: [%s]"), name
);
8569 printf (_("Library runpath: [%s]"), name
);
8573 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8578 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8591 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8595 case DT_INIT_ARRAYSZ
:
8596 case DT_FINI_ARRAYSZ
:
8597 case DT_GNU_CONFLICTSZ
:
8598 case DT_GNU_LIBLISTSZ
:
8601 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8602 printf (_(" (bytes)\n"));
8612 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8625 if (entry
->d_tag
== DT_USED
8626 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8628 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8632 printf (_("Not needed object: [%s]\n"), name
);
8637 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8643 /* The value of this entry is ignored. */
8648 case DT_GNU_PRELINKED
:
8652 time_t atime
= entry
->d_un
.d_val
;
8654 tmp
= gmtime (&atime
);
8655 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8656 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8657 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8663 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8666 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8672 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8673 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8678 switch (elf_header
.e_machine
)
8681 case EM_MIPS_RS3_LE
:
8682 dynamic_section_mips_val (entry
);
8685 dynamic_section_parisc_val (entry
);
8688 dynamic_section_ia64_val (entry
);
8691 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8703 get_ver_flags (unsigned int flags
)
8705 static char buff
[32];
8712 if (flags
& VER_FLG_BASE
)
8713 strcat (buff
, "BASE ");
8715 if (flags
& VER_FLG_WEAK
)
8717 if (flags
& VER_FLG_BASE
)
8718 strcat (buff
, "| ");
8720 strcat (buff
, "WEAK ");
8723 if (flags
& VER_FLG_INFO
)
8725 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8726 strcat (buff
, "| ");
8728 strcat (buff
, "INFO ");
8731 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8732 strcat (buff
, _("| <unknown>"));
8737 /* Display the contents of the version sections. */
8740 process_version_sections (FILE * file
)
8742 Elf_Internal_Shdr
* section
;
8749 for (i
= 0, section
= section_headers
;
8750 i
< elf_header
.e_shnum
;
8753 switch (section
->sh_type
)
8755 case SHT_GNU_verdef
:
8757 Elf_External_Verdef
* edefs
;
8765 (_("\nVersion definition section '%s' contains %u entries:\n"),
8766 SECTION_NAME (section
), section
->sh_info
);
8768 printf (_(" Addr: 0x"));
8769 printf_vma (section
->sh_addr
);
8770 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8771 (unsigned long) section
->sh_offset
, section
->sh_link
,
8772 section
->sh_link
< elf_header
.e_shnum
8773 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8776 edefs
= (Elf_External_Verdef
*)
8777 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8778 _("version definition section"));
8781 endbuf
= (char *) edefs
+ section
->sh_size
;
8783 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8786 Elf_External_Verdef
* edef
;
8787 Elf_Internal_Verdef ent
;
8788 Elf_External_Verdaux
* eaux
;
8789 Elf_Internal_Verdaux aux
;
8793 /* Check for very large indicies. */
8794 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8797 vstart
= ((char *) edefs
) + idx
;
8798 if (vstart
+ sizeof (*edef
) > endbuf
)
8801 edef
= (Elf_External_Verdef
*) vstart
;
8803 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8804 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8805 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8806 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8807 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8808 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8809 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8811 printf (_(" %#06x: Rev: %d Flags: %s"),
8812 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8814 printf (_(" Index: %d Cnt: %d "),
8815 ent
.vd_ndx
, ent
.vd_cnt
);
8817 /* Check for overflow. */
8818 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8821 vstart
+= ent
.vd_aux
;
8823 eaux
= (Elf_External_Verdaux
*) vstart
;
8825 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8826 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8828 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8829 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8831 printf (_("Name index: %ld\n"), aux
.vda_name
);
8833 isum
= idx
+ ent
.vd_aux
;
8835 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8837 /* Check for overflow. */
8838 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8841 isum
+= aux
.vda_next
;
8842 vstart
+= aux
.vda_next
;
8844 eaux
= (Elf_External_Verdaux
*) vstart
;
8845 if (vstart
+ sizeof (*eaux
) > endbuf
)
8848 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8849 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8851 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8852 printf (_(" %#06x: Parent %d: %s\n"),
8853 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8855 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8856 isum
, j
, aux
.vda_name
);
8860 printf (_(" Version def aux past end of section\n"));
8865 if (cnt
< section
->sh_info
)
8866 printf (_(" Version definition past end of section\n"));
8872 case SHT_GNU_verneed
:
8874 Elf_External_Verneed
* eneed
;
8881 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8882 SECTION_NAME (section
), section
->sh_info
);
8884 printf (_(" Addr: 0x"));
8885 printf_vma (section
->sh_addr
);
8886 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8887 (unsigned long) section
->sh_offset
, section
->sh_link
,
8888 section
->sh_link
< elf_header
.e_shnum
8889 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8892 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8893 section
->sh_offset
, 1,
8895 _("Version Needs section"));
8898 endbuf
= (char *) eneed
+ section
->sh_size
;
8900 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8902 Elf_External_Verneed
* entry
;
8903 Elf_Internal_Verneed ent
;
8908 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8911 vstart
= ((char *) eneed
) + idx
;
8912 if (vstart
+ sizeof (*entry
) > endbuf
)
8915 entry
= (Elf_External_Verneed
*) vstart
;
8917 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8918 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8919 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8920 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8921 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8923 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8925 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8926 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8928 printf (_(" File: %lx"), ent
.vn_file
);
8930 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8932 /* Check for overflow. */
8933 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8936 vstart
+= ent
.vn_aux
;
8938 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8940 Elf_External_Vernaux
* eaux
;
8941 Elf_Internal_Vernaux aux
;
8943 if (vstart
+ sizeof (*eaux
) > endbuf
)
8945 eaux
= (Elf_External_Vernaux
*) vstart
;
8947 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8948 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8949 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8950 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8951 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8953 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8954 printf (_(" %#06x: Name: %s"),
8955 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8957 printf (_(" %#06x: Name index: %lx"),
8958 isum
, aux
.vna_name
);
8960 printf (_(" Flags: %s Version: %d\n"),
8961 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8963 /* Check for overflow. */
8964 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8967 isum
+= aux
.vna_next
;
8968 vstart
+= aux
.vna_next
;
8972 warn (_("Missing Version Needs auxillary information\n"));
8974 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
8976 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
8977 cnt
= section
->sh_info
;
8983 if (cnt
< section
->sh_info
)
8984 warn (_("Missing Version Needs information\n"));
8990 case SHT_GNU_versym
:
8992 Elf_Internal_Shdr
* link_section
;
8995 unsigned char * edata
;
8996 unsigned short * data
;
8998 Elf_Internal_Sym
* symbols
;
8999 Elf_Internal_Shdr
* string_sec
;
9000 unsigned long num_syms
;
9003 if (section
->sh_link
>= elf_header
.e_shnum
)
9006 link_section
= section_headers
+ section
->sh_link
;
9007 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9009 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9014 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9015 if (symbols
== NULL
)
9018 string_sec
= section_headers
+ link_section
->sh_link
;
9020 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9021 string_sec
->sh_size
,
9022 _("version string table"));
9029 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9030 SECTION_NAME (section
), total
);
9032 printf (_(" Addr: "));
9033 printf_vma (section
->sh_addr
);
9034 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9035 (unsigned long) section
->sh_offset
, section
->sh_link
,
9036 SECTION_NAME (link_section
));
9038 off
= offset_from_vma (file
,
9039 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9040 total
* sizeof (short));
9041 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9043 _("version symbol data"));
9051 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9053 for (cnt
= total
; cnt
--;)
9054 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9059 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9062 int check_def
, check_need
;
9065 printf (" %03x:", cnt
);
9067 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9068 switch (data
[cnt
+ j
])
9071 fputs (_(" 0 (*local*) "), stdout
);
9075 fputs (_(" 1 (*global*) "), stdout
);
9079 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9080 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9082 /* If this index value is greater than the size of the symbols
9083 array, break to avoid an out-of-bounds read. */
9084 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9086 warn (_("invalid index into symbol array\n"));
9092 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9093 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9096 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9103 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9105 Elf_Internal_Verneed ivn
;
9106 unsigned long offset
;
9108 offset
= offset_from_vma
9109 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9110 sizeof (Elf_External_Verneed
));
9114 Elf_Internal_Vernaux ivna
;
9115 Elf_External_Verneed evn
;
9116 Elf_External_Vernaux evna
;
9117 unsigned long a_off
;
9119 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9120 _("version need")) == NULL
)
9123 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9124 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9126 a_off
= offset
+ ivn
.vn_aux
;
9130 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9131 1, _("version need aux (2)")) == NULL
)
9138 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9139 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9142 a_off
+= ivna
.vna_next
;
9144 while (ivna
.vna_other
!= data
[cnt
+ j
]
9145 && ivna
.vna_next
!= 0);
9147 if (ivna
.vna_other
== data
[cnt
+ j
])
9149 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9151 if (ivna
.vna_name
>= string_sec
->sh_size
)
9152 name
= _("*invalid*");
9154 name
= strtab
+ ivna
.vna_name
;
9155 nn
+= printf ("(%s%-*s",
9157 12 - (int) strlen (name
),
9163 offset
+= ivn
.vn_next
;
9165 while (ivn
.vn_next
);
9168 if (check_def
&& data
[cnt
+ j
] != 0x8001
9169 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9171 Elf_Internal_Verdef ivd
;
9172 Elf_External_Verdef evd
;
9173 unsigned long offset
;
9175 offset
= offset_from_vma
9176 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9181 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9182 _("version def")) == NULL
)
9189 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9190 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9193 offset
+= ivd
.vd_next
;
9195 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9196 && ivd
.vd_next
!= 0);
9198 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9200 Elf_External_Verdaux evda
;
9201 Elf_Internal_Verdaux ivda
;
9203 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9205 if (get_data (&evda
, file
,
9206 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9208 _("version def aux")) == NULL
)
9211 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9213 if (ivda
.vda_name
>= string_sec
->sh_size
)
9214 name
= _("*invalid*");
9216 name
= strtab
+ ivda
.vda_name
;
9217 nn
+= printf ("(%s%-*s",
9219 12 - (int) strlen (name
),
9225 printf ("%*c", 18 - nn
, ' ');
9243 printf (_("\nNo version information found in this file.\n"));
9249 get_symbol_binding (unsigned int binding
)
9251 static char buff
[32];
9255 case STB_LOCAL
: return "LOCAL";
9256 case STB_GLOBAL
: return "GLOBAL";
9257 case STB_WEAK
: return "WEAK";
9259 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9260 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9262 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9264 if (binding
== STB_GNU_UNIQUE
9265 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9266 /* GNU is still using the default value 0. */
9267 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9269 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9272 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9278 get_symbol_type (unsigned int type
)
9280 static char buff
[32];
9284 case STT_NOTYPE
: return "NOTYPE";
9285 case STT_OBJECT
: return "OBJECT";
9286 case STT_FUNC
: return "FUNC";
9287 case STT_SECTION
: return "SECTION";
9288 case STT_FILE
: return "FILE";
9289 case STT_COMMON
: return "COMMON";
9290 case STT_TLS
: return "TLS";
9291 case STT_RELC
: return "RELC";
9292 case STT_SRELC
: return "SRELC";
9294 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9296 if (elf_header
.e_machine
== EM_ARM
)
9298 if (type
== STT_ARM_TFUNC
)
9299 return "THUMB_FUNC";
9300 if (type
== STT_ARM_16BIT
)
9301 return "THUMB_LABEL";
9304 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9307 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9308 return "PARISC_MILLI";
9310 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9312 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9314 if (elf_header
.e_machine
== EM_PARISC
)
9316 if (type
== STT_HP_OPAQUE
)
9318 if (type
== STT_HP_STUB
)
9322 if (type
== STT_GNU_IFUNC
9323 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9324 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9325 /* GNU is still using the default value 0. */
9326 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9329 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9332 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9338 get_symbol_visibility (unsigned int visibility
)
9342 case STV_DEFAULT
: return "DEFAULT";
9343 case STV_INTERNAL
: return "INTERNAL";
9344 case STV_HIDDEN
: return "HIDDEN";
9345 case STV_PROTECTED
: return "PROTECTED";
9351 get_mips_symbol_other (unsigned int other
)
9363 case STO_MICROMIPS
| STO_MIPS_PIC
:
9364 return "MICROMIPS, MIPS PIC";
9373 get_ia64_symbol_other (unsigned int other
)
9377 static char res
[32];
9381 /* Function types is for images and .STB files only. */
9382 switch (elf_header
.e_type
)
9386 switch (VMS_ST_FUNC_TYPE (other
))
9388 case VMS_SFT_CODE_ADDR
:
9389 strcat (res
, " CA");
9391 case VMS_SFT_SYMV_IDX
:
9392 strcat (res
, " VEC");
9395 strcat (res
, " FD");
9397 case VMS_SFT_RESERVE
:
9398 strcat (res
, " RSV");
9407 switch (VMS_ST_LINKAGE (other
))
9409 case VMS_STL_IGNORE
:
9410 strcat (res
, " IGN");
9412 case VMS_STL_RESERVE
:
9413 strcat (res
, " RSV");
9416 strcat (res
, " STD");
9419 strcat (res
, " LNK");
9434 get_ppc64_symbol_other (unsigned int other
)
9436 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9438 static char buf
[32];
9439 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9440 PPC64_LOCAL_ENTRY_OFFSET (other
));
9447 get_symbol_other (unsigned int other
)
9449 const char * result
= NULL
;
9450 static char buff
[32];
9455 switch (elf_header
.e_machine
)
9458 result
= get_mips_symbol_other (other
);
9461 result
= get_ia64_symbol_other (other
);
9464 result
= get_ppc64_symbol_other (other
);
9473 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9478 get_symbol_index_type (unsigned int type
)
9480 static char buff
[32];
9484 case SHN_UNDEF
: return "UND";
9485 case SHN_ABS
: return "ABS";
9486 case SHN_COMMON
: return "COM";
9488 if (type
== SHN_IA_64_ANSI_COMMON
9489 && elf_header
.e_machine
== EM_IA_64
9490 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9492 else if ((elf_header
.e_machine
== EM_X86_64
9493 || elf_header
.e_machine
== EM_L1OM
9494 || elf_header
.e_machine
== EM_K1OM
)
9495 && type
== SHN_X86_64_LCOMMON
)
9497 else if ((type
== SHN_MIPS_SCOMMON
9498 && elf_header
.e_machine
== EM_MIPS
)
9499 || (type
== SHN_TIC6X_SCOMMON
9500 && elf_header
.e_machine
== EM_TI_C6000
))
9502 else if (type
== SHN_MIPS_SUNDEFINED
9503 && elf_header
.e_machine
== EM_MIPS
)
9505 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9506 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9507 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9508 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9509 else if (type
>= SHN_LORESERVE
)
9510 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9511 else if (type
>= elf_header
.e_shnum
)
9512 sprintf (buff
, "bad section index[%3d]", type
);
9514 sprintf (buff
, "%3d", type
);
9522 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9524 unsigned char * e_data
;
9527 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9531 error (_("Out of memory\n"));
9535 if (fread (e_data
, ent_size
, number
, file
) != number
)
9537 error (_("Unable to read in dynamic data\n"));
9541 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9545 error (_("Out of memory\n"));
9551 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9559 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9561 Elf_Internal_Sym
* psym
;
9564 psym
= dynamic_symbols
+ si
;
9566 n
= print_vma (si
, DEC_5
);
9568 fputs (&" "[n
], stdout
);
9569 printf (" %3lu: ", hn
);
9570 print_vma (psym
->st_value
, LONG_HEX
);
9572 print_vma (psym
->st_size
, DEC_5
);
9574 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9575 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9576 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9577 /* Check to see if any other bits in the st_other field are set.
9578 Note - displaying this information disrupts the layout of the
9579 table being generated, but for the moment this case is very
9581 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9582 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9583 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9584 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9585 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9587 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9591 /* Dump the symbol table. */
9593 process_symbol_table (FILE * file
)
9595 Elf_Internal_Shdr
* section
;
9596 bfd_vma nbuckets
= 0;
9597 bfd_vma nchains
= 0;
9598 bfd_vma
* buckets
= NULL
;
9599 bfd_vma
* chains
= NULL
;
9600 bfd_vma ngnubuckets
= 0;
9601 bfd_vma
* gnubuckets
= NULL
;
9602 bfd_vma
* gnuchains
= NULL
;
9603 bfd_vma gnusymidx
= 0;
9605 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9608 if (dynamic_info
[DT_HASH
]
9610 || (do_using_dynamic
9612 && dynamic_strings
!= NULL
)))
9614 unsigned char nb
[8];
9615 unsigned char nc
[8];
9616 int hash_ent_size
= 4;
9618 if ((elf_header
.e_machine
== EM_ALPHA
9619 || elf_header
.e_machine
== EM_S390
9620 || elf_header
.e_machine
== EM_S390_OLD
)
9621 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9625 (archive_file_offset
9626 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9627 sizeof nb
+ sizeof nc
)),
9630 error (_("Unable to seek to start of dynamic information\n"));
9634 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9636 error (_("Failed to read in number of buckets\n"));
9640 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9642 error (_("Failed to read in number of chains\n"));
9646 nbuckets
= byte_get (nb
, hash_ent_size
);
9647 nchains
= byte_get (nc
, hash_ent_size
);
9649 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9650 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9653 if (buckets
== NULL
|| chains
== NULL
)
9655 if (do_using_dynamic
)
9666 if (dynamic_info_DT_GNU_HASH
9668 || (do_using_dynamic
9670 && dynamic_strings
!= NULL
)))
9672 unsigned char nb
[16];
9673 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9674 bfd_vma buckets_vma
;
9677 (archive_file_offset
9678 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9682 error (_("Unable to seek to start of dynamic information\n"));
9686 if (fread (nb
, 16, 1, file
) != 1)
9688 error (_("Failed to read in number of buckets\n"));
9692 ngnubuckets
= byte_get (nb
, 4);
9693 gnusymidx
= byte_get (nb
+ 4, 4);
9694 bitmaskwords
= byte_get (nb
+ 8, 4);
9695 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9697 buckets_vma
+= bitmaskwords
* 4;
9699 buckets_vma
+= bitmaskwords
* 8;
9702 (archive_file_offset
9703 + offset_from_vma (file
, buckets_vma
, 4)),
9706 error (_("Unable to seek to start of dynamic information\n"));
9710 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9712 if (gnubuckets
== NULL
)
9715 for (i
= 0; i
< ngnubuckets
; i
++)
9716 if (gnubuckets
[i
] != 0)
9718 if (gnubuckets
[i
] < gnusymidx
)
9721 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9722 maxchain
= gnubuckets
[i
];
9725 if (maxchain
== 0xffffffff)
9728 maxchain
-= gnusymidx
;
9731 (archive_file_offset
9732 + offset_from_vma (file
, buckets_vma
9733 + 4 * (ngnubuckets
+ maxchain
), 4)),
9736 error (_("Unable to seek to start of dynamic information\n"));
9742 if (fread (nb
, 4, 1, file
) != 1)
9744 error (_("Failed to determine last chain length\n"));
9748 if (maxchain
+ 1 == 0)
9753 while ((byte_get (nb
, 4) & 1) == 0);
9756 (archive_file_offset
9757 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9760 error (_("Unable to seek to start of dynamic information\n"));
9764 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9767 if (gnuchains
== NULL
)
9772 if (do_using_dynamic
)
9777 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9780 && dynamic_strings
!= NULL
)
9784 if (dynamic_info
[DT_HASH
])
9788 printf (_("\nSymbol table for image:\n"));
9790 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9792 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9794 for (hn
= 0; hn
< nbuckets
; hn
++)
9799 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9800 print_dynamic_symbol (si
, hn
);
9804 if (dynamic_info_DT_GNU_HASH
)
9806 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9808 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9810 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9812 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9813 if (gnubuckets
[hn
] != 0)
9815 bfd_vma si
= gnubuckets
[hn
];
9816 bfd_vma off
= si
- gnusymidx
;
9820 print_dynamic_symbol (si
, hn
);
9823 while ((gnuchains
[off
++] & 1) == 0);
9827 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9831 for (i
= 0, section
= section_headers
;
9832 i
< elf_header
.e_shnum
;
9836 char * strtab
= NULL
;
9837 unsigned long int strtab_size
= 0;
9838 Elf_Internal_Sym
* symtab
;
9839 Elf_Internal_Sym
* psym
;
9840 unsigned long num_syms
;
9842 if ((section
->sh_type
!= SHT_SYMTAB
9843 && section
->sh_type
!= SHT_DYNSYM
)
9845 && section
->sh_type
== SHT_SYMTAB
))
9848 if (section
->sh_entsize
== 0)
9850 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9851 SECTION_NAME (section
));
9855 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9856 SECTION_NAME (section
),
9857 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9860 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9862 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9864 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9868 if (section
->sh_link
== elf_header
.e_shstrndx
)
9870 strtab
= string_table
;
9871 strtab_size
= string_table_length
;
9873 else if (section
->sh_link
< elf_header
.e_shnum
)
9875 Elf_Internal_Shdr
* string_sec
;
9877 string_sec
= section_headers
+ section
->sh_link
;
9879 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9880 1, string_sec
->sh_size
,
9882 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9885 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9887 printf ("%6d: ", si
);
9888 print_vma (psym
->st_value
, LONG_HEX
);
9890 print_vma (psym
->st_size
, DEC_5
);
9891 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9892 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9893 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9894 /* Check to see if any other bits in the st_other field are set.
9895 Note - displaying this information disrupts the layout of the
9896 table being generated, but for the moment this case is very rare. */
9897 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9898 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9899 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9900 print_symbol (25, psym
->st_name
< strtab_size
9901 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9903 if (section
->sh_type
== SHT_DYNSYM
9904 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9906 unsigned char data
[2];
9907 unsigned short vers_data
;
9908 unsigned long offset
;
9912 offset
= offset_from_vma
9913 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9914 sizeof data
+ si
* sizeof (vers_data
));
9916 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9917 sizeof (data
), 1, _("version data")) == NULL
)
9920 vers_data
= byte_get (data
, 2);
9922 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9923 && section_headers
[psym
->st_shndx
].sh_type
9926 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9928 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9930 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9931 && (is_nobits
|| ! check_def
))
9933 Elf_External_Verneed evn
;
9934 Elf_Internal_Verneed ivn
;
9935 Elf_Internal_Vernaux ivna
;
9937 /* We must test both. */
9938 offset
= offset_from_vma
9939 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9944 unsigned long vna_off
;
9946 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9947 _("version need")) == NULL
)
9955 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9956 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9958 vna_off
= offset
+ ivn
.vn_aux
;
9962 Elf_External_Vernaux evna
;
9964 if (get_data (&evna
, file
, vna_off
,
9966 _("version need aux (3)")) == NULL
)
9974 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9975 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9976 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9979 vna_off
+= ivna
.vna_next
;
9981 while (ivna
.vna_other
!= vers_data
9982 && ivna
.vna_next
!= 0);
9984 if (ivna
.vna_other
== vers_data
)
9987 offset
+= ivn
.vn_next
;
9989 while (ivn
.vn_next
!= 0);
9991 if (ivna
.vna_other
== vers_data
)
9994 ivna
.vna_name
< strtab_size
9995 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9999 else if (! is_nobits
)
10000 error (_("bad dynamic symbol\n"));
10007 if (vers_data
!= 0x8001
10008 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10010 Elf_Internal_Verdef ivd
;
10011 Elf_Internal_Verdaux ivda
;
10012 Elf_External_Verdaux evda
;
10015 off
= offset_from_vma
10017 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10018 sizeof (Elf_External_Verdef
));
10022 Elf_External_Verdef evd
;
10024 if (get_data (&evd
, file
, off
, sizeof (evd
),
10025 1, _("version def")) == NULL
)
10033 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10034 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10035 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10038 off
+= ivd
.vd_next
;
10040 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10041 && ivd
.vd_next
!= 0);
10043 off
-= ivd
.vd_next
;
10046 if (get_data (&evda
, file
, off
, sizeof (evda
),
10047 1, _("version def aux")) == NULL
)
10050 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10052 if (psym
->st_name
!= ivda
.vda_name
)
10053 printf ((vers_data
& VERSYM_HIDDEN
)
10055 ivda
.vda_name
< strtab_size
10056 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10066 if (strtab
!= string_table
)
10072 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10074 if (do_histogram
&& buckets
!= NULL
)
10076 unsigned long * lengths
;
10077 unsigned long * counts
;
10080 unsigned long maxlength
= 0;
10081 unsigned long nzero_counts
= 0;
10082 unsigned long nsyms
= 0;
10084 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10085 (unsigned long) nbuckets
);
10086 printf (_(" Length Number %% of total Coverage\n"));
10088 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10089 if (lengths
== NULL
)
10091 error (_("Out of memory\n"));
10094 for (hn
= 0; hn
< nbuckets
; ++hn
)
10096 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10099 if (maxlength
< ++lengths
[hn
])
10104 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10105 if (counts
== NULL
)
10108 error (_("Out of memory\n"));
10112 for (hn
= 0; hn
< nbuckets
; ++hn
)
10113 ++counts
[lengths
[hn
]];
10118 printf (" 0 %-10lu (%5.1f%%)\n",
10119 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10120 for (i
= 1; i
<= maxlength
; ++i
)
10122 nzero_counts
+= counts
[i
] * i
;
10123 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10124 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10125 (nzero_counts
* 100.0) / nsyms
);
10133 if (buckets
!= NULL
)
10139 if (do_histogram
&& gnubuckets
!= NULL
)
10141 unsigned long * lengths
;
10142 unsigned long * counts
;
10144 unsigned long maxlength
= 0;
10145 unsigned long nzero_counts
= 0;
10146 unsigned long nsyms
= 0;
10148 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10149 if (lengths
== NULL
)
10151 error (_("Out of memory\n"));
10155 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10156 (unsigned long) ngnubuckets
);
10157 printf (_(" Length Number %% of total Coverage\n"));
10159 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10160 if (gnubuckets
[hn
] != 0)
10162 bfd_vma off
, length
= 1;
10164 for (off
= gnubuckets
[hn
] - gnusymidx
;
10165 (gnuchains
[off
] & 1) == 0; ++off
)
10167 lengths
[hn
] = length
;
10168 if (length
> maxlength
)
10169 maxlength
= length
;
10173 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10174 if (counts
== NULL
)
10177 error (_("Out of memory\n"));
10181 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10182 ++counts
[lengths
[hn
]];
10184 if (ngnubuckets
> 0)
10187 printf (" 0 %-10lu (%5.1f%%)\n",
10188 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10189 for (j
= 1; j
<= maxlength
; ++j
)
10191 nzero_counts
+= counts
[j
] * j
;
10192 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10193 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10194 (nzero_counts
* 100.0) / nsyms
);
10208 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10212 if (dynamic_syminfo
== NULL
10214 /* No syminfo, this is ok. */
10217 /* There better should be a dynamic symbol section. */
10218 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10222 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10223 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10225 printf (_(" Num: Name BoundTo Flags\n"));
10226 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10228 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10230 printf ("%4d: ", i
);
10231 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10232 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10234 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10237 switch (dynamic_syminfo
[i
].si_boundto
)
10239 case SYMINFO_BT_SELF
:
10240 fputs ("SELF ", stdout
);
10242 case SYMINFO_BT_PARENT
:
10243 fputs ("PARENT ", stdout
);
10246 if (dynamic_syminfo
[i
].si_boundto
> 0
10247 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10248 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10250 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10254 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10258 if (flags
& SYMINFO_FLG_DIRECT
)
10259 printf (" DIRECT");
10260 if (flags
& SYMINFO_FLG_PASSTHRU
)
10261 printf (" PASSTHRU");
10262 if (flags
& SYMINFO_FLG_COPY
)
10264 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10265 printf (" LAZYLOAD");
10273 /* Check to see if the given reloc needs to be handled in a target specific
10274 manner. If so then process the reloc and return TRUE otherwise return
10278 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10279 unsigned char * start
,
10280 Elf_Internal_Sym
* symtab
)
10282 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10284 switch (elf_header
.e_machine
)
10287 case EM_MSP430_OLD
:
10289 static Elf_Internal_Sym
* saved_sym
= NULL
;
10291 switch (reloc_type
)
10293 case 10: /* R_MSP430_SYM_DIFF */
10294 if (uses_msp430x_relocs ())
10296 case 21: /* R_MSP430X_SYM_DIFF */
10297 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10300 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10301 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10302 goto handle_sym_diff
;
10304 case 5: /* R_MSP430_16_BYTE */
10305 case 9: /* R_MSP430_8 */
10306 if (uses_msp430x_relocs ())
10308 goto handle_sym_diff
;
10310 case 2: /* R_MSP430_ABS16 */
10311 case 15: /* R_MSP430X_ABS16 */
10312 if (! uses_msp430x_relocs ())
10314 goto handle_sym_diff
;
10317 if (saved_sym
!= NULL
)
10321 value
= reloc
->r_addend
10322 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10323 - saved_sym
->st_value
);
10325 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10333 if (saved_sym
!= NULL
)
10334 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10341 case EM_CYGNUS_MN10300
:
10343 static Elf_Internal_Sym
* saved_sym
= NULL
;
10345 switch (reloc_type
)
10347 case 34: /* R_MN10300_ALIGN */
10349 case 33: /* R_MN10300_SYM_DIFF */
10350 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10352 case 1: /* R_MN10300_32 */
10353 case 2: /* R_MN10300_16 */
10354 if (saved_sym
!= NULL
)
10358 value
= reloc
->r_addend
10359 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10360 - saved_sym
->st_value
);
10362 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10369 if (saved_sym
!= NULL
)
10370 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10380 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10381 DWARF debug sections. This is a target specific test. Note - we do not
10382 go through the whole including-target-headers-multiple-times route, (as
10383 we have already done with <elf/h8.h>) because this would become very
10384 messy and even then this function would have to contain target specific
10385 information (the names of the relocs instead of their numeric values).
10386 FIXME: This is not the correct way to solve this problem. The proper way
10387 is to have target specific reloc sizing and typing functions created by
10388 the reloc-macros.h header, in the same way that it already creates the
10389 reloc naming functions. */
10392 is_32bit_abs_reloc (unsigned int reloc_type
)
10394 switch (elf_header
.e_machine
)
10398 return reloc_type
== 1; /* R_386_32. */
10400 return reloc_type
== 1; /* R_68K_32. */
10402 return reloc_type
== 1; /* R_860_32. */
10404 return reloc_type
== 2; /* R_960_32. */
10406 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10408 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10410 return reloc_type
== 1; /* R_ARC_32. */
10412 return reloc_type
== 2; /* R_ARM_ABS32 */
10415 return reloc_type
== 1;
10416 case EM_ADAPTEVA_EPIPHANY
:
10417 return reloc_type
== 3;
10419 return reloc_type
== 0x12; /* R_byte4_data. */
10421 return reloc_type
== 3; /* R_CRIS_32. */
10423 return reloc_type
== 3; /* R_CR16_NUM32. */
10425 return reloc_type
== 15; /* R_CRX_NUM32. */
10426 case EM_CYGNUS_FRV
:
10427 return reloc_type
== 1;
10428 case EM_CYGNUS_D10V
:
10430 return reloc_type
== 6; /* R_D10V_32. */
10431 case EM_CYGNUS_D30V
:
10433 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10435 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10436 case EM_CYGNUS_FR30
:
10438 return reloc_type
== 3; /* R_FR30_32. */
10442 return reloc_type
== 1; /* R_H8_DIR32. */
10444 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10447 return reloc_type
== 2; /* R_IP2K_32. */
10449 return reloc_type
== 2; /* R_IQ2000_32. */
10450 case EM_LATTICEMICO32
:
10451 return reloc_type
== 3; /* R_LM32_32. */
10454 return reloc_type
== 3; /* R_M32C_32. */
10456 return reloc_type
== 34; /* R_M32R_32_RELA. */
10458 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10459 case EM_CYGNUS_MEP
:
10460 return reloc_type
== 4; /* R_MEP_32. */
10462 return reloc_type
== 2; /* R_METAG_ADDR32. */
10463 case EM_MICROBLAZE
:
10464 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10466 return reloc_type
== 2; /* R_MIPS_32. */
10468 return reloc_type
== 4; /* R_MMIX_32. */
10469 case EM_CYGNUS_MN10200
:
10471 return reloc_type
== 1; /* R_MN10200_32. */
10472 case EM_CYGNUS_MN10300
:
10474 return reloc_type
== 1; /* R_MN10300_32. */
10476 return reloc_type
== 1; /* R_MOXIE_32. */
10477 case EM_MSP430_OLD
:
10479 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10481 return reloc_type
== 2; /* R_MT_32. */
10483 return reloc_type
== 20; /* R_NDS32_RELA. */
10484 case EM_ALTERA_NIOS2
:
10485 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10487 return reloc_type
== 1; /* R_NIOS_32. */
10490 return reloc_type
== 1; /* R_OR32_32. */
10492 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10493 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10496 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10498 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10500 return reloc_type
== 1; /* R_PPC_ADDR32. */
10502 return reloc_type
== 1; /* R_RL78_DIR32. */
10504 return reloc_type
== 1; /* R_RX_DIR32. */
10506 return reloc_type
== 1; /* R_I370_ADDR31. */
10509 return reloc_type
== 4; /* R_S390_32. */
10511 return reloc_type
== 8; /* R_SCORE_ABS32. */
10513 return reloc_type
== 1; /* R_SH_DIR32. */
10514 case EM_SPARC32PLUS
:
10517 return reloc_type
== 3 /* R_SPARC_32. */
10518 || reloc_type
== 23; /* R_SPARC_UA32. */
10520 return reloc_type
== 6; /* R_SPU_ADDR32 */
10522 return reloc_type
== 1; /* R_C6000_ABS32. */
10524 return reloc_type
== 2; /* R_TILEGX_32. */
10526 return reloc_type
== 1; /* R_TILEPRO_32. */
10527 case EM_CYGNUS_V850
:
10529 return reloc_type
== 6; /* R_V850_ABS32. */
10531 return reloc_type
== 0x33; /* R_V810_WORD. */
10533 return reloc_type
== 1; /* R_VAX_32. */
10537 return reloc_type
== 10; /* R_X86_64_32. */
10540 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10542 return reloc_type
== 4; /* R_XGATE_32. */
10544 return reloc_type
== 1; /* R_XSTROMY16_32. */
10545 case EM_XTENSA_OLD
:
10547 return reloc_type
== 1; /* R_XTENSA_32. */
10549 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10550 elf_header
.e_machine
);
10555 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10556 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10559 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10561 switch (elf_header
.e_machine
)
10565 return reloc_type
== 2; /* R_386_PC32. */
10567 return reloc_type
== 4; /* R_68K_PC32. */
10569 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10570 case EM_ADAPTEVA_EPIPHANY
:
10571 return reloc_type
== 6;
10573 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10575 return reloc_type
== 3; /* R_ARM_REL32 */
10576 case EM_MICROBLAZE
:
10577 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10579 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10581 return reloc_type
== 26; /* R_PPC_REL32. */
10583 return reloc_type
== 26; /* R_PPC64_REL32. */
10586 return reloc_type
== 5; /* R_390_PC32. */
10588 return reloc_type
== 2; /* R_SH_REL32. */
10589 case EM_SPARC32PLUS
:
10592 return reloc_type
== 6; /* R_SPARC_DISP32. */
10594 return reloc_type
== 13; /* R_SPU_REL32. */
10596 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10598 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10602 return reloc_type
== 2; /* R_X86_64_PC32. */
10603 case EM_XTENSA_OLD
:
10605 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10607 /* Do not abort or issue an error message here. Not all targets use
10608 pc-relative 32-bit relocs in their DWARF debug information and we
10609 have already tested for target coverage in is_32bit_abs_reloc. A
10610 more helpful warning message will be generated by apply_relocations
10611 anyway, so just return. */
10616 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10617 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10620 is_64bit_abs_reloc (unsigned int reloc_type
)
10622 switch (elf_header
.e_machine
)
10625 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10627 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10629 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10631 return reloc_type
== 80; /* R_PARISC_DIR64. */
10633 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10634 case EM_SPARC32PLUS
:
10637 return reloc_type
== 54; /* R_SPARC_UA64. */
10641 return reloc_type
== 1; /* R_X86_64_64. */
10644 return reloc_type
== 22; /* R_S390_64. */
10646 return reloc_type
== 1; /* R_TILEGX_64. */
10648 return reloc_type
== 18; /* R_MIPS_64. */
10654 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10655 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10658 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10660 switch (elf_header
.e_machine
)
10663 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10665 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10667 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10669 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10671 return reloc_type
== 44; /* R_PPC64_REL64. */
10672 case EM_SPARC32PLUS
:
10675 return reloc_type
== 46; /* R_SPARC_DISP64. */
10679 return reloc_type
== 24; /* R_X86_64_PC64. */
10682 return reloc_type
== 23; /* R_S390_PC64. */
10684 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10690 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10691 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10694 is_24bit_abs_reloc (unsigned int reloc_type
)
10696 switch (elf_header
.e_machine
)
10698 case EM_CYGNUS_MN10200
:
10700 return reloc_type
== 4; /* R_MN10200_24. */
10706 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10707 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10710 is_16bit_abs_reloc (unsigned int reloc_type
)
10712 switch (elf_header
.e_machine
)
10716 return reloc_type
== 4; /* R_AVR_16. */
10717 case EM_ADAPTEVA_EPIPHANY
:
10718 return reloc_type
== 5;
10719 case EM_CYGNUS_D10V
:
10721 return reloc_type
== 3; /* R_D10V_16. */
10725 return reloc_type
== R_H8_DIR16
;
10728 return reloc_type
== 1; /* R_IP2K_16. */
10731 return reloc_type
== 1; /* R_M32C_16 */
10733 if (uses_msp430x_relocs ())
10734 return reloc_type
== 2; /* R_MSP430_ABS16. */
10735 case EM_MSP430_OLD
:
10736 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10738 return reloc_type
== 19; /* R_NDS32_RELA. */
10739 case EM_ALTERA_NIOS2
:
10740 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10742 return reloc_type
== 9; /* R_NIOS_16. */
10744 return reloc_type
== 2; /* R_C6000_ABS16. */
10747 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10748 case EM_CYGNUS_MN10200
:
10750 return reloc_type
== 2; /* R_MN10200_16. */
10751 case EM_CYGNUS_MN10300
:
10753 return reloc_type
== 2; /* R_MN10300_16. */
10755 return reloc_type
== 3; /* R_XGATE_16. */
10761 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10762 relocation entries (possibly formerly used for SHT_GROUP sections). */
10765 is_none_reloc (unsigned int reloc_type
)
10767 switch (elf_header
.e_machine
)
10769 case EM_68K
: /* R_68K_NONE. */
10770 case EM_386
: /* R_386_NONE. */
10771 case EM_SPARC32PLUS
:
10773 case EM_SPARC
: /* R_SPARC_NONE. */
10774 case EM_MIPS
: /* R_MIPS_NONE. */
10775 case EM_PARISC
: /* R_PARISC_NONE. */
10776 case EM_ALPHA
: /* R_ALPHA_NONE. */
10777 case EM_ADAPTEVA_EPIPHANY
:
10778 case EM_PPC
: /* R_PPC_NONE. */
10779 case EM_PPC64
: /* R_PPC64_NONE. */
10780 case EM_ARM
: /* R_ARM_NONE. */
10781 case EM_IA_64
: /* R_IA64_NONE. */
10782 case EM_SH
: /* R_SH_NONE. */
10784 case EM_S390
: /* R_390_NONE. */
10785 case EM_CRIS
: /* R_CRIS_NONE. */
10786 case EM_X86_64
: /* R_X86_64_NONE. */
10787 case EM_L1OM
: /* R_X86_64_NONE. */
10788 case EM_K1OM
: /* R_X86_64_NONE. */
10789 case EM_MN10300
: /* R_MN10300_NONE. */
10790 case EM_MOXIE
: /* R_MOXIE_NONE. */
10791 case EM_M32R
: /* R_M32R_NONE. */
10792 case EM_TI_C6000
:/* R_C6000_NONE. */
10793 case EM_TILEGX
: /* R_TILEGX_NONE. */
10794 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10796 case EM_C166
: /* R_XC16X_NONE. */
10797 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10798 case EM_NIOS32
: /* R_NIOS_NONE. */
10799 return reloc_type
== 0;
10801 return reloc_type
== 0 || reloc_type
== 256;
10803 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10804 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10805 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10806 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10807 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10808 case EM_XTENSA_OLD
:
10810 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10811 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10812 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10813 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10815 return reloc_type
== 3; /* R_METAG_NONE. */
10820 /* Apply relocations to a section.
10821 Note: So far support has been added only for those relocations
10822 which can be found in debug sections.
10823 FIXME: Add support for more relocations ? */
10826 apply_relocations (void * file
,
10827 Elf_Internal_Shdr
* section
,
10828 unsigned char * start
)
10830 Elf_Internal_Shdr
* relsec
;
10831 unsigned char * end
= start
+ section
->sh_size
;
10833 if (elf_header
.e_type
!= ET_REL
)
10836 /* Find the reloc section associated with the section. */
10837 for (relsec
= section_headers
;
10838 relsec
< section_headers
+ elf_header
.e_shnum
;
10841 bfd_boolean is_rela
;
10842 unsigned long num_relocs
;
10843 Elf_Internal_Rela
* relocs
;
10844 Elf_Internal_Rela
* rp
;
10845 Elf_Internal_Shdr
* symsec
;
10846 Elf_Internal_Sym
* symtab
;
10847 unsigned long num_syms
;
10848 Elf_Internal_Sym
* sym
;
10850 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10851 || relsec
->sh_info
>= elf_header
.e_shnum
10852 || section_headers
+ relsec
->sh_info
!= section
10853 || relsec
->sh_size
== 0
10854 || relsec
->sh_link
>= elf_header
.e_shnum
)
10857 is_rela
= relsec
->sh_type
== SHT_RELA
;
10861 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10862 relsec
->sh_size
, & relocs
, & num_relocs
))
10867 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10868 relsec
->sh_size
, & relocs
, & num_relocs
))
10872 /* SH uses RELA but uses in place value instead of the addend field. */
10873 if (elf_header
.e_machine
== EM_SH
)
10876 symsec
= section_headers
+ relsec
->sh_link
;
10877 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10879 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10882 unsigned int reloc_type
;
10883 unsigned int reloc_size
;
10884 unsigned char * rloc
;
10885 unsigned long sym_index
;
10887 reloc_type
= get_reloc_type (rp
->r_info
);
10889 if (target_specific_reloc_handling (rp
, start
, symtab
))
10891 else if (is_none_reloc (reloc_type
))
10893 else if (is_32bit_abs_reloc (reloc_type
)
10894 || is_32bit_pcrel_reloc (reloc_type
))
10896 else if (is_64bit_abs_reloc (reloc_type
)
10897 || is_64bit_pcrel_reloc (reloc_type
))
10899 else if (is_24bit_abs_reloc (reloc_type
))
10901 else if (is_16bit_abs_reloc (reloc_type
))
10905 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10906 reloc_type
, SECTION_NAME (section
));
10910 rloc
= start
+ rp
->r_offset
;
10911 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10913 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10914 (unsigned long) rp
->r_offset
,
10915 SECTION_NAME (section
));
10919 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10920 if (sym_index
>= num_syms
)
10922 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10923 sym_index
, SECTION_NAME (section
));
10926 sym
= symtab
+ sym_index
;
10928 /* If the reloc has a symbol associated with it,
10929 make sure that it is of an appropriate type.
10931 Relocations against symbols without type can happen.
10932 Gcc -feliminate-dwarf2-dups may generate symbols
10933 without type for debug info.
10935 Icc generates relocations against function symbols
10936 instead of local labels.
10938 Relocations against object symbols can happen, eg when
10939 referencing a global array. For an example of this see
10940 the _clz.o binary in libgcc.a. */
10942 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10944 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10945 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10946 (long int)(rp
- relocs
),
10947 SECTION_NAME (relsec
));
10953 addend
+= rp
->r_addend
;
10954 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10955 partial_inplace. */
10957 || (elf_header
.e_machine
== EM_XTENSA
10958 && reloc_type
== 1)
10959 || ((elf_header
.e_machine
== EM_PJ
10960 || elf_header
.e_machine
== EM_PJ_OLD
)
10961 && reloc_type
== 1)
10962 || ((elf_header
.e_machine
== EM_D30V
10963 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10964 && reloc_type
== 12))
10965 addend
+= byte_get (rloc
, reloc_size
);
10967 if (is_32bit_pcrel_reloc (reloc_type
)
10968 || is_64bit_pcrel_reloc (reloc_type
))
10970 /* On HPPA, all pc-relative relocations are biased by 8. */
10971 if (elf_header
.e_machine
== EM_PARISC
)
10973 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10977 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10986 #ifdef SUPPORT_DISASSEMBLY
10988 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10990 printf (_("\nAssembly dump of section %s\n"),
10991 SECTION_NAME (section
));
10993 /* XXX -- to be done --- XXX */
10999 /* Reads in the contents of SECTION from FILE, returning a pointer
11000 to a malloc'ed buffer or NULL if something went wrong. */
11003 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11005 bfd_size_type num_bytes
;
11007 num_bytes
= section
->sh_size
;
11009 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11011 printf (_("\nSection '%s' has no data to dump.\n"),
11012 SECTION_NAME (section
));
11016 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11017 _("section contents"));
11022 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11024 Elf_Internal_Shdr
* relsec
;
11025 bfd_size_type num_bytes
;
11029 char * name
= SECTION_NAME (section
);
11030 bfd_boolean some_strings_shown
;
11032 start
= get_section_contents (section
, file
);
11036 printf (_("\nString dump of section '%s':\n"), name
);
11038 /* If the section being dumped has relocations against it the user might
11039 be expecting these relocations to have been applied. Check for this
11040 case and issue a warning message in order to avoid confusion.
11041 FIXME: Maybe we ought to have an option that dumps a section with
11042 relocs applied ? */
11043 for (relsec
= section_headers
;
11044 relsec
< section_headers
+ elf_header
.e_shnum
;
11047 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11048 || relsec
->sh_info
>= elf_header
.e_shnum
11049 || section_headers
+ relsec
->sh_info
!= section
11050 || relsec
->sh_size
== 0
11051 || relsec
->sh_link
>= elf_header
.e_shnum
)
11054 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11058 num_bytes
= section
->sh_size
;
11060 end
= start
+ num_bytes
;
11061 some_strings_shown
= FALSE
;
11065 while (!ISPRINT (* data
))
11066 if (++ data
>= end
)
11072 /* PR 11128: Use two separate invocations in order to work
11073 around bugs in the Solaris 8 implementation of printf. */
11074 printf (" [%6tx] ", data
- start
);
11075 printf ("%s\n", data
);
11077 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11079 data
+= strlen (data
);
11080 some_strings_shown
= TRUE
;
11084 if (! some_strings_shown
)
11085 printf (_(" No strings found in this section."));
11093 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11095 bfd_boolean relocate
)
11097 Elf_Internal_Shdr
* relsec
;
11098 bfd_size_type bytes
;
11100 unsigned char * data
;
11101 unsigned char * start
;
11103 start
= (unsigned char *) get_section_contents (section
, file
);
11107 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11111 apply_relocations (file
, section
, start
);
11115 /* If the section being dumped has relocations against it the user might
11116 be expecting these relocations to have been applied. Check for this
11117 case and issue a warning message in order to avoid confusion.
11118 FIXME: Maybe we ought to have an option that dumps a section with
11119 relocs applied ? */
11120 for (relsec
= section_headers
;
11121 relsec
< section_headers
+ elf_header
.e_shnum
;
11124 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11125 || relsec
->sh_info
>= elf_header
.e_shnum
11126 || section_headers
+ relsec
->sh_info
!= section
11127 || relsec
->sh_size
== 0
11128 || relsec
->sh_link
>= elf_header
.e_shnum
)
11131 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11136 addr
= section
->sh_addr
;
11137 bytes
= section
->sh_size
;
11146 lbytes
= (bytes
> 16 ? 16 : bytes
);
11148 printf (" 0x%8.8lx ", (unsigned long) addr
);
11150 for (j
= 0; j
< 16; j
++)
11153 printf ("%2.2x", data
[j
]);
11161 for (j
= 0; j
< lbytes
; j
++)
11164 if (k
>= ' ' && k
< 0x7f)
11182 /* Uncompresses a section that was compressed using zlib, in place. */
11185 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11186 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11188 #ifndef HAVE_ZLIB_H
11191 dwarf_size_type compressed_size
= *size
;
11192 unsigned char * compressed_buffer
= *buffer
;
11193 dwarf_size_type uncompressed_size
;
11194 unsigned char * uncompressed_buffer
;
11197 dwarf_size_type header_size
= 12;
11199 /* Read the zlib header. In this case, it should be "ZLIB" followed
11200 by the uncompressed section size, 8 bytes in big-endian order. */
11201 if (compressed_size
< header_size
11202 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11205 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11206 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11207 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11208 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11209 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11210 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11211 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11212 uncompressed_size
+= compressed_buffer
[11];
11214 /* It is possible the section consists of several compressed
11215 buffers concatenated together, so we uncompress in a loop. */
11216 strm
.zalloc
= NULL
;
11218 strm
.opaque
= NULL
;
11219 strm
.avail_in
= compressed_size
- header_size
;
11220 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11221 strm
.avail_out
= uncompressed_size
;
11222 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11224 rc
= inflateInit (& strm
);
11225 while (strm
.avail_in
> 0)
11229 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11230 + (uncompressed_size
- strm
.avail_out
));
11231 rc
= inflate (&strm
, Z_FINISH
);
11232 if (rc
!= Z_STREAM_END
)
11234 rc
= inflateReset (& strm
);
11236 rc
= inflateEnd (& strm
);
11238 || strm
.avail_out
!= 0)
11241 free (compressed_buffer
);
11242 *buffer
= uncompressed_buffer
;
11243 *size
= uncompressed_size
;
11247 free (uncompressed_buffer
);
11248 /* Indicate decompression failure. */
11251 #endif /* HAVE_ZLIB_H */
11255 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11256 Elf_Internal_Shdr
* sec
, void * file
)
11258 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11261 /* If it is already loaded, do nothing. */
11262 if (section
->start
!= NULL
)
11265 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11266 section
->address
= sec
->sh_addr
;
11267 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11269 sec
->sh_size
, buf
);
11270 if (section
->start
== NULL
)
11274 section
->size
= sec
->sh_size
;
11275 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11276 sec
->sh_size
= section
->size
;
11279 if (section
->start
== NULL
)
11282 if (debug_displays
[debug
].relocate
)
11283 apply_relocations ((FILE *) file
, sec
, section
->start
);
11288 /* If this is not NULL, load_debug_section will only look for sections
11289 within the list of sections given here. */
11290 unsigned int *section_subset
= NULL
;
11293 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11295 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11296 Elf_Internal_Shdr
* sec
;
11298 /* Locate the debug section. */
11299 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11301 section
->name
= section
->uncompressed_name
;
11304 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11306 section
->name
= section
->compressed_name
;
11311 /* If we're loading from a subset of sections, and we've loaded
11312 a section matching this name before, it's likely that it's a
11314 if (section_subset
!= NULL
)
11315 free_debug_section (debug
);
11317 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11321 free_debug_section (enum dwarf_section_display_enum debug
)
11323 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11325 if (section
->start
== NULL
)
11328 free ((char *) section
->start
);
11329 section
->start
= NULL
;
11330 section
->address
= 0;
11335 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11337 char * name
= SECTION_NAME (section
);
11338 bfd_size_type length
;
11342 length
= section
->sh_size
;
11345 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11348 if (section
->sh_type
== SHT_NOBITS
)
11350 /* There is no point in dumping the contents of a debugging section
11351 which has the NOBITS type - the bits in the file will be random.
11352 This can happen when a file containing a .eh_frame section is
11353 stripped with the --only-keep-debug command line option. */
11354 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11358 if (const_strneq (name
, ".gnu.linkonce.wi."))
11359 name
= ".debug_info";
11361 /* See if we know how to display the contents of this section. */
11362 for (i
= 0; i
< max
; i
++)
11363 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11364 || (i
== line
&& const_strneq (name
, ".debug_line."))
11365 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11367 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11368 int secondary
= (section
!= find_section (name
));
11371 free_debug_section ((enum dwarf_section_display_enum
) i
);
11373 if (i
== line
&& const_strneq (name
, ".debug_line."))
11375 else if (streq (sec
->uncompressed_name
, name
))
11376 sec
->name
= sec
->uncompressed_name
;
11378 sec
->name
= sec
->compressed_name
;
11379 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11382 /* If this debug section is part of a CU/TU set in a .dwp file,
11383 restrict load_debug_section to the sections in that set. */
11384 section_subset
= find_cu_tu_set (file
, shndx
);
11386 result
&= debug_displays
[i
].display (sec
, file
);
11388 section_subset
= NULL
;
11390 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11391 free_debug_section ((enum dwarf_section_display_enum
) i
);
11399 printf (_("Unrecognized debug section: %s\n"), name
);
11406 /* Set DUMP_SECTS for all sections where dumps were requested
11407 based on section name. */
11410 initialise_dumps_byname (void)
11412 struct dump_list_entry
* cur
;
11414 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11419 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11420 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11422 request_dump_bynumber (i
, cur
->type
);
11427 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11433 process_section_contents (FILE * file
)
11435 Elf_Internal_Shdr
* section
;
11441 initialise_dumps_byname ();
11443 for (i
= 0, section
= section_headers
;
11444 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11447 #ifdef SUPPORT_DISASSEMBLY
11448 if (dump_sects
[i
] & DISASS_DUMP
)
11449 disassemble_section (section
, file
);
11451 if (dump_sects
[i
] & HEX_DUMP
)
11452 dump_section_as_bytes (section
, file
, FALSE
);
11454 if (dump_sects
[i
] & RELOC_DUMP
)
11455 dump_section_as_bytes (section
, file
, TRUE
);
11457 if (dump_sects
[i
] & STRING_DUMP
)
11458 dump_section_as_strings (section
, file
);
11460 if (dump_sects
[i
] & DEBUG_DUMP
)
11461 display_debug_section (i
, section
, file
);
11464 /* Check to see if the user requested a
11465 dump of a section that does not exist. */
11466 while (i
++ < num_dump_sects
)
11468 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11472 process_mips_fpe_exception (int mask
)
11477 if (mask
& OEX_FPU_INEX
)
11478 fputs ("INEX", stdout
), first
= 0;
11479 if (mask
& OEX_FPU_UFLO
)
11480 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11481 if (mask
& OEX_FPU_OFLO
)
11482 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11483 if (mask
& OEX_FPU_DIV0
)
11484 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11485 if (mask
& OEX_FPU_INVAL
)
11486 printf ("%sINVAL", first
? "" : "|");
11489 fputs ("0", stdout
);
11492 /* Display's the value of TAG at location P. If TAG is
11493 greater than 0 it is assumed to be an unknown tag, and
11494 a message is printed to this effect. Otherwise it is
11495 assumed that a message has already been printed.
11497 If the bottom bit of TAG is set it assumed to have a
11498 string value, otherwise it is assumed to have an integer
11501 Returns an updated P pointing to the first unread byte
11502 beyond the end of TAG's value.
11504 Reads at or beyond END will not be made. */
11506 static unsigned char *
11507 display_tag_value (int tag
,
11509 const unsigned char * const end
)
11514 printf (" Tag_unknown_%d: ", tag
);
11518 warn (_("corrupt tag\n"));
11522 /* FIXME: we could read beyond END here. */
11523 printf ("\"%s\"\n", p
);
11524 p
+= strlen ((char *) p
) + 1;
11530 val
= read_uleb128 (p
, &len
, end
);
11532 printf ("%ld (0x%lx)\n", val
, val
);
11538 /* ARM EABI attributes section. */
11543 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11545 const char ** table
;
11546 } arm_attr_public_tag
;
11548 static const char * arm_attr_tag_CPU_arch
[] =
11549 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11550 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11551 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11552 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11553 {"No", "Thumb-1", "Thumb-2"};
11554 static const char * arm_attr_tag_FP_arch
[] =
11555 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11557 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11558 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11559 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11560 static const char * arm_attr_tag_PCS_config
[] =
11561 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11562 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11563 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11564 {"V6", "SB", "TLS", "Unused"};
11565 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11566 {"Absolute", "PC-relative", "SB-relative", "None"};
11567 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11568 {"Absolute", "PC-relative", "None"};
11569 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11570 {"None", "direct", "GOT-indirect"};
11571 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11572 {"None", "??? 1", "2", "??? 3", "4"};
11573 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11574 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11575 {"Unused", "Needed", "Sign only"};
11576 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11577 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11578 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11579 {"Unused", "Finite", "RTABI", "IEEE 754"};
11580 static const char * arm_attr_tag_ABI_enum_size
[] =
11581 {"Unused", "small", "int", "forced to int"};
11582 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11583 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11584 static const char * arm_attr_tag_ABI_VFP_args
[] =
11585 {"AAPCS", "VFP registers", "custom"};
11586 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11587 {"AAPCS", "WMMX registers", "custom"};
11588 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11589 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11590 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11591 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11592 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11593 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11594 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11595 static const char * arm_attr_tag_FP_HP_extension
[] =
11596 {"Not Allowed", "Allowed"};
11597 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11598 {"None", "IEEE 754", "Alternative Format"};
11599 static const char * arm_attr_tag_MPextension_use
[] =
11600 {"Not Allowed", "Allowed"};
11601 static const char * arm_attr_tag_DIV_use
[] =
11602 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11603 "Allowed in v7-A with integer division extension"};
11604 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11605 static const char * arm_attr_tag_Virtualization_use
[] =
11606 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11607 "TrustZone and Virtualization Extensions"};
11608 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11609 {"Not Allowed", "Allowed"};
11611 #define LOOKUP(id, name) \
11612 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11613 static arm_attr_public_tag arm_attr_public_tags
[] =
11615 {4, "CPU_raw_name", 1, NULL
},
11616 {5, "CPU_name", 1, NULL
},
11617 LOOKUP(6, CPU_arch
),
11618 {7, "CPU_arch_profile", 0, NULL
},
11619 LOOKUP(8, ARM_ISA_use
),
11620 LOOKUP(9, THUMB_ISA_use
),
11621 LOOKUP(10, FP_arch
),
11622 LOOKUP(11, WMMX_arch
),
11623 LOOKUP(12, Advanced_SIMD_arch
),
11624 LOOKUP(13, PCS_config
),
11625 LOOKUP(14, ABI_PCS_R9_use
),
11626 LOOKUP(15, ABI_PCS_RW_data
),
11627 LOOKUP(16, ABI_PCS_RO_data
),
11628 LOOKUP(17, ABI_PCS_GOT_use
),
11629 LOOKUP(18, ABI_PCS_wchar_t
),
11630 LOOKUP(19, ABI_FP_rounding
),
11631 LOOKUP(20, ABI_FP_denormal
),
11632 LOOKUP(21, ABI_FP_exceptions
),
11633 LOOKUP(22, ABI_FP_user_exceptions
),
11634 LOOKUP(23, ABI_FP_number_model
),
11635 {24, "ABI_align_needed", 0, NULL
},
11636 {25, "ABI_align_preserved", 0, NULL
},
11637 LOOKUP(26, ABI_enum_size
),
11638 LOOKUP(27, ABI_HardFP_use
),
11639 LOOKUP(28, ABI_VFP_args
),
11640 LOOKUP(29, ABI_WMMX_args
),
11641 LOOKUP(30, ABI_optimization_goals
),
11642 LOOKUP(31, ABI_FP_optimization_goals
),
11643 {32, "compatibility", 0, NULL
},
11644 LOOKUP(34, CPU_unaligned_access
),
11645 LOOKUP(36, FP_HP_extension
),
11646 LOOKUP(38, ABI_FP_16bit_format
),
11647 LOOKUP(42, MPextension_use
),
11648 LOOKUP(44, DIV_use
),
11649 {64, "nodefaults", 0, NULL
},
11650 {65, "also_compatible_with", 0, NULL
},
11651 LOOKUP(66, T2EE_use
),
11652 {67, "conformance", 1, NULL
},
11653 LOOKUP(68, Virtualization_use
),
11654 LOOKUP(70, MPextension_use_legacy
)
11658 static unsigned char *
11659 display_arm_attribute (unsigned char * p
,
11660 const unsigned char * const end
)
11665 arm_attr_public_tag
* attr
;
11669 tag
= read_uleb128 (p
, &len
, end
);
11672 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11674 if (arm_attr_public_tags
[i
].tag
== tag
)
11676 attr
= &arm_attr_public_tags
[i
];
11683 printf (" Tag_%s: ", attr
->name
);
11684 switch (attr
->type
)
11689 case 7: /* Tag_CPU_arch_profile. */
11690 val
= read_uleb128 (p
, &len
, end
);
11694 case 0: printf (_("None\n")); break;
11695 case 'A': printf (_("Application\n")); break;
11696 case 'R': printf (_("Realtime\n")); break;
11697 case 'M': printf (_("Microcontroller\n")); break;
11698 case 'S': printf (_("Application or Realtime\n")); break;
11699 default: printf ("??? (%d)\n", val
); break;
11703 case 24: /* Tag_align_needed. */
11704 val
= read_uleb128 (p
, &len
, end
);
11708 case 0: printf (_("None\n")); break;
11709 case 1: printf (_("8-byte\n")); break;
11710 case 2: printf (_("4-byte\n")); break;
11711 case 3: printf ("??? 3\n"); break;
11714 printf (_("8-byte and up to %d-byte extended\n"),
11717 printf ("??? (%d)\n", val
);
11722 case 25: /* Tag_align_preserved. */
11723 val
= read_uleb128 (p
, &len
, end
);
11727 case 0: printf (_("None\n")); break;
11728 case 1: printf (_("8-byte, except leaf SP\n")); break;
11729 case 2: printf (_("8-byte\n")); break;
11730 case 3: printf ("??? 3\n"); break;
11733 printf (_("8-byte and up to %d-byte extended\n"),
11736 printf ("??? (%d)\n", val
);
11741 case 32: /* Tag_compatibility. */
11742 val
= read_uleb128 (p
, &len
, end
);
11744 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11745 p
+= strlen ((char *) p
) + 1;
11748 case 64: /* Tag_nodefaults. */
11750 printf (_("True\n"));
11753 case 65: /* Tag_also_compatible_with. */
11754 val
= read_uleb128 (p
, &len
, end
);
11756 if (val
== 6 /* Tag_CPU_arch. */)
11758 val
= read_uleb128 (p
, &len
, end
);
11760 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11761 printf ("??? (%d)\n", val
);
11763 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11767 while (*(p
++) != '\0' /* NUL terminator. */);
11776 return display_tag_value (-1, p
, end
);
11778 return display_tag_value (0, p
, end
);
11781 assert (attr
->type
& 0x80);
11782 val
= read_uleb128 (p
, &len
, end
);
11784 type
= attr
->type
& 0x7f;
11786 printf ("??? (%d)\n", val
);
11788 printf ("%s\n", attr
->table
[val
]);
11793 return display_tag_value (tag
, p
, end
);
11796 static unsigned char *
11797 display_gnu_attribute (unsigned char * p
,
11798 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11799 const unsigned char * const end
)
11805 tag
= read_uleb128 (p
, &len
, end
);
11808 /* Tag_compatibility is the only generic GNU attribute defined at
11812 val
= read_uleb128 (p
, &len
, end
);
11816 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11817 warn (_("corrupt vendor attribute\n"));
11821 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11822 p
+= strlen ((char *) p
) + 1;
11827 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11828 return display_proc_gnu_attribute (p
, tag
, end
);
11830 return display_tag_value (tag
, p
, end
);
11833 static unsigned char *
11834 display_power_gnu_attribute (unsigned char * p
,
11836 const unsigned char * const end
)
11841 if (tag
== Tag_GNU_Power_ABI_FP
)
11843 val
= read_uleb128 (p
, &len
, end
);
11845 printf (" Tag_GNU_Power_ABI_FP: ");
11850 printf (_("Hard or soft float\n"));
11853 printf (_("Hard float\n"));
11856 printf (_("Soft float\n"));
11859 printf (_("Single-precision hard float\n"));
11862 printf ("??? (%d)\n", val
);
11868 if (tag
== Tag_GNU_Power_ABI_Vector
)
11870 val
= read_uleb128 (p
, &len
, end
);
11872 printf (" Tag_GNU_Power_ABI_Vector: ");
11876 printf (_("Any\n"));
11879 printf (_("Generic\n"));
11882 printf ("AltiVec\n");
11888 printf ("??? (%d)\n", val
);
11894 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11898 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11902 val
= read_uleb128 (p
, &len
, end
);
11904 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11908 printf (_("Any\n"));
11911 printf ("r3/r4\n");
11914 printf (_("Memory\n"));
11917 printf ("??? (%d)\n", val
);
11923 return display_tag_value (tag
& 1, p
, end
);
11927 display_sparc_hwcaps (int mask
)
11932 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11933 fputs ("mul32", stdout
), first
= 0;
11934 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11935 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11936 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11937 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11938 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11939 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11940 if (mask
& ELF_SPARC_HWCAP_POPC
)
11941 printf ("%spopc", first
? "" : "|"), first
= 0;
11942 if (mask
& ELF_SPARC_HWCAP_VIS
)
11943 printf ("%svis", first
? "" : "|"), first
= 0;
11944 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11945 printf ("%svis2", first
? "" : "|"), first
= 0;
11946 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11947 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11948 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11949 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11950 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11951 printf ("%svis3", first
? "" : "|"), first
= 0;
11952 if (mask
& ELF_SPARC_HWCAP_HPC
)
11953 printf ("%shpc", first
? "" : "|"), first
= 0;
11954 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11955 printf ("%srandom", first
? "" : "|"), first
= 0;
11956 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11957 printf ("%strans", first
? "" : "|"), first
= 0;
11958 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11959 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11960 if (mask
& ELF_SPARC_HWCAP_IMA
)
11961 printf ("%sima", first
? "" : "|"), first
= 0;
11962 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11963 printf ("%scspare", first
? "" : "|"), first
= 0;
11966 fputc('0', stdout
);
11967 fputc('\n', stdout
);
11970 static unsigned char *
11971 display_sparc_gnu_attribute (unsigned char * p
,
11973 const unsigned char * const end
)
11975 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11980 val
= read_uleb128 (p
, &len
, end
);
11982 printf (" Tag_GNU_Sparc_HWCAPS: ");
11983 display_sparc_hwcaps (val
);
11987 return display_tag_value (tag
, p
, end
);
11990 static unsigned char *
11991 display_mips_gnu_attribute (unsigned char * p
,
11993 const unsigned char * const end
)
11995 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12000 val
= read_uleb128 (p
, &len
, end
);
12002 printf (" Tag_GNU_MIPS_ABI_FP: ");
12006 case Val_GNU_MIPS_ABI_FP_ANY
:
12007 printf (_("Hard or soft float\n"));
12009 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12010 printf (_("Hard float (double precision)\n"));
12012 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12013 printf (_("Hard float (single precision)\n"));
12015 case Val_GNU_MIPS_ABI_FP_SOFT
:
12016 printf (_("Soft float\n"));
12018 case Val_GNU_MIPS_ABI_FP_64
:
12019 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
12022 printf ("??? (%d)\n", val
);
12028 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12033 val
= read_uleb128 (p
, &len
, end
);
12035 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12039 case Val_GNU_MIPS_ABI_MSA_ANY
:
12040 printf (_("Any MSA or not\n"));
12042 case Val_GNU_MIPS_ABI_MSA_128
:
12043 printf (_("128-bit MSA\n"));
12046 printf ("??? (%d)\n", val
);
12052 return display_tag_value (tag
& 1, p
, end
);
12055 static unsigned char *
12056 display_tic6x_attribute (unsigned char * p
,
12057 const unsigned char * const end
)
12063 tag
= read_uleb128 (p
, &len
, end
);
12069 val
= read_uleb128 (p
, &len
, end
);
12071 printf (" Tag_ISA: ");
12075 case C6XABI_Tag_ISA_none
:
12076 printf (_("None\n"));
12078 case C6XABI_Tag_ISA_C62X
:
12081 case C6XABI_Tag_ISA_C67X
:
12084 case C6XABI_Tag_ISA_C67XP
:
12085 printf ("C67x+\n");
12087 case C6XABI_Tag_ISA_C64X
:
12090 case C6XABI_Tag_ISA_C64XP
:
12091 printf ("C64x+\n");
12093 case C6XABI_Tag_ISA_C674X
:
12094 printf ("C674x\n");
12097 printf ("??? (%d)\n", val
);
12102 case Tag_ABI_wchar_t
:
12103 val
= read_uleb128 (p
, &len
, end
);
12105 printf (" Tag_ABI_wchar_t: ");
12109 printf (_("Not used\n"));
12112 printf (_("2 bytes\n"));
12115 printf (_("4 bytes\n"));
12118 printf ("??? (%d)\n", val
);
12123 case Tag_ABI_stack_align_needed
:
12124 val
= read_uleb128 (p
, &len
, end
);
12126 printf (" Tag_ABI_stack_align_needed: ");
12130 printf (_("8-byte\n"));
12133 printf (_("16-byte\n"));
12136 printf ("??? (%d)\n", val
);
12141 case Tag_ABI_stack_align_preserved
:
12142 val
= read_uleb128 (p
, &len
, end
);
12144 printf (" Tag_ABI_stack_align_preserved: ");
12148 printf (_("8-byte\n"));
12151 printf (_("16-byte\n"));
12154 printf ("??? (%d)\n", val
);
12160 val
= read_uleb128 (p
, &len
, end
);
12162 printf (" Tag_ABI_DSBT: ");
12166 printf (_("DSBT addressing not used\n"));
12169 printf (_("DSBT addressing used\n"));
12172 printf ("??? (%d)\n", val
);
12178 val
= read_uleb128 (p
, &len
, end
);
12180 printf (" Tag_ABI_PID: ");
12184 printf (_("Data addressing position-dependent\n"));
12187 printf (_("Data addressing position-independent, GOT near DP\n"));
12190 printf (_("Data addressing position-independent, GOT far from DP\n"));
12193 printf ("??? (%d)\n", val
);
12199 val
= read_uleb128 (p
, &len
, end
);
12201 printf (" Tag_ABI_PIC: ");
12205 printf (_("Code addressing position-dependent\n"));
12208 printf (_("Code addressing position-independent\n"));
12211 printf ("??? (%d)\n", val
);
12216 case Tag_ABI_array_object_alignment
:
12217 val
= read_uleb128 (p
, &len
, end
);
12219 printf (" Tag_ABI_array_object_alignment: ");
12223 printf (_("8-byte\n"));
12226 printf (_("4-byte\n"));
12229 printf (_("16-byte\n"));
12232 printf ("??? (%d)\n", val
);
12237 case Tag_ABI_array_object_align_expected
:
12238 val
= read_uleb128 (p
, &len
, end
);
12240 printf (" Tag_ABI_array_object_align_expected: ");
12244 printf (_("8-byte\n"));
12247 printf (_("4-byte\n"));
12250 printf (_("16-byte\n"));
12253 printf ("??? (%d)\n", val
);
12258 case Tag_ABI_compatibility
:
12259 val
= read_uleb128 (p
, &len
, end
);
12261 printf (" Tag_ABI_compatibility: ");
12262 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12263 p
+= strlen ((char *) p
) + 1;
12266 case Tag_ABI_conformance
:
12267 printf (" Tag_ABI_conformance: ");
12268 printf ("\"%s\"\n", p
);
12269 p
+= strlen ((char *) p
) + 1;
12273 return display_tag_value (tag
, p
, end
);
12277 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12279 unsigned long addr
= 0;
12280 size_t bytes
= end
- p
;
12286 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12288 printf (" 0x%8.8lx ", addr
);
12290 for (j
= 0; j
< 16; j
++)
12293 printf ("%2.2x", p
[j
]);
12301 for (j
= 0; j
< lbytes
; j
++)
12304 if (k
>= ' ' && k
< 0x7f)
12320 static unsigned char *
12321 display_msp430x_attribute (unsigned char * p
,
12322 const unsigned char * const end
)
12328 tag
= read_uleb128 (p
, & len
, end
);
12333 case OFBA_MSPABI_Tag_ISA
:
12334 val
= read_uleb128 (p
, &len
, end
);
12336 printf (" Tag_ISA: ");
12339 case 0: printf (_("None\n")); break;
12340 case 1: printf (_("MSP430\n")); break;
12341 case 2: printf (_("MSP430X\n")); break;
12342 default: printf ("??? (%d)\n", val
); break;
12346 case OFBA_MSPABI_Tag_Code_Model
:
12347 val
= read_uleb128 (p
, &len
, end
);
12349 printf (" Tag_Code_Model: ");
12352 case 0: printf (_("None\n")); break;
12353 case 1: printf (_("Small\n")); break;
12354 case 2: printf (_("Large\n")); break;
12355 default: printf ("??? (%d)\n", val
); break;
12359 case OFBA_MSPABI_Tag_Data_Model
:
12360 val
= read_uleb128 (p
, &len
, end
);
12362 printf (" Tag_Data_Model: ");
12365 case 0: printf (_("None\n")); break;
12366 case 1: printf (_("Small\n")); break;
12367 case 2: printf (_("Large\n")); break;
12368 case 3: printf (_("Restricted Large\n")); break;
12369 default: printf ("??? (%d)\n", val
); break;
12374 printf (_(" <unknown tag %d>: "), tag
);
12378 printf ("\"%s\"\n", p
);
12379 p
+= strlen ((char *) p
) + 1;
12383 val
= read_uleb128 (p
, &len
, end
);
12385 printf ("%d (0x%x)\n", val
, val
);
12394 process_attributes (FILE * file
,
12395 const char * public_name
,
12396 unsigned int proc_type
,
12397 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12398 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12400 Elf_Internal_Shdr
* sect
;
12401 unsigned char * contents
;
12403 unsigned char * end
;
12404 bfd_vma section_len
;
12408 /* Find the section header so that we get the size. */
12409 for (i
= 0, sect
= section_headers
;
12410 i
< elf_header
.e_shnum
;
12413 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12416 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12417 sect
->sh_size
, _("attributes"));
12418 if (contents
== NULL
)
12424 len
= sect
->sh_size
- 1;
12429 unsigned int namelen
;
12430 bfd_boolean public_section
;
12431 bfd_boolean gnu_section
;
12433 section_len
= byte_get (p
, 4);
12436 if (section_len
> len
)
12438 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12439 (unsigned) section_len
, (unsigned) len
);
12443 len
-= section_len
;
12446 namelen
= strnlen ((char *) p
, section_len
) + 1;
12447 if (namelen
== 0 || namelen
>= section_len
)
12449 error (_("Corrupt attribute section name\n"));
12453 printf (_("Attribute Section: %s\n"), p
);
12455 if (public_name
&& streq ((char *) p
, public_name
))
12456 public_section
= TRUE
;
12458 public_section
= FALSE
;
12460 if (streq ((char *) p
, "gnu"))
12461 gnu_section
= TRUE
;
12463 gnu_section
= FALSE
;
12466 section_len
-= namelen
;
12467 while (section_len
> 0)
12473 size
= byte_get (p
, 4);
12474 if (size
> section_len
)
12476 error (_("Bad subsection length (%u > %u)\n"),
12477 (unsigned) size
, (unsigned) section_len
);
12478 size
= section_len
;
12481 section_len
-= size
;
12482 end
= p
+ size
- 1;
12488 printf (_("File Attributes\n"));
12491 printf (_("Section Attributes:"));
12494 printf (_("Symbol Attributes:"));
12500 val
= read_uleb128 (p
, &j
, end
);
12504 printf (" %d", val
);
12509 printf (_("Unknown tag: %d\n"), tag
);
12510 public_section
= FALSE
;
12514 if (public_section
)
12517 p
= display_pub_attribute (p
, end
);
12519 else if (gnu_section
)
12522 p
= display_gnu_attribute (p
,
12523 display_proc_gnu_attribute
,
12528 printf (_(" Unknown section contexts\n"));
12529 display_raw_attribute (p
, end
);
12536 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12544 process_arm_specific (FILE * file
)
12546 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12547 display_arm_attribute
, NULL
);
12551 process_power_specific (FILE * file
)
12553 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12554 display_power_gnu_attribute
);
12558 process_sparc_specific (FILE * file
)
12560 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12561 display_sparc_gnu_attribute
);
12565 process_tic6x_specific (FILE * file
)
12567 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12568 display_tic6x_attribute
, NULL
);
12572 process_msp430x_specific (FILE * file
)
12574 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12575 display_msp430x_attribute
, NULL
);
12578 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12579 Print the Address, Access and Initial fields of an entry at VMA ADDR
12580 and return the VMA of the next entry. */
12583 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12586 print_vma (addr
, LONG_HEX
);
12588 if (addr
< pltgot
+ 0xfff0)
12589 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12591 printf ("%10s", "");
12594 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12599 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12600 print_vma (entry
, LONG_HEX
);
12602 return addr
+ (is_32bit_elf
? 4 : 8);
12605 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12606 PLTGOT. Print the Address and Initial fields of an entry at VMA
12607 ADDR and return the VMA of the next entry. */
12610 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12613 print_vma (addr
, LONG_HEX
);
12616 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12621 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12622 print_vma (entry
, LONG_HEX
);
12624 return addr
+ (is_32bit_elf
? 4 : 8);
12628 process_mips_specific (FILE * file
)
12630 Elf_Internal_Dyn
* entry
;
12631 size_t liblist_offset
= 0;
12632 size_t liblistno
= 0;
12633 size_t conflictsno
= 0;
12634 size_t options_offset
= 0;
12635 size_t conflicts_offset
= 0;
12636 size_t pltrelsz
= 0;
12638 bfd_vma pltgot
= 0;
12639 bfd_vma mips_pltgot
= 0;
12640 bfd_vma jmprel
= 0;
12641 bfd_vma local_gotno
= 0;
12642 bfd_vma gotsym
= 0;
12643 bfd_vma symtabno
= 0;
12645 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12646 display_mips_gnu_attribute
);
12648 /* We have a lot of special sections. Thanks SGI! */
12649 if (dynamic_section
== NULL
)
12650 /* No information available. */
12653 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12654 switch (entry
->d_tag
)
12656 case DT_MIPS_LIBLIST
:
12658 = offset_from_vma (file
, entry
->d_un
.d_val
,
12659 liblistno
* sizeof (Elf32_External_Lib
));
12661 case DT_MIPS_LIBLISTNO
:
12662 liblistno
= entry
->d_un
.d_val
;
12664 case DT_MIPS_OPTIONS
:
12665 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12667 case DT_MIPS_CONFLICT
:
12669 = offset_from_vma (file
, entry
->d_un
.d_val
,
12670 conflictsno
* sizeof (Elf32_External_Conflict
));
12672 case DT_MIPS_CONFLICTNO
:
12673 conflictsno
= entry
->d_un
.d_val
;
12676 pltgot
= entry
->d_un
.d_ptr
;
12678 case DT_MIPS_LOCAL_GOTNO
:
12679 local_gotno
= entry
->d_un
.d_val
;
12681 case DT_MIPS_GOTSYM
:
12682 gotsym
= entry
->d_un
.d_val
;
12684 case DT_MIPS_SYMTABNO
:
12685 symtabno
= entry
->d_un
.d_val
;
12687 case DT_MIPS_PLTGOT
:
12688 mips_pltgot
= entry
->d_un
.d_ptr
;
12691 pltrel
= entry
->d_un
.d_val
;
12694 pltrelsz
= entry
->d_un
.d_val
;
12697 jmprel
= entry
->d_un
.d_ptr
;
12703 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12705 Elf32_External_Lib
* elib
;
12708 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12710 sizeof (Elf32_External_Lib
),
12711 _("liblist section data"));
12714 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12715 (unsigned long) liblistno
);
12716 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12719 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12726 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12727 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12728 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12729 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12730 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12732 tmp
= gmtime (&atime
);
12733 snprintf (timebuf
, sizeof (timebuf
),
12734 "%04u-%02u-%02uT%02u:%02u:%02u",
12735 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12736 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12738 printf ("%3lu: ", (unsigned long) cnt
);
12739 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12740 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12742 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12743 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12744 liblist
.l_version
);
12746 if (liblist
.l_flags
== 0)
12750 static const struct
12757 { " EXACT_MATCH", LL_EXACT_MATCH
},
12758 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12759 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12760 { " EXPORTS", LL_EXPORTS
},
12761 { " DELAY_LOAD", LL_DELAY_LOAD
},
12762 { " DELTA", LL_DELTA
}
12764 int flags
= liblist
.l_flags
;
12767 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12768 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12770 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12771 flags
^= l_flags_vals
[fcnt
].bit
;
12774 printf (" %#x", (unsigned int) flags
);
12784 if (options_offset
!= 0)
12786 Elf_External_Options
* eopt
;
12787 Elf_Internal_Shdr
* sect
= section_headers
;
12788 Elf_Internal_Options
* iopt
;
12789 Elf_Internal_Options
* option
;
12793 /* Find the section header so that we get the size. */
12794 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12797 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12798 sect
->sh_size
, _("options"));
12801 iopt
= (Elf_Internal_Options
*)
12802 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12805 error (_("Out of memory\n"));
12812 while (offset
< sect
->sh_size
)
12814 Elf_External_Options
* eoption
;
12816 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12818 option
->kind
= BYTE_GET (eoption
->kind
);
12819 option
->size
= BYTE_GET (eoption
->size
);
12820 option
->section
= BYTE_GET (eoption
->section
);
12821 option
->info
= BYTE_GET (eoption
->info
);
12823 offset
+= option
->size
;
12829 printf (_("\nSection '%s' contains %d entries:\n"),
12830 SECTION_NAME (sect
), cnt
);
12838 switch (option
->kind
)
12841 /* This shouldn't happen. */
12842 printf (" NULL %d %lx", option
->section
, option
->info
);
12845 printf (" REGINFO ");
12846 if (elf_header
.e_machine
== EM_MIPS
)
12849 Elf32_External_RegInfo
* ereg
;
12850 Elf32_RegInfo reginfo
;
12852 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12853 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12854 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12855 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12856 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12857 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12858 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12860 printf ("GPR %08lx GP 0x%lx\n",
12861 reginfo
.ri_gprmask
,
12862 (unsigned long) reginfo
.ri_gp_value
);
12863 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12864 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12865 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12870 Elf64_External_RegInfo
* ereg
;
12871 Elf64_Internal_RegInfo reginfo
;
12873 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12874 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12875 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12876 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12877 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12878 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12879 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12881 printf ("GPR %08lx GP 0x",
12882 reginfo
.ri_gprmask
);
12883 printf_vma (reginfo
.ri_gp_value
);
12886 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12887 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12888 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12892 case ODK_EXCEPTIONS
:
12893 fputs (" EXCEPTIONS fpe_min(", stdout
);
12894 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12895 fputs (") fpe_max(", stdout
);
12896 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12897 fputs (")", stdout
);
12899 if (option
->info
& OEX_PAGE0
)
12900 fputs (" PAGE0", stdout
);
12901 if (option
->info
& OEX_SMM
)
12902 fputs (" SMM", stdout
);
12903 if (option
->info
& OEX_FPDBUG
)
12904 fputs (" FPDBUG", stdout
);
12905 if (option
->info
& OEX_DISMISS
)
12906 fputs (" DISMISS", stdout
);
12909 fputs (" PAD ", stdout
);
12910 if (option
->info
& OPAD_PREFIX
)
12911 fputs (" PREFIX", stdout
);
12912 if (option
->info
& OPAD_POSTFIX
)
12913 fputs (" POSTFIX", stdout
);
12914 if (option
->info
& OPAD_SYMBOL
)
12915 fputs (" SYMBOL", stdout
);
12918 fputs (" HWPATCH ", stdout
);
12919 if (option
->info
& OHW_R4KEOP
)
12920 fputs (" R4KEOP", stdout
);
12921 if (option
->info
& OHW_R8KPFETCH
)
12922 fputs (" R8KPFETCH", stdout
);
12923 if (option
->info
& OHW_R5KEOP
)
12924 fputs (" R5KEOP", stdout
);
12925 if (option
->info
& OHW_R5KCVTL
)
12926 fputs (" R5KCVTL", stdout
);
12929 fputs (" FILL ", stdout
);
12930 /* XXX Print content of info word? */
12933 fputs (" TAGS ", stdout
);
12934 /* XXX Print content of info word? */
12937 fputs (" HWAND ", stdout
);
12938 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12939 fputs (" R4KEOP_CHECKED", stdout
);
12940 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12941 fputs (" R4KEOP_CLEAN", stdout
);
12944 fputs (" HWOR ", stdout
);
12945 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12946 fputs (" R4KEOP_CHECKED", stdout
);
12947 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12948 fputs (" R4KEOP_CLEAN", stdout
);
12951 printf (" GP_GROUP %#06lx self-contained %#06lx",
12952 option
->info
& OGP_GROUP
,
12953 (option
->info
& OGP_SELF
) >> 16);
12956 printf (" IDENT %#06lx self-contained %#06lx",
12957 option
->info
& OGP_GROUP
,
12958 (option
->info
& OGP_SELF
) >> 16);
12961 /* This shouldn't happen. */
12962 printf (" %3d ??? %d %lx",
12963 option
->kind
, option
->section
, option
->info
);
12967 len
= sizeof (* eopt
);
12968 while (len
< option
->size
)
12969 if (((char *) option
)[len
] >= ' '
12970 && ((char *) option
)[len
] < 0x7f)
12971 printf ("%c", ((char *) option
)[len
++]);
12973 printf ("\\%03o", ((char *) option
)[len
++]);
12975 fputs ("\n", stdout
);
12983 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12985 Elf32_Conflict
* iconf
;
12988 if (dynamic_symbols
== NULL
)
12990 error (_("conflict list found without a dynamic symbol table\n"));
12994 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12997 error (_("Out of memory\n"));
13003 Elf32_External_Conflict
* econf32
;
13005 econf32
= (Elf32_External_Conflict
*)
13006 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13007 sizeof (* econf32
), _("conflict"));
13011 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13012 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13018 Elf64_External_Conflict
* econf64
;
13020 econf64
= (Elf64_External_Conflict
*)
13021 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13022 sizeof (* econf64
), _("conflict"));
13026 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13027 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13032 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13033 (unsigned long) conflictsno
);
13034 puts (_(" Num: Index Value Name"));
13036 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13038 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13040 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13041 print_vma (psym
->st_value
, FULL_HEX
);
13043 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13044 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13046 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13053 if (pltgot
!= 0 && local_gotno
!= 0)
13055 bfd_vma ent
, local_end
, global_end
;
13057 unsigned char * data
;
13061 addr_size
= (is_32bit_elf
? 4 : 8);
13062 local_end
= pltgot
+ local_gotno
* addr_size
;
13063 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13065 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13066 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13067 global_end
- pltgot
, 1,
13068 _("Global Offset Table data"));
13072 printf (_("\nPrimary GOT:\n"));
13073 printf (_(" Canonical gp value: "));
13074 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13077 printf (_(" Reserved entries:\n"));
13078 printf (_(" %*s %10s %*s Purpose\n"),
13079 addr_size
* 2, _("Address"), _("Access"),
13080 addr_size
* 2, _("Initial"));
13081 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13082 printf (_(" Lazy resolver\n"));
13084 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13085 >> (addr_size
* 8 - 1)) != 0)
13087 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13088 printf (_(" Module pointer (GNU extension)\n"));
13092 if (ent
< local_end
)
13094 printf (_(" Local entries:\n"));
13095 printf (" %*s %10s %*s\n",
13096 addr_size
* 2, _("Address"), _("Access"),
13097 addr_size
* 2, _("Initial"));
13098 while (ent
< local_end
)
13100 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13106 if (gotsym
< symtabno
)
13110 printf (_(" Global entries:\n"));
13111 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13112 addr_size
* 2, _("Address"),
13114 addr_size
* 2, _("Initial"),
13115 addr_size
* 2, _("Sym.Val."),
13117 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13118 _("Ndx"), _("Name"));
13120 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13121 for (i
= gotsym
; i
< symtabno
; i
++)
13123 Elf_Internal_Sym
* psym
;
13125 psym
= dynamic_symbols
+ i
;
13126 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13128 print_vma (psym
->st_value
, LONG_HEX
);
13129 printf (" %-7s %3s ",
13130 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13131 get_symbol_index_type (psym
->st_shndx
));
13132 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13133 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13135 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13145 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13148 size_t offset
, rel_offset
;
13149 unsigned long count
, i
;
13150 unsigned char * data
;
13151 int addr_size
, sym_width
;
13152 Elf_Internal_Rela
* rels
;
13154 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13155 if (pltrel
== DT_RELA
)
13157 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13162 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13167 addr_size
= (is_32bit_elf
? 4 : 8);
13168 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13170 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13171 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13172 1, _("Procedure Linkage Table data"));
13176 printf ("\nPLT GOT:\n\n");
13177 printf (_(" Reserved entries:\n"));
13178 printf (_(" %*s %*s Purpose\n"),
13179 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13180 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13181 printf (_(" PLT lazy resolver\n"));
13182 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13183 printf (_(" Module pointer\n"));
13186 printf (_(" Entries:\n"));
13187 printf (" %*s %*s %*s %-7s %3s %s\n",
13188 addr_size
* 2, _("Address"),
13189 addr_size
* 2, _("Initial"),
13190 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13191 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13192 for (i
= 0; i
< count
; i
++)
13194 Elf_Internal_Sym
* psym
;
13196 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13197 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13199 print_vma (psym
->st_value
, LONG_HEX
);
13200 printf (" %-7s %3s ",
13201 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13202 get_symbol_index_type (psym
->st_shndx
));
13203 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13204 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13206 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13220 process_nds32_specific (FILE * file
)
13222 Elf_Internal_Shdr
*sect
= NULL
;
13224 sect
= find_section (".nds32_e_flags");
13227 unsigned int *flag
;
13229 printf ("\nNDS32 elf flags section:\n");
13230 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13231 sect
->sh_size
, _("NDS32 elf flags section"));
13233 switch ((*flag
) & 0x3)
13236 printf ("(VEC_SIZE):\tNo entry.\n");
13239 printf ("(VEC_SIZE):\t4 bytes\n");
13242 printf ("(VEC_SIZE):\t16 bytes\n");
13245 printf ("(VEC_SIZE):\treserved\n");
13254 process_gnu_liblist (FILE * file
)
13256 Elf_Internal_Shdr
* section
;
13257 Elf_Internal_Shdr
* string_sec
;
13258 Elf32_External_Lib
* elib
;
13260 size_t strtab_size
;
13267 for (i
= 0, section
= section_headers
;
13268 i
< elf_header
.e_shnum
;
13271 switch (section
->sh_type
)
13273 case SHT_GNU_LIBLIST
:
13274 if (section
->sh_link
>= elf_header
.e_shnum
)
13277 elib
= (Elf32_External_Lib
*)
13278 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13279 _("liblist section data"));
13283 string_sec
= section_headers
+ section
->sh_link
;
13285 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13286 string_sec
->sh_size
,
13287 _("liblist string table"));
13289 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13295 strtab_size
= string_sec
->sh_size
;
13297 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13298 SECTION_NAME (section
),
13299 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13301 puts (_(" Library Time Stamp Checksum Version Flags"));
13303 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13311 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13312 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13313 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13314 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13315 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13317 tmp
= gmtime (&atime
);
13318 snprintf (timebuf
, sizeof (timebuf
),
13319 "%04u-%02u-%02uT%02u:%02u:%02u",
13320 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13321 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13323 printf ("%3lu: ", (unsigned long) cnt
);
13325 printf ("%-20s", liblist
.l_name
< strtab_size
13326 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13328 printf ("%-20.20s", liblist
.l_name
< strtab_size
13329 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13330 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13331 liblist
.l_version
, liblist
.l_flags
);
13342 static const char *
13343 get_note_type (unsigned e_type
)
13345 static char buff
[64];
13347 if (elf_header
.e_type
== ET_CORE
)
13351 return _("NT_AUXV (auxiliary vector)");
13353 return _("NT_PRSTATUS (prstatus structure)");
13355 return _("NT_FPREGSET (floating point registers)");
13357 return _("NT_PRPSINFO (prpsinfo structure)");
13358 case NT_TASKSTRUCT
:
13359 return _("NT_TASKSTRUCT (task structure)");
13361 return _("NT_PRXFPREG (user_xfpregs structure)");
13363 return _("NT_PPC_VMX (ppc Altivec registers)");
13365 return _("NT_PPC_VSX (ppc VSX registers)");
13367 return _("NT_386_TLS (x86 TLS information)");
13368 case NT_386_IOPERM
:
13369 return _("NT_386_IOPERM (x86 I/O permissions)");
13370 case NT_X86_XSTATE
:
13371 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13372 case NT_S390_HIGH_GPRS
:
13373 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13374 case NT_S390_TIMER
:
13375 return _("NT_S390_TIMER (s390 timer register)");
13376 case NT_S390_TODCMP
:
13377 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13378 case NT_S390_TODPREG
:
13379 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13381 return _("NT_S390_CTRS (s390 control registers)");
13382 case NT_S390_PREFIX
:
13383 return _("NT_S390_PREFIX (s390 prefix register)");
13384 case NT_S390_LAST_BREAK
:
13385 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13386 case NT_S390_SYSTEM_CALL
:
13387 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13389 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13391 return _("NT_ARM_VFP (arm VFP registers)");
13393 return _("NT_ARM_TLS (AArch TLS registers)");
13394 case NT_ARM_HW_BREAK
:
13395 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13396 case NT_ARM_HW_WATCH
:
13397 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13399 return _("NT_PSTATUS (pstatus structure)");
13401 return _("NT_FPREGS (floating point registers)");
13403 return _("NT_PSINFO (psinfo structure)");
13405 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13407 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13408 case NT_WIN32PSTATUS
:
13409 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13411 return _("NT_SIGINFO (siginfo_t data)");
13413 return _("NT_FILE (mapped files)");
13421 return _("NT_VERSION (version)");
13423 return _("NT_ARCH (architecture)");
13428 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13433 print_core_note (Elf_Internal_Note
*pnote
)
13435 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13436 bfd_vma count
, page_size
;
13437 unsigned char *descdata
, *filenames
, *descend
;
13439 if (pnote
->type
!= NT_FILE
)
13445 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13446 /* Still "successful". */
13451 if (pnote
->descsz
< 2 * addr_size
)
13453 printf (_(" Malformed note - too short for header\n"));
13457 descdata
= (unsigned char *) pnote
->descdata
;
13458 descend
= descdata
+ pnote
->descsz
;
13460 if (descdata
[pnote
->descsz
- 1] != '\0')
13462 printf (_(" Malformed note - does not end with \\0\n"));
13466 count
= byte_get (descdata
, addr_size
);
13467 descdata
+= addr_size
;
13469 page_size
= byte_get (descdata
, addr_size
);
13470 descdata
+= addr_size
;
13472 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13474 printf (_(" Malformed note - too short for supplied file count\n"));
13478 printf (_(" Page size: "));
13479 print_vma (page_size
, DEC
);
13482 printf (_(" %*s%*s%*s\n"),
13483 (int) (2 + 2 * addr_size
), _("Start"),
13484 (int) (4 + 2 * addr_size
), _("End"),
13485 (int) (4 + 2 * addr_size
), _("Page Offset"));
13486 filenames
= descdata
+ count
* 3 * addr_size
;
13487 while (--count
> 0)
13489 bfd_vma start
, end
, file_ofs
;
13491 if (filenames
== descend
)
13493 printf (_(" Malformed note - filenames end too early\n"));
13497 start
= byte_get (descdata
, addr_size
);
13498 descdata
+= addr_size
;
13499 end
= byte_get (descdata
, addr_size
);
13500 descdata
+= addr_size
;
13501 file_ofs
= byte_get (descdata
, addr_size
);
13502 descdata
+= addr_size
;
13505 print_vma (start
, FULL_HEX
);
13507 print_vma (end
, FULL_HEX
);
13509 print_vma (file_ofs
, FULL_HEX
);
13510 printf ("\n %s\n", filenames
);
13512 filenames
+= 1 + strlen ((char *) filenames
);
13518 static const char *
13519 get_gnu_elf_note_type (unsigned e_type
)
13521 static char buff
[64];
13525 case NT_GNU_ABI_TAG
:
13526 return _("NT_GNU_ABI_TAG (ABI version tag)");
13528 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13529 case NT_GNU_BUILD_ID
:
13530 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13531 case NT_GNU_GOLD_VERSION
:
13532 return _("NT_GNU_GOLD_VERSION (gold version)");
13537 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13542 print_gnu_note (Elf_Internal_Note
*pnote
)
13544 switch (pnote
->type
)
13546 case NT_GNU_BUILD_ID
:
13550 printf (_(" Build ID: "));
13551 for (i
= 0; i
< pnote
->descsz
; ++i
)
13552 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13557 case NT_GNU_ABI_TAG
:
13559 unsigned long os
, major
, minor
, subminor
;
13560 const char *osname
;
13562 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13563 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13564 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13565 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13569 case GNU_ABI_TAG_LINUX
:
13572 case GNU_ABI_TAG_HURD
:
13575 case GNU_ABI_TAG_SOLARIS
:
13576 osname
= "Solaris";
13578 case GNU_ABI_TAG_FREEBSD
:
13579 osname
= "FreeBSD";
13581 case GNU_ABI_TAG_NETBSD
:
13585 osname
= "Unknown";
13589 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13590 major
, minor
, subminor
);
13594 case NT_GNU_GOLD_VERSION
:
13598 printf (_(" Version: "));
13599 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13600 printf ("%c", pnote
->descdata
[i
]);
13609 static const char *
13610 get_netbsd_elfcore_note_type (unsigned e_type
)
13612 static char buff
[64];
13614 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13616 /* NetBSD core "procinfo" structure. */
13617 return _("NetBSD procinfo structure");
13620 /* As of Jan 2002 there are no other machine-independent notes
13621 defined for NetBSD core files. If the note type is less
13622 than the start of the machine-dependent note types, we don't
13625 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13627 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13631 switch (elf_header
.e_machine
)
13633 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13634 and PT_GETFPREGS == mach+2. */
13639 case EM_SPARC32PLUS
:
13643 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13644 return _("PT_GETREGS (reg structure)");
13645 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13646 return _("PT_GETFPREGS (fpreg structure)");
13652 /* On all other arch's, PT_GETREGS == mach+1 and
13653 PT_GETFPREGS == mach+3. */
13657 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13658 return _("PT_GETREGS (reg structure)");
13659 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13660 return _("PT_GETFPREGS (fpreg structure)");
13666 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13667 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13671 static const char *
13672 get_stapsdt_note_type (unsigned e_type
)
13674 static char buff
[64];
13679 return _("NT_STAPSDT (SystemTap probe descriptors)");
13685 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13690 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13692 int addr_size
= is_32bit_elf
? 4 : 8;
13693 char *data
= pnote
->descdata
;
13694 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13695 bfd_vma pc
, base_addr
, semaphore
;
13696 char *provider
, *probe
, *arg_fmt
;
13698 pc
= byte_get ((unsigned char *) data
, addr_size
);
13700 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13702 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13706 data
+= strlen (data
) + 1;
13708 data
+= strlen (data
) + 1;
13710 data
+= strlen (data
) + 1;
13712 printf (_(" Provider: %s\n"), provider
);
13713 printf (_(" Name: %s\n"), probe
);
13714 printf (_(" Location: "));
13715 print_vma (pc
, FULL_HEX
);
13716 printf (_(", Base: "));
13717 print_vma (base_addr
, FULL_HEX
);
13718 printf (_(", Semaphore: "));
13719 print_vma (semaphore
, FULL_HEX
);
13721 printf (_(" Arguments: %s\n"), arg_fmt
);
13723 return data
== data_end
;
13726 static const char *
13727 get_ia64_vms_note_type (unsigned e_type
)
13729 static char buff
[64];
13734 return _("NT_VMS_MHD (module header)");
13736 return _("NT_VMS_LNM (language name)");
13738 return _("NT_VMS_SRC (source files)");
13740 return "NT_VMS_TITLE";
13742 return _("NT_VMS_EIDC (consistency check)");
13743 case NT_VMS_FPMODE
:
13744 return _("NT_VMS_FPMODE (FP mode)");
13745 case NT_VMS_LINKTIME
:
13746 return "NT_VMS_LINKTIME";
13747 case NT_VMS_IMGNAM
:
13748 return _("NT_VMS_IMGNAM (image name)");
13750 return _("NT_VMS_IMGID (image id)");
13751 case NT_VMS_LINKID
:
13752 return _("NT_VMS_LINKID (link id)");
13753 case NT_VMS_IMGBID
:
13754 return _("NT_VMS_IMGBID (build id)");
13755 case NT_VMS_GSTNAM
:
13756 return _("NT_VMS_GSTNAM (sym table name)");
13757 case NT_VMS_ORIG_DYN
:
13758 return "NT_VMS_ORIG_DYN";
13759 case NT_VMS_PATCHTIME
:
13760 return "NT_VMS_PATCHTIME";
13762 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13768 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13770 switch (pnote
->type
)
13773 if (pnote
->descsz
> 36)
13775 size_t l
= strlen (pnote
->descdata
+ 34);
13776 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13777 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13778 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13779 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13782 printf (_(" Invalid size\n"));
13785 printf (_(" Language: %s\n"), pnote
->descdata
);
13788 case NT_VMS_FPMODE
:
13789 printf (_(" Floating Point mode: "));
13790 printf ("0x%016" BFD_VMA_FMT
"x\n",
13791 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13793 case NT_VMS_LINKTIME
:
13794 printf (_(" Link time: "));
13796 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13799 case NT_VMS_PATCHTIME
:
13800 printf (_(" Patch time: "));
13802 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13805 case NT_VMS_ORIG_DYN
:
13806 printf (_(" Major id: %u, minor id: %u\n"),
13807 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13808 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13809 printf (_(" Last modified : "));
13811 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13812 printf (_("\n Link flags : "));
13813 printf ("0x%016" BFD_VMA_FMT
"x\n",
13814 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13815 printf (_(" Header flags: 0x%08x\n"),
13816 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13817 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13820 case NT_VMS_IMGNAM
:
13821 printf (_(" Image name: %s\n"), pnote
->descdata
);
13823 case NT_VMS_GSTNAM
:
13824 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13827 printf (_(" Image id: %s\n"), pnote
->descdata
);
13829 case NT_VMS_LINKID
:
13830 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13838 /* Note that by the ELF standard, the name field is already null byte
13839 terminated, and namesz includes the terminating null byte.
13840 I.E. the value of namesz for the name "FSF" is 4.
13842 If the value of namesz is zero, there is no name present. */
13844 process_note (Elf_Internal_Note
* pnote
)
13846 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13849 if (pnote
->namesz
== 0)
13850 /* If there is no note name, then use the default set of
13851 note type strings. */
13852 nt
= get_note_type (pnote
->type
);
13854 else if (const_strneq (pnote
->namedata
, "GNU"))
13855 /* GNU-specific object file notes. */
13856 nt
= get_gnu_elf_note_type (pnote
->type
);
13858 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13859 /* NetBSD-specific core file notes. */
13860 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13862 else if (strneq (pnote
->namedata
, "SPU/", 4))
13864 /* SPU-specific core file notes. */
13865 nt
= pnote
->namedata
+ 4;
13869 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13870 /* VMS/ia64-specific file notes. */
13871 nt
= get_ia64_vms_note_type (pnote
->type
);
13873 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13874 nt
= get_stapsdt_note_type (pnote
->type
);
13877 /* Don't recognize this note name; just use the default set of
13878 note type strings. */
13879 nt
= get_note_type (pnote
->type
);
13881 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13883 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13884 return print_ia64_vms_note (pnote
);
13885 else if (const_strneq (pnote
->namedata
, "GNU"))
13886 return print_gnu_note (pnote
);
13887 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13888 return print_stapsdt_note (pnote
);
13889 else if (const_strneq (pnote
->namedata
, "CORE"))
13890 return print_core_note (pnote
);
13897 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13899 Elf_External_Note
* pnotes
;
13900 Elf_External_Note
* external
;
13906 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13908 if (pnotes
== NULL
)
13913 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13914 (unsigned long) offset
, (unsigned long) length
);
13915 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13917 while ((char *) external
< (char *) pnotes
+ length
)
13919 Elf_Internal_Note inote
;
13922 char * temp
= NULL
;
13923 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
13925 if (!is_ia64_vms ())
13927 /* PR binutils/15191
13928 Make sure that there is enough data to read. */
13929 min_notesz
= offsetof (Elf_External_Note
, name
);
13930 if (data_remaining
< min_notesz
)
13932 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13933 (int) data_remaining
);
13936 inote
.type
= BYTE_GET (external
->type
);
13937 inote
.namesz
= BYTE_GET (external
->namesz
);
13938 inote
.namedata
= external
->name
;
13939 inote
.descsz
= BYTE_GET (external
->descsz
);
13940 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13941 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13942 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
13946 Elf64_External_VMS_Note
*vms_external
;
13948 /* PR binutils/15191
13949 Make sure that there is enough data to read. */
13950 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
13951 if (data_remaining
< min_notesz
)
13953 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13954 (int) data_remaining
);
13958 vms_external
= (Elf64_External_VMS_Note
*) external
;
13959 inote
.type
= BYTE_GET (vms_external
->type
);
13960 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13961 inote
.namedata
= vms_external
->name
;
13962 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13963 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13964 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13965 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
13968 if (inote
.descdata
< (char *) external
+ min_notesz
13969 || next
< (char *) external
+ min_notesz
13970 || data_remaining
< (size_t)(next
- (char *) external
))
13972 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13973 (unsigned long) ((char *) external
- (char *) pnotes
));
13974 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13975 inote
.type
, inote
.namesz
, inote
.descsz
);
13979 external
= (Elf_External_Note
*) next
;
13981 /* Verify that name is null terminated. It appears that at least
13982 one version of Linux (RedHat 6.0) generates corefiles that don't
13983 comply with the ELF spec by failing to include the null byte in
13985 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13987 temp
= (char *) malloc (inote
.namesz
+ 1);
13991 error (_("Out of memory\n"));
13996 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13997 temp
[inote
.namesz
] = 0;
13999 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14000 inote
.namedata
= temp
;
14003 res
&= process_note (& inote
);
14018 process_corefile_note_segments (FILE * file
)
14020 Elf_Internal_Phdr
* segment
;
14024 if (! get_program_headers (file
))
14027 for (i
= 0, segment
= program_headers
;
14028 i
< elf_header
.e_phnum
;
14031 if (segment
->p_type
== PT_NOTE
)
14032 res
&= process_corefile_note_segment (file
,
14033 (bfd_vma
) segment
->p_offset
,
14034 (bfd_vma
) segment
->p_filesz
);
14041 process_note_sections (FILE * file
)
14043 Elf_Internal_Shdr
* section
;
14047 for (i
= 0, section
= section_headers
;
14048 i
< elf_header
.e_shnum
&& section
!= NULL
;
14050 if (section
->sh_type
== SHT_NOTE
)
14051 res
&= process_corefile_note_segment (file
,
14052 (bfd_vma
) section
->sh_offset
,
14053 (bfd_vma
) section
->sh_size
);
14059 process_notes (FILE * file
)
14061 /* If we have not been asked to display the notes then do nothing. */
14065 if (elf_header
.e_type
!= ET_CORE
)
14066 return process_note_sections (file
);
14068 /* No program headers means no NOTE segment. */
14069 if (elf_header
.e_phnum
> 0)
14070 return process_corefile_note_segments (file
);
14072 printf (_("No note segments present in the core file.\n"));
14077 process_arch_specific (FILE * file
)
14082 switch (elf_header
.e_machine
)
14085 return process_arm_specific (file
);
14087 case EM_MIPS_RS3_LE
:
14088 return process_mips_specific (file
);
14091 return process_nds32_specific (file
);
14094 return process_power_specific (file
);
14097 case EM_SPARC32PLUS
:
14099 return process_sparc_specific (file
);
14102 return process_tic6x_specific (file
);
14105 return process_msp430x_specific (file
);
14113 get_file_header (FILE * file
)
14115 /* Read in the identity array. */
14116 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14119 /* Determine how to read the rest of the header. */
14120 switch (elf_header
.e_ident
[EI_DATA
])
14122 default: /* fall through */
14123 case ELFDATANONE
: /* fall through */
14125 byte_get
= byte_get_little_endian
;
14126 byte_put
= byte_put_little_endian
;
14129 byte_get
= byte_get_big_endian
;
14130 byte_put
= byte_put_big_endian
;
14134 /* For now we only support 32 bit and 64 bit ELF files. */
14135 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14137 /* Read in the rest of the header. */
14140 Elf32_External_Ehdr ehdr32
;
14142 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14145 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14146 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14147 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14148 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14149 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14150 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14151 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14152 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14153 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14154 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14155 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14156 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14157 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14161 Elf64_External_Ehdr ehdr64
;
14163 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14164 we will not be able to cope with the 64bit data found in
14165 64 ELF files. Detect this now and abort before we start
14166 overwriting things. */
14167 if (sizeof (bfd_vma
) < 8)
14169 error (_("This instance of readelf has been built without support for a\n\
14170 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14174 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14177 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14178 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14179 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14180 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14181 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14182 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14183 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14184 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14185 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14186 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14187 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14188 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14189 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14192 if (elf_header
.e_shoff
)
14194 /* There may be some extensions in the first section header. Don't
14195 bomb if we can't read it. */
14197 get_32bit_section_headers (file
, 1);
14199 get_64bit_section_headers (file
, 1);
14205 /* Process one ELF object file according to the command line options.
14206 This file may actually be stored in an archive. The file is
14207 positioned at the start of the ELF object. */
14210 process_object (char * file_name
, FILE * file
)
14214 if (! get_file_header (file
))
14216 error (_("%s: Failed to read file header\n"), file_name
);
14220 /* Initialise per file variables. */
14221 for (i
= ARRAY_SIZE (version_info
); i
--;)
14222 version_info
[i
] = 0;
14224 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14225 dynamic_info
[i
] = 0;
14226 dynamic_info_DT_GNU_HASH
= 0;
14228 /* Process the file. */
14230 printf (_("\nFile: %s\n"), file_name
);
14232 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14233 Note we do this even if cmdline_dump_sects is empty because we
14234 must make sure that the dump_sets array is zeroed out before each
14235 object file is processed. */
14236 if (num_dump_sects
> num_cmdline_dump_sects
)
14237 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14239 if (num_cmdline_dump_sects
> 0)
14241 if (num_dump_sects
== 0)
14242 /* A sneaky way of allocating the dump_sects array. */
14243 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14245 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14246 memcpy (dump_sects
, cmdline_dump_sects
,
14247 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14250 if (! process_file_header ())
14253 if (! process_section_headers (file
))
14255 /* Without loaded section headers we cannot process lots of
14257 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14259 if (! do_using_dynamic
)
14260 do_syms
= do_dyn_syms
= do_reloc
= 0;
14263 if (! process_section_groups (file
))
14265 /* Without loaded section groups we cannot process unwind. */
14269 if (process_program_headers (file
))
14270 process_dynamic_section (file
);
14272 process_relocs (file
);
14274 process_unwind (file
);
14276 process_symbol_table (file
);
14278 process_syminfo (file
);
14280 process_version_sections (file
);
14282 process_section_contents (file
);
14284 process_notes (file
);
14286 process_gnu_liblist (file
);
14288 process_arch_specific (file
);
14290 if (program_headers
)
14292 free (program_headers
);
14293 program_headers
= NULL
;
14296 if (section_headers
)
14298 free (section_headers
);
14299 section_headers
= NULL
;
14304 free (string_table
);
14305 string_table
= NULL
;
14306 string_table_length
= 0;
14309 if (dynamic_strings
)
14311 free (dynamic_strings
);
14312 dynamic_strings
= NULL
;
14313 dynamic_strings_length
= 0;
14316 if (dynamic_symbols
)
14318 free (dynamic_symbols
);
14319 dynamic_symbols
= NULL
;
14320 num_dynamic_syms
= 0;
14323 if (dynamic_syminfo
)
14325 free (dynamic_syminfo
);
14326 dynamic_syminfo
= NULL
;
14329 if (dynamic_section
)
14331 free (dynamic_section
);
14332 dynamic_section
= NULL
;
14335 if (section_headers_groups
)
14337 free (section_headers_groups
);
14338 section_headers_groups
= NULL
;
14341 if (section_groups
)
14343 struct group_list
* g
;
14344 struct group_list
* next
;
14346 for (i
= 0; i
< group_count
; i
++)
14348 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14355 free (section_groups
);
14356 section_groups
= NULL
;
14359 free_debug_memory ();
14364 /* Process an ELF archive.
14365 On entry the file is positioned just after the ARMAG string. */
14368 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14370 struct archive_info arch
;
14371 struct archive_info nested_arch
;
14377 /* The ARCH structure is used to hold information about this archive. */
14378 arch
.file_name
= NULL
;
14380 arch
.index_array
= NULL
;
14381 arch
.sym_table
= NULL
;
14382 arch
.longnames
= NULL
;
14384 /* The NESTED_ARCH structure is used as a single-item cache of information
14385 about a nested archive (when members of a thin archive reside within
14386 another regular archive file). */
14387 nested_arch
.file_name
= NULL
;
14388 nested_arch
.file
= NULL
;
14389 nested_arch
.index_array
= NULL
;
14390 nested_arch
.sym_table
= NULL
;
14391 nested_arch
.longnames
= NULL
;
14393 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14399 if (do_archive_index
)
14401 if (arch
.sym_table
== NULL
)
14402 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14406 unsigned long current_pos
;
14408 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14409 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14410 current_pos
= ftell (file
);
14412 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14414 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14416 char * member_name
;
14418 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14420 if (member_name
!= NULL
)
14422 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14424 if (qualified_name
!= NULL
)
14426 printf (_("Contents of binary %s at offset "), qualified_name
);
14427 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14429 free (qualified_name
);
14434 if (l
>= arch
.sym_size
)
14436 error (_("%s: end of the symbol table reached before the end of the index\n"),
14440 printf ("\t%s\n", arch
.sym_table
+ l
);
14441 l
+= strlen (arch
.sym_table
+ l
) + 1;
14444 if (arch
.uses_64bit_indicies
)
14449 if (l
< arch
.sym_size
)
14450 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14451 file_name
, arch
.sym_size
- l
);
14453 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14455 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14461 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14462 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14463 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14464 && !do_section_groups
&& !do_dyn_syms
)
14466 ret
= 0; /* Archive index only. */
14477 char * qualified_name
;
14479 /* Read the next archive header. */
14480 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14482 error (_("%s: failed to seek to next archive header\n"), file_name
);
14485 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14486 if (got
!= sizeof arch
.arhdr
)
14490 error (_("%s: failed to read archive header\n"), file_name
);
14494 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14496 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14501 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14503 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14504 if (archive_file_size
& 01)
14505 ++archive_file_size
;
14507 name
= get_archive_member_name (&arch
, &nested_arch
);
14510 error (_("%s: bad archive file name\n"), file_name
);
14514 namelen
= strlen (name
);
14516 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14517 if (qualified_name
== NULL
)
14519 error (_("%s: bad archive file name\n"), file_name
);
14524 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14526 /* This is a proxy for an external member of a thin archive. */
14527 FILE * member_file
;
14528 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14529 if (member_file_name
== NULL
)
14535 member_file
= fopen (member_file_name
, "rb");
14536 if (member_file
== NULL
)
14538 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14539 free (member_file_name
);
14544 archive_file_offset
= arch
.nested_member_origin
;
14546 ret
|= process_object (qualified_name
, member_file
);
14548 fclose (member_file
);
14549 free (member_file_name
);
14551 else if (is_thin_archive
)
14553 /* PR 15140: Allow for corrupt thin archives. */
14554 if (nested_arch
.file
== NULL
)
14556 error (_("%s: contains corrupt thin archive: %s\n"),
14562 /* This is a proxy for a member of a nested archive. */
14563 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14565 /* The nested archive file will have been opened and setup by
14566 get_archive_member_name. */
14567 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14569 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14574 ret
|= process_object (qualified_name
, nested_arch
.file
);
14578 archive_file_offset
= arch
.next_arhdr_offset
;
14579 arch
.next_arhdr_offset
+= archive_file_size
;
14581 ret
|= process_object (qualified_name
, file
);
14584 if (dump_sects
!= NULL
)
14588 num_dump_sects
= 0;
14591 free (qualified_name
);
14595 if (nested_arch
.file
!= NULL
)
14596 fclose (nested_arch
.file
);
14597 release_archive (&nested_arch
);
14598 release_archive (&arch
);
14604 process_file (char * file_name
)
14607 struct stat statbuf
;
14608 char armag
[SARMAG
];
14611 if (stat (file_name
, &statbuf
) < 0)
14613 if (errno
== ENOENT
)
14614 error (_("'%s': No such file\n"), file_name
);
14616 error (_("Could not locate '%s'. System error message: %s\n"),
14617 file_name
, strerror (errno
));
14621 if (! S_ISREG (statbuf
.st_mode
))
14623 error (_("'%s' is not an ordinary file\n"), file_name
);
14627 file
= fopen (file_name
, "rb");
14630 error (_("Input file '%s' is not readable.\n"), file_name
);
14634 if (fread (armag
, SARMAG
, 1, file
) != 1)
14636 error (_("%s: Failed to read file's magic number\n"), file_name
);
14641 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14642 ret
= process_archive (file_name
, file
, FALSE
);
14643 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14644 ret
= process_archive (file_name
, file
, TRUE
);
14647 if (do_archive_index
)
14648 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14652 archive_file_size
= archive_file_offset
= 0;
14653 ret
= process_object (file_name
, file
);
14661 #ifdef SUPPORT_DISASSEMBLY
14662 /* Needed by the i386 disassembler. For extra credit, someone could
14663 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14667 print_address (unsigned int addr
, FILE * outfile
)
14669 fprintf (outfile
,"0x%8.8x", addr
);
14672 /* Needed by the i386 disassembler. */
14674 db_task_printsym (unsigned int addr
)
14676 print_address (addr
, stderr
);
14681 main (int argc
, char ** argv
)
14685 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14686 setlocale (LC_MESSAGES
, "");
14688 #if defined (HAVE_SETLOCALE)
14689 setlocale (LC_CTYPE
, "");
14691 bindtextdomain (PACKAGE
, LOCALEDIR
);
14692 textdomain (PACKAGE
);
14694 expandargv (&argc
, &argv
);
14696 parse_args (argc
, argv
);
14698 if (num_dump_sects
> 0)
14700 /* Make a copy of the dump_sects array. */
14701 cmdline_dump_sects
= (dump_type
*)
14702 malloc (num_dump_sects
* sizeof (* dump_sects
));
14703 if (cmdline_dump_sects
== NULL
)
14704 error (_("Out of memory allocating dump request table.\n"));
14707 memcpy (cmdline_dump_sects
, dump_sects
,
14708 num_dump_sects
* sizeof (* dump_sects
));
14709 num_cmdline_dump_sects
= num_dump_sects
;
14713 if (optind
< (argc
- 1))
14717 while (optind
< argc
)
14718 err
|= process_file (argv
[optind
++]);
14720 if (dump_sects
!= NULL
)
14722 if (cmdline_dump_sects
!= NULL
)
14723 free (cmdline_dump_sects
);