1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998-2013 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/or32.h"
137 #include "elf/ppc64.h"
138 #include "elf/rl78.h"
140 #include "elf/s390.h"
141 #include "elf/score.h"
143 #include "elf/sparc.h"
145 #include "elf/tic6x.h"
146 #include "elf/tilegx.h"
147 #include "elf/tilepro.h"
148 #include "elf/v850.h"
150 #include "elf/x86-64.h"
151 #include "elf/xc16x.h"
152 #include "elf/xgate.h"
153 #include "elf/xstormy16.h"
154 #include "elf/xtensa.h"
156 #include "elf/nios2.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
:
656 case EM_MICROBLAZE_OLD
:
677 warn (_("Don't know about relocations on this machine architecture\n"));
683 slurp_rela_relocs (FILE * file
,
684 unsigned long rel_offset
,
685 unsigned long rel_size
,
686 Elf_Internal_Rela
** relasp
,
687 unsigned long * nrelasp
)
689 Elf_Internal_Rela
* relas
;
690 unsigned long nrelas
;
695 Elf32_External_Rela
* erelas
;
697 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
698 rel_size
, _("32-bit relocation data"));
702 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
704 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
705 sizeof (Elf_Internal_Rela
));
710 error (_("out of memory parsing relocs\n"));
714 for (i
= 0; i
< nrelas
; i
++)
716 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
717 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
718 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
725 Elf64_External_Rela
* erelas
;
727 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
728 rel_size
, _("64-bit relocation data"));
732 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
734 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
735 sizeof (Elf_Internal_Rela
));
740 error (_("out of memory parsing relocs\n"));
744 for (i
= 0; i
< nrelas
; i
++)
746 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
747 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
748 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
750 /* The #ifdef BFD64 below is to prevent a compile time
751 warning. We know that if we do not have a 64 bit data
752 type that we will never execute this code anyway. */
754 if (elf_header
.e_machine
== EM_MIPS
755 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
757 /* In little-endian objects, r_info isn't really a
758 64-bit little-endian value: it has a 32-bit
759 little-endian symbol index followed by four
760 individual byte fields. Reorder INFO
762 bfd_vma inf
= relas
[i
].r_info
;
763 inf
= (((inf
& 0xffffffff) << 32)
764 | ((inf
>> 56) & 0xff)
765 | ((inf
>> 40) & 0xff00)
766 | ((inf
>> 24) & 0xff0000)
767 | ((inf
>> 8) & 0xff000000));
768 relas
[i
].r_info
= inf
;
781 slurp_rel_relocs (FILE * file
,
782 unsigned long rel_offset
,
783 unsigned long rel_size
,
784 Elf_Internal_Rela
** relsp
,
785 unsigned long * nrelsp
)
787 Elf_Internal_Rela
* rels
;
793 Elf32_External_Rel
* erels
;
795 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
796 rel_size
, _("32-bit relocation data"));
800 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
802 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
807 error (_("out of memory parsing relocs\n"));
811 for (i
= 0; i
< nrels
; i
++)
813 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
814 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
815 rels
[i
].r_addend
= 0;
822 Elf64_External_Rel
* erels
;
824 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
825 rel_size
, _("64-bit relocation data"));
829 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
831 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
836 error (_("out of memory parsing relocs\n"));
840 for (i
= 0; i
< nrels
; i
++)
842 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
843 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
844 rels
[i
].r_addend
= 0;
846 /* The #ifdef BFD64 below is to prevent a compile time
847 warning. We know that if we do not have a 64 bit data
848 type that we will never execute this code anyway. */
850 if (elf_header
.e_machine
== EM_MIPS
851 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
853 /* In little-endian objects, r_info isn't really a
854 64-bit little-endian value: it has a 32-bit
855 little-endian symbol index followed by four
856 individual byte fields. Reorder INFO
858 bfd_vma inf
= rels
[i
].r_info
;
859 inf
= (((inf
& 0xffffffff) << 32)
860 | ((inf
>> 56) & 0xff)
861 | ((inf
>> 40) & 0xff00)
862 | ((inf
>> 24) & 0xff0000)
863 | ((inf
>> 8) & 0xff000000));
864 rels
[i
].r_info
= inf
;
876 /* Returns the reloc type extracted from the reloc info field. */
879 get_reloc_type (bfd_vma reloc_info
)
882 return ELF32_R_TYPE (reloc_info
);
884 switch (elf_header
.e_machine
)
887 /* Note: We assume that reloc_info has already been adjusted for us. */
888 return ELF64_MIPS_R_TYPE (reloc_info
);
891 return ELF64_R_TYPE_ID (reloc_info
);
894 return ELF64_R_TYPE (reloc_info
);
898 /* Return the symbol index extracted from the reloc info field. */
901 get_reloc_symindex (bfd_vma reloc_info
)
903 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
906 /* Display the contents of the relocation data found at the specified
910 dump_relocations (FILE * file
,
911 unsigned long rel_offset
,
912 unsigned long rel_size
,
913 Elf_Internal_Sym
* symtab
,
916 unsigned long strtablen
,
920 Elf_Internal_Rela
* rels
;
922 if (is_rela
== UNKNOWN
)
923 is_rela
= guess_is_rela (elf_header
.e_machine
);
927 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
932 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
941 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
943 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
948 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
950 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
958 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
960 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
965 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
967 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
971 for (i
= 0; i
< rel_size
; i
++)
976 bfd_vma symtab_index
;
979 offset
= rels
[i
].r_offset
;
980 inf
= rels
[i
].r_info
;
982 type
= get_reloc_type (inf
);
983 symtab_index
= get_reloc_symindex (inf
);
987 printf ("%8.8lx %8.8lx ",
988 (unsigned long) offset
& 0xffffffff,
989 (unsigned long) inf
& 0xffffffff);
993 #if BFD_HOST_64BIT_LONG
995 ? "%16.16lx %16.16lx "
996 : "%12.12lx %12.12lx ",
998 #elif BFD_HOST_64BIT_LONG_LONG
1001 ? "%16.16llx %16.16llx "
1002 : "%12.12llx %12.12llx ",
1006 ? "%16.16I64x %16.16I64x "
1007 : "%12.12I64x %12.12I64x ",
1012 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1013 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1014 _bfd_int64_high (offset
),
1015 _bfd_int64_low (offset
),
1016 _bfd_int64_high (inf
),
1017 _bfd_int64_low (inf
));
1021 switch (elf_header
.e_machine
)
1028 rtype
= elf_aarch64_reloc_type (type
);
1032 case EM_CYGNUS_M32R
:
1033 rtype
= elf_m32r_reloc_type (type
);
1038 rtype
= elf_i386_reloc_type (type
);
1043 rtype
= elf_m68hc11_reloc_type (type
);
1047 rtype
= elf_m68k_reloc_type (type
);
1051 rtype
= elf_i960_reloc_type (type
);
1056 rtype
= elf_avr_reloc_type (type
);
1059 case EM_OLD_SPARCV9
:
1060 case EM_SPARC32PLUS
:
1063 rtype
= elf_sparc_reloc_type (type
);
1067 rtype
= elf_spu_reloc_type (type
);
1071 rtype
= v800_reloc_type (type
);
1074 case EM_CYGNUS_V850
:
1075 rtype
= v850_reloc_type (type
);
1079 case EM_CYGNUS_D10V
:
1080 rtype
= elf_d10v_reloc_type (type
);
1084 case EM_CYGNUS_D30V
:
1085 rtype
= elf_d30v_reloc_type (type
);
1089 rtype
= elf_dlx_reloc_type (type
);
1093 rtype
= elf_sh_reloc_type (type
);
1097 case EM_CYGNUS_MN10300
:
1098 rtype
= elf_mn10300_reloc_type (type
);
1102 case EM_CYGNUS_MN10200
:
1103 rtype
= elf_mn10200_reloc_type (type
);
1107 case EM_CYGNUS_FR30
:
1108 rtype
= elf_fr30_reloc_type (type
);
1112 rtype
= elf_frv_reloc_type (type
);
1116 rtype
= elf_mcore_reloc_type (type
);
1120 rtype
= elf_mmix_reloc_type (type
);
1124 rtype
= elf_moxie_reloc_type (type
);
1129 rtype
= elf_msp430_reloc_type (type
);
1133 rtype
= elf_ppc_reloc_type (type
);
1137 rtype
= elf_ppc64_reloc_type (type
);
1141 case EM_MIPS_RS3_LE
:
1142 rtype
= elf_mips_reloc_type (type
);
1146 rtype
= elf_alpha_reloc_type (type
);
1150 rtype
= elf_arm_reloc_type (type
);
1154 rtype
= elf_arc_reloc_type (type
);
1158 rtype
= elf_hppa_reloc_type (type
);
1164 rtype
= elf_h8_reloc_type (type
);
1169 rtype
= elf_or32_reloc_type (type
);
1174 rtype
= elf_pj_reloc_type (type
);
1177 rtype
= elf_ia64_reloc_type (type
);
1181 rtype
= elf_cris_reloc_type (type
);
1185 rtype
= elf_i860_reloc_type (type
);
1191 rtype
= elf_x86_64_reloc_type (type
);
1195 rtype
= i370_reloc_type (type
);
1200 rtype
= elf_s390_reloc_type (type
);
1204 rtype
= elf_score_reloc_type (type
);
1208 rtype
= elf_xstormy16_reloc_type (type
);
1212 rtype
= elf_crx_reloc_type (type
);
1216 rtype
= elf_vax_reloc_type (type
);
1219 case EM_ADAPTEVA_EPIPHANY
:
1220 rtype
= elf_epiphany_reloc_type (type
);
1225 rtype
= elf_ip2k_reloc_type (type
);
1229 rtype
= elf_iq2000_reloc_type (type
);
1234 rtype
= elf_xtensa_reloc_type (type
);
1237 case EM_LATTICEMICO32
:
1238 rtype
= elf_lm32_reloc_type (type
);
1243 rtype
= elf_m32c_reloc_type (type
);
1247 rtype
= elf_mt_reloc_type (type
);
1251 rtype
= elf_bfin_reloc_type (type
);
1255 rtype
= elf_mep_reloc_type (type
);
1259 rtype
= elf_cr16_reloc_type (type
);
1263 case EM_MICROBLAZE_OLD
:
1264 rtype
= elf_microblaze_reloc_type (type
);
1268 rtype
= elf_rl78_reloc_type (type
);
1272 rtype
= elf_rx_reloc_type (type
);
1276 rtype
= elf_metag_reloc_type (type
);
1281 rtype
= elf_xc16x_reloc_type (type
);
1285 rtype
= elf_tic6x_reloc_type (type
);
1289 rtype
= elf_tilegx_reloc_type (type
);
1293 rtype
= elf_tilepro_reloc_type (type
);
1297 rtype
= elf_xgate_reloc_type (type
);
1300 case EM_ALTERA_NIOS2
:
1301 rtype
= elf_nios2_reloc_type (type
);
1306 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1308 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1310 if (elf_header
.e_machine
== EM_ALPHA
1312 && streq (rtype
, "R_ALPHA_LITUSE")
1315 switch (rels
[i
].r_addend
)
1317 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1318 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1319 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1320 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1321 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1322 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1323 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1324 default: rtype
= NULL
;
1327 printf (" (%s)", rtype
);
1331 printf (_("<unknown addend: %lx>"),
1332 (unsigned long) rels
[i
].r_addend
);
1335 else if (symtab_index
)
1337 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1338 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1341 Elf_Internal_Sym
* psym
;
1343 psym
= symtab
+ symtab_index
;
1347 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1351 unsigned int width
= is_32bit_elf
? 8 : 14;
1353 /* Relocations against GNU_IFUNC symbols do not use the value
1354 of the symbol as the address to relocate against. Instead
1355 they invoke the function named by the symbol and use its
1356 result as the address for relocation.
1358 To indicate this to the user, do not display the value of
1359 the symbol in the "Symbols's Value" field. Instead show
1360 its name followed by () as a hint that the symbol is
1364 || psym
->st_name
== 0
1365 || psym
->st_name
>= strtablen
)
1368 name
= strtab
+ psym
->st_name
;
1370 len
= print_symbol (width
, name
);
1371 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1375 print_vma (psym
->st_value
, LONG_HEX
);
1377 printf (is_32bit_elf
? " " : " ");
1380 if (psym
->st_name
== 0)
1382 const char * sec_name
= "<null>";
1385 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1387 if (psym
->st_shndx
< elf_header
.e_shnum
)
1389 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1390 else if (psym
->st_shndx
== SHN_ABS
)
1392 else if (psym
->st_shndx
== SHN_COMMON
)
1393 sec_name
= "COMMON";
1394 else if ((elf_header
.e_machine
== EM_MIPS
1395 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1396 || (elf_header
.e_machine
== EM_TI_C6000
1397 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1398 sec_name
= "SCOMMON";
1399 else if (elf_header
.e_machine
== EM_MIPS
1400 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1401 sec_name
= "SUNDEF";
1402 else if ((elf_header
.e_machine
== EM_X86_64
1403 || elf_header
.e_machine
== EM_L1OM
1404 || elf_header
.e_machine
== EM_K1OM
)
1405 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1406 sec_name
= "LARGE_COMMON";
1407 else if (elf_header
.e_machine
== EM_IA_64
1408 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1409 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1410 sec_name
= "ANSI_COM";
1411 else if (is_ia64_vms ()
1412 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1413 sec_name
= "VMS_SYMVEC";
1416 sprintf (name_buf
, "<section 0x%x>",
1417 (unsigned int) psym
->st_shndx
);
1418 sec_name
= name_buf
;
1421 print_symbol (22, sec_name
);
1423 else if (strtab
== NULL
)
1424 printf (_("<string table index: %3ld>"), psym
->st_name
);
1425 else if (psym
->st_name
>= strtablen
)
1426 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1428 print_symbol (22, strtab
+ psym
->st_name
);
1432 bfd_signed_vma off
= rels
[i
].r_addend
;
1435 printf (" - %" BFD_VMA_FMT
"x", - off
);
1437 printf (" + %" BFD_VMA_FMT
"x", off
);
1443 bfd_signed_vma off
= rels
[i
].r_addend
;
1445 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1447 printf ("-%" BFD_VMA_FMT
"x", - off
);
1449 printf ("%" BFD_VMA_FMT
"x", off
);
1452 if (elf_header
.e_machine
== EM_SPARCV9
1454 && streq (rtype
, "R_SPARC_OLO10"))
1455 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1460 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1462 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1463 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1464 const char * rtype2
= elf_mips_reloc_type (type2
);
1465 const char * rtype3
= elf_mips_reloc_type (type3
);
1467 printf (" Type2: ");
1470 printf (_("unrecognized: %-7lx"),
1471 (unsigned long) type2
& 0xffffffff);
1473 printf ("%-17.17s", rtype2
);
1475 printf ("\n Type3: ");
1478 printf (_("unrecognized: %-7lx"),
1479 (unsigned long) type3
& 0xffffffff);
1481 printf ("%-17.17s", rtype3
);
1492 get_mips_dynamic_type (unsigned long type
)
1496 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1497 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1498 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1499 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1500 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1501 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1502 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1503 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1504 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1505 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1506 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1507 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1508 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1509 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1510 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1511 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1512 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1513 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1514 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1515 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1516 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1517 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1518 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1519 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1520 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1521 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1522 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1523 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1524 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1525 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1526 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1527 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1528 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1529 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1530 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1531 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1532 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1533 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1534 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1535 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1536 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1537 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1538 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1539 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1540 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1547 get_sparc64_dynamic_type (unsigned long type
)
1551 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1558 get_ppc_dynamic_type (unsigned long type
)
1562 case DT_PPC_GOT
: return "PPC_GOT";
1563 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1570 get_ppc64_dynamic_type (unsigned long type
)
1574 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1575 case DT_PPC64_OPD
: return "PPC64_OPD";
1576 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1577 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1584 get_parisc_dynamic_type (unsigned long type
)
1588 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1589 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1590 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1591 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1592 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1593 case DT_HP_PREINIT
: return "HP_PREINIT";
1594 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1595 case DT_HP_NEEDED
: return "HP_NEEDED";
1596 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1597 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1598 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1599 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1600 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1601 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1602 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1603 case DT_HP_FILTERED
: return "HP_FILTERED";
1604 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1605 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1606 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1607 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1608 case DT_PLT
: return "PLT";
1609 case DT_PLT_SIZE
: return "PLT_SIZE";
1610 case DT_DLT
: return "DLT";
1611 case DT_DLT_SIZE
: return "DLT_SIZE";
1618 get_ia64_dynamic_type (unsigned long type
)
1622 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1623 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1624 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1625 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1626 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1627 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1628 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1629 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1630 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1631 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1632 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1633 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1634 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1635 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1636 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1637 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1638 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1639 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1640 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1641 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1642 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1643 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1644 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1645 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1646 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1647 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1648 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1649 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1650 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1651 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1652 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1659 get_alpha_dynamic_type (unsigned long type
)
1663 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1670 get_score_dynamic_type (unsigned long type
)
1674 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1675 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1676 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1677 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1678 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1679 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1686 get_tic6x_dynamic_type (unsigned long type
)
1690 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1691 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1692 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1693 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1694 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1695 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1702 get_nios2_dynamic_type (unsigned long type
)
1706 case DT_NIOS2_GP
: return "NIOS2_GP";
1713 get_dynamic_type (unsigned long type
)
1715 static char buff
[64];
1719 case DT_NULL
: return "NULL";
1720 case DT_NEEDED
: return "NEEDED";
1721 case DT_PLTRELSZ
: return "PLTRELSZ";
1722 case DT_PLTGOT
: return "PLTGOT";
1723 case DT_HASH
: return "HASH";
1724 case DT_STRTAB
: return "STRTAB";
1725 case DT_SYMTAB
: return "SYMTAB";
1726 case DT_RELA
: return "RELA";
1727 case DT_RELASZ
: return "RELASZ";
1728 case DT_RELAENT
: return "RELAENT";
1729 case DT_STRSZ
: return "STRSZ";
1730 case DT_SYMENT
: return "SYMENT";
1731 case DT_INIT
: return "INIT";
1732 case DT_FINI
: return "FINI";
1733 case DT_SONAME
: return "SONAME";
1734 case DT_RPATH
: return "RPATH";
1735 case DT_SYMBOLIC
: return "SYMBOLIC";
1736 case DT_REL
: return "REL";
1737 case DT_RELSZ
: return "RELSZ";
1738 case DT_RELENT
: return "RELENT";
1739 case DT_PLTREL
: return "PLTREL";
1740 case DT_DEBUG
: return "DEBUG";
1741 case DT_TEXTREL
: return "TEXTREL";
1742 case DT_JMPREL
: return "JMPREL";
1743 case DT_BIND_NOW
: return "BIND_NOW";
1744 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1745 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1746 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1747 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1748 case DT_RUNPATH
: return "RUNPATH";
1749 case DT_FLAGS
: return "FLAGS";
1751 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1752 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1754 case DT_CHECKSUM
: return "CHECKSUM";
1755 case DT_PLTPADSZ
: return "PLTPADSZ";
1756 case DT_MOVEENT
: return "MOVEENT";
1757 case DT_MOVESZ
: return "MOVESZ";
1758 case DT_FEATURE
: return "FEATURE";
1759 case DT_POSFLAG_1
: return "POSFLAG_1";
1760 case DT_SYMINSZ
: return "SYMINSZ";
1761 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1763 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1764 case DT_CONFIG
: return "CONFIG";
1765 case DT_DEPAUDIT
: return "DEPAUDIT";
1766 case DT_AUDIT
: return "AUDIT";
1767 case DT_PLTPAD
: return "PLTPAD";
1768 case DT_MOVETAB
: return "MOVETAB";
1769 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1771 case DT_VERSYM
: return "VERSYM";
1773 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1774 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1775 case DT_RELACOUNT
: return "RELACOUNT";
1776 case DT_RELCOUNT
: return "RELCOUNT";
1777 case DT_FLAGS_1
: return "FLAGS_1";
1778 case DT_VERDEF
: return "VERDEF";
1779 case DT_VERDEFNUM
: return "VERDEFNUM";
1780 case DT_VERNEED
: return "VERNEED";
1781 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1783 case DT_AUXILIARY
: return "AUXILIARY";
1784 case DT_USED
: return "USED";
1785 case DT_FILTER
: return "FILTER";
1787 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1788 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1789 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1790 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1791 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1792 case DT_GNU_HASH
: return "GNU_HASH";
1795 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1797 const char * result
;
1799 switch (elf_header
.e_machine
)
1802 case EM_MIPS_RS3_LE
:
1803 result
= get_mips_dynamic_type (type
);
1806 result
= get_sparc64_dynamic_type (type
);
1809 result
= get_ppc_dynamic_type (type
);
1812 result
= get_ppc64_dynamic_type (type
);
1815 result
= get_ia64_dynamic_type (type
);
1818 result
= get_alpha_dynamic_type (type
);
1821 result
= get_score_dynamic_type (type
);
1824 result
= get_tic6x_dynamic_type (type
);
1826 case EM_ALTERA_NIOS2
:
1827 result
= get_nios2_dynamic_type (type
);
1837 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1839 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1840 || (elf_header
.e_machine
== EM_PARISC
1841 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1843 const char * result
;
1845 switch (elf_header
.e_machine
)
1848 result
= get_parisc_dynamic_type (type
);
1851 result
= get_ia64_dynamic_type (type
);
1861 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1865 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1872 get_file_type (unsigned e_type
)
1874 static char buff
[32];
1878 case ET_NONE
: return _("NONE (None)");
1879 case ET_REL
: return _("REL (Relocatable file)");
1880 case ET_EXEC
: return _("EXEC (Executable file)");
1881 case ET_DYN
: return _("DYN (Shared object file)");
1882 case ET_CORE
: return _("CORE (Core file)");
1885 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1886 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1887 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1888 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1890 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1896 get_machine_name (unsigned e_machine
)
1898 static char buff
[64]; /* XXX */
1902 case EM_NONE
: return _("None");
1903 case EM_AARCH64
: return "AArch64";
1904 case EM_M32
: return "WE32100";
1905 case EM_SPARC
: return "Sparc";
1906 case EM_SPU
: return "SPU";
1907 case EM_386
: return "Intel 80386";
1908 case EM_68K
: return "MC68000";
1909 case EM_88K
: return "MC88000";
1910 case EM_486
: return "Intel 80486";
1911 case EM_860
: return "Intel 80860";
1912 case EM_MIPS
: return "MIPS R3000";
1913 case EM_S370
: return "IBM System/370";
1914 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1915 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1916 case EM_PARISC
: return "HPPA";
1917 case EM_PPC_OLD
: return "Power PC (old)";
1918 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1919 case EM_960
: return "Intel 90860";
1920 case EM_PPC
: return "PowerPC";
1921 case EM_PPC64
: return "PowerPC64";
1922 case EM_FR20
: return "Fujitsu FR20";
1923 case EM_RH32
: return "TRW RH32";
1924 case EM_MCORE
: return "MCORE";
1925 case EM_ARM
: return "ARM";
1926 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1927 case EM_SH
: return "Renesas / SuperH SH";
1928 case EM_SPARCV9
: return "Sparc v9";
1929 case EM_TRICORE
: return "Siemens Tricore";
1930 case EM_ARC
: return "ARC";
1931 case EM_H8_300
: return "Renesas H8/300";
1932 case EM_H8_300H
: return "Renesas H8/300H";
1933 case EM_H8S
: return "Renesas H8S";
1934 case EM_H8_500
: return "Renesas H8/500";
1935 case EM_IA_64
: return "Intel IA-64";
1936 case EM_MIPS_X
: return "Stanford MIPS-X";
1937 case EM_COLDFIRE
: return "Motorola Coldfire";
1938 case EM_ALPHA
: return "Alpha";
1939 case EM_CYGNUS_D10V
:
1940 case EM_D10V
: return "d10v";
1941 case EM_CYGNUS_D30V
:
1942 case EM_D30V
: return "d30v";
1943 case EM_CYGNUS_M32R
:
1944 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1945 case EM_CYGNUS_V850
:
1946 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1947 case EM_V850
: return "Renesas V850";
1948 case EM_CYGNUS_MN10300
:
1949 case EM_MN10300
: return "mn10300";
1950 case EM_CYGNUS_MN10200
:
1951 case EM_MN10200
: return "mn10200";
1952 case EM_MOXIE
: return "Moxie";
1953 case EM_CYGNUS_FR30
:
1954 case EM_FR30
: return "Fujitsu FR30";
1955 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1957 case EM_PJ
: return "picoJava";
1958 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1959 case EM_PCP
: return "Siemens PCP";
1960 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1961 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1962 case EM_STARCORE
: return "Motorola Star*Core processor";
1963 case EM_ME16
: return "Toyota ME16 processor";
1964 case EM_ST100
: return "STMicroelectronics ST100 processor";
1965 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1966 case EM_PDSP
: return "Sony DSP processor";
1967 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1968 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1969 case EM_FX66
: return "Siemens FX66 microcontroller";
1970 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1971 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1972 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1973 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1974 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1975 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1976 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1977 case EM_SVX
: return "Silicon Graphics SVx";
1978 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1979 case EM_VAX
: return "Digital VAX";
1981 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1982 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1983 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1984 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1985 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1986 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1987 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1988 case EM_PRISM
: return "Vitesse Prism";
1989 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1990 case EM_L1OM
: return "Intel L1OM";
1991 case EM_K1OM
: return "Intel K1OM";
1993 case EM_S390
: return "IBM S/390";
1994 case EM_SCORE
: return "SUNPLUS S+Core";
1995 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1997 case EM_OR32
: return "OpenRISC";
1998 case EM_ARC_A5
: return "ARC International ARCompact processor";
1999 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2000 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2001 case EM_DLX
: return "OpenDLX";
2003 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2004 case EM_IQ2000
: return "Vitesse IQ2000";
2006 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2007 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2008 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2009 case EM_NS32K
: return "National Semiconductor 32000 series";
2010 case EM_TPC
: return "Tenor Network TPC processor";
2011 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2012 case EM_MAX
: return "MAX Processor";
2013 case EM_CR
: return "National Semiconductor CompactRISC";
2014 case EM_F2MC16
: return "Fujitsu F2MC16";
2015 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2016 case EM_LATTICEMICO32
: return "Lattice Mico32";
2018 case EM_M32C
: return "Renesas M32c";
2019 case EM_MT
: return "Morpho Techologies MT processor";
2020 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2021 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2022 case EM_SEP
: return "Sharp embedded microprocessor";
2023 case EM_ARCA
: return "Arca RISC microprocessor";
2024 case EM_UNICORE
: return "Unicore";
2025 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2026 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2027 case EM_NIOS32
: return "Altera Nios";
2028 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2030 case EM_XC16X
: return "Infineon Technologies xc16x";
2031 case EM_M16C
: return "Renesas M16C series microprocessors";
2032 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2033 case EM_CE
: return "Freescale Communication Engine RISC core";
2034 case EM_TSK3000
: return "Altium TSK3000 core";
2035 case EM_RS08
: return "Freescale RS08 embedded processor";
2036 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2037 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2038 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2039 case EM_SE_C17
: return "Seiko Epson C17 family";
2040 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2041 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2042 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2043 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2044 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2045 case EM_R32C
: return "Renesas R32C series microprocessors";
2046 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2047 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2048 case EM_8051
: return "Intel 8051 and variants";
2049 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2050 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2051 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2052 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2053 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2054 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2055 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2056 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2059 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2060 case EM_RL78
: return "Renesas RL78";
2061 case EM_RX
: return "Renesas RX";
2062 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2063 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2064 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2065 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2066 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2067 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2068 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2069 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2070 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2071 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2072 case EM_CUDA
: return "NVIDIA CUDA architecture";
2073 case EM_XGATE
: return "Motorola XGATE embedded processor";
2075 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2081 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2086 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2087 e_flags
&= ~ EF_ARM_EABIMASK
;
2089 /* Handle "generic" ARM flags. */
2090 if (e_flags
& EF_ARM_RELEXEC
)
2092 strcat (buf
, ", relocatable executable");
2093 e_flags
&= ~ EF_ARM_RELEXEC
;
2096 if (e_flags
& EF_ARM_HASENTRY
)
2098 strcat (buf
, ", has entry point");
2099 e_flags
&= ~ EF_ARM_HASENTRY
;
2102 /* Now handle EABI specific flags. */
2106 strcat (buf
, ", <unrecognized EABI>");
2111 case EF_ARM_EABI_VER1
:
2112 strcat (buf
, ", Version1 EABI");
2117 /* Process flags one bit at a time. */
2118 flag
= e_flags
& - e_flags
;
2123 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2124 strcat (buf
, ", sorted symbol tables");
2134 case EF_ARM_EABI_VER2
:
2135 strcat (buf
, ", Version2 EABI");
2140 /* Process flags one bit at a time. */
2141 flag
= e_flags
& - e_flags
;
2146 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2147 strcat (buf
, ", sorted symbol tables");
2150 case EF_ARM_DYNSYMSUSESEGIDX
:
2151 strcat (buf
, ", dynamic symbols use segment index");
2154 case EF_ARM_MAPSYMSFIRST
:
2155 strcat (buf
, ", mapping symbols precede others");
2165 case EF_ARM_EABI_VER3
:
2166 strcat (buf
, ", Version3 EABI");
2169 case EF_ARM_EABI_VER4
:
2170 strcat (buf
, ", Version4 EABI");
2175 /* Process flags one bit at a time. */
2176 flag
= e_flags
& - e_flags
;
2182 strcat (buf
, ", BE8");
2186 strcat (buf
, ", LE8");
2197 case EF_ARM_EABI_VER5
:
2198 strcat (buf
, ", Version5 EABI");
2203 /* Process flags one bit at a time. */
2204 flag
= e_flags
& - e_flags
;
2210 strcat (buf
, ", BE8");
2214 strcat (buf
, ", LE8");
2217 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2218 strcat (buf
, ", soft-float ABI");
2221 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2222 strcat (buf
, ", hard-float ABI");
2232 case EF_ARM_EABI_UNKNOWN
:
2233 strcat (buf
, ", GNU EABI");
2238 /* Process flags one bit at a time. */
2239 flag
= e_flags
& - e_flags
;
2244 case EF_ARM_INTERWORK
:
2245 strcat (buf
, ", interworking enabled");
2248 case EF_ARM_APCS_26
:
2249 strcat (buf
, ", uses APCS/26");
2252 case EF_ARM_APCS_FLOAT
:
2253 strcat (buf
, ", uses APCS/float");
2257 strcat (buf
, ", position independent");
2261 strcat (buf
, ", 8 bit structure alignment");
2264 case EF_ARM_NEW_ABI
:
2265 strcat (buf
, ", uses new ABI");
2268 case EF_ARM_OLD_ABI
:
2269 strcat (buf
, ", uses old ABI");
2272 case EF_ARM_SOFT_FLOAT
:
2273 strcat (buf
, ", software FP");
2276 case EF_ARM_VFP_FLOAT
:
2277 strcat (buf
, ", VFP");
2280 case EF_ARM_MAVERICK_FLOAT
:
2281 strcat (buf
, ", Maverick FP");
2292 strcat (buf
,_(", <unknown>"));
2296 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2298 static char buf
[1024];
2310 decode_ARM_machine_flags (e_flags
, buf
);
2314 if (e_flags
& EF_BFIN_PIC
)
2315 strcat (buf
, ", PIC");
2317 if (e_flags
& EF_BFIN_FDPIC
)
2318 strcat (buf
, ", FDPIC");
2320 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2321 strcat (buf
, ", code in L1");
2323 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2324 strcat (buf
, ", data in L1");
2329 switch (e_flags
& EF_FRV_CPU_MASK
)
2331 case EF_FRV_CPU_GENERIC
:
2335 strcat (buf
, ", fr???");
2338 case EF_FRV_CPU_FR300
:
2339 strcat (buf
, ", fr300");
2342 case EF_FRV_CPU_FR400
:
2343 strcat (buf
, ", fr400");
2345 case EF_FRV_CPU_FR405
:
2346 strcat (buf
, ", fr405");
2349 case EF_FRV_CPU_FR450
:
2350 strcat (buf
, ", fr450");
2353 case EF_FRV_CPU_FR500
:
2354 strcat (buf
, ", fr500");
2356 case EF_FRV_CPU_FR550
:
2357 strcat (buf
, ", fr550");
2360 case EF_FRV_CPU_SIMPLE
:
2361 strcat (buf
, ", simple");
2363 case EF_FRV_CPU_TOMCAT
:
2364 strcat (buf
, ", tomcat");
2370 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2371 strcat (buf
, ", m68000");
2372 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2373 strcat (buf
, ", cpu32");
2374 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2375 strcat (buf
, ", fido_a");
2378 char const * isa
= _("unknown");
2379 char const * mac
= _("unknown mac");
2380 char const * additional
= NULL
;
2382 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2384 case EF_M68K_CF_ISA_A_NODIV
:
2386 additional
= ", nodiv";
2388 case EF_M68K_CF_ISA_A
:
2391 case EF_M68K_CF_ISA_A_PLUS
:
2394 case EF_M68K_CF_ISA_B_NOUSP
:
2396 additional
= ", nousp";
2398 case EF_M68K_CF_ISA_B
:
2401 case EF_M68K_CF_ISA_C
:
2404 case EF_M68K_CF_ISA_C_NODIV
:
2406 additional
= ", nodiv";
2409 strcat (buf
, ", cf, isa ");
2412 strcat (buf
, additional
);
2413 if (e_flags
& EF_M68K_CF_FLOAT
)
2414 strcat (buf
, ", float");
2415 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2420 case EF_M68K_CF_MAC
:
2423 case EF_M68K_CF_EMAC
:
2426 case EF_M68K_CF_EMAC_B
:
2439 if (e_flags
& EF_PPC_EMB
)
2440 strcat (buf
, ", emb");
2442 if (e_flags
& EF_PPC_RELOCATABLE
)
2443 strcat (buf
, _(", relocatable"));
2445 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2446 strcat (buf
, _(", relocatable-lib"));
2450 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2451 strcat (buf
, ", RH850 ABI");
2453 if (e_flags
& EF_V800_850E3
)
2454 strcat (buf
, ", V3 architecture");
2456 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2457 strcat (buf
, ", FPU not used");
2459 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2460 strcat (buf
, ", regmode: COMMON");
2462 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2463 strcat (buf
, ", r4 not used");
2465 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2466 strcat (buf
, ", r30 not used");
2468 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2469 strcat (buf
, ", r5 not used");
2471 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2472 strcat (buf
, ", r2 not used");
2474 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2476 switch (e_flags
& - e_flags
)
2478 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2479 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2480 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2481 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2482 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2483 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2484 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2485 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2486 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2487 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2488 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2489 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2490 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2491 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2492 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2493 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2500 case EM_CYGNUS_V850
:
2501 switch (e_flags
& EF_V850_ARCH
)
2503 case E_V850E3V5_ARCH
:
2504 strcat (buf
, ", v850e3v5");
2506 case E_V850E2V3_ARCH
:
2507 strcat (buf
, ", v850e2v3");
2510 strcat (buf
, ", v850e2");
2513 strcat (buf
, ", v850e1");
2516 strcat (buf
, ", v850e");
2519 strcat (buf
, ", v850");
2522 strcat (buf
, _(", unknown v850 architecture variant"));
2528 case EM_CYGNUS_M32R
:
2529 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2530 strcat (buf
, ", m32r");
2534 case EM_MIPS_RS3_LE
:
2535 if (e_flags
& EF_MIPS_NOREORDER
)
2536 strcat (buf
, ", noreorder");
2538 if (e_flags
& EF_MIPS_PIC
)
2539 strcat (buf
, ", pic");
2541 if (e_flags
& EF_MIPS_CPIC
)
2542 strcat (buf
, ", cpic");
2544 if (e_flags
& EF_MIPS_UCODE
)
2545 strcat (buf
, ", ugen_reserved");
2547 if (e_flags
& EF_MIPS_ABI2
)
2548 strcat (buf
, ", abi2");
2550 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2551 strcat (buf
, ", odk first");
2553 if (e_flags
& EF_MIPS_32BITMODE
)
2554 strcat (buf
, ", 32bitmode");
2556 switch ((e_flags
& EF_MIPS_MACH
))
2558 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2559 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2560 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2561 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2562 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2563 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2564 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2565 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2566 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2567 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2568 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2569 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2570 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2571 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2572 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2573 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2575 /* We simply ignore the field in this case to avoid confusion:
2576 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2579 default: strcat (buf
, _(", unknown CPU")); break;
2582 switch ((e_flags
& EF_MIPS_ABI
))
2584 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2585 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2586 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2587 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2589 /* We simply ignore the field in this case to avoid confusion:
2590 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2591 This means it is likely to be an o32 file, but not for
2594 default: strcat (buf
, _(", unknown ABI")); break;
2597 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2598 strcat (buf
, ", mdmx");
2600 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2601 strcat (buf
, ", mips16");
2603 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2604 strcat (buf
, ", micromips");
2606 switch ((e_flags
& EF_MIPS_ARCH
))
2608 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2609 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2610 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2611 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2612 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2613 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2614 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2615 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2616 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2617 default: strcat (buf
, _(", unknown ISA")); break;
2622 switch ((e_flags
& EF_SH_MACH_MASK
))
2624 case EF_SH1
: strcat (buf
, ", sh1"); break;
2625 case EF_SH2
: strcat (buf
, ", sh2"); break;
2626 case EF_SH3
: strcat (buf
, ", sh3"); break;
2627 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2628 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2629 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2630 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2631 case EF_SH4
: strcat (buf
, ", sh4"); break;
2632 case EF_SH5
: strcat (buf
, ", sh5"); break;
2633 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2634 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2635 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2636 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2637 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2638 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2639 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2640 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2641 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2642 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2643 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2644 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2645 default: strcat (buf
, _(", unknown ISA")); break;
2648 if (e_flags
& EF_SH_PIC
)
2649 strcat (buf
, ", pic");
2651 if (e_flags
& EF_SH_FDPIC
)
2652 strcat (buf
, ", fdpic");
2656 if (e_flags
& EF_SPARC_32PLUS
)
2657 strcat (buf
, ", v8+");
2659 if (e_flags
& EF_SPARC_SUN_US1
)
2660 strcat (buf
, ", ultrasparcI");
2662 if (e_flags
& EF_SPARC_SUN_US3
)
2663 strcat (buf
, ", ultrasparcIII");
2665 if (e_flags
& EF_SPARC_HAL_R1
)
2666 strcat (buf
, ", halr1");
2668 if (e_flags
& EF_SPARC_LEDATA
)
2669 strcat (buf
, ", ledata");
2671 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2672 strcat (buf
, ", tso");
2674 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2675 strcat (buf
, ", pso");
2677 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2678 strcat (buf
, ", rmo");
2682 switch (e_flags
& EF_PARISC_ARCH
)
2684 case EFA_PARISC_1_0
:
2685 strcpy (buf
, ", PA-RISC 1.0");
2687 case EFA_PARISC_1_1
:
2688 strcpy (buf
, ", PA-RISC 1.1");
2690 case EFA_PARISC_2_0
:
2691 strcpy (buf
, ", PA-RISC 2.0");
2696 if (e_flags
& EF_PARISC_TRAPNIL
)
2697 strcat (buf
, ", trapnil");
2698 if (e_flags
& EF_PARISC_EXT
)
2699 strcat (buf
, ", ext");
2700 if (e_flags
& EF_PARISC_LSB
)
2701 strcat (buf
, ", lsb");
2702 if (e_flags
& EF_PARISC_WIDE
)
2703 strcat (buf
, ", wide");
2704 if (e_flags
& EF_PARISC_NO_KABP
)
2705 strcat (buf
, ", no kabp");
2706 if (e_flags
& EF_PARISC_LAZYSWAP
)
2707 strcat (buf
, ", lazyswap");
2712 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2713 strcat (buf
, ", new calling convention");
2715 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2716 strcat (buf
, ", gnu calling convention");
2720 if ((e_flags
& EF_IA_64_ABI64
))
2721 strcat (buf
, ", 64-bit");
2723 strcat (buf
, ", 32-bit");
2724 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2725 strcat (buf
, ", reduced fp model");
2726 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2727 strcat (buf
, ", no function descriptors, constant gp");
2728 else if ((e_flags
& EF_IA_64_CONS_GP
))
2729 strcat (buf
, ", constant gp");
2730 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2731 strcat (buf
, ", absolute");
2732 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2734 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2735 strcat (buf
, ", vms_linkages");
2736 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2738 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2740 case EF_IA_64_VMS_COMCOD_WARNING
:
2741 strcat (buf
, ", warning");
2743 case EF_IA_64_VMS_COMCOD_ERROR
:
2744 strcat (buf
, ", error");
2746 case EF_IA_64_VMS_COMCOD_ABORT
:
2747 strcat (buf
, ", abort");
2756 if ((e_flags
& EF_VAX_NONPIC
))
2757 strcat (buf
, ", non-PIC");
2758 if ((e_flags
& EF_VAX_DFLOAT
))
2759 strcat (buf
, ", D-Float");
2760 if ((e_flags
& EF_VAX_GFLOAT
))
2761 strcat (buf
, ", G-Float");
2765 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2766 strcat (buf
, ", 64-bit doubles");
2767 if (e_flags
& E_FLAG_RX_DSP
)
2768 strcat (buf
, ", dsp");
2769 if (e_flags
& E_FLAG_RX_PID
)
2770 strcat (buf
, ", pid");
2771 if (e_flags
& E_FLAG_RX_ABI
)
2772 strcat (buf
, ", RX ABI");
2776 if (e_flags
& EF_S390_HIGH_GPRS
)
2777 strcat (buf
, ", highgprs");
2781 if ((e_flags
& EF_C6000_REL
))
2782 strcat (buf
, ", relocatable module");
2791 get_osabi_name (unsigned int osabi
)
2793 static char buff
[32];
2797 case ELFOSABI_NONE
: return "UNIX - System V";
2798 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2799 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2800 case ELFOSABI_GNU
: return "UNIX - GNU";
2801 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2802 case ELFOSABI_AIX
: return "UNIX - AIX";
2803 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2804 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2805 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2806 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2807 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2808 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2809 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2810 case ELFOSABI_AROS
: return "AROS";
2811 case ELFOSABI_FENIXOS
: return "FenixOS";
2814 switch (elf_header
.e_machine
)
2819 case ELFOSABI_ARM
: return "ARM";
2829 case ELFOSABI_STANDALONE
: return _("Standalone App");
2838 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2839 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2848 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2854 get_aarch64_segment_type (unsigned long type
)
2858 case PT_AARCH64_ARCHEXT
:
2859 return "AARCH64_ARCHEXT";
2868 get_arm_segment_type (unsigned long type
)
2882 get_mips_segment_type (unsigned long type
)
2886 case PT_MIPS_REGINFO
:
2888 case PT_MIPS_RTPROC
:
2890 case PT_MIPS_OPTIONS
:
2900 get_parisc_segment_type (unsigned long type
)
2904 case PT_HP_TLS
: return "HP_TLS";
2905 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2906 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2907 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2908 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2909 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2910 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2911 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2912 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2913 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2914 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2915 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2916 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2917 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2918 case PT_HP_STACK
: return "HP_STACK";
2919 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2920 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2921 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2922 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2931 get_ia64_segment_type (unsigned long type
)
2935 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2936 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2937 case PT_HP_TLS
: return "HP_TLS";
2938 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2939 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2940 case PT_IA_64_HP_STACK
: return "HP_STACK";
2949 get_tic6x_segment_type (unsigned long type
)
2953 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2962 get_segment_type (unsigned long p_type
)
2964 static char buff
[32];
2968 case PT_NULL
: return "NULL";
2969 case PT_LOAD
: return "LOAD";
2970 case PT_DYNAMIC
: return "DYNAMIC";
2971 case PT_INTERP
: return "INTERP";
2972 case PT_NOTE
: return "NOTE";
2973 case PT_SHLIB
: return "SHLIB";
2974 case PT_PHDR
: return "PHDR";
2975 case PT_TLS
: return "TLS";
2977 case PT_GNU_EH_FRAME
:
2978 return "GNU_EH_FRAME";
2979 case PT_GNU_STACK
: return "GNU_STACK";
2980 case PT_GNU_RELRO
: return "GNU_RELRO";
2983 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2985 const char * result
;
2987 switch (elf_header
.e_machine
)
2990 result
= get_aarch64_segment_type (p_type
);
2993 result
= get_arm_segment_type (p_type
);
2996 case EM_MIPS_RS3_LE
:
2997 result
= get_mips_segment_type (p_type
);
3000 result
= get_parisc_segment_type (p_type
);
3003 result
= get_ia64_segment_type (p_type
);
3006 result
= get_tic6x_segment_type (p_type
);
3016 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3018 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3020 const char * result
;
3022 switch (elf_header
.e_machine
)
3025 result
= get_parisc_segment_type (p_type
);
3028 result
= get_ia64_segment_type (p_type
);
3038 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3041 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3048 get_mips_section_type_name (unsigned int sh_type
)
3052 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3053 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3054 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3055 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3056 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3057 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3058 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3059 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3060 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3061 case SHT_MIPS_RELD
: return "MIPS_RELD";
3062 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3063 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3064 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3065 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3066 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3067 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3068 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3069 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3070 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3071 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3072 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3073 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3074 case SHT_MIPS_LINE
: return "MIPS_LINE";
3075 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3076 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3077 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3078 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3079 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3080 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3081 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3082 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3083 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3084 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3085 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3086 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3087 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3088 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3089 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3090 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3098 get_parisc_section_type_name (unsigned int sh_type
)
3102 case SHT_PARISC_EXT
: return "PARISC_EXT";
3103 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3104 case SHT_PARISC_DOC
: return "PARISC_DOC";
3105 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3106 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3107 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3108 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3116 get_ia64_section_type_name (unsigned int sh_type
)
3118 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3119 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3120 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3124 case SHT_IA_64_EXT
: return "IA_64_EXT";
3125 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3126 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3127 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3128 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3129 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3130 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3131 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3132 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3133 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3141 get_x86_64_section_type_name (unsigned int sh_type
)
3145 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3153 get_aarch64_section_type_name (unsigned int sh_type
)
3157 case SHT_AARCH64_ATTRIBUTES
:
3158 return "AARCH64_ATTRIBUTES";
3166 get_arm_section_type_name (unsigned int sh_type
)
3170 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3171 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3172 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3173 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3174 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3182 get_tic6x_section_type_name (unsigned int sh_type
)
3186 case SHT_C6000_UNWIND
:
3187 return "C6000_UNWIND";
3188 case SHT_C6000_PREEMPTMAP
:
3189 return "C6000_PREEMPTMAP";
3190 case SHT_C6000_ATTRIBUTES
:
3191 return "C6000_ATTRIBUTES";
3196 case SHT_TI_HANDLER
:
3197 return "TI_HANDLER";
3198 case SHT_TI_INITINFO
:
3199 return "TI_INITINFO";
3200 case SHT_TI_PHATTRS
:
3201 return "TI_PHATTRS";
3209 get_section_type_name (unsigned int sh_type
)
3211 static char buff
[32];
3215 case SHT_NULL
: return "NULL";
3216 case SHT_PROGBITS
: return "PROGBITS";
3217 case SHT_SYMTAB
: return "SYMTAB";
3218 case SHT_STRTAB
: return "STRTAB";
3219 case SHT_RELA
: return "RELA";
3220 case SHT_HASH
: return "HASH";
3221 case SHT_DYNAMIC
: return "DYNAMIC";
3222 case SHT_NOTE
: return "NOTE";
3223 case SHT_NOBITS
: return "NOBITS";
3224 case SHT_REL
: return "REL";
3225 case SHT_SHLIB
: return "SHLIB";
3226 case SHT_DYNSYM
: return "DYNSYM";
3227 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3228 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3229 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3230 case SHT_GNU_HASH
: return "GNU_HASH";
3231 case SHT_GROUP
: return "GROUP";
3232 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3233 case SHT_GNU_verdef
: return "VERDEF";
3234 case SHT_GNU_verneed
: return "VERNEED";
3235 case SHT_GNU_versym
: return "VERSYM";
3236 case 0x6ffffff0: return "VERSYM";
3237 case 0x6ffffffc: return "VERDEF";
3238 case 0x7ffffffd: return "AUXILIARY";
3239 case 0x7fffffff: return "FILTER";
3240 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3243 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3245 const char * result
;
3247 switch (elf_header
.e_machine
)
3250 case EM_MIPS_RS3_LE
:
3251 result
= get_mips_section_type_name (sh_type
);
3254 result
= get_parisc_section_type_name (sh_type
);
3257 result
= get_ia64_section_type_name (sh_type
);
3262 result
= get_x86_64_section_type_name (sh_type
);
3265 result
= get_aarch64_section_type_name (sh_type
);
3268 result
= get_arm_section_type_name (sh_type
);
3271 result
= get_tic6x_section_type_name (sh_type
);
3281 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3283 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3285 const char * result
;
3287 switch (elf_header
.e_machine
)
3290 result
= get_ia64_section_type_name (sh_type
);
3300 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3302 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3303 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3305 /* This message is probably going to be displayed in a 15
3306 character wide field, so put the hex value first. */
3307 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3313 #define OPTION_DEBUG_DUMP 512
3314 #define OPTION_DYN_SYMS 513
3315 #define OPTION_DWARF_DEPTH 514
3316 #define OPTION_DWARF_START 515
3317 #define OPTION_DWARF_CHECK 516
3319 static struct option options
[] =
3321 {"all", no_argument
, 0, 'a'},
3322 {"file-header", no_argument
, 0, 'h'},
3323 {"program-headers", no_argument
, 0, 'l'},
3324 {"headers", no_argument
, 0, 'e'},
3325 {"histogram", no_argument
, 0, 'I'},
3326 {"segments", no_argument
, 0, 'l'},
3327 {"sections", no_argument
, 0, 'S'},
3328 {"section-headers", no_argument
, 0, 'S'},
3329 {"section-groups", no_argument
, 0, 'g'},
3330 {"section-details", no_argument
, 0, 't'},
3331 {"full-section-name",no_argument
, 0, 'N'},
3332 {"symbols", no_argument
, 0, 's'},
3333 {"syms", no_argument
, 0, 's'},
3334 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3335 {"relocs", no_argument
, 0, 'r'},
3336 {"notes", no_argument
, 0, 'n'},
3337 {"dynamic", no_argument
, 0, 'd'},
3338 {"arch-specific", no_argument
, 0, 'A'},
3339 {"version-info", no_argument
, 0, 'V'},
3340 {"use-dynamic", no_argument
, 0, 'D'},
3341 {"unwind", no_argument
, 0, 'u'},
3342 {"archive-index", no_argument
, 0, 'c'},
3343 {"hex-dump", required_argument
, 0, 'x'},
3344 {"relocated-dump", required_argument
, 0, 'R'},
3345 {"string-dump", required_argument
, 0, 'p'},
3346 #ifdef SUPPORT_DISASSEMBLY
3347 {"instruction-dump", required_argument
, 0, 'i'},
3349 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3351 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3352 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3353 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3355 {"version", no_argument
, 0, 'v'},
3356 {"wide", no_argument
, 0, 'W'},
3357 {"help", no_argument
, 0, 'H'},
3358 {0, no_argument
, 0, 0}
3362 usage (FILE * stream
)
3364 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3365 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3366 fprintf (stream
, _(" Options are:\n\
3367 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3368 -h --file-header Display the ELF file header\n\
3369 -l --program-headers Display the program headers\n\
3370 --segments An alias for --program-headers\n\
3371 -S --section-headers Display the sections' header\n\
3372 --sections An alias for --section-headers\n\
3373 -g --section-groups Display the section groups\n\
3374 -t --section-details Display the section details\n\
3375 -e --headers Equivalent to: -h -l -S\n\
3376 -s --syms Display the symbol table\n\
3377 --symbols An alias for --syms\n\
3378 --dyn-syms Display the dynamic symbol table\n\
3379 -n --notes Display the core notes (if present)\n\
3380 -r --relocs Display the relocations (if present)\n\
3381 -u --unwind Display the unwind info (if present)\n\
3382 -d --dynamic Display the dynamic section (if present)\n\
3383 -V --version-info Display the version sections (if present)\n\
3384 -A --arch-specific Display architecture specific information (if any)\n\
3385 -c --archive-index Display the symbol/file index in an archive\n\
3386 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3387 -x --hex-dump=<number|name>\n\
3388 Dump the contents of section <number|name> as bytes\n\
3389 -p --string-dump=<number|name>\n\
3390 Dump the contents of section <number|name> as strings\n\
3391 -R --relocated-dump=<number|name>\n\
3392 Dump the contents of section <number|name> as relocated bytes\n\
3393 -w[lLiaprmfFsoRt] or\n\
3394 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3395 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3396 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3398 Display the contents of DWARF2 debug sections\n"));
3399 fprintf (stream
, _("\
3400 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3401 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3403 #ifdef SUPPORT_DISASSEMBLY
3404 fprintf (stream
, _("\
3405 -i --instruction-dump=<number|name>\n\
3406 Disassemble the contents of section <number|name>\n"));
3408 fprintf (stream
, _("\
3409 -I --histogram Display histogram of bucket list lengths\n\
3410 -W --wide Allow output width to exceed 80 characters\n\
3411 @<file> Read options from <file>\n\
3412 -H --help Display this information\n\
3413 -v --version Display the version number of readelf\n"));
3415 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3416 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3418 exit (stream
== stdout
? 0 : 1);
3421 /* Record the fact that the user wants the contents of section number
3422 SECTION to be displayed using the method(s) encoded as flags bits
3423 in TYPE. Note, TYPE can be zero if we are creating the array for
3427 request_dump_bynumber (unsigned int section
, dump_type type
)
3429 if (section
>= num_dump_sects
)
3431 dump_type
* new_dump_sects
;
3433 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3434 sizeof (* dump_sects
));
3436 if (new_dump_sects
== NULL
)
3437 error (_("Out of memory allocating dump request table.\n"));
3440 /* Copy current flag settings. */
3441 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3445 dump_sects
= new_dump_sects
;
3446 num_dump_sects
= section
+ 1;
3451 dump_sects
[section
] |= type
;
3456 /* Request a dump by section name. */
3459 request_dump_byname (const char * section
, dump_type type
)
3461 struct dump_list_entry
* new_request
;
3463 new_request
= (struct dump_list_entry
*)
3464 malloc (sizeof (struct dump_list_entry
));
3466 error (_("Out of memory allocating dump request table.\n"));
3468 new_request
->name
= strdup (section
);
3469 if (!new_request
->name
)
3470 error (_("Out of memory allocating dump request table.\n"));
3472 new_request
->type
= type
;
3474 new_request
->next
= dump_sects_byname
;
3475 dump_sects_byname
= new_request
;
3479 request_dump (dump_type type
)
3485 section
= strtoul (optarg
, & cp
, 0);
3487 if (! *cp
&& section
>= 0)
3488 request_dump_bynumber (section
, type
);
3490 request_dump_byname (optarg
, type
);
3495 parse_args (int argc
, char ** argv
)
3502 while ((c
= getopt_long
3503 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3521 do_section_groups
++;
3529 do_section_groups
++;
3534 do_section_details
++;
3578 request_dump (HEX_DUMP
);
3581 request_dump (STRING_DUMP
);
3584 request_dump (RELOC_DUMP
);
3591 dwarf_select_sections_all ();
3596 dwarf_select_sections_by_letters (optarg
);
3599 case OPTION_DEBUG_DUMP
:
3606 dwarf_select_sections_by_names (optarg
);
3609 case OPTION_DWARF_DEPTH
:
3613 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3616 case OPTION_DWARF_START
:
3620 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3623 case OPTION_DWARF_CHECK
:
3626 case OPTION_DYN_SYMS
:
3629 #ifdef SUPPORT_DISASSEMBLY
3631 request_dump (DISASS_DUMP
);
3635 print_version (program_name
);
3644 /* xgettext:c-format */
3645 error (_("Invalid option '-%c'\n"), c
);
3652 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3653 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3654 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3655 && !do_section_groups
&& !do_archive_index
3660 warn (_("Nothing to do.\n"));
3666 get_elf_class (unsigned int elf_class
)
3668 static char buff
[32];
3672 case ELFCLASSNONE
: return _("none");
3673 case ELFCLASS32
: return "ELF32";
3674 case ELFCLASS64
: return "ELF64";
3676 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3682 get_data_encoding (unsigned int encoding
)
3684 static char buff
[32];
3688 case ELFDATANONE
: return _("none");
3689 case ELFDATA2LSB
: return _("2's complement, little endian");
3690 case ELFDATA2MSB
: return _("2's complement, big endian");
3692 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3697 /* Decode the data held in 'elf_header'. */
3700 process_file_header (void)
3702 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3703 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3704 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3705 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3708 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3712 init_dwarf_regnames (elf_header
.e_machine
);
3718 printf (_("ELF Header:\n"));
3719 printf (_(" Magic: "));
3720 for (i
= 0; i
< EI_NIDENT
; i
++)
3721 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3723 printf (_(" Class: %s\n"),
3724 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3725 printf (_(" Data: %s\n"),
3726 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3727 printf (_(" Version: %d %s\n"),
3728 elf_header
.e_ident
[EI_VERSION
],
3729 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3731 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3732 ? _("<unknown: %lx>")
3734 printf (_(" OS/ABI: %s\n"),
3735 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3736 printf (_(" ABI Version: %d\n"),
3737 elf_header
.e_ident
[EI_ABIVERSION
]);
3738 printf (_(" Type: %s\n"),
3739 get_file_type (elf_header
.e_type
));
3740 printf (_(" Machine: %s\n"),
3741 get_machine_name (elf_header
.e_machine
));
3742 printf (_(" Version: 0x%lx\n"),
3743 (unsigned long) elf_header
.e_version
);
3745 printf (_(" Entry point address: "));
3746 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3747 printf (_("\n Start of program headers: "));
3748 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3749 printf (_(" (bytes into file)\n Start of section headers: "));
3750 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3751 printf (_(" (bytes into file)\n"));
3753 printf (_(" Flags: 0x%lx%s\n"),
3754 (unsigned long) elf_header
.e_flags
,
3755 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3756 printf (_(" Size of this header: %ld (bytes)\n"),
3757 (long) elf_header
.e_ehsize
);
3758 printf (_(" Size of program headers: %ld (bytes)\n"),
3759 (long) elf_header
.e_phentsize
);
3760 printf (_(" Number of program headers: %ld"),
3761 (long) elf_header
.e_phnum
);
3762 if (section_headers
!= NULL
3763 && elf_header
.e_phnum
== PN_XNUM
3764 && section_headers
[0].sh_info
!= 0)
3765 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3766 putc ('\n', stdout
);
3767 printf (_(" Size of section headers: %ld (bytes)\n"),
3768 (long) elf_header
.e_shentsize
);
3769 printf (_(" Number of section headers: %ld"),
3770 (long) elf_header
.e_shnum
);
3771 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3772 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3773 putc ('\n', stdout
);
3774 printf (_(" Section header string table index: %ld"),
3775 (long) elf_header
.e_shstrndx
);
3776 if (section_headers
!= NULL
3777 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3778 printf (" (%u)", section_headers
[0].sh_link
);
3779 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3780 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3781 printf (_(" <corrupt: out of range>"));
3782 putc ('\n', stdout
);
3785 if (section_headers
!= NULL
)
3787 if (elf_header
.e_phnum
== PN_XNUM
3788 && section_headers
[0].sh_info
!= 0)
3789 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3790 if (elf_header
.e_shnum
== SHN_UNDEF
)
3791 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3792 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3793 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3794 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3795 elf_header
.e_shstrndx
= SHN_UNDEF
;
3796 free (section_headers
);
3797 section_headers
= NULL
;
3805 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3807 Elf32_External_Phdr
* phdrs
;
3808 Elf32_External_Phdr
* external
;
3809 Elf_Internal_Phdr
* internal
;
3812 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3813 elf_header
.e_phentsize
,
3815 _("program headers"));
3819 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3820 i
< elf_header
.e_phnum
;
3821 i
++, internal
++, external
++)
3823 internal
->p_type
= BYTE_GET (external
->p_type
);
3824 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3825 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3826 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3827 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3828 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3829 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3830 internal
->p_align
= BYTE_GET (external
->p_align
);
3839 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3841 Elf64_External_Phdr
* phdrs
;
3842 Elf64_External_Phdr
* external
;
3843 Elf_Internal_Phdr
* internal
;
3846 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3847 elf_header
.e_phentsize
,
3849 _("program headers"));
3853 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3854 i
< elf_header
.e_phnum
;
3855 i
++, internal
++, external
++)
3857 internal
->p_type
= BYTE_GET (external
->p_type
);
3858 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3859 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3860 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3861 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3862 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3863 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3864 internal
->p_align
= BYTE_GET (external
->p_align
);
3872 /* Returns 1 if the program headers were read into `program_headers'. */
3875 get_program_headers (FILE * file
)
3877 Elf_Internal_Phdr
* phdrs
;
3879 /* Check cache of prior read. */
3880 if (program_headers
!= NULL
)
3883 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3884 sizeof (Elf_Internal_Phdr
));
3888 error (_("Out of memory\n"));
3893 ? get_32bit_program_headers (file
, phdrs
)
3894 : get_64bit_program_headers (file
, phdrs
))
3896 program_headers
= phdrs
;
3904 /* Returns 1 if the program headers were loaded. */
3907 process_program_headers (FILE * file
)
3909 Elf_Internal_Phdr
* segment
;
3912 if (elf_header
.e_phnum
== 0)
3914 /* PR binutils/12467. */
3915 if (elf_header
.e_phoff
!= 0)
3916 warn (_("possibly corrupt ELF header - it has a non-zero program"
3917 " header offset, but no program headers"));
3918 else if (do_segments
)
3919 printf (_("\nThere are no program headers in this file.\n"));
3923 if (do_segments
&& !do_header
)
3925 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3926 printf (_("Entry point "));
3927 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3928 printf (_("\nThere are %d program headers, starting at offset "),
3929 elf_header
.e_phnum
);
3930 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3934 if (! get_program_headers (file
))
3939 if (elf_header
.e_phnum
> 1)
3940 printf (_("\nProgram Headers:\n"));
3942 printf (_("\nProgram Headers:\n"));
3946 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3949 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3953 (_(" Type Offset VirtAddr PhysAddr\n"));
3955 (_(" FileSiz MemSiz Flags Align\n"));
3962 for (i
= 0, segment
= program_headers
;
3963 i
< elf_header
.e_phnum
;
3968 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3972 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3973 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3974 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3975 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3976 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3978 (segment
->p_flags
& PF_R
? 'R' : ' '),
3979 (segment
->p_flags
& PF_W
? 'W' : ' '),
3980 (segment
->p_flags
& PF_X
? 'E' : ' '));
3981 printf ("%#lx", (unsigned long) segment
->p_align
);
3985 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3986 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3989 print_vma (segment
->p_offset
, FULL_HEX
);
3993 print_vma (segment
->p_vaddr
, FULL_HEX
);
3995 print_vma (segment
->p_paddr
, FULL_HEX
);
3998 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3999 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4002 print_vma (segment
->p_filesz
, FULL_HEX
);
4006 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4007 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4010 print_vma (segment
->p_memsz
, FULL_HEX
);
4014 (segment
->p_flags
& PF_R
? 'R' : ' '),
4015 (segment
->p_flags
& PF_W
? 'W' : ' '),
4016 (segment
->p_flags
& PF_X
? 'E' : ' '));
4018 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4019 printf ("%#lx", (unsigned long) segment
->p_align
);
4022 print_vma (segment
->p_align
, PREFIX_HEX
);
4027 print_vma (segment
->p_offset
, FULL_HEX
);
4029 print_vma (segment
->p_vaddr
, FULL_HEX
);
4031 print_vma (segment
->p_paddr
, FULL_HEX
);
4033 print_vma (segment
->p_filesz
, FULL_HEX
);
4035 print_vma (segment
->p_memsz
, FULL_HEX
);
4037 (segment
->p_flags
& PF_R
? 'R' : ' '),
4038 (segment
->p_flags
& PF_W
? 'W' : ' '),
4039 (segment
->p_flags
& PF_X
? 'E' : ' '));
4040 print_vma (segment
->p_align
, HEX
);
4044 switch (segment
->p_type
)
4048 error (_("more than one dynamic segment\n"));
4050 /* By default, assume that the .dynamic section is the first
4051 section in the DYNAMIC segment. */
4052 dynamic_addr
= segment
->p_offset
;
4053 dynamic_size
= segment
->p_filesz
;
4055 /* Try to locate the .dynamic section. If there is
4056 a section header table, we can easily locate it. */
4057 if (section_headers
!= NULL
)
4059 Elf_Internal_Shdr
* sec
;
4061 sec
= find_section (".dynamic");
4062 if (sec
== NULL
|| sec
->sh_size
== 0)
4064 /* A corresponding .dynamic section is expected, but on
4065 IA-64/OpenVMS it is OK for it to be missing. */
4066 if (!is_ia64_vms ())
4067 error (_("no .dynamic section in the dynamic segment\n"));
4071 if (sec
->sh_type
== SHT_NOBITS
)
4077 dynamic_addr
= sec
->sh_offset
;
4078 dynamic_size
= sec
->sh_size
;
4080 if (dynamic_addr
< segment
->p_offset
4081 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4082 warn (_("the .dynamic section is not contained"
4083 " within the dynamic segment\n"));
4084 else if (dynamic_addr
> segment
->p_offset
)
4085 warn (_("the .dynamic section is not the first section"
4086 " in the dynamic segment.\n"));
4091 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4093 error (_("Unable to find program interpreter name\n"));
4097 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4099 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4100 error (_("Internal error: failed to create format string to display program interpreter\n"));
4102 program_interpreter
[0] = 0;
4103 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4104 error (_("Unable to read program interpreter name\n"));
4107 printf (_("\n [Requesting program interpreter: %s]"),
4108 program_interpreter
);
4114 putc ('\n', stdout
);
4117 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4119 printf (_("\n Section to Segment mapping:\n"));
4120 printf (_(" Segment Sections...\n"));
4122 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4125 Elf_Internal_Shdr
* section
;
4127 segment
= program_headers
+ i
;
4128 section
= section_headers
+ 1;
4130 printf (" %2.2d ", i
);
4132 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4134 if (!ELF_TBSS_SPECIAL (section
, segment
)
4135 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4136 printf ("%s ", SECTION_NAME (section
));
4147 /* Find the file offset corresponding to VMA by using the program headers. */
4150 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4152 Elf_Internal_Phdr
* seg
;
4154 if (! get_program_headers (file
))
4156 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4160 for (seg
= program_headers
;
4161 seg
< program_headers
+ elf_header
.e_phnum
;
4164 if (seg
->p_type
!= PT_LOAD
)
4167 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4168 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4169 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4172 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4173 (unsigned long) vma
);
4179 get_32bit_section_headers (FILE * file
, unsigned int num
)
4181 Elf32_External_Shdr
* shdrs
;
4182 Elf_Internal_Shdr
* internal
;
4185 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4186 elf_header
.e_shentsize
, num
,
4187 _("section headers"));
4191 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4192 sizeof (Elf_Internal_Shdr
));
4194 if (section_headers
== NULL
)
4196 error (_("Out of memory\n"));
4200 for (i
= 0, internal
= section_headers
;
4204 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4205 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4206 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4207 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4208 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4209 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4210 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4211 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4212 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4213 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4222 get_64bit_section_headers (FILE * file
, unsigned int num
)
4224 Elf64_External_Shdr
* shdrs
;
4225 Elf_Internal_Shdr
* internal
;
4228 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4229 elf_header
.e_shentsize
, num
,
4230 _("section headers"));
4234 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4235 sizeof (Elf_Internal_Shdr
));
4237 if (section_headers
== NULL
)
4239 error (_("Out of memory\n"));
4243 for (i
= 0, internal
= section_headers
;
4247 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4248 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4249 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4250 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4251 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4252 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4253 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4254 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4255 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4256 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4264 static Elf_Internal_Sym
*
4265 get_32bit_elf_symbols (FILE * file
,
4266 Elf_Internal_Shdr
* section
,
4267 unsigned long * num_syms_return
)
4269 unsigned long number
= 0;
4270 Elf32_External_Sym
* esyms
= NULL
;
4271 Elf_External_Sym_Shndx
* shndx
= NULL
;
4272 Elf_Internal_Sym
* isyms
= NULL
;
4273 Elf_Internal_Sym
* psym
;
4276 /* Run some sanity checks first. */
4277 if (section
->sh_entsize
== 0)
4279 error (_("sh_entsize is zero\n"));
4283 number
= section
->sh_size
/ section
->sh_entsize
;
4285 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4287 error (_("Invalid sh_entsize\n"));
4291 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4292 section
->sh_size
, _("symbols"));
4297 if (symtab_shndx_hdr
!= NULL
4298 && (symtab_shndx_hdr
->sh_link
4299 == (unsigned long) (section
- section_headers
)))
4301 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4302 symtab_shndx_hdr
->sh_offset
,
4303 1, symtab_shndx_hdr
->sh_size
,
4304 _("symbol table section indicies"));
4309 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4313 error (_("Out of memory\n"));
4317 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4319 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4320 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4321 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4322 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4323 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4325 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4326 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4327 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4328 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4329 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4338 if (num_syms_return
!= NULL
)
4339 * num_syms_return
= isyms
== NULL
? 0 : number
;
4344 static Elf_Internal_Sym
*
4345 get_64bit_elf_symbols (FILE * file
,
4346 Elf_Internal_Shdr
* section
,
4347 unsigned long * num_syms_return
)
4349 unsigned long number
= 0;
4350 Elf64_External_Sym
* esyms
= NULL
;
4351 Elf_External_Sym_Shndx
* shndx
= NULL
;
4352 Elf_Internal_Sym
* isyms
= NULL
;
4353 Elf_Internal_Sym
* psym
;
4356 /* Run some sanity checks first. */
4357 if (section
->sh_entsize
== 0)
4359 error (_("sh_entsize is zero\n"));
4363 number
= section
->sh_size
/ section
->sh_entsize
;
4365 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4367 error (_("Invalid sh_entsize\n"));
4371 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4372 section
->sh_size
, _("symbols"));
4376 if (symtab_shndx_hdr
!= NULL
4377 && (symtab_shndx_hdr
->sh_link
4378 == (unsigned long) (section
- section_headers
)))
4380 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4381 symtab_shndx_hdr
->sh_offset
,
4382 1, symtab_shndx_hdr
->sh_size
,
4383 _("symbol table section indicies"));
4388 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4392 error (_("Out of memory\n"));
4396 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4398 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4399 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4400 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4401 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4403 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4405 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4406 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4407 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4409 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4410 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4419 if (num_syms_return
!= NULL
)
4420 * num_syms_return
= isyms
== NULL
? 0 : number
;
4426 get_elf_section_flags (bfd_vma sh_flags
)
4428 static char buff
[1024];
4430 int field_size
= is_32bit_elf
? 8 : 16;
4432 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4433 bfd_vma os_flags
= 0;
4434 bfd_vma proc_flags
= 0;
4435 bfd_vma unknown_flags
= 0;
4443 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4444 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4445 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4446 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4447 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4448 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4449 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4450 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4451 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4452 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4453 /* IA-64 specific. */
4454 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4455 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4456 /* IA-64 OpenVMS specific. */
4457 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4458 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4459 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4460 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4461 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4462 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4464 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4465 /* SPARC specific. */
4466 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4469 if (do_section_details
)
4471 sprintf (buff
, "[%*.*lx]: ",
4472 field_size
, field_size
, (unsigned long) sh_flags
);
4473 p
+= field_size
+ 4;
4480 flag
= sh_flags
& - sh_flags
;
4483 if (do_section_details
)
4487 case SHF_WRITE
: sindex
= 0; break;
4488 case SHF_ALLOC
: sindex
= 1; break;
4489 case SHF_EXECINSTR
: sindex
= 2; break;
4490 case SHF_MERGE
: sindex
= 3; break;
4491 case SHF_STRINGS
: sindex
= 4; break;
4492 case SHF_INFO_LINK
: sindex
= 5; break;
4493 case SHF_LINK_ORDER
: sindex
= 6; break;
4494 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4495 case SHF_GROUP
: sindex
= 8; break;
4496 case SHF_TLS
: sindex
= 9; break;
4497 case SHF_EXCLUDE
: sindex
= 18; break;
4501 switch (elf_header
.e_machine
)
4504 if (flag
== SHF_IA_64_SHORT
)
4506 else if (flag
== SHF_IA_64_NORECOV
)
4509 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4512 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4513 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4514 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4515 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4516 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4517 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4528 case EM_OLD_SPARCV9
:
4529 case EM_SPARC32PLUS
:
4532 if (flag
== SHF_ORDERED
)
4542 if (p
!= buff
+ field_size
+ 4)
4544 if (size
< (10 + 2))
4551 size
-= flags
[sindex
].len
;
4552 p
= stpcpy (p
, flags
[sindex
].str
);
4554 else if (flag
& SHF_MASKOS
)
4556 else if (flag
& SHF_MASKPROC
)
4559 unknown_flags
|= flag
;
4565 case SHF_WRITE
: *p
= 'W'; break;
4566 case SHF_ALLOC
: *p
= 'A'; break;
4567 case SHF_EXECINSTR
: *p
= 'X'; break;
4568 case SHF_MERGE
: *p
= 'M'; break;
4569 case SHF_STRINGS
: *p
= 'S'; break;
4570 case SHF_INFO_LINK
: *p
= 'I'; break;
4571 case SHF_LINK_ORDER
: *p
= 'L'; break;
4572 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4573 case SHF_GROUP
: *p
= 'G'; break;
4574 case SHF_TLS
: *p
= 'T'; break;
4575 case SHF_EXCLUDE
: *p
= 'E'; break;
4578 if ((elf_header
.e_machine
== EM_X86_64
4579 || elf_header
.e_machine
== EM_L1OM
4580 || elf_header
.e_machine
== EM_K1OM
)
4581 && flag
== SHF_X86_64_LARGE
)
4583 else if (flag
& SHF_MASKOS
)
4586 sh_flags
&= ~ SHF_MASKOS
;
4588 else if (flag
& SHF_MASKPROC
)
4591 sh_flags
&= ~ SHF_MASKPROC
;
4601 if (do_section_details
)
4605 size
-= 5 + field_size
;
4606 if (p
!= buff
+ field_size
+ 4)
4614 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4615 (unsigned long) os_flags
);
4616 p
+= 5 + field_size
;
4620 size
-= 7 + field_size
;
4621 if (p
!= buff
+ field_size
+ 4)
4629 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4630 (unsigned long) proc_flags
);
4631 p
+= 7 + field_size
;
4635 size
-= 10 + field_size
;
4636 if (p
!= buff
+ field_size
+ 4)
4644 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4645 (unsigned long) unknown_flags
);
4646 p
+= 10 + field_size
;
4655 process_section_headers (FILE * file
)
4657 Elf_Internal_Shdr
* section
;
4660 section_headers
= NULL
;
4662 if (elf_header
.e_shnum
== 0)
4664 /* PR binutils/12467. */
4665 if (elf_header
.e_shoff
!= 0)
4666 warn (_("possibly corrupt ELF file header - it has a non-zero"
4667 " section header offset, but no section headers\n"));
4668 else if (do_sections
)
4669 printf (_("\nThere are no sections in this file.\n"));
4674 if (do_sections
&& !do_header
)
4675 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4676 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4680 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4683 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4686 /* Read in the string table, so that we have names to display. */
4687 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4688 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4690 section
= section_headers
+ elf_header
.e_shstrndx
;
4692 if (section
->sh_size
!= 0)
4694 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4695 1, section
->sh_size
,
4698 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4702 /* Scan the sections for the dynamic symbol table
4703 and dynamic string table and debug sections. */
4704 dynamic_symbols
= NULL
;
4705 dynamic_strings
= NULL
;
4706 dynamic_syminfo
= NULL
;
4707 symtab_shndx_hdr
= NULL
;
4709 eh_addr_size
= is_32bit_elf
? 4 : 8;
4710 switch (elf_header
.e_machine
)
4713 case EM_MIPS_RS3_LE
:
4714 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4715 FDE addresses. However, the ABI also has a semi-official ILP32
4716 variant for which the normal FDE address size rules apply.
4718 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4719 section, where XX is the size of longs in bits. Unfortunately,
4720 earlier compilers provided no way of distinguishing ILP32 objects
4721 from LP64 objects, so if there's any doubt, we should assume that
4722 the official LP64 form is being used. */
4723 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4724 && find_section (".gcc_compiled_long32") == NULL
)
4730 switch (elf_header
.e_flags
& EF_H8_MACH
)
4732 case E_H8_MACH_H8300
:
4733 case E_H8_MACH_H8300HN
:
4734 case E_H8_MACH_H8300SN
:
4735 case E_H8_MACH_H8300SXN
:
4738 case E_H8_MACH_H8300H
:
4739 case E_H8_MACH_H8300S
:
4740 case E_H8_MACH_H8300SX
:
4748 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4750 case EF_M32C_CPU_M16C
:
4757 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4760 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
4761 if (section->sh_entsize != expected_entsize) \
4763 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
4764 i, section->sh_entsize); \
4765 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
4766 (int) expected_entsize); \
4767 section->sh_entsize = expected_entsize; \
4772 #define CHECK_ENTSIZE(section, i, type) \
4773 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4774 sizeof (Elf64_External_##type))
4776 for (i
= 0, section
= section_headers
;
4777 i
< elf_header
.e_shnum
;
4780 char * name
= SECTION_NAME (section
);
4782 if (section
->sh_type
== SHT_DYNSYM
)
4784 if (dynamic_symbols
!= NULL
)
4786 error (_("File contains multiple dynamic symbol tables\n"));
4790 CHECK_ENTSIZE (section
, i
, Sym
);
4791 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4793 else if (section
->sh_type
== SHT_STRTAB
4794 && streq (name
, ".dynstr"))
4796 if (dynamic_strings
!= NULL
)
4798 error (_("File contains multiple dynamic string tables\n"));
4802 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4803 1, section
->sh_size
,
4804 _("dynamic strings"));
4805 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4807 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4809 if (symtab_shndx_hdr
!= NULL
)
4811 error (_("File contains multiple symtab shndx tables\n"));
4814 symtab_shndx_hdr
= section
;
4816 else if (section
->sh_type
== SHT_SYMTAB
)
4817 CHECK_ENTSIZE (section
, i
, Sym
);
4818 else if (section
->sh_type
== SHT_GROUP
)
4819 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4820 else if (section
->sh_type
== SHT_REL
)
4821 CHECK_ENTSIZE (section
, i
, Rel
);
4822 else if (section
->sh_type
== SHT_RELA
)
4823 CHECK_ENTSIZE (section
, i
, Rela
);
4824 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4825 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4826 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4827 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4828 || do_debug_addr
|| do_debug_cu_index
)
4829 && (const_strneq (name
, ".debug_")
4830 || const_strneq (name
, ".zdebug_")))
4833 name
+= sizeof (".zdebug_") - 1;
4835 name
+= sizeof (".debug_") - 1;
4838 || (do_debug_info
&& const_strneq (name
, "info"))
4839 || (do_debug_info
&& const_strneq (name
, "types"))
4840 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4841 || (do_debug_lines
&& strcmp (name
, "line") == 0)
4842 || (do_debug_lines
&& const_strneq (name
, "line."))
4843 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4844 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4845 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4846 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4847 || (do_debug_frames
&& const_strneq (name
, "frame"))
4848 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4849 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4850 || (do_debug_str
&& const_strneq (name
, "str"))
4851 || (do_debug_loc
&& const_strneq (name
, "loc"))
4852 || (do_debug_addr
&& const_strneq (name
, "addr"))
4853 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4854 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4856 request_dump_bynumber (i
, DEBUG_DUMP
);
4858 /* Linkonce section to be combined with .debug_info at link time. */
4859 else if ((do_debugging
|| do_debug_info
)
4860 && const_strneq (name
, ".gnu.linkonce.wi."))
4861 request_dump_bynumber (i
, DEBUG_DUMP
);
4862 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4863 request_dump_bynumber (i
, DEBUG_DUMP
);
4864 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4865 request_dump_bynumber (i
, DEBUG_DUMP
);
4866 /* Trace sections for Itanium VMS. */
4867 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4868 || do_trace_aranges
)
4869 && const_strneq (name
, ".trace_"))
4871 name
+= sizeof (".trace_") - 1;
4874 || (do_trace_info
&& streq (name
, "info"))
4875 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4876 || (do_trace_aranges
&& streq (name
, "aranges"))
4878 request_dump_bynumber (i
, DEBUG_DUMP
);
4886 if (elf_header
.e_shnum
> 1)
4887 printf (_("\nSection Headers:\n"));
4889 printf (_("\nSection Header:\n"));
4893 if (do_section_details
)
4895 printf (_(" [Nr] Name\n"));
4896 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4900 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4904 if (do_section_details
)
4906 printf (_(" [Nr] Name\n"));
4907 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4911 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4915 if (do_section_details
)
4917 printf (_(" [Nr] Name\n"));
4918 printf (_(" Type Address Offset Link\n"));
4919 printf (_(" Size EntSize Info Align\n"));
4923 printf (_(" [Nr] Name Type Address Offset\n"));
4924 printf (_(" Size EntSize Flags Link Info Align\n"));
4928 if (do_section_details
)
4929 printf (_(" Flags\n"));
4931 for (i
= 0, section
= section_headers
;
4932 i
< elf_header
.e_shnum
;
4935 printf (" [%2u] ", i
);
4936 if (do_section_details
)
4938 print_symbol (INT_MAX
, SECTION_NAME (section
));
4943 print_symbol (-17, SECTION_NAME (section
));
4946 printf (do_wide
? " %-15s " : " %-15.15s ",
4947 get_section_type_name (section
->sh_type
));
4951 const char * link_too_big
= NULL
;
4953 print_vma (section
->sh_addr
, LONG_HEX
);
4955 printf ( " %6.6lx %6.6lx %2.2lx",
4956 (unsigned long) section
->sh_offset
,
4957 (unsigned long) section
->sh_size
,
4958 (unsigned long) section
->sh_entsize
);
4960 if (do_section_details
)
4961 fputs (" ", stdout
);
4963 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4965 if (section
->sh_link
>= elf_header
.e_shnum
)
4968 /* The sh_link value is out of range. Normally this indicates
4969 an error but it can have special values in Solaris binaries. */
4970 switch (elf_header
.e_machine
)
4977 case EM_OLD_SPARCV9
:
4978 case EM_SPARC32PLUS
:
4981 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4982 link_too_big
= "BEFORE";
4983 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4984 link_too_big
= "AFTER";
4991 if (do_section_details
)
4993 if (link_too_big
!= NULL
&& * link_too_big
)
4994 printf ("<%s> ", link_too_big
);
4996 printf ("%2u ", section
->sh_link
);
4997 printf ("%3u %2lu\n", section
->sh_info
,
4998 (unsigned long) section
->sh_addralign
);
5001 printf ("%2u %3u %2lu\n",
5004 (unsigned long) section
->sh_addralign
);
5006 if (link_too_big
&& ! * link_too_big
)
5007 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5008 i
, section
->sh_link
);
5012 print_vma (section
->sh_addr
, LONG_HEX
);
5014 if ((long) section
->sh_offset
== section
->sh_offset
)
5015 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5019 print_vma (section
->sh_offset
, LONG_HEX
);
5022 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5023 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5027 print_vma (section
->sh_size
, LONG_HEX
);
5030 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5031 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5035 print_vma (section
->sh_entsize
, LONG_HEX
);
5038 if (do_section_details
)
5039 fputs (" ", stdout
);
5041 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5043 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5045 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5046 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5049 print_vma (section
->sh_addralign
, DEC
);
5053 else if (do_section_details
)
5055 printf (" %-15.15s ",
5056 get_section_type_name (section
->sh_type
));
5057 print_vma (section
->sh_addr
, LONG_HEX
);
5058 if ((long) section
->sh_offset
== section
->sh_offset
)
5059 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5063 print_vma (section
->sh_offset
, LONG_HEX
);
5065 printf (" %u\n ", section
->sh_link
);
5066 print_vma (section
->sh_size
, LONG_HEX
);
5068 print_vma (section
->sh_entsize
, LONG_HEX
);
5070 printf (" %-16u %lu\n",
5072 (unsigned long) section
->sh_addralign
);
5077 print_vma (section
->sh_addr
, LONG_HEX
);
5078 if ((long) section
->sh_offset
== section
->sh_offset
)
5079 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5083 print_vma (section
->sh_offset
, LONG_HEX
);
5086 print_vma (section
->sh_size
, LONG_HEX
);
5088 print_vma (section
->sh_entsize
, LONG_HEX
);
5090 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5092 printf (" %2u %3u %lu\n",
5095 (unsigned long) section
->sh_addralign
);
5098 if (do_section_details
)
5099 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5102 if (!do_section_details
)
5104 if (elf_header
.e_machine
== EM_X86_64
5105 || elf_header
.e_machine
== EM_L1OM
5106 || elf_header
.e_machine
== EM_K1OM
)
5107 printf (_("Key to Flags:\n\
5108 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5109 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5110 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5112 printf (_("Key to Flags:\n\
5113 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5114 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5115 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5122 get_group_flags (unsigned int flags
)
5124 static char buff
[32];
5134 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5141 process_section_groups (FILE * file
)
5143 Elf_Internal_Shdr
* section
;
5145 struct group
* group
;
5146 Elf_Internal_Shdr
* symtab_sec
;
5147 Elf_Internal_Shdr
* strtab_sec
;
5148 Elf_Internal_Sym
* symtab
;
5149 unsigned long num_syms
;
5153 /* Don't process section groups unless needed. */
5154 if (!do_unwind
&& !do_section_groups
)
5157 if (elf_header
.e_shnum
== 0)
5159 if (do_section_groups
)
5160 printf (_("\nThere are no sections to group in this file.\n"));
5165 if (section_headers
== NULL
)
5167 error (_("Section headers are not available!\n"));
5168 /* PR 13622: This can happen with a corrupt ELF header. */
5172 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5173 sizeof (struct group
*));
5175 if (section_headers_groups
== NULL
)
5177 error (_("Out of memory\n"));
5181 /* Scan the sections for the group section. */
5183 for (i
= 0, section
= section_headers
;
5184 i
< elf_header
.e_shnum
;
5186 if (section
->sh_type
== SHT_GROUP
)
5189 if (group_count
== 0)
5191 if (do_section_groups
)
5192 printf (_("\nThere are no section groups in this file.\n"));
5197 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5199 if (section_groups
== NULL
)
5201 error (_("Out of memory\n"));
5211 for (i
= 0, section
= section_headers
, group
= section_groups
;
5212 i
< elf_header
.e_shnum
;
5215 if (section
->sh_type
== SHT_GROUP
)
5217 char * name
= SECTION_NAME (section
);
5219 unsigned char * start
;
5220 unsigned char * indices
;
5221 unsigned int entry
, j
, size
;
5222 Elf_Internal_Shdr
* sec
;
5223 Elf_Internal_Sym
* sym
;
5225 /* Get the symbol table. */
5226 if (section
->sh_link
>= elf_header
.e_shnum
5227 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5230 error (_("Bad sh_link in group section `%s'\n"), name
);
5234 if (symtab_sec
!= sec
)
5239 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5244 error (_("Corrupt header in group section `%s'\n"), name
);
5248 if (section
->sh_info
>= num_syms
)
5250 error (_("Bad sh_info in group section `%s'\n"), name
);
5254 sym
= symtab
+ section
->sh_info
;
5256 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5258 if (sym
->st_shndx
== 0
5259 || sym
->st_shndx
>= elf_header
.e_shnum
)
5261 error (_("Bad sh_info in group section `%s'\n"), name
);
5265 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5274 /* Get the string table. */
5275 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5284 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5289 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5290 1, strtab_sec
->sh_size
,
5292 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5294 group_name
= sym
->st_name
< strtab_size
5295 ? strtab
+ sym
->st_name
: _("<corrupt>");
5298 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5299 1, section
->sh_size
,
5305 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5306 entry
= byte_get (indices
, 4);
5309 if (do_section_groups
)
5311 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5312 get_group_flags (entry
), i
, name
, group_name
, size
);
5314 printf (_(" [Index] Name\n"));
5317 group
->group_index
= i
;
5319 for (j
= 0; j
< size
; j
++)
5321 struct group_list
* g
;
5323 entry
= byte_get (indices
, 4);
5326 if (entry
>= elf_header
.e_shnum
)
5328 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5329 entry
, i
, elf_header
.e_shnum
- 1);
5333 if (section_headers_groups
[entry
] != NULL
)
5337 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5339 section_headers_groups
[entry
]->group_index
);
5344 /* Intel C/C++ compiler may put section 0 in a
5345 section group. We just warn it the first time
5346 and ignore it afterwards. */
5347 static int warned
= 0;
5350 error (_("section 0 in group section [%5u]\n"),
5351 section_headers_groups
[entry
]->group_index
);
5357 section_headers_groups
[entry
] = group
;
5359 if (do_section_groups
)
5361 sec
= section_headers
+ entry
;
5362 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5365 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5366 g
->section_index
= entry
;
5367 g
->next
= group
->root
;
5385 /* Data used to display dynamic fixups. */
5387 struct ia64_vms_dynfixup
5389 bfd_vma needed_ident
; /* Library ident number. */
5390 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5391 bfd_vma fixup_needed
; /* Index of the library. */
5392 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5393 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5396 /* Data used to display dynamic relocations. */
5398 struct ia64_vms_dynimgrela
5400 bfd_vma img_rela_cnt
; /* Number of relocations. */
5401 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5404 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5408 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5409 const char *strtab
, unsigned int strtab_sz
)
5411 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5413 const char *lib_name
;
5415 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5416 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5417 _("dynamic section image fixups"));
5421 if (fixup
->needed
< strtab_sz
)
5422 lib_name
= strtab
+ fixup
->needed
;
5425 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5426 (unsigned long) fixup
->needed
);
5429 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5430 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5432 (_("Seg Offset Type SymVec DataType\n"));
5434 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5439 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5440 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5441 type
= BYTE_GET (imfs
[i
].type
);
5442 rtype
= elf_ia64_reloc_type (type
);
5444 printf (" 0x%08x ", type
);
5446 printf (" %-32s ", rtype
);
5447 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5448 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5454 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5457 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5459 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5462 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5463 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5464 _("dynamic section image relocations"));
5468 printf (_("\nImage relocs\n"));
5470 (_("Seg Offset Type Addend Seg Sym Off\n"));
5472 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5477 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5478 printf ("%08" BFD_VMA_FMT
"x ",
5479 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5480 type
= BYTE_GET (imrs
[i
].type
);
5481 rtype
= elf_ia64_reloc_type (type
);
5483 printf ("0x%08x ", type
);
5485 printf ("%-31s ", rtype
);
5486 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5487 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5488 printf ("%08" BFD_VMA_FMT
"x\n",
5489 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5495 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5498 process_ia64_vms_dynamic_relocs (FILE *file
)
5500 struct ia64_vms_dynfixup fixup
;
5501 struct ia64_vms_dynimgrela imgrela
;
5502 Elf_Internal_Dyn
*entry
;
5504 bfd_vma strtab_off
= 0;
5505 bfd_vma strtab_sz
= 0;
5506 char *strtab
= NULL
;
5508 memset (&fixup
, 0, sizeof (fixup
));
5509 memset (&imgrela
, 0, sizeof (imgrela
));
5511 /* Note: the order of the entries is specified by the OpenVMS specs. */
5512 for (entry
= dynamic_section
;
5513 entry
< dynamic_section
+ dynamic_nent
;
5516 switch (entry
->d_tag
)
5518 case DT_IA_64_VMS_STRTAB_OFFSET
:
5519 strtab_off
= entry
->d_un
.d_val
;
5522 strtab_sz
= entry
->d_un
.d_val
;
5524 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5525 1, strtab_sz
, _("dynamic string section"));
5528 case DT_IA_64_VMS_NEEDED_IDENT
:
5529 fixup
.needed_ident
= entry
->d_un
.d_val
;
5532 fixup
.needed
= entry
->d_un
.d_val
;
5534 case DT_IA_64_VMS_FIXUP_NEEDED
:
5535 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5537 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5538 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5540 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5541 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5543 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5546 case DT_IA_64_VMS_IMG_RELA_CNT
:
5547 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5549 case DT_IA_64_VMS_IMG_RELA_OFF
:
5550 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5552 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5572 } dynamic_relocations
[] =
5574 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5575 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5576 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5579 /* Process the reloc section. */
5582 process_relocs (FILE * file
)
5584 unsigned long rel_size
;
5585 unsigned long rel_offset
;
5591 if (do_using_dynamic
)
5595 int has_dynamic_reloc
;
5598 has_dynamic_reloc
= 0;
5600 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5602 is_rela
= dynamic_relocations
[i
].rela
;
5603 name
= dynamic_relocations
[i
].name
;
5604 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5605 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5607 has_dynamic_reloc
|= rel_size
;
5609 if (is_rela
== UNKNOWN
)
5611 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5612 switch (dynamic_info
[DT_PLTREL
])
5626 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5627 name
, rel_offset
, rel_size
);
5629 dump_relocations (file
,
5630 offset_from_vma (file
, rel_offset
, rel_size
),
5632 dynamic_symbols
, num_dynamic_syms
,
5633 dynamic_strings
, dynamic_strings_length
, is_rela
);
5638 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5640 if (! has_dynamic_reloc
)
5641 printf (_("\nThere are no dynamic relocations in this file.\n"));
5645 Elf_Internal_Shdr
* section
;
5649 for (i
= 0, section
= section_headers
;
5650 i
< elf_header
.e_shnum
;
5653 if ( section
->sh_type
!= SHT_RELA
5654 && section
->sh_type
!= SHT_REL
)
5657 rel_offset
= section
->sh_offset
;
5658 rel_size
= section
->sh_size
;
5662 Elf_Internal_Shdr
* strsec
;
5665 printf (_("\nRelocation section "));
5667 if (string_table
== NULL
)
5668 printf ("%d", section
->sh_name
);
5670 printf ("'%s'", SECTION_NAME (section
));
5672 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5673 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5675 is_rela
= section
->sh_type
== SHT_RELA
;
5677 if (section
->sh_link
!= 0
5678 && section
->sh_link
< elf_header
.e_shnum
)
5680 Elf_Internal_Shdr
* symsec
;
5681 Elf_Internal_Sym
* symtab
;
5682 unsigned long nsyms
;
5683 unsigned long strtablen
= 0;
5684 char * strtab
= NULL
;
5686 symsec
= section_headers
+ section
->sh_link
;
5687 if (symsec
->sh_type
!= SHT_SYMTAB
5688 && symsec
->sh_type
!= SHT_DYNSYM
)
5691 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5696 if (symsec
->sh_link
!= 0
5697 && symsec
->sh_link
< elf_header
.e_shnum
)
5699 strsec
= section_headers
+ symsec
->sh_link
;
5701 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5704 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5707 dump_relocations (file
, rel_offset
, rel_size
,
5708 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5714 dump_relocations (file
, rel_offset
, rel_size
,
5715 NULL
, 0, NULL
, 0, is_rela
);
5722 printf (_("\nThere are no relocations in this file.\n"));
5728 /* Process the unwind section. */
5730 #include "unwind-ia64.h"
5732 /* An absolute address consists of a section and an offset. If the
5733 section is NULL, the offset itself is the address, otherwise, the
5734 address equals to LOAD_ADDRESS(section) + offset. */
5738 unsigned short section
;
5742 #define ABSADDR(a) \
5744 ? section_headers [(a).section].sh_addr + (a).offset \
5747 struct ia64_unw_table_entry
5749 struct absaddr start
;
5751 struct absaddr info
;
5754 struct ia64_unw_aux_info
5757 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5758 unsigned long table_len
; /* Length of unwind table. */
5759 unsigned char * info
; /* Unwind info. */
5760 unsigned long info_size
; /* Size of unwind info. */
5761 bfd_vma info_addr
; /* starting address of unwind info. */
5762 bfd_vma seg_base
; /* Starting address of segment. */
5763 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5764 unsigned long nsyms
; /* Number of symbols. */
5765 char * strtab
; /* The string table. */
5766 unsigned long strtab_size
; /* Size of string table. */
5770 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5771 unsigned long nsyms
,
5772 const char * strtab
,
5773 unsigned long strtab_size
,
5774 struct absaddr addr
,
5775 const char ** symname
,
5778 bfd_vma dist
= 0x100000;
5779 Elf_Internal_Sym
* sym
;
5780 Elf_Internal_Sym
* best
= NULL
;
5783 REMOVE_ARCH_BITS (addr
.offset
);
5785 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5787 bfd_vma value
= sym
->st_value
;
5789 REMOVE_ARCH_BITS (value
);
5791 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5792 && sym
->st_name
!= 0
5793 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5794 && addr
.offset
>= value
5795 && addr
.offset
- value
< dist
)
5798 dist
= addr
.offset
- value
;
5806 *symname
= (best
->st_name
>= strtab_size
5807 ? _("<corrupt>") : strtab
+ best
->st_name
);
5813 *offset
= addr
.offset
;
5817 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5819 struct ia64_unw_table_entry
* tp
;
5822 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5826 const unsigned char * dp
;
5827 const unsigned char * head
;
5828 const char * procname
;
5830 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5831 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5833 fputs ("\n<", stdout
);
5837 fputs (procname
, stdout
);
5840 printf ("+%lx", (unsigned long) offset
);
5843 fputs (">: [", stdout
);
5844 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5845 fputc ('-', stdout
);
5846 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5847 printf ("], info at +0x%lx\n",
5848 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5850 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5851 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5853 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5854 (unsigned) UNW_VER (stamp
),
5855 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5856 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5857 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5858 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5860 if (UNW_VER (stamp
) != 1)
5862 printf (_("\tUnknown version.\n"));
5867 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5868 dp
= unw_decode (dp
, in_body
, & in_body
);
5873 slurp_ia64_unwind_table (FILE * file
,
5874 struct ia64_unw_aux_info
* aux
,
5875 Elf_Internal_Shdr
* sec
)
5877 unsigned long size
, nrelas
, i
;
5878 Elf_Internal_Phdr
* seg
;
5879 struct ia64_unw_table_entry
* tep
;
5880 Elf_Internal_Shdr
* relsec
;
5881 Elf_Internal_Rela
* rela
;
5882 Elf_Internal_Rela
* rp
;
5883 unsigned char * table
;
5885 Elf_Internal_Sym
* sym
;
5886 const char * relname
;
5888 /* First, find the starting address of the segment that includes
5891 if (elf_header
.e_phnum
)
5893 if (! get_program_headers (file
))
5896 for (seg
= program_headers
;
5897 seg
< program_headers
+ elf_header
.e_phnum
;
5900 if (seg
->p_type
!= PT_LOAD
)
5903 if (sec
->sh_addr
>= seg
->p_vaddr
5904 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5906 aux
->seg_base
= seg
->p_vaddr
;
5912 /* Second, build the unwind table from the contents of the unwind section: */
5913 size
= sec
->sh_size
;
5914 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5919 aux
->table
= (struct ia64_unw_table_entry
*)
5920 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5922 for (tp
= table
; tp
< table
+ size
; ++tep
)
5924 tep
->start
.section
= SHN_UNDEF
;
5925 tep
->end
.section
= SHN_UNDEF
;
5926 tep
->info
.section
= SHN_UNDEF
;
5927 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5928 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5929 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5930 tep
->start
.offset
+= aux
->seg_base
;
5931 tep
->end
.offset
+= aux
->seg_base
;
5932 tep
->info
.offset
+= aux
->seg_base
;
5936 /* Third, apply any relocations to the unwind table: */
5937 for (relsec
= section_headers
;
5938 relsec
< section_headers
+ elf_header
.e_shnum
;
5941 if (relsec
->sh_type
!= SHT_RELA
5942 || relsec
->sh_info
>= elf_header
.e_shnum
5943 || section_headers
+ relsec
->sh_info
!= sec
)
5946 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5950 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5952 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5953 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5955 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5957 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5961 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5963 switch (rp
->r_offset
/eh_addr_size
% 3)
5966 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5967 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5970 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5971 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5974 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5975 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5985 aux
->table_len
= size
/ (3 * eh_addr_size
);
5990 ia64_process_unwind (FILE * file
)
5992 Elf_Internal_Shdr
* sec
;
5993 Elf_Internal_Shdr
* unwsec
= NULL
;
5994 Elf_Internal_Shdr
* strsec
;
5995 unsigned long i
, unwcount
= 0, unwstart
= 0;
5996 struct ia64_unw_aux_info aux
;
5998 memset (& aux
, 0, sizeof (aux
));
6000 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6002 if (sec
->sh_type
== SHT_SYMTAB
6003 && sec
->sh_link
< elf_header
.e_shnum
)
6005 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6007 strsec
= section_headers
+ sec
->sh_link
;
6008 assert (aux
.strtab
== NULL
);
6009 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6012 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6014 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6019 printf (_("\nThere are no unwind sections in this file.\n"));
6021 while (unwcount
-- > 0)
6026 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6027 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6028 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6035 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6037 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6039 /* We need to find which section group it is in. */
6040 struct group_list
* g
= section_headers_groups
[i
]->root
;
6042 for (; g
!= NULL
; g
= g
->next
)
6044 sec
= section_headers
+ g
->section_index
;
6046 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6051 i
= elf_header
.e_shnum
;
6053 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6055 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6056 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6057 suffix
= SECTION_NAME (unwsec
) + len
;
6058 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6060 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6061 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6066 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6067 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6068 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6069 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6071 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6072 suffix
= SECTION_NAME (unwsec
) + len
;
6073 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6075 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6076 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6080 if (i
== elf_header
.e_shnum
)
6082 printf (_("\nCould not find unwind info section for "));
6084 if (string_table
== NULL
)
6085 printf ("%d", unwsec
->sh_name
);
6087 printf (_("'%s'"), SECTION_NAME (unwsec
));
6091 aux
.info_addr
= sec
->sh_addr
;
6092 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6095 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6097 printf (_("\nUnwind section "));
6099 if (string_table
== NULL
)
6100 printf ("%d", unwsec
->sh_name
);
6102 printf (_("'%s'"), SECTION_NAME (unwsec
));
6104 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6105 (unsigned long) unwsec
->sh_offset
,
6106 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6108 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6110 if (aux
.table_len
> 0)
6111 dump_ia64_unwind (& aux
);
6114 free ((char *) aux
.table
);
6116 free ((char *) aux
.info
);
6125 free ((char *) aux
.strtab
);
6128 struct hppa_unw_table_entry
6130 struct absaddr start
;
6132 unsigned int Cannot_unwind
:1; /* 0 */
6133 unsigned int Millicode
:1; /* 1 */
6134 unsigned int Millicode_save_sr0
:1; /* 2 */
6135 unsigned int Region_description
:2; /* 3..4 */
6136 unsigned int reserved1
:1; /* 5 */
6137 unsigned int Entry_SR
:1; /* 6 */
6138 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6139 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6140 unsigned int Args_stored
:1; /* 16 */
6141 unsigned int Variable_Frame
:1; /* 17 */
6142 unsigned int Separate_Package_Body
:1; /* 18 */
6143 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6144 unsigned int Stack_Overflow_Check
:1; /* 20 */
6145 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6146 unsigned int Ada_Region
:1; /* 22 */
6147 unsigned int cxx_info
:1; /* 23 */
6148 unsigned int cxx_try_catch
:1; /* 24 */
6149 unsigned int sched_entry_seq
:1; /* 25 */
6150 unsigned int reserved2
:1; /* 26 */
6151 unsigned int Save_SP
:1; /* 27 */
6152 unsigned int Save_RP
:1; /* 28 */
6153 unsigned int Save_MRP_in_frame
:1; /* 29 */
6154 unsigned int extn_ptr_defined
:1; /* 30 */
6155 unsigned int Cleanup_defined
:1; /* 31 */
6157 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6158 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6159 unsigned int Large_frame
:1; /* 2 */
6160 unsigned int Pseudo_SP_Set
:1; /* 3 */
6161 unsigned int reserved4
:1; /* 4 */
6162 unsigned int Total_frame_size
:27; /* 5..31 */
6165 struct hppa_unw_aux_info
6167 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6168 unsigned long table_len
; /* Length of unwind table. */
6169 bfd_vma seg_base
; /* Starting address of segment. */
6170 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6171 unsigned long nsyms
; /* Number of symbols. */
6172 char * strtab
; /* The string table. */
6173 unsigned long strtab_size
; /* Size of string table. */
6177 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6179 struct hppa_unw_table_entry
* tp
;
6181 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6184 const char * procname
;
6186 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6187 aux
->strtab_size
, tp
->start
, &procname
,
6190 fputs ("\n<", stdout
);
6194 fputs (procname
, stdout
);
6197 printf ("+%lx", (unsigned long) offset
);
6200 fputs (">: [", stdout
);
6201 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6202 fputc ('-', stdout
);
6203 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6206 #define PF(_m) if (tp->_m) printf (#_m " ");
6207 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6210 PF(Millicode_save_sr0
);
6211 /* PV(Region_description); */
6217 PF(Separate_Package_Body
);
6218 PF(Frame_Extension_Millicode
);
6219 PF(Stack_Overflow_Check
);
6220 PF(Two_Instruction_SP_Increment
);
6224 PF(sched_entry_seq
);
6227 PF(Save_MRP_in_frame
);
6228 PF(extn_ptr_defined
);
6229 PF(Cleanup_defined
);
6230 PF(MPE_XL_interrupt_marker
);
6231 PF(HP_UX_interrupt_marker
);
6234 PV(Total_frame_size
);
6243 slurp_hppa_unwind_table (FILE * file
,
6244 struct hppa_unw_aux_info
* aux
,
6245 Elf_Internal_Shdr
* sec
)
6247 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6248 Elf_Internal_Phdr
* seg
;
6249 struct hppa_unw_table_entry
* tep
;
6250 Elf_Internal_Shdr
* relsec
;
6251 Elf_Internal_Rela
* rela
;
6252 Elf_Internal_Rela
* rp
;
6253 unsigned char * table
;
6255 Elf_Internal_Sym
* sym
;
6256 const char * relname
;
6258 /* First, find the starting address of the segment that includes
6261 if (elf_header
.e_phnum
)
6263 if (! get_program_headers (file
))
6266 for (seg
= program_headers
;
6267 seg
< program_headers
+ elf_header
.e_phnum
;
6270 if (seg
->p_type
!= PT_LOAD
)
6273 if (sec
->sh_addr
>= seg
->p_vaddr
6274 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6276 aux
->seg_base
= seg
->p_vaddr
;
6282 /* Second, build the unwind table from the contents of the unwind
6284 size
= sec
->sh_size
;
6285 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6291 nentries
= size
/ unw_ent_size
;
6292 size
= unw_ent_size
* nentries
;
6294 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6295 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6297 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6299 unsigned int tmp1
, tmp2
;
6301 tep
->start
.section
= SHN_UNDEF
;
6302 tep
->end
.section
= SHN_UNDEF
;
6304 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6305 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6306 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6307 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6309 tep
->start
.offset
+= aux
->seg_base
;
6310 tep
->end
.offset
+= aux
->seg_base
;
6312 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6313 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6314 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6315 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6316 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6317 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6318 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6319 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6320 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6321 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6322 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6323 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6324 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6325 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6326 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6327 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6328 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6329 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6330 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6331 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6332 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6333 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6334 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6335 tep
->Cleanup_defined
= tmp1
& 0x1;
6337 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6338 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6339 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6340 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6341 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6342 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6346 /* Third, apply any relocations to the unwind table. */
6347 for (relsec
= section_headers
;
6348 relsec
< section_headers
+ elf_header
.e_shnum
;
6351 if (relsec
->sh_type
!= SHT_RELA
6352 || relsec
->sh_info
>= elf_header
.e_shnum
6353 || section_headers
+ relsec
->sh_info
!= sec
)
6356 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6360 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6362 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6363 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6365 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6366 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6368 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6372 i
= rp
->r_offset
/ unw_ent_size
;
6374 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6377 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6378 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6381 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6382 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6392 aux
->table_len
= nentries
;
6398 hppa_process_unwind (FILE * file
)
6400 struct hppa_unw_aux_info aux
;
6401 Elf_Internal_Shdr
* unwsec
= NULL
;
6402 Elf_Internal_Shdr
* strsec
;
6403 Elf_Internal_Shdr
* sec
;
6406 if (string_table
== NULL
)
6409 memset (& aux
, 0, sizeof (aux
));
6411 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6413 if (sec
->sh_type
== SHT_SYMTAB
6414 && sec
->sh_link
< elf_header
.e_shnum
)
6416 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6418 strsec
= section_headers
+ sec
->sh_link
;
6419 assert (aux
.strtab
== NULL
);
6420 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6423 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6425 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6430 printf (_("\nThere are no unwind sections in this file.\n"));
6432 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6434 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6436 printf (_("\nUnwind section "));
6437 printf (_("'%s'"), SECTION_NAME (sec
));
6439 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6440 (unsigned long) sec
->sh_offset
,
6441 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6443 slurp_hppa_unwind_table (file
, &aux
, sec
);
6444 if (aux
.table_len
> 0)
6445 dump_hppa_unwind (&aux
);
6448 free ((char *) aux
.table
);
6456 free ((char *) aux
.strtab
);
6461 unsigned char * data
; /* The unwind data. */
6462 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6463 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6464 unsigned long nrelas
; /* The number of relocations. */
6465 unsigned int rel_type
; /* REL or RELA ? */
6466 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6469 struct arm_unw_aux_info
6471 FILE * file
; /* The file containing the unwind sections. */
6472 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6473 unsigned long nsyms
; /* Number of symbols. */
6474 char * strtab
; /* The file's string table. */
6475 unsigned long strtab_size
; /* Size of string table. */
6479 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6480 bfd_vma fn
, struct absaddr addr
)
6482 const char *procname
;
6485 if (addr
.section
== SHN_UNDEF
)
6488 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6489 aux
->strtab_size
, addr
, &procname
,
6492 print_vma (fn
, PREFIX_HEX
);
6496 fputs (" <", stdout
);
6497 fputs (procname
, stdout
);
6500 printf ("+0x%lx", (unsigned long) sym_offset
);
6501 fputc ('>', stdout
);
6508 arm_free_section (struct arm_section
*arm_sec
)
6510 if (arm_sec
->data
!= NULL
)
6511 free (arm_sec
->data
);
6513 if (arm_sec
->rela
!= NULL
)
6514 free (arm_sec
->rela
);
6517 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6518 cached section and install SEC instead.
6519 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6520 and return its valued in * WORDP, relocating if necessary.
6521 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6522 relocation's offset in ADDR.
6523 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6524 into the string table of the symbol associated with the reloc. If no
6525 reloc was applied store -1 there.
6526 5) Return TRUE upon success, FALSE otherwise. */
6529 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6530 struct arm_section
* arm_sec
,
6531 Elf_Internal_Shdr
* sec
,
6532 bfd_vma word_offset
,
6533 unsigned int * wordp
,
6534 struct absaddr
* addr
,
6537 Elf_Internal_Rela
*rp
;
6538 Elf_Internal_Sym
*sym
;
6539 const char * relname
;
6541 bfd_boolean wrapped
;
6543 addr
->section
= SHN_UNDEF
;
6546 if (sym_name
!= NULL
)
6547 *sym_name
= (bfd_vma
) -1;
6549 /* If necessary, update the section cache. */
6550 if (sec
!= arm_sec
->sec
)
6552 Elf_Internal_Shdr
*relsec
;
6554 arm_free_section (arm_sec
);
6557 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6558 sec
->sh_size
, _("unwind data"));
6559 arm_sec
->rela
= NULL
;
6560 arm_sec
->nrelas
= 0;
6562 for (relsec
= section_headers
;
6563 relsec
< section_headers
+ elf_header
.e_shnum
;
6566 if (relsec
->sh_info
>= elf_header
.e_shnum
6567 || section_headers
+ relsec
->sh_info
!= sec
)
6570 arm_sec
->rel_type
= relsec
->sh_type
;
6571 if (relsec
->sh_type
== SHT_REL
)
6573 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6575 & arm_sec
->rela
, & arm_sec
->nrelas
))
6579 else if (relsec
->sh_type
== SHT_RELA
)
6581 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6583 & arm_sec
->rela
, & arm_sec
->nrelas
))
6588 warn (_("unexpected relocation type (%d) for section %d"),
6589 relsec
->sh_type
, relsec
->sh_info
);
6592 arm_sec
->next_rela
= arm_sec
->rela
;
6595 /* If there is no unwind data we can do nothing. */
6596 if (arm_sec
->data
== NULL
)
6599 /* Get the word at the required offset. */
6600 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6602 /* Look through the relocs to find the one that applies to the provided offset. */
6604 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6606 bfd_vma prelval
, offset
;
6608 if (rp
->r_offset
> word_offset
&& !wrapped
)
6613 if (rp
->r_offset
> word_offset
)
6616 if (rp
->r_offset
& 3)
6618 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6619 (unsigned long) rp
->r_offset
);
6623 if (rp
->r_offset
< word_offset
)
6626 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6628 if (arm_sec
->rel_type
== SHT_REL
)
6630 offset
= word
& 0x7fffffff;
6631 if (offset
& 0x40000000)
6632 offset
|= ~ (bfd_vma
) 0x7fffffff;
6634 else if (arm_sec
->rel_type
== SHT_RELA
)
6635 offset
= rp
->r_addend
;
6639 offset
+= sym
->st_value
;
6640 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6642 /* Check that we are processing the expected reloc type. */
6643 if (elf_header
.e_machine
== EM_ARM
)
6645 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6647 if (streq (relname
, "R_ARM_NONE"))
6650 if (! streq (relname
, "R_ARM_PREL31"))
6652 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6656 else if (elf_header
.e_machine
== EM_TI_C6000
)
6658 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6660 if (streq (relname
, "R_C6000_NONE"))
6663 if (! streq (relname
, "R_C6000_PREL31"))
6665 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6672 /* This function currently only supports ARM and TI unwinders. */
6675 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6676 addr
->section
= sym
->st_shndx
;
6677 addr
->offset
= offset
;
6679 * sym_name
= sym
->st_name
;
6684 arm_sec
->next_rela
= rp
;
6689 static const char *tic6x_unwind_regnames
[16] =
6691 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6692 "A14", "A13", "A12", "A11", "A10",
6693 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6697 decode_tic6x_unwind_regmask (unsigned int mask
)
6701 for (i
= 12; mask
; mask
>>= 1, i
--)
6705 fputs (tic6x_unwind_regnames
[i
], stdout
);
6707 fputs (", ", stdout
);
6713 if (remaining == 0 && more_words) \
6716 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6717 data_offset, & word, & addr, NULL)) \
6723 #define GET_OP(OP) \
6728 (OP) = word >> 24; \
6733 printf (_("[Truncated opcode]\n")); \
6736 printf ("0x%02x ", OP)
6739 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6740 unsigned int word
, unsigned int remaining
,
6741 unsigned int more_words
,
6742 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6743 struct arm_section
*data_arm_sec
)
6745 struct absaddr addr
;
6747 /* Decode the unwinding instructions. */
6750 unsigned int op
, op2
;
6759 printf (" 0x%02x ", op
);
6761 if ((op
& 0xc0) == 0x00)
6763 int offset
= ((op
& 0x3f) << 2) + 4;
6765 printf (" vsp = vsp + %d", offset
);
6767 else if ((op
& 0xc0) == 0x40)
6769 int offset
= ((op
& 0x3f) << 2) + 4;
6771 printf (" vsp = vsp - %d", offset
);
6773 else if ((op
& 0xf0) == 0x80)
6776 if (op
== 0x80 && op2
== 0)
6777 printf (_("Refuse to unwind"));
6780 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6785 for (i
= 0; i
< 12; i
++)
6786 if (mask
& (1 << i
))
6792 printf ("r%d", 4 + i
);
6797 else if ((op
& 0xf0) == 0x90)
6799 if (op
== 0x9d || op
== 0x9f)
6800 printf (_(" [Reserved]"));
6802 printf (" vsp = r%d", op
& 0x0f);
6804 else if ((op
& 0xf0) == 0xa0)
6806 int end
= 4 + (op
& 0x07);
6811 for (i
= 4; i
<= end
; i
++)
6827 else if (op
== 0xb0)
6828 printf (_(" finish"));
6829 else if (op
== 0xb1)
6832 if (op2
== 0 || (op2
& 0xf0) != 0)
6833 printf (_("[Spare]"));
6836 unsigned int mask
= op2
& 0x0f;
6841 for (i
= 0; i
< 12; i
++)
6842 if (mask
& (1 << i
))
6853 else if (op
== 0xb2)
6855 unsigned char buf
[9];
6856 unsigned int i
, len
;
6857 unsigned long offset
;
6859 for (i
= 0; i
< sizeof (buf
); i
++)
6862 if ((buf
[i
] & 0x80) == 0)
6865 assert (i
< sizeof (buf
));
6866 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
6867 assert (len
== i
+ 1);
6868 offset
= offset
* 4 + 0x204;
6869 printf ("vsp = vsp + %ld", offset
);
6871 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6873 unsigned int first
, last
;
6880 printf ("pop {D%d", first
);
6882 printf ("-D%d", first
+ last
);
6885 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6887 unsigned int count
= op
& 0x07;
6891 printf ("-D%d", 8 + count
);
6894 else if (op
>= 0xc0 && op
<= 0xc5)
6896 unsigned int count
= op
& 0x07;
6898 printf (" pop {wR10");
6900 printf ("-wR%d", 10 + count
);
6903 else if (op
== 0xc6)
6905 unsigned int first
, last
;
6910 printf ("pop {wR%d", first
);
6912 printf ("-wR%d", first
+ last
);
6915 else if (op
== 0xc7)
6918 if (op2
== 0 || (op2
& 0xf0) != 0)
6919 printf (_("[Spare]"));
6922 unsigned int mask
= op2
& 0x0f;
6927 for (i
= 0; i
< 4; i
++)
6928 if (mask
& (1 << i
))
6934 printf ("wCGR%d", i
);
6940 printf (_(" [unsupported opcode]"));
6946 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6947 unsigned int word
, unsigned int remaining
,
6948 unsigned int more_words
,
6949 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6950 struct arm_section
*data_arm_sec
)
6952 struct absaddr addr
;
6954 /* Decode the unwinding instructions. */
6957 unsigned int op
, op2
;
6966 printf (" 0x%02x ", op
);
6968 if ((op
& 0xc0) == 0x00)
6970 int offset
= ((op
& 0x3f) << 3) + 8;
6971 printf (" sp = sp + %d", offset
);
6973 else if ((op
& 0xc0) == 0x80)
6976 if (op
== 0x80 && op2
== 0)
6977 printf (_("Refuse to unwind"));
6980 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6982 printf ("pop compact {");
6986 decode_tic6x_unwind_regmask (mask
);
6990 else if ((op
& 0xf0) == 0xc0)
6998 unsigned int offset
;
7002 /* Scan entire instruction first so that GET_OP output is not
7003 interleaved with disassembly. */
7005 for (i
= 0; nregs
< (op
& 0xf); i
++)
7011 regpos
[nregs
].offset
= i
* 2;
7012 regpos
[nregs
].reg
= reg
;
7019 regpos
[nregs
].offset
= i
* 2 + 1;
7020 regpos
[nregs
].reg
= reg
;
7025 printf (_("pop frame {"));
7027 for (i
= i
* 2; i
> 0; i
--)
7029 if (regpos
[reg
].offset
== i
- 1)
7031 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7038 fputs (name
, stdout
);
7045 else if (op
== 0xd0)
7046 printf (" MOV FP, SP");
7047 else if (op
== 0xd1)
7048 printf (" __c6xabi_pop_rts");
7049 else if (op
== 0xd2)
7051 unsigned char buf
[9];
7052 unsigned int i
, len
;
7053 unsigned long offset
;
7055 for (i
= 0; i
< sizeof (buf
); i
++)
7058 if ((buf
[i
] & 0x80) == 0)
7061 assert (i
< sizeof (buf
));
7062 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7063 assert (len
== i
+ 1);
7064 offset
= offset
* 8 + 0x408;
7065 printf (_("sp = sp + %ld"), offset
);
7067 else if ((op
& 0xf0) == 0xe0)
7069 if ((op
& 0x0f) == 7)
7072 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7076 printf (_(" [unsupported opcode]"));
7083 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7087 offset
= word
& 0x7fffffff;
7088 if (offset
& 0x40000000)
7089 offset
|= ~ (bfd_vma
) 0x7fffffff;
7091 if (elf_header
.e_machine
== EM_TI_C6000
)
7094 return offset
+ where
;
7098 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7100 unsigned int remaining
,
7101 bfd_vma data_offset
,
7102 Elf_Internal_Shdr
* data_sec
,
7103 struct arm_section
* data_arm_sec
)
7106 unsigned int more_words
= 0;
7107 struct absaddr addr
;
7108 bfd_vma sym_name
= (bfd_vma
) -1;
7112 /* Fetch the first word.
7113 Note - when decoding an object file the address extracted
7114 here will always be 0. So we also pass in the sym_name
7115 parameter so that we can find the symbol associated with
7116 the personality routine. */
7117 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7118 & word
, & addr
, & sym_name
))
7124 if ((word
& 0x80000000) == 0)
7126 /* Expand prel31 for personality routine. */
7128 const char *procname
;
7130 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7131 printf (_(" Personality routine: "));
7133 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7134 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7136 procname
= aux
->strtab
+ sym_name
;
7137 print_vma (fn
, PREFIX_HEX
);
7140 fputs (" <", stdout
);
7141 fputs (procname
, stdout
);
7142 fputc ('>', stdout
);
7146 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7147 fputc ('\n', stdout
);
7149 /* The GCC personality routines use the standard compact
7150 encoding, starting with one byte giving the number of
7152 if (procname
!= NULL
7153 && (const_strneq (procname
, "__gcc_personality_v0")
7154 || const_strneq (procname
, "__gxx_personality_v0")
7155 || const_strneq (procname
, "__gcj_personality_v0")
7156 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7163 printf (_(" [Truncated data]\n"));
7166 more_words
= word
>> 24;
7176 /* ARM EHABI Section 6.3:
7178 An exception-handling table entry for the compact model looks like:
7182 1 0 index Data for personalityRoutine[index] */
7184 if (elf_header
.e_machine
== EM_ARM
7185 && (word
& 0x70000000))
7186 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7188 per_index
= (word
>> 24) & 0x7f;
7189 printf (_(" Compact model index: %d\n"), per_index
);
7196 else if (per_index
< 3)
7198 more_words
= (word
>> 16) & 0xff;
7204 switch (elf_header
.e_machine
)
7209 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7210 data_offset
, data_sec
, data_arm_sec
);
7214 warn (_("Unknown ARM compact model index encountered\n"));
7215 printf (_(" [reserved]\n"));
7222 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7223 data_offset
, data_sec
, data_arm_sec
);
7225 else if (per_index
< 5)
7227 if (((word
>> 17) & 0x7f) == 0x7f)
7228 printf (_(" Restore stack from frame pointer\n"));
7230 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7231 printf (_(" Registers restored: "));
7233 printf (" (compact) ");
7234 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7236 printf (_(" Return register: %s\n"),
7237 tic6x_unwind_regnames
[word
& 0xf]);
7240 printf (_(" [reserved (%d)]\n"), per_index
);
7244 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7245 elf_header
.e_machine
);
7248 /* Decode the descriptors. Not implemented. */
7252 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7254 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7255 unsigned int i
, exidx_len
;
7257 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7258 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7259 exidx_len
= exidx_sec
->sh_size
/ 8;
7261 for (i
= 0; i
< exidx_len
; i
++)
7263 unsigned int exidx_fn
, exidx_entry
;
7264 struct absaddr fn_addr
, entry_addr
;
7267 fputc ('\n', stdout
);
7269 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7270 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7271 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7272 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7274 arm_free_section (& exidx_arm_sec
);
7275 arm_free_section (& extab_arm_sec
);
7279 /* ARM EHABI, Section 5:
7280 An index table entry consists of 2 words.
7281 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7282 if (exidx_fn
& 0x80000000)
7283 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7285 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7287 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7288 fputs (": ", stdout
);
7290 if (exidx_entry
== 1)
7292 print_vma (exidx_entry
, PREFIX_HEX
);
7293 fputs (" [cantunwind]\n", stdout
);
7295 else if (exidx_entry
& 0x80000000)
7297 print_vma (exidx_entry
, PREFIX_HEX
);
7298 fputc ('\n', stdout
);
7299 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7303 bfd_vma table
, table_offset
= 0;
7304 Elf_Internal_Shdr
*table_sec
;
7306 fputs ("@", stdout
);
7307 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7308 print_vma (table
, PREFIX_HEX
);
7311 /* Locate the matching .ARM.extab. */
7312 if (entry_addr
.section
!= SHN_UNDEF
7313 && entry_addr
.section
< elf_header
.e_shnum
)
7315 table_sec
= section_headers
+ entry_addr
.section
;
7316 table_offset
= entry_addr
.offset
;
7320 table_sec
= find_section_by_address (table
);
7321 if (table_sec
!= NULL
)
7322 table_offset
= table
- table_sec
->sh_addr
;
7324 if (table_sec
== NULL
)
7326 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7327 (unsigned long) table
);
7330 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7337 arm_free_section (&exidx_arm_sec
);
7338 arm_free_section (&extab_arm_sec
);
7341 /* Used for both ARM and C6X unwinding tables. */
7344 arm_process_unwind (FILE *file
)
7346 struct arm_unw_aux_info aux
;
7347 Elf_Internal_Shdr
*unwsec
= NULL
;
7348 Elf_Internal_Shdr
*strsec
;
7349 Elf_Internal_Shdr
*sec
;
7351 unsigned int sec_type
;
7353 switch (elf_header
.e_machine
)
7356 sec_type
= SHT_ARM_EXIDX
;
7360 sec_type
= SHT_C6000_UNWIND
;
7364 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7365 elf_header
.e_machine
);
7369 if (string_table
== NULL
)
7372 memset (& aux
, 0, sizeof (aux
));
7375 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7377 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7379 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7381 strsec
= section_headers
+ sec
->sh_link
;
7382 assert (aux
.strtab
== NULL
);
7383 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7384 1, strsec
->sh_size
, _("string table"));
7385 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7387 else if (sec
->sh_type
== sec_type
)
7392 printf (_("\nThere are no unwind sections in this file.\n"));
7394 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7396 if (sec
->sh_type
== sec_type
)
7398 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7400 (unsigned long) sec
->sh_offset
,
7401 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7403 dump_arm_unwind (&aux
, sec
);
7410 free ((char *) aux
.strtab
);
7414 process_unwind (FILE * file
)
7416 struct unwind_handler
7419 void (* handler
)(FILE *);
7422 { EM_ARM
, arm_process_unwind
},
7423 { EM_IA_64
, ia64_process_unwind
},
7424 { EM_PARISC
, hppa_process_unwind
},
7425 { EM_TI_C6000
, arm_process_unwind
},
7433 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7434 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7435 return handlers
[i
].handler (file
);
7437 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7438 get_machine_name (elf_header
.e_machine
));
7442 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7444 switch (entry
->d_tag
)
7447 if (entry
->d_un
.d_val
== 0)
7451 static const char * opts
[] =
7453 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7454 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7455 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7456 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7462 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7463 if (entry
->d_un
.d_val
& (1 << cnt
))
7465 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7471 case DT_MIPS_IVERSION
:
7472 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7473 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7475 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7478 case DT_MIPS_TIME_STAMP
:
7483 time_t atime
= entry
->d_un
.d_val
;
7484 tmp
= gmtime (&atime
);
7485 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7486 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7487 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7488 printf (_("Time Stamp: %s"), timebuf
);
7492 case DT_MIPS_RLD_VERSION
:
7493 case DT_MIPS_LOCAL_GOTNO
:
7494 case DT_MIPS_CONFLICTNO
:
7495 case DT_MIPS_LIBLISTNO
:
7496 case DT_MIPS_SYMTABNO
:
7497 case DT_MIPS_UNREFEXTNO
:
7498 case DT_MIPS_HIPAGENO
:
7499 case DT_MIPS_DELTA_CLASS_NO
:
7500 case DT_MIPS_DELTA_INSTANCE_NO
:
7501 case DT_MIPS_DELTA_RELOC_NO
:
7502 case DT_MIPS_DELTA_SYM_NO
:
7503 case DT_MIPS_DELTA_CLASSSYM_NO
:
7504 case DT_MIPS_COMPACT_SIZE
:
7505 print_vma (entry
->d_un
.d_ptr
, DEC
);
7509 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7515 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7517 switch (entry
->d_tag
)
7519 case DT_HP_DLD_FLAGS
:
7528 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7529 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7530 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7531 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7532 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7533 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7534 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7535 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7536 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7537 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7538 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7539 { DT_HP_GST
, "HP_GST" },
7540 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7541 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7542 { DT_HP_NODELETE
, "HP_NODELETE" },
7543 { DT_HP_GROUP
, "HP_GROUP" },
7544 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7548 bfd_vma val
= entry
->d_un
.d_val
;
7550 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7551 if (val
& flags
[cnt
].bit
)
7555 fputs (flags
[cnt
].str
, stdout
);
7557 val
^= flags
[cnt
].bit
;
7560 if (val
!= 0 || first
)
7564 print_vma (val
, HEX
);
7570 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7578 /* VMS vs Unix time offset and factor. */
7580 #define VMS_EPOCH_OFFSET 35067168000000000LL
7581 #define VMS_GRANULARITY_FACTOR 10000000
7583 /* Display a VMS time in a human readable format. */
7586 print_vms_time (bfd_int64_t vmstime
)
7591 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7592 tm
= gmtime (&unxtime
);
7593 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7594 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7595 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7600 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7602 switch (entry
->d_tag
)
7604 case DT_IA_64_PLT_RESERVE
:
7605 /* First 3 slots reserved. */
7606 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7608 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7611 case DT_IA_64_VMS_LINKTIME
:
7613 print_vms_time (entry
->d_un
.d_val
);
7617 case DT_IA_64_VMS_LNKFLAGS
:
7618 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7619 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7620 printf (" CALL_DEBUG");
7621 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7622 printf (" NOP0BUFS");
7623 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7624 printf (" P0IMAGE");
7625 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7626 printf (" MKTHREADS");
7627 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7628 printf (" UPCALLS");
7629 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7631 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7632 printf (" INITIALIZE");
7633 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7635 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7636 printf (" EXE_INIT");
7637 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7638 printf (" TBK_IN_IMG");
7639 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7640 printf (" DBG_IN_IMG");
7641 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7642 printf (" TBK_IN_DSF");
7643 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7644 printf (" DBG_IN_DSF");
7645 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7646 printf (" SIGNATURES");
7647 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7648 printf (" REL_SEG_OFF");
7652 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7659 get_32bit_dynamic_section (FILE * file
)
7661 Elf32_External_Dyn
* edyn
;
7662 Elf32_External_Dyn
* ext
;
7663 Elf_Internal_Dyn
* entry
;
7665 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7666 dynamic_size
, _("dynamic section"));
7670 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7671 might not have the luxury of section headers. Look for the DT_NULL
7672 terminator to determine the number of entries. */
7673 for (ext
= edyn
, dynamic_nent
= 0;
7674 (char *) ext
< (char *) edyn
+ dynamic_size
;
7678 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7682 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7684 if (dynamic_section
== NULL
)
7686 error (_("Out of memory\n"));
7691 for (ext
= edyn
, entry
= dynamic_section
;
7692 entry
< dynamic_section
+ dynamic_nent
;
7695 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7696 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7705 get_64bit_dynamic_section (FILE * file
)
7707 Elf64_External_Dyn
* edyn
;
7708 Elf64_External_Dyn
* ext
;
7709 Elf_Internal_Dyn
* entry
;
7711 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7712 dynamic_size
, _("dynamic section"));
7716 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7717 might not have the luxury of section headers. Look for the DT_NULL
7718 terminator to determine the number of entries. */
7719 for (ext
= edyn
, dynamic_nent
= 0;
7720 (char *) ext
< (char *) edyn
+ dynamic_size
;
7724 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7728 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7730 if (dynamic_section
== NULL
)
7732 error (_("Out of memory\n"));
7737 for (ext
= edyn
, entry
= dynamic_section
;
7738 entry
< dynamic_section
+ dynamic_nent
;
7741 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7742 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7751 print_dynamic_flags (bfd_vma flags
)
7759 flag
= flags
& - flags
;
7769 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7770 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7771 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7772 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7773 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7774 default: fputs (_("unknown"), stdout
); break;
7780 /* Parse and display the contents of the dynamic section. */
7783 process_dynamic_section (FILE * file
)
7785 Elf_Internal_Dyn
* entry
;
7787 if (dynamic_size
== 0)
7790 printf (_("\nThere is no dynamic section in this file.\n"));
7797 if (! get_32bit_dynamic_section (file
))
7800 else if (! get_64bit_dynamic_section (file
))
7803 /* Find the appropriate symbol table. */
7804 if (dynamic_symbols
== NULL
)
7806 for (entry
= dynamic_section
;
7807 entry
< dynamic_section
+ dynamic_nent
;
7810 Elf_Internal_Shdr section
;
7812 if (entry
->d_tag
!= DT_SYMTAB
)
7815 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7817 /* Since we do not know how big the symbol table is,
7818 we default to reading in the entire file (!) and
7819 processing that. This is overkill, I know, but it
7821 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7823 if (archive_file_offset
!= 0)
7824 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7827 if (fseek (file
, 0, SEEK_END
))
7828 error (_("Unable to seek to end of file!\n"));
7830 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7834 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7836 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7838 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7839 if (num_dynamic_syms
< 1)
7841 error (_("Unable to determine the number of symbols to load\n"));
7847 /* Similarly find a string table. */
7848 if (dynamic_strings
== NULL
)
7850 for (entry
= dynamic_section
;
7851 entry
< dynamic_section
+ dynamic_nent
;
7854 unsigned long offset
;
7857 if (entry
->d_tag
!= DT_STRTAB
)
7860 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7862 /* Since we do not know how big the string table is,
7863 we default to reading in the entire file (!) and
7864 processing that. This is overkill, I know, but it
7867 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7869 if (archive_file_offset
!= 0)
7870 str_tab_len
= archive_file_size
- offset
;
7873 if (fseek (file
, 0, SEEK_END
))
7874 error (_("Unable to seek to end of file\n"));
7875 str_tab_len
= ftell (file
) - offset
;
7878 if (str_tab_len
< 1)
7881 (_("Unable to determine the length of the dynamic string table\n"));
7885 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7887 _("dynamic string table"));
7888 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7893 /* And find the syminfo section if available. */
7894 if (dynamic_syminfo
== NULL
)
7896 unsigned long syminsz
= 0;
7898 for (entry
= dynamic_section
;
7899 entry
< dynamic_section
+ dynamic_nent
;
7902 if (entry
->d_tag
== DT_SYMINENT
)
7904 /* Note: these braces are necessary to avoid a syntax
7905 error from the SunOS4 C compiler. */
7906 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7908 else if (entry
->d_tag
== DT_SYMINSZ
)
7909 syminsz
= entry
->d_un
.d_val
;
7910 else if (entry
->d_tag
== DT_SYMINFO
)
7911 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7915 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7917 Elf_External_Syminfo
* extsyminfo
;
7918 Elf_External_Syminfo
* extsym
;
7919 Elf_Internal_Syminfo
* syminfo
;
7921 /* There is a syminfo section. Read the data. */
7922 extsyminfo
= (Elf_External_Syminfo
*)
7923 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7924 _("symbol information"));
7928 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7929 if (dynamic_syminfo
== NULL
)
7931 error (_("Out of memory\n"));
7935 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7936 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7937 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7938 ++syminfo
, ++extsym
)
7940 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7941 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7948 if (do_dynamic
&& dynamic_addr
)
7949 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7950 dynamic_addr
, dynamic_nent
);
7952 printf (_(" Tag Type Name/Value\n"));
7954 for (entry
= dynamic_section
;
7955 entry
< dynamic_section
+ dynamic_nent
;
7963 print_vma (entry
->d_tag
, FULL_HEX
);
7964 dtype
= get_dynamic_type (entry
->d_tag
);
7965 printf (" (%s)%*s", dtype
,
7966 ((is_32bit_elf
? 27 : 19)
7967 - (int) strlen (dtype
)),
7971 switch (entry
->d_tag
)
7975 print_dynamic_flags (entry
->d_un
.d_val
);
7985 switch (entry
->d_tag
)
7988 printf (_("Auxiliary library"));
7992 printf (_("Filter library"));
7996 printf (_("Configuration file"));
8000 printf (_("Dependency audit library"));
8004 printf (_("Audit library"));
8008 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8009 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8013 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8022 printf (_("Flags:"));
8024 if (entry
->d_un
.d_val
== 0)
8025 printf (_(" None\n"));
8028 unsigned long int val
= entry
->d_un
.d_val
;
8030 if (val
& DTF_1_PARINIT
)
8032 printf (" PARINIT");
8033 val
^= DTF_1_PARINIT
;
8035 if (val
& DTF_1_CONFEXP
)
8037 printf (" CONFEXP");
8038 val
^= DTF_1_CONFEXP
;
8041 printf (" %lx", val
);
8050 printf (_("Flags:"));
8052 if (entry
->d_un
.d_val
== 0)
8053 printf (_(" None\n"));
8056 unsigned long int val
= entry
->d_un
.d_val
;
8058 if (val
& DF_P1_LAZYLOAD
)
8060 printf (" LAZYLOAD");
8061 val
^= DF_P1_LAZYLOAD
;
8063 if (val
& DF_P1_GROUPPERM
)
8065 printf (" GROUPPERM");
8066 val
^= DF_P1_GROUPPERM
;
8069 printf (" %lx", val
);
8078 printf (_("Flags:"));
8079 if (entry
->d_un
.d_val
== 0)
8080 printf (_(" None\n"));
8083 unsigned long int val
= entry
->d_un
.d_val
;
8090 if (val
& DF_1_GLOBAL
)
8095 if (val
& DF_1_GROUP
)
8100 if (val
& DF_1_NODELETE
)
8102 printf (" NODELETE");
8103 val
^= DF_1_NODELETE
;
8105 if (val
& DF_1_LOADFLTR
)
8107 printf (" LOADFLTR");
8108 val
^= DF_1_LOADFLTR
;
8110 if (val
& DF_1_INITFIRST
)
8112 printf (" INITFIRST");
8113 val
^= DF_1_INITFIRST
;
8115 if (val
& DF_1_NOOPEN
)
8120 if (val
& DF_1_ORIGIN
)
8125 if (val
& DF_1_DIRECT
)
8130 if (val
& DF_1_TRANS
)
8135 if (val
& DF_1_INTERPOSE
)
8137 printf (" INTERPOSE");
8138 val
^= DF_1_INTERPOSE
;
8140 if (val
& DF_1_NODEFLIB
)
8142 printf (" NODEFLIB");
8143 val
^= DF_1_NODEFLIB
;
8145 if (val
& DF_1_NODUMP
)
8150 if (val
& DF_1_CONFALT
)
8152 printf (" CONFALT");
8153 val
^= DF_1_CONFALT
;
8155 if (val
& DF_1_ENDFILTEE
)
8157 printf (" ENDFILTEE");
8158 val
^= DF_1_ENDFILTEE
;
8160 if (val
& DF_1_DISPRELDNE
)
8162 printf (" DISPRELDNE");
8163 val
^= DF_1_DISPRELDNE
;
8165 if (val
& DF_1_DISPRELPND
)
8167 printf (" DISPRELPND");
8168 val
^= DF_1_DISPRELPND
;
8170 if (val
& DF_1_NODIRECT
)
8172 printf (" NODIRECT");
8173 val
^= DF_1_NODIRECT
;
8175 if (val
& DF_1_IGNMULDEF
)
8177 printf (" IGNMULDEF");
8178 val
^= DF_1_IGNMULDEF
;
8180 if (val
& DF_1_NOKSYMS
)
8182 printf (" NOKSYMS");
8183 val
^= DF_1_NOKSYMS
;
8185 if (val
& DF_1_NOHDR
)
8190 if (val
& DF_1_EDITED
)
8195 if (val
& DF_1_NORELOC
)
8197 printf (" NORELOC");
8198 val
^= DF_1_NORELOC
;
8200 if (val
& DF_1_SYMINTPOSE
)
8202 printf (" SYMINTPOSE");
8203 val
^= DF_1_SYMINTPOSE
;
8205 if (val
& DF_1_GLOBAUDIT
)
8207 printf (" GLOBAUDIT");
8208 val
^= DF_1_GLOBAUDIT
;
8210 if (val
& DF_1_SINGLETON
)
8212 printf (" SINGLETON");
8213 val
^= DF_1_SINGLETON
;
8216 printf (" %lx", val
);
8223 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8225 puts (get_dynamic_type (entry
->d_un
.d_val
));
8245 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8251 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8252 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8258 switch (entry
->d_tag
)
8261 printf (_("Shared library: [%s]"), name
);
8263 if (streq (name
, program_interpreter
))
8264 printf (_(" program interpreter"));
8268 printf (_("Library soname: [%s]"), name
);
8272 printf (_("Library rpath: [%s]"), name
);
8276 printf (_("Library runpath: [%s]"), name
);
8280 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8285 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8298 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8302 case DT_INIT_ARRAYSZ
:
8303 case DT_FINI_ARRAYSZ
:
8304 case DT_GNU_CONFLICTSZ
:
8305 case DT_GNU_LIBLISTSZ
:
8308 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8309 printf (_(" (bytes)\n"));
8319 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8332 if (entry
->d_tag
== DT_USED
8333 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8335 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8339 printf (_("Not needed object: [%s]\n"), name
);
8344 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8350 /* The value of this entry is ignored. */
8355 case DT_GNU_PRELINKED
:
8359 time_t atime
= entry
->d_un
.d_val
;
8361 tmp
= gmtime (&atime
);
8362 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8363 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8364 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8370 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8373 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8379 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8380 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8385 switch (elf_header
.e_machine
)
8388 case EM_MIPS_RS3_LE
:
8389 dynamic_section_mips_val (entry
);
8392 dynamic_section_parisc_val (entry
);
8395 dynamic_section_ia64_val (entry
);
8398 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8410 get_ver_flags (unsigned int flags
)
8412 static char buff
[32];
8419 if (flags
& VER_FLG_BASE
)
8420 strcat (buff
, "BASE ");
8422 if (flags
& VER_FLG_WEAK
)
8424 if (flags
& VER_FLG_BASE
)
8425 strcat (buff
, "| ");
8427 strcat (buff
, "WEAK ");
8430 if (flags
& VER_FLG_INFO
)
8432 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8433 strcat (buff
, "| ");
8435 strcat (buff
, "INFO ");
8438 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8439 strcat (buff
, _("| <unknown>"));
8444 /* Display the contents of the version sections. */
8447 process_version_sections (FILE * file
)
8449 Elf_Internal_Shdr
* section
;
8456 for (i
= 0, section
= section_headers
;
8457 i
< elf_header
.e_shnum
;
8460 switch (section
->sh_type
)
8462 case SHT_GNU_verdef
:
8464 Elf_External_Verdef
* edefs
;
8472 (_("\nVersion definition section '%s' contains %u entries:\n"),
8473 SECTION_NAME (section
), section
->sh_info
);
8475 printf (_(" Addr: 0x"));
8476 printf_vma (section
->sh_addr
);
8477 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8478 (unsigned long) section
->sh_offset
, section
->sh_link
,
8479 section
->sh_link
< elf_header
.e_shnum
8480 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8483 edefs
= (Elf_External_Verdef
*)
8484 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8485 _("version definition section"));
8488 endbuf
= (char *) edefs
+ section
->sh_size
;
8490 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8493 Elf_External_Verdef
* edef
;
8494 Elf_Internal_Verdef ent
;
8495 Elf_External_Verdaux
* eaux
;
8496 Elf_Internal_Verdaux aux
;
8500 /* Check for very large indicies. */
8501 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8504 vstart
= ((char *) edefs
) + idx
;
8505 if (vstart
+ sizeof (*edef
) > endbuf
)
8508 edef
= (Elf_External_Verdef
*) vstart
;
8510 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8511 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8512 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8513 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8514 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8515 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8516 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8518 printf (_(" %#06x: Rev: %d Flags: %s"),
8519 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8521 printf (_(" Index: %d Cnt: %d "),
8522 ent
.vd_ndx
, ent
.vd_cnt
);
8524 /* Check for overflow. */
8525 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8528 vstart
+= ent
.vd_aux
;
8530 eaux
= (Elf_External_Verdaux
*) vstart
;
8532 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8533 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8535 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8536 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8538 printf (_("Name index: %ld\n"), aux
.vda_name
);
8540 isum
= idx
+ ent
.vd_aux
;
8542 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8544 /* Check for overflow. */
8545 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8548 isum
+= aux
.vda_next
;
8549 vstart
+= aux
.vda_next
;
8551 eaux
= (Elf_External_Verdaux
*) vstart
;
8552 if (vstart
+ sizeof (*eaux
) > endbuf
)
8555 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8556 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8558 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8559 printf (_(" %#06x: Parent %d: %s\n"),
8560 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8562 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8563 isum
, j
, aux
.vda_name
);
8567 printf (_(" Version def aux past end of section\n"));
8572 if (cnt
< section
->sh_info
)
8573 printf (_(" Version definition past end of section\n"));
8579 case SHT_GNU_verneed
:
8581 Elf_External_Verneed
* eneed
;
8588 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8589 SECTION_NAME (section
), section
->sh_info
);
8591 printf (_(" Addr: 0x"));
8592 printf_vma (section
->sh_addr
);
8593 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8594 (unsigned long) section
->sh_offset
, section
->sh_link
,
8595 section
->sh_link
< elf_header
.e_shnum
8596 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8599 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8600 section
->sh_offset
, 1,
8602 _("Version Needs section"));
8605 endbuf
= (char *) eneed
+ section
->sh_size
;
8607 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8609 Elf_External_Verneed
* entry
;
8610 Elf_Internal_Verneed ent
;
8615 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8618 vstart
= ((char *) eneed
) + idx
;
8619 if (vstart
+ sizeof (*entry
) > endbuf
)
8622 entry
= (Elf_External_Verneed
*) vstart
;
8624 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8625 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8626 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8627 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8628 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8630 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8632 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8633 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8635 printf (_(" File: %lx"), ent
.vn_file
);
8637 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8639 /* Check for overflow. */
8640 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8643 vstart
+= ent
.vn_aux
;
8645 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8647 Elf_External_Vernaux
* eaux
;
8648 Elf_Internal_Vernaux aux
;
8650 if (vstart
+ sizeof (*eaux
) > endbuf
)
8652 eaux
= (Elf_External_Vernaux
*) vstart
;
8654 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8655 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8656 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8657 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8658 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8660 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8661 printf (_(" %#06x: Name: %s"),
8662 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8664 printf (_(" %#06x: Name index: %lx"),
8665 isum
, aux
.vna_name
);
8667 printf (_(" Flags: %s Version: %d\n"),
8668 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8670 /* Check for overflow. */
8671 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8674 isum
+= aux
.vna_next
;
8675 vstart
+= aux
.vna_next
;
8679 warn (_("Missing Version Needs auxillary information\n"));
8684 if (cnt
< section
->sh_info
)
8685 warn (_("Missing Version Needs information\n"));
8691 case SHT_GNU_versym
:
8693 Elf_Internal_Shdr
* link_section
;
8696 unsigned char * edata
;
8697 unsigned short * data
;
8699 Elf_Internal_Sym
* symbols
;
8700 Elf_Internal_Shdr
* string_sec
;
8701 unsigned long num_syms
;
8704 if (section
->sh_link
>= elf_header
.e_shnum
)
8707 link_section
= section_headers
+ section
->sh_link
;
8708 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8710 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8715 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8716 if (symbols
== NULL
)
8719 string_sec
= section_headers
+ link_section
->sh_link
;
8721 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8722 string_sec
->sh_size
,
8723 _("version string table"));
8730 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8731 SECTION_NAME (section
), total
);
8733 printf (_(" Addr: "));
8734 printf_vma (section
->sh_addr
);
8735 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8736 (unsigned long) section
->sh_offset
, section
->sh_link
,
8737 SECTION_NAME (link_section
));
8739 off
= offset_from_vma (file
,
8740 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8741 total
* sizeof (short));
8742 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8744 _("version symbol data"));
8752 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8754 for (cnt
= total
; cnt
--;)
8755 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8760 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8763 int check_def
, check_need
;
8766 printf (" %03x:", cnt
);
8768 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8769 switch (data
[cnt
+ j
])
8772 fputs (_(" 0 (*local*) "), stdout
);
8776 fputs (_(" 1 (*global*) "), stdout
);
8780 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8781 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8783 /* If this index value is greater than the size of the symbols
8784 array, break to avoid an out-of-bounds read. */
8785 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8787 warn (_("invalid index into symbol array\n"));
8793 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8794 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8797 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8804 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8806 Elf_Internal_Verneed ivn
;
8807 unsigned long offset
;
8809 offset
= offset_from_vma
8810 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8811 sizeof (Elf_External_Verneed
));
8815 Elf_Internal_Vernaux ivna
;
8816 Elf_External_Verneed evn
;
8817 Elf_External_Vernaux evna
;
8818 unsigned long a_off
;
8820 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8821 _("version need")) == NULL
)
8824 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8825 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8827 a_off
= offset
+ ivn
.vn_aux
;
8831 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8832 1, _("version need aux (2)")) == NULL
)
8839 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8840 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8843 a_off
+= ivna
.vna_next
;
8845 while (ivna
.vna_other
!= data
[cnt
+ j
]
8846 && ivna
.vna_next
!= 0);
8848 if (ivna
.vna_other
== data
[cnt
+ j
])
8850 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8852 if (ivna
.vna_name
>= string_sec
->sh_size
)
8853 name
= _("*invalid*");
8855 name
= strtab
+ ivna
.vna_name
;
8856 nn
+= printf ("(%s%-*s",
8858 12 - (int) strlen (name
),
8864 offset
+= ivn
.vn_next
;
8866 while (ivn
.vn_next
);
8869 if (check_def
&& data
[cnt
+ j
] != 0x8001
8870 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8872 Elf_Internal_Verdef ivd
;
8873 Elf_External_Verdef evd
;
8874 unsigned long offset
;
8876 offset
= offset_from_vma
8877 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8882 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8883 _("version def")) == NULL
)
8890 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8891 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8894 offset
+= ivd
.vd_next
;
8896 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8897 && ivd
.vd_next
!= 0);
8899 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8901 Elf_External_Verdaux evda
;
8902 Elf_Internal_Verdaux ivda
;
8904 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8906 if (get_data (&evda
, file
,
8907 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8909 _("version def aux")) == NULL
)
8912 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8914 if (ivda
.vda_name
>= string_sec
->sh_size
)
8915 name
= _("*invalid*");
8917 name
= strtab
+ ivda
.vda_name
;
8918 nn
+= printf ("(%s%-*s",
8920 12 - (int) strlen (name
),
8926 printf ("%*c", 18 - nn
, ' ');
8944 printf (_("\nNo version information found in this file.\n"));
8950 get_symbol_binding (unsigned int binding
)
8952 static char buff
[32];
8956 case STB_LOCAL
: return "LOCAL";
8957 case STB_GLOBAL
: return "GLOBAL";
8958 case STB_WEAK
: return "WEAK";
8960 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8961 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8963 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8965 if (binding
== STB_GNU_UNIQUE
8966 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8967 /* GNU is still using the default value 0. */
8968 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8970 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8973 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8979 get_symbol_type (unsigned int type
)
8981 static char buff
[32];
8985 case STT_NOTYPE
: return "NOTYPE";
8986 case STT_OBJECT
: return "OBJECT";
8987 case STT_FUNC
: return "FUNC";
8988 case STT_SECTION
: return "SECTION";
8989 case STT_FILE
: return "FILE";
8990 case STT_COMMON
: return "COMMON";
8991 case STT_TLS
: return "TLS";
8992 case STT_RELC
: return "RELC";
8993 case STT_SRELC
: return "SRELC";
8995 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8997 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8998 return "THUMB_FUNC";
9000 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9003 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9004 return "PARISC_MILLI";
9006 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9008 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9010 if (elf_header
.e_machine
== EM_PARISC
)
9012 if (type
== STT_HP_OPAQUE
)
9014 if (type
== STT_HP_STUB
)
9018 if (type
== STT_GNU_IFUNC
9019 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9020 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9021 /* GNU is still using the default value 0. */
9022 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9025 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9028 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9034 get_symbol_visibility (unsigned int visibility
)
9038 case STV_DEFAULT
: return "DEFAULT";
9039 case STV_INTERNAL
: return "INTERNAL";
9040 case STV_HIDDEN
: return "HIDDEN";
9041 case STV_PROTECTED
: return "PROTECTED";
9047 get_mips_symbol_other (unsigned int other
)
9059 case STO_MICROMIPS
| STO_MIPS_PIC
:
9060 return "MICROMIPS, MIPS PIC";
9069 get_ia64_symbol_other (unsigned int other
)
9073 static char res
[32];
9077 /* Function types is for images and .STB files only. */
9078 switch (elf_header
.e_type
)
9082 switch (VMS_ST_FUNC_TYPE (other
))
9084 case VMS_SFT_CODE_ADDR
:
9085 strcat (res
, " CA");
9087 case VMS_SFT_SYMV_IDX
:
9088 strcat (res
, " VEC");
9091 strcat (res
, " FD");
9093 case VMS_SFT_RESERVE
:
9094 strcat (res
, " RSV");
9103 switch (VMS_ST_LINKAGE (other
))
9105 case VMS_STL_IGNORE
:
9106 strcat (res
, " IGN");
9108 case VMS_STL_RESERVE
:
9109 strcat (res
, " RSV");
9112 strcat (res
, " STD");
9115 strcat (res
, " LNK");
9130 get_symbol_other (unsigned int other
)
9132 const char * result
= NULL
;
9133 static char buff
[32];
9138 switch (elf_header
.e_machine
)
9141 result
= get_mips_symbol_other (other
);
9144 result
= get_ia64_symbol_other (other
);
9153 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9158 get_symbol_index_type (unsigned int type
)
9160 static char buff
[32];
9164 case SHN_UNDEF
: return "UND";
9165 case SHN_ABS
: return "ABS";
9166 case SHN_COMMON
: return "COM";
9168 if (type
== SHN_IA_64_ANSI_COMMON
9169 && elf_header
.e_machine
== EM_IA_64
9170 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9172 else if ((elf_header
.e_machine
== EM_X86_64
9173 || elf_header
.e_machine
== EM_L1OM
9174 || elf_header
.e_machine
== EM_K1OM
)
9175 && type
== SHN_X86_64_LCOMMON
)
9177 else if ((type
== SHN_MIPS_SCOMMON
9178 && elf_header
.e_machine
== EM_MIPS
)
9179 || (type
== SHN_TIC6X_SCOMMON
9180 && elf_header
.e_machine
== EM_TI_C6000
))
9182 else if (type
== SHN_MIPS_SUNDEFINED
9183 && elf_header
.e_machine
== EM_MIPS
)
9185 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9186 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9187 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9188 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9189 else if (type
>= SHN_LORESERVE
)
9190 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9191 else if (type
>= elf_header
.e_shnum
)
9192 sprintf (buff
, "bad section index[%3d]", type
);
9194 sprintf (buff
, "%3d", type
);
9202 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9204 unsigned char * e_data
;
9207 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9211 error (_("Out of memory\n"));
9215 if (fread (e_data
, ent_size
, number
, file
) != number
)
9217 error (_("Unable to read in dynamic data\n"));
9221 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9225 error (_("Out of memory\n"));
9231 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9239 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9241 Elf_Internal_Sym
* psym
;
9244 psym
= dynamic_symbols
+ si
;
9246 n
= print_vma (si
, DEC_5
);
9248 fputs (" " + n
, stdout
);
9249 printf (" %3lu: ", hn
);
9250 print_vma (psym
->st_value
, LONG_HEX
);
9252 print_vma (psym
->st_size
, DEC_5
);
9254 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9255 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9256 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9257 /* Check to see if any other bits in the st_other field are set.
9258 Note - displaying this information disrupts the layout of the
9259 table being generated, but for the moment this case is very
9261 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9262 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9263 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9264 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9265 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9267 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9271 /* Dump the symbol table. */
9273 process_symbol_table (FILE * file
)
9275 Elf_Internal_Shdr
* section
;
9276 bfd_vma nbuckets
= 0;
9277 bfd_vma nchains
= 0;
9278 bfd_vma
* buckets
= NULL
;
9279 bfd_vma
* chains
= NULL
;
9280 bfd_vma ngnubuckets
= 0;
9281 bfd_vma
* gnubuckets
= NULL
;
9282 bfd_vma
* gnuchains
= NULL
;
9283 bfd_vma gnusymidx
= 0;
9285 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9288 if (dynamic_info
[DT_HASH
]
9290 || (do_using_dynamic
9292 && dynamic_strings
!= NULL
)))
9294 unsigned char nb
[8];
9295 unsigned char nc
[8];
9296 int hash_ent_size
= 4;
9298 if ((elf_header
.e_machine
== EM_ALPHA
9299 || elf_header
.e_machine
== EM_S390
9300 || elf_header
.e_machine
== EM_S390_OLD
)
9301 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9305 (archive_file_offset
9306 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9307 sizeof nb
+ sizeof nc
)),
9310 error (_("Unable to seek to start of dynamic information\n"));
9314 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9316 error (_("Failed to read in number of buckets\n"));
9320 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9322 error (_("Failed to read in number of chains\n"));
9326 nbuckets
= byte_get (nb
, hash_ent_size
);
9327 nchains
= byte_get (nc
, hash_ent_size
);
9329 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9330 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9333 if (buckets
== NULL
|| chains
== NULL
)
9335 if (do_using_dynamic
)
9346 if (dynamic_info_DT_GNU_HASH
9348 || (do_using_dynamic
9350 && dynamic_strings
!= NULL
)))
9352 unsigned char nb
[16];
9353 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9354 bfd_vma buckets_vma
;
9357 (archive_file_offset
9358 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9362 error (_("Unable to seek to start of dynamic information\n"));
9366 if (fread (nb
, 16, 1, file
) != 1)
9368 error (_("Failed to read in number of buckets\n"));
9372 ngnubuckets
= byte_get (nb
, 4);
9373 gnusymidx
= byte_get (nb
+ 4, 4);
9374 bitmaskwords
= byte_get (nb
+ 8, 4);
9375 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9377 buckets_vma
+= bitmaskwords
* 4;
9379 buckets_vma
+= bitmaskwords
* 8;
9382 (archive_file_offset
9383 + offset_from_vma (file
, buckets_vma
, 4)),
9386 error (_("Unable to seek to start of dynamic information\n"));
9390 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9392 if (gnubuckets
== NULL
)
9395 for (i
= 0; i
< ngnubuckets
; i
++)
9396 if (gnubuckets
[i
] != 0)
9398 if (gnubuckets
[i
] < gnusymidx
)
9401 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9402 maxchain
= gnubuckets
[i
];
9405 if (maxchain
== 0xffffffff)
9408 maxchain
-= gnusymidx
;
9411 (archive_file_offset
9412 + offset_from_vma (file
, buckets_vma
9413 + 4 * (ngnubuckets
+ maxchain
), 4)),
9416 error (_("Unable to seek to start of dynamic information\n"));
9422 if (fread (nb
, 4, 1, file
) != 1)
9424 error (_("Failed to determine last chain length\n"));
9428 if (maxchain
+ 1 == 0)
9433 while ((byte_get (nb
, 4) & 1) == 0);
9436 (archive_file_offset
9437 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9440 error (_("Unable to seek to start of dynamic information\n"));
9444 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9447 if (gnuchains
== NULL
)
9452 if (do_using_dynamic
)
9457 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9460 && dynamic_strings
!= NULL
)
9464 if (dynamic_info
[DT_HASH
])
9468 printf (_("\nSymbol table for image:\n"));
9470 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9472 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9474 for (hn
= 0; hn
< nbuckets
; hn
++)
9479 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9480 print_dynamic_symbol (si
, hn
);
9484 if (dynamic_info_DT_GNU_HASH
)
9486 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9488 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9490 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9492 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9493 if (gnubuckets
[hn
] != 0)
9495 bfd_vma si
= gnubuckets
[hn
];
9496 bfd_vma off
= si
- gnusymidx
;
9500 print_dynamic_symbol (si
, hn
);
9503 while ((gnuchains
[off
++] & 1) == 0);
9507 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9511 for (i
= 0, section
= section_headers
;
9512 i
< elf_header
.e_shnum
;
9516 char * strtab
= NULL
;
9517 unsigned long int strtab_size
= 0;
9518 Elf_Internal_Sym
* symtab
;
9519 Elf_Internal_Sym
* psym
;
9520 unsigned long num_syms
;
9522 if ((section
->sh_type
!= SHT_SYMTAB
9523 && section
->sh_type
!= SHT_DYNSYM
)
9525 && section
->sh_type
== SHT_SYMTAB
))
9528 if (section
->sh_entsize
== 0)
9530 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9531 SECTION_NAME (section
));
9535 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9536 SECTION_NAME (section
),
9537 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9540 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9542 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9544 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9548 if (section
->sh_link
== elf_header
.e_shstrndx
)
9550 strtab
= string_table
;
9551 strtab_size
= string_table_length
;
9553 else if (section
->sh_link
< elf_header
.e_shnum
)
9555 Elf_Internal_Shdr
* string_sec
;
9557 string_sec
= section_headers
+ section
->sh_link
;
9559 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9560 1, string_sec
->sh_size
,
9562 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9565 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9567 printf ("%6d: ", si
);
9568 print_vma (psym
->st_value
, LONG_HEX
);
9570 print_vma (psym
->st_size
, DEC_5
);
9571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9573 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9574 /* Check to see if any other bits in the st_other field are set.
9575 Note - displaying this information disrupts the layout of the
9576 table being generated, but for the moment this case is very rare. */
9577 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9578 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9579 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9580 print_symbol (25, psym
->st_name
< strtab_size
9581 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9583 if (section
->sh_type
== SHT_DYNSYM
9584 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9586 unsigned char data
[2];
9587 unsigned short vers_data
;
9588 unsigned long offset
;
9592 offset
= offset_from_vma
9593 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9594 sizeof data
+ si
* sizeof (vers_data
));
9596 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9597 sizeof (data
), 1, _("version data")) == NULL
)
9600 vers_data
= byte_get (data
, 2);
9602 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9603 && section_headers
[psym
->st_shndx
].sh_type
9606 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9608 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9610 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9611 && (is_nobits
|| ! check_def
))
9613 Elf_External_Verneed evn
;
9614 Elf_Internal_Verneed ivn
;
9615 Elf_Internal_Vernaux ivna
;
9617 /* We must test both. */
9618 offset
= offset_from_vma
9619 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9624 unsigned long vna_off
;
9626 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9627 _("version need")) == NULL
)
9635 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9636 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9638 vna_off
= offset
+ ivn
.vn_aux
;
9642 Elf_External_Vernaux evna
;
9644 if (get_data (&evna
, file
, vna_off
,
9646 _("version need aux (3)")) == NULL
)
9654 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9655 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9656 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9659 vna_off
+= ivna
.vna_next
;
9661 while (ivna
.vna_other
!= vers_data
9662 && ivna
.vna_next
!= 0);
9664 if (ivna
.vna_other
== vers_data
)
9667 offset
+= ivn
.vn_next
;
9669 while (ivn
.vn_next
!= 0);
9671 if (ivna
.vna_other
== vers_data
)
9674 ivna
.vna_name
< strtab_size
9675 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9679 else if (! is_nobits
)
9680 error (_("bad dynamic symbol\n"));
9687 if (vers_data
!= 0x8001
9688 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9690 Elf_Internal_Verdef ivd
;
9691 Elf_Internal_Verdaux ivda
;
9692 Elf_External_Verdaux evda
;
9695 off
= offset_from_vma
9697 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9698 sizeof (Elf_External_Verdef
));
9702 Elf_External_Verdef evd
;
9704 if (get_data (&evd
, file
, off
, sizeof (evd
),
9705 1, _("version def")) == NULL
)
9713 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9714 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9715 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9720 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9721 && ivd
.vd_next
!= 0);
9726 if (get_data (&evda
, file
, off
, sizeof (evda
),
9727 1, _("version def aux")) == NULL
)
9730 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9732 if (psym
->st_name
!= ivda
.vda_name
)
9733 printf ((vers_data
& VERSYM_HIDDEN
)
9735 ivda
.vda_name
< strtab_size
9736 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9746 if (strtab
!= string_table
)
9752 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9754 if (do_histogram
&& buckets
!= NULL
)
9756 unsigned long * lengths
;
9757 unsigned long * counts
;
9760 unsigned long maxlength
= 0;
9761 unsigned long nzero_counts
= 0;
9762 unsigned long nsyms
= 0;
9764 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9765 (unsigned long) nbuckets
);
9766 printf (_(" Length Number %% of total Coverage\n"));
9768 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9769 if (lengths
== NULL
)
9771 error (_("Out of memory\n"));
9774 for (hn
= 0; hn
< nbuckets
; ++hn
)
9776 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9779 if (maxlength
< ++lengths
[hn
])
9784 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9787 error (_("Out of memory\n"));
9791 for (hn
= 0; hn
< nbuckets
; ++hn
)
9792 ++counts
[lengths
[hn
]];
9797 printf (" 0 %-10lu (%5.1f%%)\n",
9798 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9799 for (i
= 1; i
<= maxlength
; ++i
)
9801 nzero_counts
+= counts
[i
] * i
;
9802 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9803 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9804 (nzero_counts
* 100.0) / nsyms
);
9812 if (buckets
!= NULL
)
9818 if (do_histogram
&& gnubuckets
!= NULL
)
9820 unsigned long * lengths
;
9821 unsigned long * counts
;
9823 unsigned long maxlength
= 0;
9824 unsigned long nzero_counts
= 0;
9825 unsigned long nsyms
= 0;
9827 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9828 if (lengths
== NULL
)
9830 error (_("Out of memory\n"));
9834 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9835 (unsigned long) ngnubuckets
);
9836 printf (_(" Length Number %% of total Coverage\n"));
9838 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9839 if (gnubuckets
[hn
] != 0)
9841 bfd_vma off
, length
= 1;
9843 for (off
= gnubuckets
[hn
] - gnusymidx
;
9844 (gnuchains
[off
] & 1) == 0; ++off
)
9846 lengths
[hn
] = length
;
9847 if (length
> maxlength
)
9852 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9855 error (_("Out of memory\n"));
9859 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9860 ++counts
[lengths
[hn
]];
9862 if (ngnubuckets
> 0)
9865 printf (" 0 %-10lu (%5.1f%%)\n",
9866 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9867 for (j
= 1; j
<= maxlength
; ++j
)
9869 nzero_counts
+= counts
[j
] * j
;
9870 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9871 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9872 (nzero_counts
* 100.0) / nsyms
);
9886 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9890 if (dynamic_syminfo
== NULL
9892 /* No syminfo, this is ok. */
9895 /* There better should be a dynamic symbol section. */
9896 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9900 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9901 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9903 printf (_(" Num: Name BoundTo Flags\n"));
9904 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9906 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9908 printf ("%4d: ", i
);
9909 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9910 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9912 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9915 switch (dynamic_syminfo
[i
].si_boundto
)
9917 case SYMINFO_BT_SELF
:
9918 fputs ("SELF ", stdout
);
9920 case SYMINFO_BT_PARENT
:
9921 fputs ("PARENT ", stdout
);
9924 if (dynamic_syminfo
[i
].si_boundto
> 0
9925 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9926 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9928 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9932 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9936 if (flags
& SYMINFO_FLG_DIRECT
)
9938 if (flags
& SYMINFO_FLG_PASSTHRU
)
9939 printf (" PASSTHRU");
9940 if (flags
& SYMINFO_FLG_COPY
)
9942 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9943 printf (" LAZYLOAD");
9951 /* Check to see if the given reloc needs to be handled in a target specific
9952 manner. If so then process the reloc and return TRUE otherwise return
9956 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9957 unsigned char * start
,
9958 Elf_Internal_Sym
* symtab
)
9960 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9962 switch (elf_header
.e_machine
)
9965 case EM_CYGNUS_MN10300
:
9967 static Elf_Internal_Sym
* saved_sym
= NULL
;
9971 case 34: /* R_MN10300_ALIGN */
9973 case 33: /* R_MN10300_SYM_DIFF */
9974 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9976 case 1: /* R_MN10300_32 */
9977 case 2: /* R_MN10300_16 */
9978 if (saved_sym
!= NULL
)
9982 value
= reloc
->r_addend
9983 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9984 - saved_sym
->st_value
);
9986 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9993 if (saved_sym
!= NULL
)
9994 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10004 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10005 DWARF debug sections. This is a target specific test. Note - we do not
10006 go through the whole including-target-headers-multiple-times route, (as
10007 we have already done with <elf/h8.h>) because this would become very
10008 messy and even then this function would have to contain target specific
10009 information (the names of the relocs instead of their numeric values).
10010 FIXME: This is not the correct way to solve this problem. The proper way
10011 is to have target specific reloc sizing and typing functions created by
10012 the reloc-macros.h header, in the same way that it already creates the
10013 reloc naming functions. */
10016 is_32bit_abs_reloc (unsigned int reloc_type
)
10018 switch (elf_header
.e_machine
)
10022 return reloc_type
== 1; /* R_386_32. */
10024 return reloc_type
== 1; /* R_68K_32. */
10026 return reloc_type
== 1; /* R_860_32. */
10028 return reloc_type
== 2; /* R_960_32. */
10030 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10032 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10034 return reloc_type
== 1; /* R_ARC_32. */
10036 return reloc_type
== 2; /* R_ARM_ABS32 */
10039 return reloc_type
== 1;
10040 case EM_ADAPTEVA_EPIPHANY
:
10041 return reloc_type
== 3;
10043 return reloc_type
== 0x12; /* R_byte4_data. */
10045 return reloc_type
== 3; /* R_CRIS_32. */
10047 return reloc_type
== 3; /* R_CR16_NUM32. */
10049 return reloc_type
== 15; /* R_CRX_NUM32. */
10050 case EM_CYGNUS_FRV
:
10051 return reloc_type
== 1;
10052 case EM_CYGNUS_D10V
:
10054 return reloc_type
== 6; /* R_D10V_32. */
10055 case EM_CYGNUS_D30V
:
10057 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10059 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10060 case EM_CYGNUS_FR30
:
10062 return reloc_type
== 3; /* R_FR30_32. */
10066 return reloc_type
== 1; /* R_H8_DIR32. */
10068 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10071 return reloc_type
== 2; /* R_IP2K_32. */
10073 return reloc_type
== 2; /* R_IQ2000_32. */
10074 case EM_LATTICEMICO32
:
10075 return reloc_type
== 3; /* R_LM32_32. */
10078 return reloc_type
== 3; /* R_M32C_32. */
10080 return reloc_type
== 34; /* R_M32R_32_RELA. */
10082 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10083 case EM_CYGNUS_MEP
:
10084 return reloc_type
== 4; /* R_MEP_32. */
10086 return reloc_type
== 2; /* R_METAG_ADDR32. */
10087 case EM_MICROBLAZE
:
10088 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10090 return reloc_type
== 2; /* R_MIPS_32. */
10092 return reloc_type
== 4; /* R_MMIX_32. */
10093 case EM_CYGNUS_MN10200
:
10095 return reloc_type
== 1; /* R_MN10200_32. */
10096 case EM_CYGNUS_MN10300
:
10098 return reloc_type
== 1; /* R_MN10300_32. */
10100 return reloc_type
== 1; /* R_MOXIE_32. */
10101 case EM_MSP430_OLD
:
10103 return reloc_type
== 1; /* R_MSP43_32. */
10105 return reloc_type
== 2; /* R_MT_32. */
10106 case EM_ALTERA_NIOS2
:
10107 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10109 return reloc_type
== 1; /* R_NIOS_32. */
10112 return reloc_type
== 1; /* R_OR32_32. */
10114 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10115 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10118 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10120 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10122 return reloc_type
== 1; /* R_PPC_ADDR32. */
10124 return reloc_type
== 1; /* R_RL78_DIR32. */
10126 return reloc_type
== 1; /* R_RX_DIR32. */
10128 return reloc_type
== 1; /* R_I370_ADDR31. */
10131 return reloc_type
== 4; /* R_S390_32. */
10133 return reloc_type
== 8; /* R_SCORE_ABS32. */
10135 return reloc_type
== 1; /* R_SH_DIR32. */
10136 case EM_SPARC32PLUS
:
10139 return reloc_type
== 3 /* R_SPARC_32. */
10140 || reloc_type
== 23; /* R_SPARC_UA32. */
10142 return reloc_type
== 6; /* R_SPU_ADDR32 */
10144 return reloc_type
== 1; /* R_C6000_ABS32. */
10146 return reloc_type
== 2; /* R_TILEGX_32. */
10148 return reloc_type
== 1; /* R_TILEPRO_32. */
10149 case EM_CYGNUS_V850
:
10151 return reloc_type
== 6; /* R_V850_ABS32. */
10153 return reloc_type
== 0x33; /* R_V810_WORD. */
10155 return reloc_type
== 1; /* R_VAX_32. */
10159 return reloc_type
== 10; /* R_X86_64_32. */
10162 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10164 return reloc_type
== 4; /* R_XGATE_32. */
10166 return reloc_type
== 1; /* R_XSTROMY16_32. */
10167 case EM_XTENSA_OLD
:
10169 return reloc_type
== 1; /* R_XTENSA_32. */
10171 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10172 elf_header
.e_machine
);
10177 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10178 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10181 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10183 switch (elf_header
.e_machine
)
10187 return reloc_type
== 2; /* R_386_PC32. */
10189 return reloc_type
== 4; /* R_68K_PC32. */
10191 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10192 case EM_ADAPTEVA_EPIPHANY
:
10193 return reloc_type
== 6;
10195 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10197 return reloc_type
== 3; /* R_ARM_REL32 */
10198 case EM_MICROBLAZE
:
10199 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10201 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10203 return reloc_type
== 26; /* R_PPC_REL32. */
10205 return reloc_type
== 26; /* R_PPC64_REL32. */
10208 return reloc_type
== 5; /* R_390_PC32. */
10210 return reloc_type
== 2; /* R_SH_REL32. */
10211 case EM_SPARC32PLUS
:
10214 return reloc_type
== 6; /* R_SPARC_DISP32. */
10216 return reloc_type
== 13; /* R_SPU_REL32. */
10218 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10220 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10224 return reloc_type
== 2; /* R_X86_64_PC32. */
10225 case EM_XTENSA_OLD
:
10227 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10229 /* Do not abort or issue an error message here. Not all targets use
10230 pc-relative 32-bit relocs in their DWARF debug information and we
10231 have already tested for target coverage in is_32bit_abs_reloc. A
10232 more helpful warning message will be generated by apply_relocations
10233 anyway, so just return. */
10238 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10239 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10242 is_64bit_abs_reloc (unsigned int reloc_type
)
10244 switch (elf_header
.e_machine
)
10247 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10249 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10251 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10253 return reloc_type
== 80; /* R_PARISC_DIR64. */
10255 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10256 case EM_SPARC32PLUS
:
10259 return reloc_type
== 54; /* R_SPARC_UA64. */
10263 return reloc_type
== 1; /* R_X86_64_64. */
10266 return reloc_type
== 22; /* R_S390_64. */
10268 return reloc_type
== 1; /* R_TILEGX_64. */
10270 return reloc_type
== 18; /* R_MIPS_64. */
10276 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10277 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10280 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10282 switch (elf_header
.e_machine
)
10285 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10287 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10289 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10291 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10293 return reloc_type
== 44; /* R_PPC64_REL64. */
10294 case EM_SPARC32PLUS
:
10297 return reloc_type
== 46; /* R_SPARC_DISP64. */
10301 return reloc_type
== 24; /* R_X86_64_PC64. */
10304 return reloc_type
== 23; /* R_S390_PC64. */
10306 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10312 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10313 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10316 is_24bit_abs_reloc (unsigned int reloc_type
)
10318 switch (elf_header
.e_machine
)
10320 case EM_CYGNUS_MN10200
:
10322 return reloc_type
== 4; /* R_MN10200_24. */
10328 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10329 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10332 is_16bit_abs_reloc (unsigned int reloc_type
)
10334 switch (elf_header
.e_machine
)
10338 return reloc_type
== 4; /* R_AVR_16. */
10339 case EM_ADAPTEVA_EPIPHANY
:
10340 return reloc_type
== 5;
10341 case EM_CYGNUS_D10V
:
10343 return reloc_type
== 3; /* R_D10V_16. */
10347 return reloc_type
== R_H8_DIR16
;
10350 return reloc_type
== 1; /* R_IP2K_16. */
10353 return reloc_type
== 1; /* R_M32C_16 */
10355 case EM_MSP430_OLD
:
10356 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10357 case EM_ALTERA_NIOS2
:
10358 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10360 return reloc_type
== 9; /* R_NIOS_16. */
10362 return reloc_type
== 2; /* R_C6000_ABS16. */
10365 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10366 case EM_CYGNUS_MN10200
:
10368 return reloc_type
== 2; /* R_MN10200_16. */
10369 case EM_CYGNUS_MN10300
:
10371 return reloc_type
== 2; /* R_MN10300_16. */
10373 return reloc_type
== 3; /* R_XGATE_16. */
10379 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10380 relocation entries (possibly formerly used for SHT_GROUP sections). */
10383 is_none_reloc (unsigned int reloc_type
)
10385 switch (elf_header
.e_machine
)
10387 case EM_68K
: /* R_68K_NONE. */
10388 case EM_386
: /* R_386_NONE. */
10389 case EM_SPARC32PLUS
:
10391 case EM_SPARC
: /* R_SPARC_NONE. */
10392 case EM_MIPS
: /* R_MIPS_NONE. */
10393 case EM_PARISC
: /* R_PARISC_NONE. */
10394 case EM_ALPHA
: /* R_ALPHA_NONE. */
10395 case EM_ADAPTEVA_EPIPHANY
:
10396 case EM_PPC
: /* R_PPC_NONE. */
10397 case EM_PPC64
: /* R_PPC64_NONE. */
10398 case EM_ARM
: /* R_ARM_NONE. */
10399 case EM_IA_64
: /* R_IA64_NONE. */
10400 case EM_SH
: /* R_SH_NONE. */
10402 case EM_S390
: /* R_390_NONE. */
10403 case EM_CRIS
: /* R_CRIS_NONE. */
10404 case EM_X86_64
: /* R_X86_64_NONE. */
10405 case EM_L1OM
: /* R_X86_64_NONE. */
10406 case EM_K1OM
: /* R_X86_64_NONE. */
10407 case EM_MN10300
: /* R_MN10300_NONE. */
10408 case EM_MOXIE
: /* R_MOXIE_NONE. */
10409 case EM_M32R
: /* R_M32R_NONE. */
10410 case EM_TI_C6000
:/* R_C6000_NONE. */
10411 case EM_TILEGX
: /* R_TILEGX_NONE. */
10412 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10414 case EM_C166
: /* R_XC16X_NONE. */
10415 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10416 case EM_NIOS32
: /* R_NIOS_NONE. */
10417 return reloc_type
== 0;
10419 return reloc_type
== 0 || reloc_type
== 256;
10420 case EM_XTENSA_OLD
:
10422 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10423 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10424 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10425 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10427 return reloc_type
== 3; /* R_METAG_NONE. */
10432 /* Apply relocations to a section.
10433 Note: So far support has been added only for those relocations
10434 which can be found in debug sections.
10435 FIXME: Add support for more relocations ? */
10438 apply_relocations (void * file
,
10439 Elf_Internal_Shdr
* section
,
10440 unsigned char * start
)
10442 Elf_Internal_Shdr
* relsec
;
10443 unsigned char * end
= start
+ section
->sh_size
;
10445 if (elf_header
.e_type
!= ET_REL
)
10448 /* Find the reloc section associated with the section. */
10449 for (relsec
= section_headers
;
10450 relsec
< section_headers
+ elf_header
.e_shnum
;
10453 bfd_boolean is_rela
;
10454 unsigned long num_relocs
;
10455 Elf_Internal_Rela
* relocs
;
10456 Elf_Internal_Rela
* rp
;
10457 Elf_Internal_Shdr
* symsec
;
10458 Elf_Internal_Sym
* symtab
;
10459 unsigned long num_syms
;
10460 Elf_Internal_Sym
* sym
;
10462 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10463 || relsec
->sh_info
>= elf_header
.e_shnum
10464 || section_headers
+ relsec
->sh_info
!= section
10465 || relsec
->sh_size
== 0
10466 || relsec
->sh_link
>= elf_header
.e_shnum
)
10469 is_rela
= relsec
->sh_type
== SHT_RELA
;
10473 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10474 relsec
->sh_size
, & relocs
, & num_relocs
))
10479 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10480 relsec
->sh_size
, & relocs
, & num_relocs
))
10484 /* SH uses RELA but uses in place value instead of the addend field. */
10485 if (elf_header
.e_machine
== EM_SH
)
10488 symsec
= section_headers
+ relsec
->sh_link
;
10489 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10491 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10494 unsigned int reloc_type
;
10495 unsigned int reloc_size
;
10496 unsigned char * rloc
;
10497 unsigned long sym_index
;
10499 reloc_type
= get_reloc_type (rp
->r_info
);
10501 if (target_specific_reloc_handling (rp
, start
, symtab
))
10503 else if (is_none_reloc (reloc_type
))
10505 else if (is_32bit_abs_reloc (reloc_type
)
10506 || is_32bit_pcrel_reloc (reloc_type
))
10508 else if (is_64bit_abs_reloc (reloc_type
)
10509 || is_64bit_pcrel_reloc (reloc_type
))
10511 else if (is_24bit_abs_reloc (reloc_type
))
10513 else if (is_16bit_abs_reloc (reloc_type
))
10517 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10518 reloc_type
, SECTION_NAME (section
));
10522 rloc
= start
+ rp
->r_offset
;
10523 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10525 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10526 (unsigned long) rp
->r_offset
,
10527 SECTION_NAME (section
));
10531 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10532 if (sym_index
>= num_syms
)
10534 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10535 sym_index
, SECTION_NAME (section
));
10538 sym
= symtab
+ sym_index
;
10540 /* If the reloc has a symbol associated with it,
10541 make sure that it is of an appropriate type.
10543 Relocations against symbols without type can happen.
10544 Gcc -feliminate-dwarf2-dups may generate symbols
10545 without type for debug info.
10547 Icc generates relocations against function symbols
10548 instead of local labels.
10550 Relocations against object symbols can happen, eg when
10551 referencing a global array. For an example of this see
10552 the _clz.o binary in libgcc.a. */
10554 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10556 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10557 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10558 (long int)(rp
- relocs
),
10559 SECTION_NAME (relsec
));
10565 addend
+= rp
->r_addend
;
10566 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10567 partial_inplace. */
10569 || (elf_header
.e_machine
== EM_XTENSA
10570 && reloc_type
== 1)
10571 || ((elf_header
.e_machine
== EM_PJ
10572 || elf_header
.e_machine
== EM_PJ_OLD
)
10573 && reloc_type
== 1)
10574 || ((elf_header
.e_machine
== EM_D30V
10575 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10576 && reloc_type
== 12))
10577 addend
+= byte_get (rloc
, reloc_size
);
10579 if (is_32bit_pcrel_reloc (reloc_type
)
10580 || is_64bit_pcrel_reloc (reloc_type
))
10582 /* On HPPA, all pc-relative relocations are biased by 8. */
10583 if (elf_header
.e_machine
== EM_PARISC
)
10585 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10589 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10598 #ifdef SUPPORT_DISASSEMBLY
10600 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10602 printf (_("\nAssembly dump of section %s\n"),
10603 SECTION_NAME (section
));
10605 /* XXX -- to be done --- XXX */
10611 /* Reads in the contents of SECTION from FILE, returning a pointer
10612 to a malloc'ed buffer or NULL if something went wrong. */
10615 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10617 bfd_size_type num_bytes
;
10619 num_bytes
= section
->sh_size
;
10621 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10623 printf (_("\nSection '%s' has no data to dump.\n"),
10624 SECTION_NAME (section
));
10628 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10629 _("section contents"));
10634 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10636 Elf_Internal_Shdr
* relsec
;
10637 bfd_size_type num_bytes
;
10641 char * name
= SECTION_NAME (section
);
10642 bfd_boolean some_strings_shown
;
10644 start
= get_section_contents (section
, file
);
10648 printf (_("\nString dump of section '%s':\n"), name
);
10650 /* If the section being dumped has relocations against it the user might
10651 be expecting these relocations to have been applied. Check for this
10652 case and issue a warning message in order to avoid confusion.
10653 FIXME: Maybe we ought to have an option that dumps a section with
10654 relocs applied ? */
10655 for (relsec
= section_headers
;
10656 relsec
< section_headers
+ elf_header
.e_shnum
;
10659 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10660 || relsec
->sh_info
>= elf_header
.e_shnum
10661 || section_headers
+ relsec
->sh_info
!= section
10662 || relsec
->sh_size
== 0
10663 || relsec
->sh_link
>= elf_header
.e_shnum
)
10666 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10670 num_bytes
= section
->sh_size
;
10672 end
= start
+ num_bytes
;
10673 some_strings_shown
= FALSE
;
10677 while (!ISPRINT (* data
))
10678 if (++ data
>= end
)
10684 /* PR 11128: Use two separate invocations in order to work
10685 around bugs in the Solaris 8 implementation of printf. */
10686 printf (" [%6tx] ", data
- start
);
10687 printf ("%s\n", data
);
10689 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10691 data
+= strlen (data
);
10692 some_strings_shown
= TRUE
;
10696 if (! some_strings_shown
)
10697 printf (_(" No strings found in this section."));
10705 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10707 bfd_boolean relocate
)
10709 Elf_Internal_Shdr
* relsec
;
10710 bfd_size_type bytes
;
10712 unsigned char * data
;
10713 unsigned char * start
;
10715 start
= (unsigned char *) get_section_contents (section
, file
);
10719 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10723 apply_relocations (file
, section
, start
);
10727 /* If the section being dumped has relocations against it the user might
10728 be expecting these relocations to have been applied. Check for this
10729 case and issue a warning message in order to avoid confusion.
10730 FIXME: Maybe we ought to have an option that dumps a section with
10731 relocs applied ? */
10732 for (relsec
= section_headers
;
10733 relsec
< section_headers
+ elf_header
.e_shnum
;
10736 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10737 || relsec
->sh_info
>= elf_header
.e_shnum
10738 || section_headers
+ relsec
->sh_info
!= section
10739 || relsec
->sh_size
== 0
10740 || relsec
->sh_link
>= elf_header
.e_shnum
)
10743 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10748 addr
= section
->sh_addr
;
10749 bytes
= section
->sh_size
;
10758 lbytes
= (bytes
> 16 ? 16 : bytes
);
10760 printf (" 0x%8.8lx ", (unsigned long) addr
);
10762 for (j
= 0; j
< 16; j
++)
10765 printf ("%2.2x", data
[j
]);
10773 for (j
= 0; j
< lbytes
; j
++)
10776 if (k
>= ' ' && k
< 0x7f)
10794 /* Uncompresses a section that was compressed using zlib, in place. */
10797 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10798 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10800 #ifndef HAVE_ZLIB_H
10803 dwarf_size_type compressed_size
= *size
;
10804 unsigned char * compressed_buffer
= *buffer
;
10805 dwarf_size_type uncompressed_size
;
10806 unsigned char * uncompressed_buffer
;
10809 dwarf_size_type header_size
= 12;
10811 /* Read the zlib header. In this case, it should be "ZLIB" followed
10812 by the uncompressed section size, 8 bytes in big-endian order. */
10813 if (compressed_size
< header_size
10814 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10817 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10818 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10819 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10820 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10821 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10822 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10823 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10824 uncompressed_size
+= compressed_buffer
[11];
10826 /* It is possible the section consists of several compressed
10827 buffers concatenated together, so we uncompress in a loop. */
10828 strm
.zalloc
= NULL
;
10830 strm
.opaque
= NULL
;
10831 strm
.avail_in
= compressed_size
- header_size
;
10832 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10833 strm
.avail_out
= uncompressed_size
;
10834 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10836 rc
= inflateInit (& strm
);
10837 while (strm
.avail_in
> 0)
10841 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10842 + (uncompressed_size
- strm
.avail_out
));
10843 rc
= inflate (&strm
, Z_FINISH
);
10844 if (rc
!= Z_STREAM_END
)
10846 rc
= inflateReset (& strm
);
10848 rc
= inflateEnd (& strm
);
10850 || strm
.avail_out
!= 0)
10853 free (compressed_buffer
);
10854 *buffer
= uncompressed_buffer
;
10855 *size
= uncompressed_size
;
10859 free (uncompressed_buffer
);
10860 /* Indicate decompression failure. */
10863 #endif /* HAVE_ZLIB_H */
10867 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10868 Elf_Internal_Shdr
* sec
, void * file
)
10870 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10873 /* If it is already loaded, do nothing. */
10874 if (section
->start
!= NULL
)
10877 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10878 section
->address
= sec
->sh_addr
;
10879 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10881 sec
->sh_size
, buf
);
10882 if (section
->start
== NULL
)
10886 section
->size
= sec
->sh_size
;
10887 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10888 sec
->sh_size
= section
->size
;
10891 if (section
->start
== NULL
)
10894 if (debug_displays
[debug
].relocate
)
10895 apply_relocations ((FILE *) file
, sec
, section
->start
);
10900 /* If this is not NULL, load_debug_section will only look for sections
10901 within the list of sections given here. */
10902 unsigned int *section_subset
= NULL
;
10905 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10907 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10908 Elf_Internal_Shdr
* sec
;
10910 /* Locate the debug section. */
10911 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10913 section
->name
= section
->uncompressed_name
;
10916 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10918 section
->name
= section
->compressed_name
;
10923 /* If we're loading from a subset of sections, and we've loaded
10924 a section matching this name before, it's likely that it's a
10926 if (section_subset
!= NULL
)
10927 free_debug_section (debug
);
10929 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10933 free_debug_section (enum dwarf_section_display_enum debug
)
10935 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10937 if (section
->start
== NULL
)
10940 free ((char *) section
->start
);
10941 section
->start
= NULL
;
10942 section
->address
= 0;
10947 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10949 char * name
= SECTION_NAME (section
);
10950 bfd_size_type length
;
10954 length
= section
->sh_size
;
10957 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10960 if (section
->sh_type
== SHT_NOBITS
)
10962 /* There is no point in dumping the contents of a debugging section
10963 which has the NOBITS type - the bits in the file will be random.
10964 This can happen when a file containing a .eh_frame section is
10965 stripped with the --only-keep-debug command line option. */
10966 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10970 if (const_strneq (name
, ".gnu.linkonce.wi."))
10971 name
= ".debug_info";
10973 /* See if we know how to display the contents of this section. */
10974 for (i
= 0; i
< max
; i
++)
10975 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10976 || (i
== line
&& const_strneq (name
, ".debug_line."))
10977 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10979 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10980 int secondary
= (section
!= find_section (name
));
10983 free_debug_section ((enum dwarf_section_display_enum
) i
);
10985 if (i
== line
&& const_strneq (name
, ".debug_line."))
10987 else if (streq (sec
->uncompressed_name
, name
))
10988 sec
->name
= sec
->uncompressed_name
;
10990 sec
->name
= sec
->compressed_name
;
10991 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10994 /* If this debug section is part of a CU/TU set in a .dwp file,
10995 restrict load_debug_section to the sections in that set. */
10996 section_subset
= find_cu_tu_set (file
, shndx
);
10998 result
&= debug_displays
[i
].display (sec
, file
);
11000 section_subset
= NULL
;
11002 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11003 free_debug_section ((enum dwarf_section_display_enum
) i
);
11011 printf (_("Unrecognized debug section: %s\n"), name
);
11018 /* Set DUMP_SECTS for all sections where dumps were requested
11019 based on section name. */
11022 initialise_dumps_byname (void)
11024 struct dump_list_entry
* cur
;
11026 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11031 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11032 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11034 request_dump_bynumber (i
, cur
->type
);
11039 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11045 process_section_contents (FILE * file
)
11047 Elf_Internal_Shdr
* section
;
11053 initialise_dumps_byname ();
11055 for (i
= 0, section
= section_headers
;
11056 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11059 #ifdef SUPPORT_DISASSEMBLY
11060 if (dump_sects
[i
] & DISASS_DUMP
)
11061 disassemble_section (section
, file
);
11063 if (dump_sects
[i
] & HEX_DUMP
)
11064 dump_section_as_bytes (section
, file
, FALSE
);
11066 if (dump_sects
[i
] & RELOC_DUMP
)
11067 dump_section_as_bytes (section
, file
, TRUE
);
11069 if (dump_sects
[i
] & STRING_DUMP
)
11070 dump_section_as_strings (section
, file
);
11072 if (dump_sects
[i
] & DEBUG_DUMP
)
11073 display_debug_section (i
, section
, file
);
11076 /* Check to see if the user requested a
11077 dump of a section that does not exist. */
11078 while (i
++ < num_dump_sects
)
11080 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11084 process_mips_fpe_exception (int mask
)
11089 if (mask
& OEX_FPU_INEX
)
11090 fputs ("INEX", stdout
), first
= 0;
11091 if (mask
& OEX_FPU_UFLO
)
11092 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11093 if (mask
& OEX_FPU_OFLO
)
11094 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11095 if (mask
& OEX_FPU_DIV0
)
11096 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11097 if (mask
& OEX_FPU_INVAL
)
11098 printf ("%sINVAL", first
? "" : "|");
11101 fputs ("0", stdout
);
11104 /* Display's the value of TAG at location P. If TAG is
11105 greater than 0 it is assumed to be an unknown tag, and
11106 a message is printed to this effect. Otherwise it is
11107 assumed that a message has already been printed.
11109 If the bottom bit of TAG is set it assumed to have a
11110 string value, otherwise it is assumed to have an integer
11113 Returns an updated P pointing to the first unread byte
11114 beyond the end of TAG's value.
11116 Reads at or beyond END will not be made. */
11118 static unsigned char *
11119 display_tag_value (int tag
,
11121 const unsigned char * const end
)
11126 printf (" Tag_unknown_%d: ", tag
);
11130 warn (_("corrupt tag\n"));
11134 /* FIXME: we could read beyond END here. */
11135 printf ("\"%s\"\n", p
);
11136 p
+= strlen ((char *) p
) + 1;
11142 val
= read_uleb128 (p
, &len
, end
);
11144 printf ("%ld (0x%lx)\n", val
, val
);
11150 /* ARM EABI attributes section. */
11155 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11157 const char ** table
;
11158 } arm_attr_public_tag
;
11160 static const char * arm_attr_tag_CPU_arch
[] =
11161 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11162 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11163 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11164 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11165 {"No", "Thumb-1", "Thumb-2"};
11166 static const char * arm_attr_tag_FP_arch
[] =
11167 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11169 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11170 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11171 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11172 static const char * arm_attr_tag_PCS_config
[] =
11173 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11174 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11175 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11176 {"V6", "SB", "TLS", "Unused"};
11177 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11178 {"Absolute", "PC-relative", "SB-relative", "None"};
11179 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11180 {"Absolute", "PC-relative", "None"};
11181 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11182 {"None", "direct", "GOT-indirect"};
11183 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11184 {"None", "??? 1", "2", "??? 3", "4"};
11185 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11186 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11187 {"Unused", "Needed", "Sign only"};
11188 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11189 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11190 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11191 {"Unused", "Finite", "RTABI", "IEEE 754"};
11192 static const char * arm_attr_tag_ABI_enum_size
[] =
11193 {"Unused", "small", "int", "forced to int"};
11194 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11195 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11196 static const char * arm_attr_tag_ABI_VFP_args
[] =
11197 {"AAPCS", "VFP registers", "custom"};
11198 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11199 {"AAPCS", "WMMX registers", "custom"};
11200 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11201 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11202 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11203 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11204 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11205 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11206 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11207 static const char * arm_attr_tag_FP_HP_extension
[] =
11208 {"Not Allowed", "Allowed"};
11209 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11210 {"None", "IEEE 754", "Alternative Format"};
11211 static const char * arm_attr_tag_MPextension_use
[] =
11212 {"Not Allowed", "Allowed"};
11213 static const char * arm_attr_tag_DIV_use
[] =
11214 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11215 "Allowed in v7-A with integer division extension"};
11216 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11217 static const char * arm_attr_tag_Virtualization_use
[] =
11218 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11219 "TrustZone and Virtualization Extensions"};
11220 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11221 {"Not Allowed", "Allowed"};
11223 #define LOOKUP(id, name) \
11224 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11225 static arm_attr_public_tag arm_attr_public_tags
[] =
11227 {4, "CPU_raw_name", 1, NULL
},
11228 {5, "CPU_name", 1, NULL
},
11229 LOOKUP(6, CPU_arch
),
11230 {7, "CPU_arch_profile", 0, NULL
},
11231 LOOKUP(8, ARM_ISA_use
),
11232 LOOKUP(9, THUMB_ISA_use
),
11233 LOOKUP(10, FP_arch
),
11234 LOOKUP(11, WMMX_arch
),
11235 LOOKUP(12, Advanced_SIMD_arch
),
11236 LOOKUP(13, PCS_config
),
11237 LOOKUP(14, ABI_PCS_R9_use
),
11238 LOOKUP(15, ABI_PCS_RW_data
),
11239 LOOKUP(16, ABI_PCS_RO_data
),
11240 LOOKUP(17, ABI_PCS_GOT_use
),
11241 LOOKUP(18, ABI_PCS_wchar_t
),
11242 LOOKUP(19, ABI_FP_rounding
),
11243 LOOKUP(20, ABI_FP_denormal
),
11244 LOOKUP(21, ABI_FP_exceptions
),
11245 LOOKUP(22, ABI_FP_user_exceptions
),
11246 LOOKUP(23, ABI_FP_number_model
),
11247 {24, "ABI_align_needed", 0, NULL
},
11248 {25, "ABI_align_preserved", 0, NULL
},
11249 LOOKUP(26, ABI_enum_size
),
11250 LOOKUP(27, ABI_HardFP_use
),
11251 LOOKUP(28, ABI_VFP_args
),
11252 LOOKUP(29, ABI_WMMX_args
),
11253 LOOKUP(30, ABI_optimization_goals
),
11254 LOOKUP(31, ABI_FP_optimization_goals
),
11255 {32, "compatibility", 0, NULL
},
11256 LOOKUP(34, CPU_unaligned_access
),
11257 LOOKUP(36, FP_HP_extension
),
11258 LOOKUP(38, ABI_FP_16bit_format
),
11259 LOOKUP(42, MPextension_use
),
11260 LOOKUP(44, DIV_use
),
11261 {64, "nodefaults", 0, NULL
},
11262 {65, "also_compatible_with", 0, NULL
},
11263 LOOKUP(66, T2EE_use
),
11264 {67, "conformance", 1, NULL
},
11265 LOOKUP(68, Virtualization_use
),
11266 LOOKUP(70, MPextension_use_legacy
)
11270 static unsigned char *
11271 display_arm_attribute (unsigned char * p
,
11272 const unsigned char * const end
)
11277 arm_attr_public_tag
* attr
;
11281 tag
= read_uleb128 (p
, &len
, end
);
11284 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11286 if (arm_attr_public_tags
[i
].tag
== tag
)
11288 attr
= &arm_attr_public_tags
[i
];
11295 printf (" Tag_%s: ", attr
->name
);
11296 switch (attr
->type
)
11301 case 7: /* Tag_CPU_arch_profile. */
11302 val
= read_uleb128 (p
, &len
, end
);
11306 case 0: printf (_("None\n")); break;
11307 case 'A': printf (_("Application\n")); break;
11308 case 'R': printf (_("Realtime\n")); break;
11309 case 'M': printf (_("Microcontroller\n")); break;
11310 case 'S': printf (_("Application or Realtime\n")); break;
11311 default: printf ("??? (%d)\n", val
); break;
11315 case 24: /* Tag_align_needed. */
11316 val
= read_uleb128 (p
, &len
, end
);
11320 case 0: printf (_("None\n")); break;
11321 case 1: printf (_("8-byte\n")); break;
11322 case 2: printf (_("4-byte\n")); break;
11323 case 3: printf ("??? 3\n"); break;
11326 printf (_("8-byte and up to %d-byte extended\n"),
11329 printf ("??? (%d)\n", val
);
11334 case 25: /* Tag_align_preserved. */
11335 val
= read_uleb128 (p
, &len
, end
);
11339 case 0: printf (_("None\n")); break;
11340 case 1: printf (_("8-byte, except leaf SP\n")); break;
11341 case 2: printf (_("8-byte\n")); break;
11342 case 3: printf ("??? 3\n"); break;
11345 printf (_("8-byte and up to %d-byte extended\n"),
11348 printf ("??? (%d)\n", val
);
11353 case 32: /* Tag_compatibility. */
11354 val
= read_uleb128 (p
, &len
, end
);
11356 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11357 p
+= strlen ((char *) p
) + 1;
11360 case 64: /* Tag_nodefaults. */
11362 printf (_("True\n"));
11365 case 65: /* Tag_also_compatible_with. */
11366 val
= read_uleb128 (p
, &len
, end
);
11368 if (val
== 6 /* Tag_CPU_arch. */)
11370 val
= read_uleb128 (p
, &len
, end
);
11372 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11373 printf ("??? (%d)\n", val
);
11375 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11379 while (*(p
++) != '\0' /* NUL terminator. */);
11388 return display_tag_value (-1, p
, end
);
11390 return display_tag_value (0, p
, end
);
11393 assert (attr
->type
& 0x80);
11394 val
= read_uleb128 (p
, &len
, end
);
11396 type
= attr
->type
& 0x7f;
11398 printf ("??? (%d)\n", val
);
11400 printf ("%s\n", attr
->table
[val
]);
11405 return display_tag_value (tag
, p
, end
);
11408 static unsigned char *
11409 display_gnu_attribute (unsigned char * p
,
11410 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11411 const unsigned char * const end
)
11417 tag
= read_uleb128 (p
, &len
, end
);
11420 /* Tag_compatibility is the only generic GNU attribute defined at
11424 val
= read_uleb128 (p
, &len
, end
);
11428 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11429 warn (_("corrupt vendor attribute\n"));
11433 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11434 p
+= strlen ((char *) p
) + 1;
11439 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11440 return display_proc_gnu_attribute (p
, tag
, end
);
11442 return display_tag_value (tag
, p
, end
);
11445 static unsigned char *
11446 display_power_gnu_attribute (unsigned char * p
,
11448 const unsigned char * const end
)
11453 if (tag
== Tag_GNU_Power_ABI_FP
)
11455 val
= read_uleb128 (p
, &len
, end
);
11457 printf (" Tag_GNU_Power_ABI_FP: ");
11462 printf (_("Hard or soft float\n"));
11465 printf (_("Hard float\n"));
11468 printf (_("Soft float\n"));
11471 printf (_("Single-precision hard float\n"));
11474 printf ("??? (%d)\n", val
);
11480 if (tag
== Tag_GNU_Power_ABI_Vector
)
11482 val
= read_uleb128 (p
, &len
, end
);
11484 printf (" Tag_GNU_Power_ABI_Vector: ");
11488 printf (_("Any\n"));
11491 printf (_("Generic\n"));
11494 printf ("AltiVec\n");
11500 printf ("??? (%d)\n", val
);
11506 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11510 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11514 val
= read_uleb128 (p
, &len
, end
);
11516 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11520 printf (_("Any\n"));
11523 printf ("r3/r4\n");
11526 printf (_("Memory\n"));
11529 printf ("??? (%d)\n", val
);
11535 return display_tag_value (tag
& 1, p
, end
);
11539 display_sparc_hwcaps (int mask
)
11544 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11545 fputs ("mul32", stdout
), first
= 0;
11546 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11547 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11548 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11549 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11550 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11551 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11552 if (mask
& ELF_SPARC_HWCAP_POPC
)
11553 printf ("%spopc", first
? "" : "|"), first
= 0;
11554 if (mask
& ELF_SPARC_HWCAP_VIS
)
11555 printf ("%svis", first
? "" : "|"), first
= 0;
11556 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11557 printf ("%svis2", first
? "" : "|"), first
= 0;
11558 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11559 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11560 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11561 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11562 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11563 printf ("%svis3", first
? "" : "|"), first
= 0;
11564 if (mask
& ELF_SPARC_HWCAP_HPC
)
11565 printf ("%shpc", first
? "" : "|"), first
= 0;
11566 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11567 printf ("%srandom", first
? "" : "|"), first
= 0;
11568 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11569 printf ("%strans", first
? "" : "|"), first
= 0;
11570 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11571 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11572 if (mask
& ELF_SPARC_HWCAP_IMA
)
11573 printf ("%sima", first
? "" : "|"), first
= 0;
11574 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11575 printf ("%scspare", first
? "" : "|"), first
= 0;
11578 fputc('0', stdout
);
11579 fputc('\n', stdout
);
11582 static unsigned char *
11583 display_sparc_gnu_attribute (unsigned char * p
,
11585 const unsigned char * const end
)
11587 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11592 val
= read_uleb128 (p
, &len
, end
);
11594 printf (" Tag_GNU_Sparc_HWCAPS: ");
11595 display_sparc_hwcaps (val
);
11599 return display_tag_value (tag
, p
, end
);
11602 static unsigned char *
11603 display_mips_gnu_attribute (unsigned char * p
,
11605 const unsigned char * const end
)
11607 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11612 val
= read_uleb128 (p
, &len
, end
);
11614 printf (" Tag_GNU_MIPS_ABI_FP: ");
11619 printf (_("Hard or soft float\n"));
11622 printf (_("Hard float (double precision)\n"));
11625 printf (_("Hard float (single precision)\n"));
11628 printf (_("Soft float\n"));
11631 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11634 printf ("??? (%d)\n", val
);
11640 return display_tag_value (tag
& 1, p
, end
);
11643 static unsigned char *
11644 display_tic6x_attribute (unsigned char * p
,
11645 const unsigned char * const end
)
11651 tag
= read_uleb128 (p
, &len
, end
);
11657 val
= read_uleb128 (p
, &len
, end
);
11659 printf (" Tag_ISA: ");
11663 case C6XABI_Tag_ISA_none
:
11664 printf (_("None\n"));
11666 case C6XABI_Tag_ISA_C62X
:
11669 case C6XABI_Tag_ISA_C67X
:
11672 case C6XABI_Tag_ISA_C67XP
:
11673 printf ("C67x+\n");
11675 case C6XABI_Tag_ISA_C64X
:
11678 case C6XABI_Tag_ISA_C64XP
:
11679 printf ("C64x+\n");
11681 case C6XABI_Tag_ISA_C674X
:
11682 printf ("C674x\n");
11685 printf ("??? (%d)\n", val
);
11690 case Tag_ABI_wchar_t
:
11691 val
= read_uleb128 (p
, &len
, end
);
11693 printf (" Tag_ABI_wchar_t: ");
11697 printf (_("Not used\n"));
11700 printf (_("2 bytes\n"));
11703 printf (_("4 bytes\n"));
11706 printf ("??? (%d)\n", val
);
11711 case Tag_ABI_stack_align_needed
:
11712 val
= read_uleb128 (p
, &len
, end
);
11714 printf (" Tag_ABI_stack_align_needed: ");
11718 printf (_("8-byte\n"));
11721 printf (_("16-byte\n"));
11724 printf ("??? (%d)\n", val
);
11729 case Tag_ABI_stack_align_preserved
:
11730 val
= read_uleb128 (p
, &len
, end
);
11732 printf (" Tag_ABI_stack_align_preserved: ");
11736 printf (_("8-byte\n"));
11739 printf (_("16-byte\n"));
11742 printf ("??? (%d)\n", val
);
11748 val
= read_uleb128 (p
, &len
, end
);
11750 printf (" Tag_ABI_DSBT: ");
11754 printf (_("DSBT addressing not used\n"));
11757 printf (_("DSBT addressing used\n"));
11760 printf ("??? (%d)\n", val
);
11766 val
= read_uleb128 (p
, &len
, end
);
11768 printf (" Tag_ABI_PID: ");
11772 printf (_("Data addressing position-dependent\n"));
11775 printf (_("Data addressing position-independent, GOT near DP\n"));
11778 printf (_("Data addressing position-independent, GOT far from DP\n"));
11781 printf ("??? (%d)\n", val
);
11787 val
= read_uleb128 (p
, &len
, end
);
11789 printf (" Tag_ABI_PIC: ");
11793 printf (_("Code addressing position-dependent\n"));
11796 printf (_("Code addressing position-independent\n"));
11799 printf ("??? (%d)\n", val
);
11804 case Tag_ABI_array_object_alignment
:
11805 val
= read_uleb128 (p
, &len
, end
);
11807 printf (" Tag_ABI_array_object_alignment: ");
11811 printf (_("8-byte\n"));
11814 printf (_("4-byte\n"));
11817 printf (_("16-byte\n"));
11820 printf ("??? (%d)\n", val
);
11825 case Tag_ABI_array_object_align_expected
:
11826 val
= read_uleb128 (p
, &len
, end
);
11828 printf (" Tag_ABI_array_object_align_expected: ");
11832 printf (_("8-byte\n"));
11835 printf (_("4-byte\n"));
11838 printf (_("16-byte\n"));
11841 printf ("??? (%d)\n", val
);
11846 case Tag_ABI_compatibility
:
11847 val
= read_uleb128 (p
, &len
, end
);
11849 printf (" Tag_ABI_compatibility: ");
11850 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11851 p
+= strlen ((char *) p
) + 1;
11854 case Tag_ABI_conformance
:
11855 printf (" Tag_ABI_conformance: ");
11856 printf ("\"%s\"\n", p
);
11857 p
+= strlen ((char *) p
) + 1;
11861 return display_tag_value (tag
, p
, end
);
11865 display_raw_attribute (unsigned char * p
, unsigned char * end
)
11867 unsigned long addr
= 0;
11868 size_t bytes
= end
- p
;
11874 int lbytes
= (bytes
> 16 ? 16 : bytes
);
11876 printf (" 0x%8.8lx ", addr
);
11878 for (j
= 0; j
< 16; j
++)
11881 printf ("%2.2x", p
[j
]);
11889 for (j
= 0; j
< lbytes
; j
++)
11892 if (k
>= ' ' && k
< 0x7f)
11909 process_attributes (FILE * file
,
11910 const char * public_name
,
11911 unsigned int proc_type
,
11912 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
11913 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
11915 Elf_Internal_Shdr
* sect
;
11916 unsigned char * contents
;
11918 unsigned char * end
;
11919 bfd_vma section_len
;
11923 /* Find the section header so that we get the size. */
11924 for (i
= 0, sect
= section_headers
;
11925 i
< elf_header
.e_shnum
;
11928 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11931 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11932 sect
->sh_size
, _("attributes"));
11933 if (contents
== NULL
)
11939 len
= sect
->sh_size
- 1;
11945 bfd_boolean public_section
;
11946 bfd_boolean gnu_section
;
11948 section_len
= byte_get (p
, 4);
11951 if (section_len
> len
)
11953 printf (_("ERROR: Bad section length (%d > %d)\n"),
11954 (int) section_len
, (int) len
);
11958 len
-= section_len
;
11959 printf (_("Attribute Section: %s\n"), p
);
11961 if (public_name
&& streq ((char *) p
, public_name
))
11962 public_section
= TRUE
;
11964 public_section
= FALSE
;
11966 if (streq ((char *) p
, "gnu"))
11967 gnu_section
= TRUE
;
11969 gnu_section
= FALSE
;
11971 namelen
= strlen ((char *) p
) + 1;
11973 section_len
-= namelen
+ 4;
11975 while (section_len
> 0)
11981 size
= byte_get (p
, 4);
11982 if (size
> section_len
)
11984 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11985 (int) size
, (int) section_len
);
11986 size
= section_len
;
11989 section_len
-= size
;
11990 end
= p
+ size
- 1;
11996 printf (_("File Attributes\n"));
11999 printf (_("Section Attributes:"));
12002 printf (_("Symbol Attributes:"));
12008 val
= read_uleb128 (p
, &j
, end
);
12012 printf (" %d", val
);
12017 printf (_("Unknown tag: %d\n"), tag
);
12018 public_section
= FALSE
;
12022 if (public_section
)
12025 p
= display_pub_attribute (p
, end
);
12027 else if (gnu_section
)
12030 p
= display_gnu_attribute (p
,
12031 display_proc_gnu_attribute
,
12036 printf (_(" Unknown section contexts\n"));
12037 display_raw_attribute (p
, end
);
12044 printf (_("Unknown format '%c'\n"), *p
);
12052 process_arm_specific (FILE * file
)
12054 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12055 display_arm_attribute
, NULL
);
12059 process_power_specific (FILE * file
)
12061 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12062 display_power_gnu_attribute
);
12066 process_sparc_specific (FILE * file
)
12068 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12069 display_sparc_gnu_attribute
);
12073 process_tic6x_specific (FILE * file
)
12075 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12076 display_tic6x_attribute
, NULL
);
12079 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12080 Print the Address, Access and Initial fields of an entry at VMA ADDR
12081 and return the VMA of the next entry. */
12084 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12087 print_vma (addr
, LONG_HEX
);
12089 if (addr
< pltgot
+ 0xfff0)
12090 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12092 printf ("%10s", "");
12095 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12100 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12101 print_vma (entry
, LONG_HEX
);
12103 return addr
+ (is_32bit_elf
? 4 : 8);
12106 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12107 PLTGOT. Print the Address and Initial fields of an entry at VMA
12108 ADDR and return the VMA of the next entry. */
12111 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12114 print_vma (addr
, LONG_HEX
);
12117 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12122 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12123 print_vma (entry
, LONG_HEX
);
12125 return addr
+ (is_32bit_elf
? 4 : 8);
12129 process_mips_specific (FILE * file
)
12131 Elf_Internal_Dyn
* entry
;
12132 size_t liblist_offset
= 0;
12133 size_t liblistno
= 0;
12134 size_t conflictsno
= 0;
12135 size_t options_offset
= 0;
12136 size_t conflicts_offset
= 0;
12137 size_t pltrelsz
= 0;
12139 bfd_vma pltgot
= 0;
12140 bfd_vma mips_pltgot
= 0;
12141 bfd_vma jmprel
= 0;
12142 bfd_vma local_gotno
= 0;
12143 bfd_vma gotsym
= 0;
12144 bfd_vma symtabno
= 0;
12146 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12147 display_mips_gnu_attribute
);
12149 /* We have a lot of special sections. Thanks SGI! */
12150 if (dynamic_section
== NULL
)
12151 /* No information available. */
12154 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12155 switch (entry
->d_tag
)
12157 case DT_MIPS_LIBLIST
:
12159 = offset_from_vma (file
, entry
->d_un
.d_val
,
12160 liblistno
* sizeof (Elf32_External_Lib
));
12162 case DT_MIPS_LIBLISTNO
:
12163 liblistno
= entry
->d_un
.d_val
;
12165 case DT_MIPS_OPTIONS
:
12166 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12168 case DT_MIPS_CONFLICT
:
12170 = offset_from_vma (file
, entry
->d_un
.d_val
,
12171 conflictsno
* sizeof (Elf32_External_Conflict
));
12173 case DT_MIPS_CONFLICTNO
:
12174 conflictsno
= entry
->d_un
.d_val
;
12177 pltgot
= entry
->d_un
.d_ptr
;
12179 case DT_MIPS_LOCAL_GOTNO
:
12180 local_gotno
= entry
->d_un
.d_val
;
12182 case DT_MIPS_GOTSYM
:
12183 gotsym
= entry
->d_un
.d_val
;
12185 case DT_MIPS_SYMTABNO
:
12186 symtabno
= entry
->d_un
.d_val
;
12188 case DT_MIPS_PLTGOT
:
12189 mips_pltgot
= entry
->d_un
.d_ptr
;
12192 pltrel
= entry
->d_un
.d_val
;
12195 pltrelsz
= entry
->d_un
.d_val
;
12198 jmprel
= entry
->d_un
.d_ptr
;
12204 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12206 Elf32_External_Lib
* elib
;
12209 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12211 sizeof (Elf32_External_Lib
),
12212 _("liblist section data"));
12215 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12216 (unsigned long) liblistno
);
12217 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12220 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12227 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12228 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12229 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12230 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12231 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12233 tmp
= gmtime (&atime
);
12234 snprintf (timebuf
, sizeof (timebuf
),
12235 "%04u-%02u-%02uT%02u:%02u:%02u",
12236 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12237 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12239 printf ("%3lu: ", (unsigned long) cnt
);
12240 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12241 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12243 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12244 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12245 liblist
.l_version
);
12247 if (liblist
.l_flags
== 0)
12251 static const struct
12258 { " EXACT_MATCH", LL_EXACT_MATCH
},
12259 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12260 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12261 { " EXPORTS", LL_EXPORTS
},
12262 { " DELAY_LOAD", LL_DELAY_LOAD
},
12263 { " DELTA", LL_DELTA
}
12265 int flags
= liblist
.l_flags
;
12268 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12269 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12271 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12272 flags
^= l_flags_vals
[fcnt
].bit
;
12275 printf (" %#x", (unsigned int) flags
);
12285 if (options_offset
!= 0)
12287 Elf_External_Options
* eopt
;
12288 Elf_Internal_Shdr
* sect
= section_headers
;
12289 Elf_Internal_Options
* iopt
;
12290 Elf_Internal_Options
* option
;
12294 /* Find the section header so that we get the size. */
12295 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12298 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12299 sect
->sh_size
, _("options"));
12302 iopt
= (Elf_Internal_Options
*)
12303 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12306 error (_("Out of memory\n"));
12313 while (offset
< sect
->sh_size
)
12315 Elf_External_Options
* eoption
;
12317 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12319 option
->kind
= BYTE_GET (eoption
->kind
);
12320 option
->size
= BYTE_GET (eoption
->size
);
12321 option
->section
= BYTE_GET (eoption
->section
);
12322 option
->info
= BYTE_GET (eoption
->info
);
12324 offset
+= option
->size
;
12330 printf (_("\nSection '%s' contains %d entries:\n"),
12331 SECTION_NAME (sect
), cnt
);
12339 switch (option
->kind
)
12342 /* This shouldn't happen. */
12343 printf (" NULL %d %lx", option
->section
, option
->info
);
12346 printf (" REGINFO ");
12347 if (elf_header
.e_machine
== EM_MIPS
)
12350 Elf32_External_RegInfo
* ereg
;
12351 Elf32_RegInfo reginfo
;
12353 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12354 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12355 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12356 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12357 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12358 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12359 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12361 printf ("GPR %08lx GP 0x%lx\n",
12362 reginfo
.ri_gprmask
,
12363 (unsigned long) reginfo
.ri_gp_value
);
12364 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12365 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12366 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12371 Elf64_External_RegInfo
* ereg
;
12372 Elf64_Internal_RegInfo reginfo
;
12374 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12375 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12376 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12377 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12378 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12379 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12380 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12382 printf ("GPR %08lx GP 0x",
12383 reginfo
.ri_gprmask
);
12384 printf_vma (reginfo
.ri_gp_value
);
12387 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12388 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12389 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12393 case ODK_EXCEPTIONS
:
12394 fputs (" EXCEPTIONS fpe_min(", stdout
);
12395 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12396 fputs (") fpe_max(", stdout
);
12397 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12398 fputs (")", stdout
);
12400 if (option
->info
& OEX_PAGE0
)
12401 fputs (" PAGE0", stdout
);
12402 if (option
->info
& OEX_SMM
)
12403 fputs (" SMM", stdout
);
12404 if (option
->info
& OEX_FPDBUG
)
12405 fputs (" FPDBUG", stdout
);
12406 if (option
->info
& OEX_DISMISS
)
12407 fputs (" DISMISS", stdout
);
12410 fputs (" PAD ", stdout
);
12411 if (option
->info
& OPAD_PREFIX
)
12412 fputs (" PREFIX", stdout
);
12413 if (option
->info
& OPAD_POSTFIX
)
12414 fputs (" POSTFIX", stdout
);
12415 if (option
->info
& OPAD_SYMBOL
)
12416 fputs (" SYMBOL", stdout
);
12419 fputs (" HWPATCH ", stdout
);
12420 if (option
->info
& OHW_R4KEOP
)
12421 fputs (" R4KEOP", stdout
);
12422 if (option
->info
& OHW_R8KPFETCH
)
12423 fputs (" R8KPFETCH", stdout
);
12424 if (option
->info
& OHW_R5KEOP
)
12425 fputs (" R5KEOP", stdout
);
12426 if (option
->info
& OHW_R5KCVTL
)
12427 fputs (" R5KCVTL", stdout
);
12430 fputs (" FILL ", stdout
);
12431 /* XXX Print content of info word? */
12434 fputs (" TAGS ", stdout
);
12435 /* XXX Print content of info word? */
12438 fputs (" HWAND ", stdout
);
12439 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12440 fputs (" R4KEOP_CHECKED", stdout
);
12441 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12442 fputs (" R4KEOP_CLEAN", stdout
);
12445 fputs (" HWOR ", stdout
);
12446 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12447 fputs (" R4KEOP_CHECKED", stdout
);
12448 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12449 fputs (" R4KEOP_CLEAN", stdout
);
12452 printf (" GP_GROUP %#06lx self-contained %#06lx",
12453 option
->info
& OGP_GROUP
,
12454 (option
->info
& OGP_SELF
) >> 16);
12457 printf (" IDENT %#06lx self-contained %#06lx",
12458 option
->info
& OGP_GROUP
,
12459 (option
->info
& OGP_SELF
) >> 16);
12462 /* This shouldn't happen. */
12463 printf (" %3d ??? %d %lx",
12464 option
->kind
, option
->section
, option
->info
);
12468 len
= sizeof (* eopt
);
12469 while (len
< option
->size
)
12470 if (((char *) option
)[len
] >= ' '
12471 && ((char *) option
)[len
] < 0x7f)
12472 printf ("%c", ((char *) option
)[len
++]);
12474 printf ("\\%03o", ((char *) option
)[len
++]);
12476 fputs ("\n", stdout
);
12484 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12486 Elf32_Conflict
* iconf
;
12489 if (dynamic_symbols
== NULL
)
12491 error (_("conflict list found without a dynamic symbol table\n"));
12495 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12498 error (_("Out of memory\n"));
12504 Elf32_External_Conflict
* econf32
;
12506 econf32
= (Elf32_External_Conflict
*)
12507 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12508 sizeof (* econf32
), _("conflict"));
12512 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12513 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12519 Elf64_External_Conflict
* econf64
;
12521 econf64
= (Elf64_External_Conflict
*)
12522 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12523 sizeof (* econf64
), _("conflict"));
12527 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12528 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12533 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12534 (unsigned long) conflictsno
);
12535 puts (_(" Num: Index Value Name"));
12537 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12539 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12541 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12542 print_vma (psym
->st_value
, FULL_HEX
);
12544 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12545 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12547 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12554 if (pltgot
!= 0 && local_gotno
!= 0)
12556 bfd_vma ent
, local_end
, global_end
;
12558 unsigned char * data
;
12562 addr_size
= (is_32bit_elf
? 4 : 8);
12563 local_end
= pltgot
+ local_gotno
* addr_size
;
12564 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12566 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12567 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12568 global_end
- pltgot
, 1,
12569 _("Global Offset Table data"));
12573 printf (_("\nPrimary GOT:\n"));
12574 printf (_(" Canonical gp value: "));
12575 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12578 printf (_(" Reserved entries:\n"));
12579 printf (_(" %*s %10s %*s Purpose\n"),
12580 addr_size
* 2, _("Address"), _("Access"),
12581 addr_size
* 2, _("Initial"));
12582 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12583 printf (_(" Lazy resolver\n"));
12585 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12586 >> (addr_size
* 8 - 1)) != 0)
12588 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12589 printf (_(" Module pointer (GNU extension)\n"));
12593 if (ent
< local_end
)
12595 printf (_(" Local entries:\n"));
12596 printf (" %*s %10s %*s\n",
12597 addr_size
* 2, _("Address"), _("Access"),
12598 addr_size
* 2, _("Initial"));
12599 while (ent
< local_end
)
12601 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12607 if (gotsym
< symtabno
)
12611 printf (_(" Global entries:\n"));
12612 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12613 addr_size
* 2, _("Address"),
12615 addr_size
* 2, _("Initial"),
12616 addr_size
* 2, _("Sym.Val."),
12618 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12619 _("Ndx"), _("Name"));
12621 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12622 for (i
= gotsym
; i
< symtabno
; i
++)
12624 Elf_Internal_Sym
* psym
;
12626 psym
= dynamic_symbols
+ i
;
12627 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12629 print_vma (psym
->st_value
, LONG_HEX
);
12630 printf (" %-7s %3s ",
12631 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12632 get_symbol_index_type (psym
->st_shndx
));
12633 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12634 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12636 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12646 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12649 size_t offset
, rel_offset
;
12650 unsigned long count
, i
;
12651 unsigned char * data
;
12652 int addr_size
, sym_width
;
12653 Elf_Internal_Rela
* rels
;
12655 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12656 if (pltrel
== DT_RELA
)
12658 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12663 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12668 addr_size
= (is_32bit_elf
? 4 : 8);
12669 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12671 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12672 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12673 1, _("Procedure Linkage Table data"));
12677 printf ("\nPLT GOT:\n\n");
12678 printf (_(" Reserved entries:\n"));
12679 printf (_(" %*s %*s Purpose\n"),
12680 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12681 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12682 printf (_(" PLT lazy resolver\n"));
12683 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12684 printf (_(" Module pointer\n"));
12687 printf (_(" Entries:\n"));
12688 printf (" %*s %*s %*s %-7s %3s %s\n",
12689 addr_size
* 2, _("Address"),
12690 addr_size
* 2, _("Initial"),
12691 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12692 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12693 for (i
= 0; i
< count
; i
++)
12695 Elf_Internal_Sym
* psym
;
12697 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12698 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12700 print_vma (psym
->st_value
, LONG_HEX
);
12701 printf (" %-7s %3s ",
12702 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12703 get_symbol_index_type (psym
->st_shndx
));
12704 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12705 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12707 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12721 process_gnu_liblist (FILE * file
)
12723 Elf_Internal_Shdr
* section
;
12724 Elf_Internal_Shdr
* string_sec
;
12725 Elf32_External_Lib
* elib
;
12727 size_t strtab_size
;
12734 for (i
= 0, section
= section_headers
;
12735 i
< elf_header
.e_shnum
;
12738 switch (section
->sh_type
)
12740 case SHT_GNU_LIBLIST
:
12741 if (section
->sh_link
>= elf_header
.e_shnum
)
12744 elib
= (Elf32_External_Lib
*)
12745 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12746 _("liblist section data"));
12750 string_sec
= section_headers
+ section
->sh_link
;
12752 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12753 string_sec
->sh_size
,
12754 _("liblist string table"));
12756 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12762 strtab_size
= string_sec
->sh_size
;
12764 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12765 SECTION_NAME (section
),
12766 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12768 puts (_(" Library Time Stamp Checksum Version Flags"));
12770 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12778 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12779 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12780 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12781 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12782 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12784 tmp
= gmtime (&atime
);
12785 snprintf (timebuf
, sizeof (timebuf
),
12786 "%04u-%02u-%02uT%02u:%02u:%02u",
12787 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12788 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12790 printf ("%3lu: ", (unsigned long) cnt
);
12792 printf ("%-20s", liblist
.l_name
< strtab_size
12793 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12795 printf ("%-20.20s", liblist
.l_name
< strtab_size
12796 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12797 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12798 liblist
.l_version
, liblist
.l_flags
);
12809 static const char *
12810 get_note_type (unsigned e_type
)
12812 static char buff
[64];
12814 if (elf_header
.e_type
== ET_CORE
)
12818 return _("NT_AUXV (auxiliary vector)");
12820 return _("NT_PRSTATUS (prstatus structure)");
12822 return _("NT_FPREGSET (floating point registers)");
12824 return _("NT_PRPSINFO (prpsinfo structure)");
12825 case NT_TASKSTRUCT
:
12826 return _("NT_TASKSTRUCT (task structure)");
12828 return _("NT_PRXFPREG (user_xfpregs structure)");
12830 return _("NT_PPC_VMX (ppc Altivec registers)");
12832 return _("NT_PPC_VSX (ppc VSX registers)");
12834 return _("NT_386_TLS (x86 TLS information)");
12835 case NT_386_IOPERM
:
12836 return _("NT_386_IOPERM (x86 I/O permissions)");
12837 case NT_X86_XSTATE
:
12838 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12839 case NT_S390_HIGH_GPRS
:
12840 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12841 case NT_S390_TIMER
:
12842 return _("NT_S390_TIMER (s390 timer register)");
12843 case NT_S390_TODCMP
:
12844 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12845 case NT_S390_TODPREG
:
12846 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12848 return _("NT_S390_CTRS (s390 control registers)");
12849 case NT_S390_PREFIX
:
12850 return _("NT_S390_PREFIX (s390 prefix register)");
12851 case NT_S390_LAST_BREAK
:
12852 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12853 case NT_S390_SYSTEM_CALL
:
12854 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12856 return _("NT_S390_TDB (s390 transaction diagnostic block)");
12858 return _("NT_ARM_VFP (arm VFP registers)");
12860 return _("NT_ARM_TLS (AArch TLS registers)");
12861 case NT_ARM_HW_BREAK
:
12862 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12863 case NT_ARM_HW_WATCH
:
12864 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12866 return _("NT_PSTATUS (pstatus structure)");
12868 return _("NT_FPREGS (floating point registers)");
12870 return _("NT_PSINFO (psinfo structure)");
12872 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12874 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12875 case NT_WIN32PSTATUS
:
12876 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12878 return _("NT_SIGINFO (siginfo_t data)");
12880 return _("NT_FILE (mapped files)");
12888 return _("NT_VERSION (version)");
12890 return _("NT_ARCH (architecture)");
12895 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12900 print_core_note (Elf_Internal_Note
*pnote
)
12902 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12903 bfd_vma count
, page_size
;
12904 unsigned char *descdata
, *filenames
, *descend
;
12906 if (pnote
->type
!= NT_FILE
)
12912 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12913 /* Still "successful". */
12918 if (pnote
->descsz
< 2 * addr_size
)
12920 printf (_(" Malformed note - too short for header\n"));
12924 descdata
= (unsigned char *) pnote
->descdata
;
12925 descend
= descdata
+ pnote
->descsz
;
12927 if (descdata
[pnote
->descsz
- 1] != '\0')
12929 printf (_(" Malformed note - does not end with \\0\n"));
12933 count
= byte_get (descdata
, addr_size
);
12934 descdata
+= addr_size
;
12936 page_size
= byte_get (descdata
, addr_size
);
12937 descdata
+= addr_size
;
12939 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12941 printf (_(" Malformed note - too short for supplied file count\n"));
12945 printf (_(" Page size: "));
12946 print_vma (page_size
, DEC
);
12949 printf (_(" %*s%*s%*s\n"),
12950 (int) (2 + 2 * addr_size
), _("Start"),
12951 (int) (4 + 2 * addr_size
), _("End"),
12952 (int) (4 + 2 * addr_size
), _("Page Offset"));
12953 filenames
= descdata
+ count
* 3 * addr_size
;
12954 while (--count
> 0)
12956 bfd_vma start
, end
, file_ofs
;
12958 if (filenames
== descend
)
12960 printf (_(" Malformed note - filenames end too early\n"));
12964 start
= byte_get (descdata
, addr_size
);
12965 descdata
+= addr_size
;
12966 end
= byte_get (descdata
, addr_size
);
12967 descdata
+= addr_size
;
12968 file_ofs
= byte_get (descdata
, addr_size
);
12969 descdata
+= addr_size
;
12972 print_vma (start
, FULL_HEX
);
12974 print_vma (end
, FULL_HEX
);
12976 print_vma (file_ofs
, FULL_HEX
);
12977 printf ("\n %s\n", filenames
);
12979 filenames
+= 1 + strlen ((char *) filenames
);
12985 static const char *
12986 get_gnu_elf_note_type (unsigned e_type
)
12988 static char buff
[64];
12992 case NT_GNU_ABI_TAG
:
12993 return _("NT_GNU_ABI_TAG (ABI version tag)");
12995 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12996 case NT_GNU_BUILD_ID
:
12997 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12998 case NT_GNU_GOLD_VERSION
:
12999 return _("NT_GNU_GOLD_VERSION (gold version)");
13004 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13009 print_gnu_note (Elf_Internal_Note
*pnote
)
13011 switch (pnote
->type
)
13013 case NT_GNU_BUILD_ID
:
13017 printf (_(" Build ID: "));
13018 for (i
= 0; i
< pnote
->descsz
; ++i
)
13019 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13024 case NT_GNU_ABI_TAG
:
13026 unsigned long os
, major
, minor
, subminor
;
13027 const char *osname
;
13029 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13030 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13031 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13032 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13036 case GNU_ABI_TAG_LINUX
:
13039 case GNU_ABI_TAG_HURD
:
13042 case GNU_ABI_TAG_SOLARIS
:
13043 osname
= "Solaris";
13045 case GNU_ABI_TAG_FREEBSD
:
13046 osname
= "FreeBSD";
13048 case GNU_ABI_TAG_NETBSD
:
13052 osname
= "Unknown";
13056 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13057 major
, minor
, subminor
);
13065 static const char *
13066 get_netbsd_elfcore_note_type (unsigned e_type
)
13068 static char buff
[64];
13070 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13072 /* NetBSD core "procinfo" structure. */
13073 return _("NetBSD procinfo structure");
13076 /* As of Jan 2002 there are no other machine-independent notes
13077 defined for NetBSD core files. If the note type is less
13078 than the start of the machine-dependent note types, we don't
13081 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13083 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13087 switch (elf_header
.e_machine
)
13089 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13090 and PT_GETFPREGS == mach+2. */
13095 case EM_SPARC32PLUS
:
13099 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13100 return _("PT_GETREGS (reg structure)");
13101 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13102 return _("PT_GETFPREGS (fpreg structure)");
13108 /* On all other arch's, PT_GETREGS == mach+1 and
13109 PT_GETFPREGS == mach+3. */
13113 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13114 return _("PT_GETREGS (reg structure)");
13115 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13116 return _("PT_GETFPREGS (fpreg structure)");
13122 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13123 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13127 static const char *
13128 get_stapsdt_note_type (unsigned e_type
)
13130 static char buff
[64];
13135 return _("NT_STAPSDT (SystemTap probe descriptors)");
13141 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13146 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13148 int addr_size
= is_32bit_elf
? 4 : 8;
13149 char *data
= pnote
->descdata
;
13150 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13151 bfd_vma pc
, base_addr
, semaphore
;
13152 char *provider
, *probe
, *arg_fmt
;
13154 pc
= byte_get ((unsigned char *) data
, addr_size
);
13156 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13158 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13162 data
+= strlen (data
) + 1;
13164 data
+= strlen (data
) + 1;
13166 data
+= strlen (data
) + 1;
13168 printf (_(" Provider: %s\n"), provider
);
13169 printf (_(" Name: %s\n"), probe
);
13170 printf (_(" Location: "));
13171 print_vma (pc
, FULL_HEX
);
13172 printf (_(", Base: "));
13173 print_vma (base_addr
, FULL_HEX
);
13174 printf (_(", Semaphore: "));
13175 print_vma (semaphore
, FULL_HEX
);
13177 printf (_(" Arguments: %s\n"), arg_fmt
);
13179 return data
== data_end
;
13182 static const char *
13183 get_ia64_vms_note_type (unsigned e_type
)
13185 static char buff
[64];
13190 return _("NT_VMS_MHD (module header)");
13192 return _("NT_VMS_LNM (language name)");
13194 return _("NT_VMS_SRC (source files)");
13196 return "NT_VMS_TITLE";
13198 return _("NT_VMS_EIDC (consistency check)");
13199 case NT_VMS_FPMODE
:
13200 return _("NT_VMS_FPMODE (FP mode)");
13201 case NT_VMS_LINKTIME
:
13202 return "NT_VMS_LINKTIME";
13203 case NT_VMS_IMGNAM
:
13204 return _("NT_VMS_IMGNAM (image name)");
13206 return _("NT_VMS_IMGID (image id)");
13207 case NT_VMS_LINKID
:
13208 return _("NT_VMS_LINKID (link id)");
13209 case NT_VMS_IMGBID
:
13210 return _("NT_VMS_IMGBID (build id)");
13211 case NT_VMS_GSTNAM
:
13212 return _("NT_VMS_GSTNAM (sym table name)");
13213 case NT_VMS_ORIG_DYN
:
13214 return "NT_VMS_ORIG_DYN";
13215 case NT_VMS_PATCHTIME
:
13216 return "NT_VMS_PATCHTIME";
13218 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13224 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13226 switch (pnote
->type
)
13229 if (pnote
->descsz
> 36)
13231 size_t l
= strlen (pnote
->descdata
+ 34);
13232 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13233 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13234 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13235 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13238 printf (_(" Invalid size\n"));
13241 printf (_(" Language: %s\n"), pnote
->descdata
);
13244 case NT_VMS_FPMODE
:
13245 printf (_(" Floating Point mode: "));
13246 printf ("0x%016" BFD_VMA_FMT
"x\n",
13247 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13249 case NT_VMS_LINKTIME
:
13250 printf (_(" Link time: "));
13252 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13255 case NT_VMS_PATCHTIME
:
13256 printf (_(" Patch time: "));
13258 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13261 case NT_VMS_ORIG_DYN
:
13262 printf (_(" Major id: %u, minor id: %u\n"),
13263 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13264 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13265 printf (_(" Last modified : "));
13267 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13268 printf (_("\n Link flags : "));
13269 printf ("0x%016" BFD_VMA_FMT
"x\n",
13270 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13271 printf (_(" Header flags: 0x%08x\n"),
13272 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13273 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13276 case NT_VMS_IMGNAM
:
13277 printf (_(" Image name: %s\n"), pnote
->descdata
);
13279 case NT_VMS_GSTNAM
:
13280 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13283 printf (_(" Image id: %s\n"), pnote
->descdata
);
13285 case NT_VMS_LINKID
:
13286 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13294 /* Note that by the ELF standard, the name field is already null byte
13295 terminated, and namesz includes the terminating null byte.
13296 I.E. the value of namesz for the name "FSF" is 4.
13298 If the value of namesz is zero, there is no name present. */
13300 process_note (Elf_Internal_Note
* pnote
)
13302 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13305 if (pnote
->namesz
== 0)
13306 /* If there is no note name, then use the default set of
13307 note type strings. */
13308 nt
= get_note_type (pnote
->type
);
13310 else if (const_strneq (pnote
->namedata
, "GNU"))
13311 /* GNU-specific object file notes. */
13312 nt
= get_gnu_elf_note_type (pnote
->type
);
13314 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13315 /* NetBSD-specific core file notes. */
13316 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13318 else if (strneq (pnote
->namedata
, "SPU/", 4))
13320 /* SPU-specific core file notes. */
13321 nt
= pnote
->namedata
+ 4;
13325 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13326 /* VMS/ia64-specific file notes. */
13327 nt
= get_ia64_vms_note_type (pnote
->type
);
13329 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13330 nt
= get_stapsdt_note_type (pnote
->type
);
13333 /* Don't recognize this note name; just use the default set of
13334 note type strings. */
13335 nt
= get_note_type (pnote
->type
);
13337 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13339 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13340 return print_ia64_vms_note (pnote
);
13341 else if (const_strneq (pnote
->namedata
, "GNU"))
13342 return print_gnu_note (pnote
);
13343 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13344 return print_stapsdt_note (pnote
);
13345 else if (const_strneq (pnote
->namedata
, "CORE"))
13346 return print_core_note (pnote
);
13353 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13355 Elf_External_Note
* pnotes
;
13356 Elf_External_Note
* external
;
13362 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13364 if (pnotes
== NULL
)
13369 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13370 (unsigned long) offset
, (unsigned long) length
);
13371 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13373 while ((char *) external
< (char *) pnotes
+ length
)
13375 Elf_Internal_Note inote
;
13378 char * temp
= NULL
;
13379 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
13381 if (!is_ia64_vms ())
13383 /* PR binutils/15191
13384 Make sure that there is enough data to read. */
13385 min_notesz
= offsetof (Elf_External_Note
, name
);
13386 if (data_remaining
< min_notesz
)
13388 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13389 (int) data_remaining
);
13392 inote
.type
= BYTE_GET (external
->type
);
13393 inote
.namesz
= BYTE_GET (external
->namesz
);
13394 inote
.namedata
= external
->name
;
13395 inote
.descsz
= BYTE_GET (external
->descsz
);
13396 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13397 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13398 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
13402 Elf64_External_VMS_Note
*vms_external
;
13404 /* PR binutils/15191
13405 Make sure that there is enough data to read. */
13406 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
13407 if (data_remaining
< min_notesz
)
13409 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13410 (int) data_remaining
);
13414 vms_external
= (Elf64_External_VMS_Note
*) external
;
13415 inote
.type
= BYTE_GET (vms_external
->type
);
13416 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13417 inote
.namedata
= vms_external
->name
;
13418 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13419 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13420 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13421 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
13424 if (inote
.descdata
< (char *) external
+ min_notesz
13425 || next
< (char *) external
+ min_notesz
13426 || data_remaining
< (size_t)(next
- (char *) external
))
13428 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13429 (unsigned long) ((char *) external
- (char *) pnotes
));
13430 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13431 inote
.type
, inote
.namesz
, inote
.descsz
);
13435 external
= (Elf_External_Note
*) next
;
13437 /* Verify that name is null terminated. It appears that at least
13438 one version of Linux (RedHat 6.0) generates corefiles that don't
13439 comply with the ELF spec by failing to include the null byte in
13441 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13443 temp
= (char *) malloc (inote
.namesz
+ 1);
13447 error (_("Out of memory\n"));
13452 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13453 temp
[inote
.namesz
] = 0;
13455 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13456 inote
.namedata
= temp
;
13459 res
&= process_note (& inote
);
13474 process_corefile_note_segments (FILE * file
)
13476 Elf_Internal_Phdr
* segment
;
13480 if (! get_program_headers (file
))
13483 for (i
= 0, segment
= program_headers
;
13484 i
< elf_header
.e_phnum
;
13487 if (segment
->p_type
== PT_NOTE
)
13488 res
&= process_corefile_note_segment (file
,
13489 (bfd_vma
) segment
->p_offset
,
13490 (bfd_vma
) segment
->p_filesz
);
13497 process_note_sections (FILE * file
)
13499 Elf_Internal_Shdr
* section
;
13503 for (i
= 0, section
= section_headers
;
13504 i
< elf_header
.e_shnum
&& section
!= NULL
;
13506 if (section
->sh_type
== SHT_NOTE
)
13507 res
&= process_corefile_note_segment (file
,
13508 (bfd_vma
) section
->sh_offset
,
13509 (bfd_vma
) section
->sh_size
);
13515 process_notes (FILE * file
)
13517 /* If we have not been asked to display the notes then do nothing. */
13521 if (elf_header
.e_type
!= ET_CORE
)
13522 return process_note_sections (file
);
13524 /* No program headers means no NOTE segment. */
13525 if (elf_header
.e_phnum
> 0)
13526 return process_corefile_note_segments (file
);
13528 printf (_("No note segments present in the core file.\n"));
13533 process_arch_specific (FILE * file
)
13538 switch (elf_header
.e_machine
)
13541 return process_arm_specific (file
);
13543 case EM_MIPS_RS3_LE
:
13544 return process_mips_specific (file
);
13547 return process_power_specific (file
);
13550 case EM_SPARC32PLUS
:
13552 return process_sparc_specific (file
);
13555 return process_tic6x_specific (file
);
13564 get_file_header (FILE * file
)
13566 /* Read in the identity array. */
13567 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13570 /* Determine how to read the rest of the header. */
13571 switch (elf_header
.e_ident
[EI_DATA
])
13573 default: /* fall through */
13574 case ELFDATANONE
: /* fall through */
13576 byte_get
= byte_get_little_endian
;
13577 byte_put
= byte_put_little_endian
;
13580 byte_get
= byte_get_big_endian
;
13581 byte_put
= byte_put_big_endian
;
13585 /* For now we only support 32 bit and 64 bit ELF files. */
13586 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13588 /* Read in the rest of the header. */
13591 Elf32_External_Ehdr ehdr32
;
13593 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13596 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13597 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13598 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13599 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13600 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13601 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13602 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13603 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13604 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13605 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13606 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13607 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13608 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13612 Elf64_External_Ehdr ehdr64
;
13614 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13615 we will not be able to cope with the 64bit data found in
13616 64 ELF files. Detect this now and abort before we start
13617 overwriting things. */
13618 if (sizeof (bfd_vma
) < 8)
13620 error (_("This instance of readelf has been built without support for a\n\
13621 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13625 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13628 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13629 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13630 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13631 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13632 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13633 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13634 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13635 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13636 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13637 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13638 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13639 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13640 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13643 if (elf_header
.e_shoff
)
13645 /* There may be some extensions in the first section header. Don't
13646 bomb if we can't read it. */
13648 get_32bit_section_headers (file
, 1);
13650 get_64bit_section_headers (file
, 1);
13656 /* Process one ELF object file according to the command line options.
13657 This file may actually be stored in an archive. The file is
13658 positioned at the start of the ELF object. */
13661 process_object (char * file_name
, FILE * file
)
13665 if (! get_file_header (file
))
13667 error (_("%s: Failed to read file header\n"), file_name
);
13671 /* Initialise per file variables. */
13672 for (i
= ARRAY_SIZE (version_info
); i
--;)
13673 version_info
[i
] = 0;
13675 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13676 dynamic_info
[i
] = 0;
13677 dynamic_info_DT_GNU_HASH
= 0;
13679 /* Process the file. */
13681 printf (_("\nFile: %s\n"), file_name
);
13683 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13684 Note we do this even if cmdline_dump_sects is empty because we
13685 must make sure that the dump_sets array is zeroed out before each
13686 object file is processed. */
13687 if (num_dump_sects
> num_cmdline_dump_sects
)
13688 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13690 if (num_cmdline_dump_sects
> 0)
13692 if (num_dump_sects
== 0)
13693 /* A sneaky way of allocating the dump_sects array. */
13694 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13696 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13697 memcpy (dump_sects
, cmdline_dump_sects
,
13698 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13701 if (! process_file_header ())
13704 if (! process_section_headers (file
))
13706 /* Without loaded section headers we cannot process lots of
13708 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13710 if (! do_using_dynamic
)
13711 do_syms
= do_dyn_syms
= do_reloc
= 0;
13714 if (! process_section_groups (file
))
13716 /* Without loaded section groups we cannot process unwind. */
13720 if (process_program_headers (file
))
13721 process_dynamic_section (file
);
13723 process_relocs (file
);
13725 process_unwind (file
);
13727 process_symbol_table (file
);
13729 process_syminfo (file
);
13731 process_version_sections (file
);
13733 process_section_contents (file
);
13735 process_notes (file
);
13737 process_gnu_liblist (file
);
13739 process_arch_specific (file
);
13741 if (program_headers
)
13743 free (program_headers
);
13744 program_headers
= NULL
;
13747 if (section_headers
)
13749 free (section_headers
);
13750 section_headers
= NULL
;
13755 free (string_table
);
13756 string_table
= NULL
;
13757 string_table_length
= 0;
13760 if (dynamic_strings
)
13762 free (dynamic_strings
);
13763 dynamic_strings
= NULL
;
13764 dynamic_strings_length
= 0;
13767 if (dynamic_symbols
)
13769 free (dynamic_symbols
);
13770 dynamic_symbols
= NULL
;
13771 num_dynamic_syms
= 0;
13774 if (dynamic_syminfo
)
13776 free (dynamic_syminfo
);
13777 dynamic_syminfo
= NULL
;
13780 if (dynamic_section
)
13782 free (dynamic_section
);
13783 dynamic_section
= NULL
;
13786 if (section_headers_groups
)
13788 free (section_headers_groups
);
13789 section_headers_groups
= NULL
;
13792 if (section_groups
)
13794 struct group_list
* g
;
13795 struct group_list
* next
;
13797 for (i
= 0; i
< group_count
; i
++)
13799 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13806 free (section_groups
);
13807 section_groups
= NULL
;
13810 free_debug_memory ();
13815 /* Process an ELF archive.
13816 On entry the file is positioned just after the ARMAG string. */
13819 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13821 struct archive_info arch
;
13822 struct archive_info nested_arch
;
13828 /* The ARCH structure is used to hold information about this archive. */
13829 arch
.file_name
= NULL
;
13831 arch
.index_array
= NULL
;
13832 arch
.sym_table
= NULL
;
13833 arch
.longnames
= NULL
;
13835 /* The NESTED_ARCH structure is used as a single-item cache of information
13836 about a nested archive (when members of a thin archive reside within
13837 another regular archive file). */
13838 nested_arch
.file_name
= NULL
;
13839 nested_arch
.file
= NULL
;
13840 nested_arch
.index_array
= NULL
;
13841 nested_arch
.sym_table
= NULL
;
13842 nested_arch
.longnames
= NULL
;
13844 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13850 if (do_archive_index
)
13852 if (arch
.sym_table
== NULL
)
13853 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13857 unsigned long current_pos
;
13859 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13860 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13861 current_pos
= ftell (file
);
13863 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13865 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13867 char * member_name
;
13869 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13871 if (member_name
!= NULL
)
13873 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13875 if (qualified_name
!= NULL
)
13877 printf (_("Contents of binary %s at offset "), qualified_name
);
13878 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13880 free (qualified_name
);
13885 if (l
>= arch
.sym_size
)
13887 error (_("%s: end of the symbol table reached before the end of the index\n"),
13891 printf ("\t%s\n", arch
.sym_table
+ l
);
13892 l
+= strlen (arch
.sym_table
+ l
) + 1;
13895 if (arch
.uses_64bit_indicies
)
13900 if (l
< arch
.sym_size
)
13901 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13902 file_name
, arch
.sym_size
- l
);
13904 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13906 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13912 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13913 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13914 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13915 && !do_section_groups
&& !do_dyn_syms
)
13917 ret
= 0; /* Archive index only. */
13928 char * qualified_name
;
13930 /* Read the next archive header. */
13931 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13933 error (_("%s: failed to seek to next archive header\n"), file_name
);
13936 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13937 if (got
!= sizeof arch
.arhdr
)
13941 error (_("%s: failed to read archive header\n"), file_name
);
13945 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13947 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13952 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13954 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13955 if (archive_file_size
& 01)
13956 ++archive_file_size
;
13958 name
= get_archive_member_name (&arch
, &nested_arch
);
13961 error (_("%s: bad archive file name\n"), file_name
);
13965 namelen
= strlen (name
);
13967 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13968 if (qualified_name
== NULL
)
13970 error (_("%s: bad archive file name\n"), file_name
);
13975 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13977 /* This is a proxy for an external member of a thin archive. */
13978 FILE * member_file
;
13979 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13980 if (member_file_name
== NULL
)
13986 member_file
= fopen (member_file_name
, "rb");
13987 if (member_file
== NULL
)
13989 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13990 free (member_file_name
);
13995 archive_file_offset
= arch
.nested_member_origin
;
13997 ret
|= process_object (qualified_name
, member_file
);
13999 fclose (member_file
);
14000 free (member_file_name
);
14002 else if (is_thin_archive
)
14004 /* PR 15140: Allow for corrupt thin archives. */
14005 if (nested_arch
.file
== NULL
)
14007 error (_("%s: contains corrupt thin archive: %s\n"),
14013 /* This is a proxy for a member of a nested archive. */
14014 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14016 /* The nested archive file will have been opened and setup by
14017 get_archive_member_name. */
14018 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14020 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14025 ret
|= process_object (qualified_name
, nested_arch
.file
);
14029 archive_file_offset
= arch
.next_arhdr_offset
;
14030 arch
.next_arhdr_offset
+= archive_file_size
;
14032 ret
|= process_object (qualified_name
, file
);
14035 if (dump_sects
!= NULL
)
14039 num_dump_sects
= 0;
14042 free (qualified_name
);
14046 if (nested_arch
.file
!= NULL
)
14047 fclose (nested_arch
.file
);
14048 release_archive (&nested_arch
);
14049 release_archive (&arch
);
14055 process_file (char * file_name
)
14058 struct stat statbuf
;
14059 char armag
[SARMAG
];
14062 if (stat (file_name
, &statbuf
) < 0)
14064 if (errno
== ENOENT
)
14065 error (_("'%s': No such file\n"), file_name
);
14067 error (_("Could not locate '%s'. System error message: %s\n"),
14068 file_name
, strerror (errno
));
14072 if (! S_ISREG (statbuf
.st_mode
))
14074 error (_("'%s' is not an ordinary file\n"), file_name
);
14078 file
= fopen (file_name
, "rb");
14081 error (_("Input file '%s' is not readable.\n"), file_name
);
14085 if (fread (armag
, SARMAG
, 1, file
) != 1)
14087 error (_("%s: Failed to read file's magic number\n"), file_name
);
14092 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14093 ret
= process_archive (file_name
, file
, FALSE
);
14094 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14095 ret
= process_archive (file_name
, file
, TRUE
);
14098 if (do_archive_index
)
14099 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14103 archive_file_size
= archive_file_offset
= 0;
14104 ret
= process_object (file_name
, file
);
14112 #ifdef SUPPORT_DISASSEMBLY
14113 /* Needed by the i386 disassembler. For extra credit, someone could
14114 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14118 print_address (unsigned int addr
, FILE * outfile
)
14120 fprintf (outfile
,"0x%8.8x", addr
);
14123 /* Needed by the i386 disassembler. */
14125 db_task_printsym (unsigned int addr
)
14127 print_address (addr
, stderr
);
14132 main (int argc
, char ** argv
)
14136 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14137 setlocale (LC_MESSAGES
, "");
14139 #if defined (HAVE_SETLOCALE)
14140 setlocale (LC_CTYPE
, "");
14142 bindtextdomain (PACKAGE
, LOCALEDIR
);
14143 textdomain (PACKAGE
);
14145 expandargv (&argc
, &argv
);
14147 parse_args (argc
, argv
);
14149 if (num_dump_sects
> 0)
14151 /* Make a copy of the dump_sects array. */
14152 cmdline_dump_sects
= (dump_type
*)
14153 malloc (num_dump_sects
* sizeof (* dump_sects
));
14154 if (cmdline_dump_sects
== NULL
)
14155 error (_("Out of memory allocating dump request table.\n"));
14158 memcpy (cmdline_dump_sects
, dump_sects
,
14159 num_dump_sects
* sizeof (* dump_sects
));
14160 num_cmdline_dump_sects
= num_dump_sects
;
14164 if (optind
< (argc
- 1))
14168 while (optind
< argc
)
14169 err
|= process_file (argv
[optind
++]);
14171 if (dump_sects
!= NULL
)
14173 if (cmdline_dump_sects
!= NULL
)
14174 free (cmdline_dump_sects
);