1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name
= "readelf";
168 static long archive_file_offset
;
169 static unsigned long archive_file_size
;
170 static bfd_size_type current_file_size
;
171 static unsigned long dynamic_addr
;
172 static bfd_size_type dynamic_size
;
173 static unsigned int dynamic_nent
;
174 static char * dynamic_strings
;
175 static unsigned long dynamic_strings_length
;
176 static char * string_table
;
177 static unsigned long string_table_length
;
178 static unsigned long num_dynamic_syms
;
179 static Elf_Internal_Sym
* dynamic_symbols
;
180 static Elf_Internal_Syminfo
* dynamic_syminfo
;
181 static unsigned long dynamic_syminfo_offset
;
182 static unsigned int dynamic_syminfo_nent
;
183 static char program_interpreter
[PATH_MAX
];
184 static bfd_vma dynamic_info
[DT_ENCODING
];
185 static bfd_vma dynamic_info_DT_GNU_HASH
;
186 static bfd_vma version_info
[16];
187 static Elf_Internal_Ehdr elf_header
;
188 static Elf_Internal_Shdr
* section_headers
;
189 static Elf_Internal_Phdr
* program_headers
;
190 static Elf_Internal_Dyn
* dynamic_section
;
191 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
192 static int show_name
;
193 static int do_dynamic
;
195 static int do_dyn_syms
;
197 static int do_sections
;
198 static int do_section_groups
;
199 static int do_section_details
;
200 static int do_segments
;
201 static int do_unwind
;
202 static int do_using_dynamic
;
203 static int do_header
;
205 static int do_version
;
206 static int do_histogram
;
207 static int do_debugging
;
210 static int do_archive_index
;
211 static int is_32bit_elf
;
215 struct group_list
* next
;
216 unsigned int section_index
;
221 struct group_list
* root
;
222 unsigned int group_index
;
225 static size_t group_count
;
226 static struct group
* section_groups
;
227 static struct group
** section_headers_groups
;
230 /* Flag bits indicating particular types of dump. */
231 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
232 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
237 typedef unsigned char dump_type
;
239 /* A linked list of the section names for which dumps were requested. */
240 struct dump_list_entry
244 struct dump_list_entry
* next
;
246 static struct dump_list_entry
* dump_sects_byname
;
248 /* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250 static dump_type
* cmdline_dump_sects
= NULL
;
251 static unsigned int num_cmdline_dump_sects
= 0;
253 /* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
258 static dump_type
* dump_sects
= NULL
;
259 static unsigned int num_dump_sects
= 0;
262 /* How to print a vma value. */
263 typedef enum print_mode
277 #define SECTION_NAME(X) \
278 ((X) == NULL ? _("<none>") \
279 : string_table == NULL ? _("<no-name>") \
280 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
281 : string_table + (X)->sh_name))
283 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
285 #define GET_ELF_SYMBOLS(file, section, sym_count) \
286 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
287 : get_64bit_elf_symbols (file, section, sym_count))
289 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
290 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
291 already been called and verified that the string exists. */
292 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
294 #define REMOVE_ARCH_BITS(ADDR) \
297 if (elf_header.e_machine == EM_ARM) \
302 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
303 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
304 using malloc and fill that. In either case return the pointer to the start of
305 the retrieved data or NULL if something went wrong. If something does go wrong
306 emit an error message using REASON as part of the context. */
309 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
314 if (size
== 0 || nmemb
== 0)
317 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
319 error (_("Unable to seek to 0x%lx for %s\n"),
320 (unsigned long) archive_file_offset
+ offset
, reason
);
327 /* Check for overflow. */
328 if (nmemb
< (~(size_t) 0 - 1) / size
)
329 /* + 1 so that we can '\0' terminate invalid string table sections. */
330 mvar
= malloc (size
* nmemb
+ 1);
334 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
335 (unsigned long)(size
* nmemb
), reason
);
339 ((char *) mvar
)[size
* nmemb
] = '\0';
342 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
344 error (_("Unable to read in 0x%lx bytes of %s\n"),
345 (unsigned long)(size
* nmemb
), reason
);
354 /* Print a VMA value. */
357 print_vma (bfd_vma vma
, print_mode mode
)
370 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
377 return printf ("%5" BFD_VMA_FMT
"d", vma
);
385 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
388 return printf ("%" BFD_VMA_FMT
"d", vma
);
391 return printf ("%" BFD_VMA_FMT
"u", vma
);
396 /* Display a symbol on stdout. Handles the display of control characters and
397 multibye characters (assuming the host environment supports them).
399 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
401 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
402 padding as necessary.
404 Returns the number of emitted characters. */
407 print_symbol (int width
, const char *symbol
)
409 bfd_boolean extra_padding
= FALSE
;
411 #ifdef HAVE_MBSTATE_T
418 /* Keep the width positive. This also helps. */
420 extra_padding
= TRUE
;
424 /* Set the remaining width to a very large value.
425 This simplifies the code below. */
426 width_remaining
= INT_MAX
;
428 width_remaining
= width
;
430 #ifdef HAVE_MBSTATE_T
431 /* Initialise the multibyte conversion state. */
432 memset (& state
, 0, sizeof (state
));
435 while (width_remaining
)
438 const char c
= *symbol
++;
443 /* Do not print control characters directly as they can affect terminal
444 settings. Such characters usually appear in the names generated
445 by the assembler for local labels. */
448 if (width_remaining
< 2)
451 printf ("^%c", c
+ 0x40);
452 width_remaining
-= 2;
455 else if (ISPRINT (c
))
463 #ifdef HAVE_MBSTATE_T
466 /* Let printf do the hard work of displaying multibyte characters. */
467 printf ("%.1s", symbol
- 1);
471 #ifdef HAVE_MBSTATE_T
472 /* Try to find out how many bytes made up the character that was
473 just printed. Advance the symbol pointer past the bytes that
475 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
479 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
484 if (extra_padding
&& num_printed
< width
)
486 /* Fill in the remaining spaces. */
487 printf ("%-*s", width
- num_printed
, " ");
494 /* Return a pointer to section NAME, or NULL if no such section exists. */
496 static Elf_Internal_Shdr
*
497 find_section (const char * name
)
501 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
502 if (streq (SECTION_NAME (section_headers
+ i
), name
))
503 return section_headers
+ i
;
508 /* Return a pointer to a section containing ADDR, or NULL if no such
511 static Elf_Internal_Shdr
*
512 find_section_by_address (bfd_vma addr
)
516 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
518 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
519 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
526 /* Return a pointer to section NAME, or NULL if no such section exists,
527 restricted to the list of sections given in SET. */
529 static Elf_Internal_Shdr
*
530 find_section_in_set (const char * name
, unsigned int * set
)
536 while ((i
= *set
++) > 0)
537 if (streq (SECTION_NAME (section_headers
+ i
), name
))
538 return section_headers
+ i
;
541 return find_section (name
);
544 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
547 static inline unsigned long
548 read_uleb128 (unsigned char *data
,
549 unsigned int *length_return
,
550 const unsigned char * const end
)
552 return read_leb128 (data
, length_return
, FALSE
, end
);
555 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
556 This OS has so many departures from the ELF standard that we test it at
562 return elf_header
.e_machine
== EM_IA_64
563 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
566 /* Guess the relocation size commonly used by the specific machines. */
569 guess_is_rela (unsigned int e_machine
)
573 /* Targets that use REL relocations. */
588 /* Targets that use RELA relocations. */
592 case EM_ADAPTEVA_EPIPHANY
:
594 case EM_ALTERA_NIOS2
:
613 case EM_LATTICEMICO32
:
622 case EM_CYGNUS_MN10200
:
624 case EM_CYGNUS_MN10300
:
657 case EM_MICROBLAZE_OLD
:
678 warn (_("Don't know about relocations on this machine architecture\n"));
684 slurp_rela_relocs (FILE * file
,
685 unsigned long rel_offset
,
686 unsigned long rel_size
,
687 Elf_Internal_Rela
** relasp
,
688 unsigned long * nrelasp
)
690 Elf_Internal_Rela
* relas
;
691 unsigned long nrelas
;
696 Elf32_External_Rela
* erelas
;
698 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
699 rel_size
, _("32-bit relocation data"));
703 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
705 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
706 sizeof (Elf_Internal_Rela
));
711 error (_("out of memory parsing relocs\n"));
715 for (i
= 0; i
< nrelas
; i
++)
717 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
718 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
719 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
726 Elf64_External_Rela
* erelas
;
728 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
729 rel_size
, _("64-bit relocation data"));
733 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
735 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
736 sizeof (Elf_Internal_Rela
));
741 error (_("out of memory parsing relocs\n"));
745 for (i
= 0; i
< nrelas
; i
++)
747 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
748 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
749 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
751 /* The #ifdef BFD64 below is to prevent a compile time
752 warning. We know that if we do not have a 64 bit data
753 type that we will never execute this code anyway. */
755 if (elf_header
.e_machine
== EM_MIPS
756 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
758 /* In little-endian objects, r_info isn't really a
759 64-bit little-endian value: it has a 32-bit
760 little-endian symbol index followed by four
761 individual byte fields. Reorder INFO
763 bfd_vma inf
= relas
[i
].r_info
;
764 inf
= (((inf
& 0xffffffff) << 32)
765 | ((inf
>> 56) & 0xff)
766 | ((inf
>> 40) & 0xff00)
767 | ((inf
>> 24) & 0xff0000)
768 | ((inf
>> 8) & 0xff000000));
769 relas
[i
].r_info
= inf
;
782 slurp_rel_relocs (FILE * file
,
783 unsigned long rel_offset
,
784 unsigned long rel_size
,
785 Elf_Internal_Rela
** relsp
,
786 unsigned long * nrelsp
)
788 Elf_Internal_Rela
* rels
;
794 Elf32_External_Rel
* erels
;
796 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
797 rel_size
, _("32-bit relocation data"));
801 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
803 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
808 error (_("out of memory parsing relocs\n"));
812 for (i
= 0; i
< nrels
; i
++)
814 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
815 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
816 rels
[i
].r_addend
= 0;
823 Elf64_External_Rel
* erels
;
825 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
826 rel_size
, _("64-bit relocation data"));
830 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
832 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
837 error (_("out of memory parsing relocs\n"));
841 for (i
= 0; i
< nrels
; i
++)
843 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
844 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
845 rels
[i
].r_addend
= 0;
847 /* The #ifdef BFD64 below is to prevent a compile time
848 warning. We know that if we do not have a 64 bit data
849 type that we will never execute this code anyway. */
851 if (elf_header
.e_machine
== EM_MIPS
852 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
854 /* In little-endian objects, r_info isn't really a
855 64-bit little-endian value: it has a 32-bit
856 little-endian symbol index followed by four
857 individual byte fields. Reorder INFO
859 bfd_vma inf
= rels
[i
].r_info
;
860 inf
= (((inf
& 0xffffffff) << 32)
861 | ((inf
>> 56) & 0xff)
862 | ((inf
>> 40) & 0xff00)
863 | ((inf
>> 24) & 0xff0000)
864 | ((inf
>> 8) & 0xff000000));
865 rels
[i
].r_info
= inf
;
877 /* Returns the reloc type extracted from the reloc info field. */
880 get_reloc_type (bfd_vma reloc_info
)
883 return ELF32_R_TYPE (reloc_info
);
885 switch (elf_header
.e_machine
)
888 /* Note: We assume that reloc_info has already been adjusted for us. */
889 return ELF64_MIPS_R_TYPE (reloc_info
);
892 return ELF64_R_TYPE_ID (reloc_info
);
895 return ELF64_R_TYPE (reloc_info
);
899 /* Return the symbol index extracted from the reloc info field. */
902 get_reloc_symindex (bfd_vma reloc_info
)
904 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
907 static inline bfd_boolean
908 uses_msp430x_relocs (void)
911 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
912 /* GCC uses osabi == ELFOSBI_STANDALONE. */
913 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
914 /* TI compiler uses ELFOSABI_NONE. */
915 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
918 /* Display the contents of the relocation data found at the specified
922 dump_relocations (FILE * file
,
923 unsigned long rel_offset
,
924 unsigned long rel_size
,
925 Elf_Internal_Sym
* symtab
,
928 unsigned long strtablen
,
932 Elf_Internal_Rela
* rels
;
934 if (is_rela
== UNKNOWN
)
935 is_rela
= guess_is_rela (elf_header
.e_machine
);
939 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
944 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
953 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
955 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
960 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
962 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
970 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
972 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
977 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
979 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
983 for (i
= 0; i
< rel_size
; i
++)
988 bfd_vma symtab_index
;
991 offset
= rels
[i
].r_offset
;
992 inf
= rels
[i
].r_info
;
994 type
= get_reloc_type (inf
);
995 symtab_index
= get_reloc_symindex (inf
);
999 printf ("%8.8lx %8.8lx ",
1000 (unsigned long) offset
& 0xffffffff,
1001 (unsigned long) inf
& 0xffffffff);
1005 #if BFD_HOST_64BIT_LONG
1007 ? "%16.16lx %16.16lx "
1008 : "%12.12lx %12.12lx ",
1010 #elif BFD_HOST_64BIT_LONG_LONG
1013 ? "%16.16llx %16.16llx "
1014 : "%12.12llx %12.12llx ",
1018 ? "%16.16I64x %16.16I64x "
1019 : "%12.12I64x %12.12I64x ",
1024 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1025 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1026 _bfd_int64_high (offset
),
1027 _bfd_int64_low (offset
),
1028 _bfd_int64_high (inf
),
1029 _bfd_int64_low (inf
));
1033 switch (elf_header
.e_machine
)
1040 rtype
= elf_aarch64_reloc_type (type
);
1044 case EM_CYGNUS_M32R
:
1045 rtype
= elf_m32r_reloc_type (type
);
1050 rtype
= elf_i386_reloc_type (type
);
1055 rtype
= elf_m68hc11_reloc_type (type
);
1059 rtype
= elf_m68k_reloc_type (type
);
1063 rtype
= elf_i960_reloc_type (type
);
1068 rtype
= elf_avr_reloc_type (type
);
1071 case EM_OLD_SPARCV9
:
1072 case EM_SPARC32PLUS
:
1075 rtype
= elf_sparc_reloc_type (type
);
1079 rtype
= elf_spu_reloc_type (type
);
1083 rtype
= v800_reloc_type (type
);
1086 case EM_CYGNUS_V850
:
1087 rtype
= v850_reloc_type (type
);
1091 case EM_CYGNUS_D10V
:
1092 rtype
= elf_d10v_reloc_type (type
);
1096 case EM_CYGNUS_D30V
:
1097 rtype
= elf_d30v_reloc_type (type
);
1101 rtype
= elf_dlx_reloc_type (type
);
1105 rtype
= elf_sh_reloc_type (type
);
1109 case EM_CYGNUS_MN10300
:
1110 rtype
= elf_mn10300_reloc_type (type
);
1114 case EM_CYGNUS_MN10200
:
1115 rtype
= elf_mn10200_reloc_type (type
);
1119 case EM_CYGNUS_FR30
:
1120 rtype
= elf_fr30_reloc_type (type
);
1124 rtype
= elf_frv_reloc_type (type
);
1128 rtype
= elf_mcore_reloc_type (type
);
1132 rtype
= elf_mmix_reloc_type (type
);
1136 rtype
= elf_moxie_reloc_type (type
);
1140 if (uses_msp430x_relocs ())
1142 rtype
= elf_msp430x_reloc_type (type
);
1146 rtype
= elf_msp430_reloc_type (type
);
1150 rtype
= elf_nds32_reloc_type (type
);
1154 rtype
= elf_ppc_reloc_type (type
);
1158 rtype
= elf_ppc64_reloc_type (type
);
1162 case EM_MIPS_RS3_LE
:
1163 rtype
= elf_mips_reloc_type (type
);
1167 rtype
= elf_alpha_reloc_type (type
);
1171 rtype
= elf_arm_reloc_type (type
);
1175 rtype
= elf_arc_reloc_type (type
);
1179 rtype
= elf_hppa_reloc_type (type
);
1185 rtype
= elf_h8_reloc_type (type
);
1189 rtype
= elf_or1k_reloc_type (type
);
1194 rtype
= elf_pj_reloc_type (type
);
1197 rtype
= elf_ia64_reloc_type (type
);
1201 rtype
= elf_cris_reloc_type (type
);
1205 rtype
= elf_i860_reloc_type (type
);
1211 rtype
= elf_x86_64_reloc_type (type
);
1215 rtype
= i370_reloc_type (type
);
1220 rtype
= elf_s390_reloc_type (type
);
1224 rtype
= elf_score_reloc_type (type
);
1228 rtype
= elf_xstormy16_reloc_type (type
);
1232 rtype
= elf_crx_reloc_type (type
);
1236 rtype
= elf_vax_reloc_type (type
);
1239 case EM_ADAPTEVA_EPIPHANY
:
1240 rtype
= elf_epiphany_reloc_type (type
);
1245 rtype
= elf_ip2k_reloc_type (type
);
1249 rtype
= elf_iq2000_reloc_type (type
);
1254 rtype
= elf_xtensa_reloc_type (type
);
1257 case EM_LATTICEMICO32
:
1258 rtype
= elf_lm32_reloc_type (type
);
1263 rtype
= elf_m32c_reloc_type (type
);
1267 rtype
= elf_mt_reloc_type (type
);
1271 rtype
= elf_bfin_reloc_type (type
);
1275 rtype
= elf_mep_reloc_type (type
);
1279 rtype
= elf_cr16_reloc_type (type
);
1283 case EM_MICROBLAZE_OLD
:
1284 rtype
= elf_microblaze_reloc_type (type
);
1288 rtype
= elf_rl78_reloc_type (type
);
1292 rtype
= elf_rx_reloc_type (type
);
1296 rtype
= elf_metag_reloc_type (type
);
1301 rtype
= elf_xc16x_reloc_type (type
);
1305 rtype
= elf_tic6x_reloc_type (type
);
1309 rtype
= elf_tilegx_reloc_type (type
);
1313 rtype
= elf_tilepro_reloc_type (type
);
1317 rtype
= elf_xgate_reloc_type (type
);
1320 case EM_ALTERA_NIOS2
:
1321 rtype
= elf_nios2_reloc_type (type
);
1326 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1328 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1330 if (elf_header
.e_machine
== EM_ALPHA
1332 && streq (rtype
, "R_ALPHA_LITUSE")
1335 switch (rels
[i
].r_addend
)
1337 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1338 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1339 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1340 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1341 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1342 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1343 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1344 default: rtype
= NULL
;
1347 printf (" (%s)", rtype
);
1351 printf (_("<unknown addend: %lx>"),
1352 (unsigned long) rels
[i
].r_addend
);
1355 else if (symtab_index
)
1357 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1358 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1361 Elf_Internal_Sym
* psym
;
1363 psym
= symtab
+ symtab_index
;
1367 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1371 unsigned int width
= is_32bit_elf
? 8 : 14;
1373 /* Relocations against GNU_IFUNC symbols do not use the value
1374 of the symbol as the address to relocate against. Instead
1375 they invoke the function named by the symbol and use its
1376 result as the address for relocation.
1378 To indicate this to the user, do not display the value of
1379 the symbol in the "Symbols's Value" field. Instead show
1380 its name followed by () as a hint that the symbol is
1384 || psym
->st_name
== 0
1385 || psym
->st_name
>= strtablen
)
1388 name
= strtab
+ psym
->st_name
;
1390 len
= print_symbol (width
, name
);
1391 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1395 print_vma (psym
->st_value
, LONG_HEX
);
1397 printf (is_32bit_elf
? " " : " ");
1400 if (psym
->st_name
== 0)
1402 const char * sec_name
= "<null>";
1405 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1407 if (psym
->st_shndx
< elf_header
.e_shnum
)
1409 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1410 else if (psym
->st_shndx
== SHN_ABS
)
1412 else if (psym
->st_shndx
== SHN_COMMON
)
1413 sec_name
= "COMMON";
1414 else if ((elf_header
.e_machine
== EM_MIPS
1415 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1416 || (elf_header
.e_machine
== EM_TI_C6000
1417 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1418 sec_name
= "SCOMMON";
1419 else if (elf_header
.e_machine
== EM_MIPS
1420 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1421 sec_name
= "SUNDEF";
1422 else if ((elf_header
.e_machine
== EM_X86_64
1423 || elf_header
.e_machine
== EM_L1OM
1424 || elf_header
.e_machine
== EM_K1OM
)
1425 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1426 sec_name
= "LARGE_COMMON";
1427 else if (elf_header
.e_machine
== EM_IA_64
1428 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1429 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1430 sec_name
= "ANSI_COM";
1431 else if (is_ia64_vms ()
1432 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1433 sec_name
= "VMS_SYMVEC";
1436 sprintf (name_buf
, "<section 0x%x>",
1437 (unsigned int) psym
->st_shndx
);
1438 sec_name
= name_buf
;
1441 print_symbol (22, sec_name
);
1443 else if (strtab
== NULL
)
1444 printf (_("<string table index: %3ld>"), psym
->st_name
);
1445 else if (psym
->st_name
>= strtablen
)
1446 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1448 print_symbol (22, strtab
+ psym
->st_name
);
1452 bfd_signed_vma off
= rels
[i
].r_addend
;
1455 printf (" - %" BFD_VMA_FMT
"x", - off
);
1457 printf (" + %" BFD_VMA_FMT
"x", off
);
1463 bfd_signed_vma off
= rels
[i
].r_addend
;
1465 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1467 printf ("-%" BFD_VMA_FMT
"x", - off
);
1469 printf ("%" BFD_VMA_FMT
"x", off
);
1472 if (elf_header
.e_machine
== EM_SPARCV9
1474 && streq (rtype
, "R_SPARC_OLO10"))
1475 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1480 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1482 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1483 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1484 const char * rtype2
= elf_mips_reloc_type (type2
);
1485 const char * rtype3
= elf_mips_reloc_type (type3
);
1487 printf (" Type2: ");
1490 printf (_("unrecognized: %-7lx"),
1491 (unsigned long) type2
& 0xffffffff);
1493 printf ("%-17.17s", rtype2
);
1495 printf ("\n Type3: ");
1498 printf (_("unrecognized: %-7lx"),
1499 (unsigned long) type3
& 0xffffffff);
1501 printf ("%-17.17s", rtype3
);
1512 get_mips_dynamic_type (unsigned long type
)
1516 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1517 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1518 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1519 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1520 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1521 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1522 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1523 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1524 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1525 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1526 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1527 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1528 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1529 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1530 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1531 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1532 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1533 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1534 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1535 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1536 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1537 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1538 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1539 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1540 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1541 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1542 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1543 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1544 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1545 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1546 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1547 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1548 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1549 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1550 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1551 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1552 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1553 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1554 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1555 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1556 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1557 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1558 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1559 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1560 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1567 get_sparc64_dynamic_type (unsigned long type
)
1571 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1578 get_ppc_dynamic_type (unsigned long type
)
1582 case DT_PPC_GOT
: return "PPC_GOT";
1583 case DT_PPC_OPT
: return "PPC_OPT";
1590 get_ppc64_dynamic_type (unsigned long type
)
1594 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1595 case DT_PPC64_OPD
: return "PPC64_OPD";
1596 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1597 case DT_PPC64_OPT
: return "PPC64_OPT";
1604 get_parisc_dynamic_type (unsigned long type
)
1608 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1609 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1610 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1611 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1612 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1613 case DT_HP_PREINIT
: return "HP_PREINIT";
1614 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1615 case DT_HP_NEEDED
: return "HP_NEEDED";
1616 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1617 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1618 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1619 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1620 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1621 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1622 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1623 case DT_HP_FILTERED
: return "HP_FILTERED";
1624 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1625 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1626 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1627 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1628 case DT_PLT
: return "PLT";
1629 case DT_PLT_SIZE
: return "PLT_SIZE";
1630 case DT_DLT
: return "DLT";
1631 case DT_DLT_SIZE
: return "DLT_SIZE";
1638 get_ia64_dynamic_type (unsigned long type
)
1642 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1643 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1644 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1645 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1646 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1647 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1648 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1649 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1650 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1651 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1652 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1653 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1654 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1655 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1656 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1657 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1658 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1659 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1660 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1661 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1662 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1663 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1664 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1665 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1666 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1667 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1668 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1669 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1670 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1671 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1672 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1679 get_alpha_dynamic_type (unsigned long type
)
1683 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1690 get_score_dynamic_type (unsigned long type
)
1694 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1695 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1696 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1697 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1698 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1699 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1706 get_tic6x_dynamic_type (unsigned long type
)
1710 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1711 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1712 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1713 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1714 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1715 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1722 get_nios2_dynamic_type (unsigned long type
)
1726 case DT_NIOS2_GP
: return "NIOS2_GP";
1733 get_dynamic_type (unsigned long type
)
1735 static char buff
[64];
1739 case DT_NULL
: return "NULL";
1740 case DT_NEEDED
: return "NEEDED";
1741 case DT_PLTRELSZ
: return "PLTRELSZ";
1742 case DT_PLTGOT
: return "PLTGOT";
1743 case DT_HASH
: return "HASH";
1744 case DT_STRTAB
: return "STRTAB";
1745 case DT_SYMTAB
: return "SYMTAB";
1746 case DT_RELA
: return "RELA";
1747 case DT_RELASZ
: return "RELASZ";
1748 case DT_RELAENT
: return "RELAENT";
1749 case DT_STRSZ
: return "STRSZ";
1750 case DT_SYMENT
: return "SYMENT";
1751 case DT_INIT
: return "INIT";
1752 case DT_FINI
: return "FINI";
1753 case DT_SONAME
: return "SONAME";
1754 case DT_RPATH
: return "RPATH";
1755 case DT_SYMBOLIC
: return "SYMBOLIC";
1756 case DT_REL
: return "REL";
1757 case DT_RELSZ
: return "RELSZ";
1758 case DT_RELENT
: return "RELENT";
1759 case DT_PLTREL
: return "PLTREL";
1760 case DT_DEBUG
: return "DEBUG";
1761 case DT_TEXTREL
: return "TEXTREL";
1762 case DT_JMPREL
: return "JMPREL";
1763 case DT_BIND_NOW
: return "BIND_NOW";
1764 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1765 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1766 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1767 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1768 case DT_RUNPATH
: return "RUNPATH";
1769 case DT_FLAGS
: return "FLAGS";
1771 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1772 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1774 case DT_CHECKSUM
: return "CHECKSUM";
1775 case DT_PLTPADSZ
: return "PLTPADSZ";
1776 case DT_MOVEENT
: return "MOVEENT";
1777 case DT_MOVESZ
: return "MOVESZ";
1778 case DT_FEATURE
: return "FEATURE";
1779 case DT_POSFLAG_1
: return "POSFLAG_1";
1780 case DT_SYMINSZ
: return "SYMINSZ";
1781 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1783 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1784 case DT_CONFIG
: return "CONFIG";
1785 case DT_DEPAUDIT
: return "DEPAUDIT";
1786 case DT_AUDIT
: return "AUDIT";
1787 case DT_PLTPAD
: return "PLTPAD";
1788 case DT_MOVETAB
: return "MOVETAB";
1789 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1791 case DT_VERSYM
: return "VERSYM";
1793 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1794 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1795 case DT_RELACOUNT
: return "RELACOUNT";
1796 case DT_RELCOUNT
: return "RELCOUNT";
1797 case DT_FLAGS_1
: return "FLAGS_1";
1798 case DT_VERDEF
: return "VERDEF";
1799 case DT_VERDEFNUM
: return "VERDEFNUM";
1800 case DT_VERNEED
: return "VERNEED";
1801 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1803 case DT_AUXILIARY
: return "AUXILIARY";
1804 case DT_USED
: return "USED";
1805 case DT_FILTER
: return "FILTER";
1807 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1808 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1809 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1810 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1811 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1812 case DT_GNU_HASH
: return "GNU_HASH";
1815 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1817 const char * result
;
1819 switch (elf_header
.e_machine
)
1822 case EM_MIPS_RS3_LE
:
1823 result
= get_mips_dynamic_type (type
);
1826 result
= get_sparc64_dynamic_type (type
);
1829 result
= get_ppc_dynamic_type (type
);
1832 result
= get_ppc64_dynamic_type (type
);
1835 result
= get_ia64_dynamic_type (type
);
1838 result
= get_alpha_dynamic_type (type
);
1841 result
= get_score_dynamic_type (type
);
1844 result
= get_tic6x_dynamic_type (type
);
1846 case EM_ALTERA_NIOS2
:
1847 result
= get_nios2_dynamic_type (type
);
1857 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1859 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1860 || (elf_header
.e_machine
== EM_PARISC
1861 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1863 const char * result
;
1865 switch (elf_header
.e_machine
)
1868 result
= get_parisc_dynamic_type (type
);
1871 result
= get_ia64_dynamic_type (type
);
1881 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1885 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1892 get_file_type (unsigned e_type
)
1894 static char buff
[32];
1898 case ET_NONE
: return _("NONE (None)");
1899 case ET_REL
: return _("REL (Relocatable file)");
1900 case ET_EXEC
: return _("EXEC (Executable file)");
1901 case ET_DYN
: return _("DYN (Shared object file)");
1902 case ET_CORE
: return _("CORE (Core file)");
1905 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1906 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1907 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1908 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1910 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1916 get_machine_name (unsigned e_machine
)
1918 static char buff
[64]; /* XXX */
1922 case EM_NONE
: return _("None");
1923 case EM_AARCH64
: return "AArch64";
1924 case EM_M32
: return "WE32100";
1925 case EM_SPARC
: return "Sparc";
1926 case EM_SPU
: return "SPU";
1927 case EM_386
: return "Intel 80386";
1928 case EM_68K
: return "MC68000";
1929 case EM_88K
: return "MC88000";
1930 case EM_486
: return "Intel 80486";
1931 case EM_860
: return "Intel 80860";
1932 case EM_MIPS
: return "MIPS R3000";
1933 case EM_S370
: return "IBM System/370";
1934 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1935 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1936 case EM_PARISC
: return "HPPA";
1937 case EM_PPC_OLD
: return "Power PC (old)";
1938 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1939 case EM_960
: return "Intel 90860";
1940 case EM_PPC
: return "PowerPC";
1941 case EM_PPC64
: return "PowerPC64";
1942 case EM_FR20
: return "Fujitsu FR20";
1943 case EM_RH32
: return "TRW RH32";
1944 case EM_MCORE
: return "MCORE";
1945 case EM_ARM
: return "ARM";
1946 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1947 case EM_SH
: return "Renesas / SuperH SH";
1948 case EM_SPARCV9
: return "Sparc v9";
1949 case EM_TRICORE
: return "Siemens Tricore";
1950 case EM_ARC
: return "ARC";
1951 case EM_H8_300
: return "Renesas H8/300";
1952 case EM_H8_300H
: return "Renesas H8/300H";
1953 case EM_H8S
: return "Renesas H8S";
1954 case EM_H8_500
: return "Renesas H8/500";
1955 case EM_IA_64
: return "Intel IA-64";
1956 case EM_MIPS_X
: return "Stanford MIPS-X";
1957 case EM_COLDFIRE
: return "Motorola Coldfire";
1958 case EM_ALPHA
: return "Alpha";
1959 case EM_CYGNUS_D10V
:
1960 case EM_D10V
: return "d10v";
1961 case EM_CYGNUS_D30V
:
1962 case EM_D30V
: return "d30v";
1963 case EM_CYGNUS_M32R
:
1964 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1965 case EM_CYGNUS_V850
:
1966 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1967 case EM_V850
: return "Renesas V850";
1968 case EM_CYGNUS_MN10300
:
1969 case EM_MN10300
: return "mn10300";
1970 case EM_CYGNUS_MN10200
:
1971 case EM_MN10200
: return "mn10200";
1972 case EM_MOXIE
: return "Moxie";
1973 case EM_CYGNUS_FR30
:
1974 case EM_FR30
: return "Fujitsu FR30";
1975 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1977 case EM_PJ
: return "picoJava";
1978 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1979 case EM_PCP
: return "Siemens PCP";
1980 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1981 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1982 case EM_STARCORE
: return "Motorola Star*Core processor";
1983 case EM_ME16
: return "Toyota ME16 processor";
1984 case EM_ST100
: return "STMicroelectronics ST100 processor";
1985 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1986 case EM_PDSP
: return "Sony DSP processor";
1987 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1988 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1989 case EM_FX66
: return "Siemens FX66 microcontroller";
1990 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1991 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1992 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1993 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1994 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1995 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1996 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1997 case EM_SVX
: return "Silicon Graphics SVx";
1998 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1999 case EM_VAX
: return "Digital VAX";
2001 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2002 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2003 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2004 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2005 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2006 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2007 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2008 case EM_PRISM
: return "Vitesse Prism";
2009 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2010 case EM_L1OM
: return "Intel L1OM";
2011 case EM_K1OM
: return "Intel K1OM";
2013 case EM_S390
: return "IBM S/390";
2014 case EM_SCORE
: return "SUNPLUS S+Core";
2015 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2016 case EM_OR1K
: return "OpenRISC 1000";
2017 case EM_ARC_A5
: return "ARC International ARCompact processor";
2018 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2019 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2020 case EM_DLX
: return "OpenDLX";
2022 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2023 case EM_IQ2000
: return "Vitesse IQ2000";
2025 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2026 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2027 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2028 case EM_NS32K
: return "National Semiconductor 32000 series";
2029 case EM_TPC
: return "Tenor Network TPC processor";
2030 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2031 case EM_MAX
: return "MAX Processor";
2032 case EM_CR
: return "National Semiconductor CompactRISC";
2033 case EM_F2MC16
: return "Fujitsu F2MC16";
2034 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2035 case EM_LATTICEMICO32
: return "Lattice Mico32";
2037 case EM_M32C
: return "Renesas M32c";
2038 case EM_MT
: return "Morpho Techologies MT processor";
2039 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2040 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2041 case EM_SEP
: return "Sharp embedded microprocessor";
2042 case EM_ARCA
: return "Arca RISC microprocessor";
2043 case EM_UNICORE
: return "Unicore";
2044 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2045 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2046 case EM_NIOS32
: return "Altera Nios";
2047 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2049 case EM_XC16X
: return "Infineon Technologies xc16x";
2050 case EM_M16C
: return "Renesas M16C series microprocessors";
2051 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2052 case EM_CE
: return "Freescale Communication Engine RISC core";
2053 case EM_TSK3000
: return "Altium TSK3000 core";
2054 case EM_RS08
: return "Freescale RS08 embedded processor";
2055 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2056 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2057 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2058 case EM_SE_C17
: return "Seiko Epson C17 family";
2059 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2060 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2061 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2062 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2063 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2064 case EM_R32C
: return "Renesas R32C series microprocessors";
2065 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2066 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2067 case EM_8051
: return "Intel 8051 and variants";
2068 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2069 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2070 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2071 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2072 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2073 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2074 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2075 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2078 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2079 case EM_RL78
: return "Renesas RL78";
2080 case EM_RX
: return "Renesas RX";
2081 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2082 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2083 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2084 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2085 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2086 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2087 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2088 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2089 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2090 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2091 case EM_CUDA
: return "NVIDIA CUDA architecture";
2092 case EM_XGATE
: return "Motorola XGATE embedded processor";
2094 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2100 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2105 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2106 e_flags
&= ~ EF_ARM_EABIMASK
;
2108 /* Handle "generic" ARM flags. */
2109 if (e_flags
& EF_ARM_RELEXEC
)
2111 strcat (buf
, ", relocatable executable");
2112 e_flags
&= ~ EF_ARM_RELEXEC
;
2115 if (e_flags
& EF_ARM_HASENTRY
)
2117 strcat (buf
, ", has entry point");
2118 e_flags
&= ~ EF_ARM_HASENTRY
;
2121 /* Now handle EABI specific flags. */
2125 strcat (buf
, ", <unrecognized EABI>");
2130 case EF_ARM_EABI_VER1
:
2131 strcat (buf
, ", Version1 EABI");
2136 /* Process flags one bit at a time. */
2137 flag
= e_flags
& - e_flags
;
2142 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2143 strcat (buf
, ", sorted symbol tables");
2153 case EF_ARM_EABI_VER2
:
2154 strcat (buf
, ", Version2 EABI");
2159 /* Process flags one bit at a time. */
2160 flag
= e_flags
& - e_flags
;
2165 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2166 strcat (buf
, ", sorted symbol tables");
2169 case EF_ARM_DYNSYMSUSESEGIDX
:
2170 strcat (buf
, ", dynamic symbols use segment index");
2173 case EF_ARM_MAPSYMSFIRST
:
2174 strcat (buf
, ", mapping symbols precede others");
2184 case EF_ARM_EABI_VER3
:
2185 strcat (buf
, ", Version3 EABI");
2188 case EF_ARM_EABI_VER4
:
2189 strcat (buf
, ", Version4 EABI");
2194 /* Process flags one bit at a time. */
2195 flag
= e_flags
& - e_flags
;
2201 strcat (buf
, ", BE8");
2205 strcat (buf
, ", LE8");
2216 case EF_ARM_EABI_VER5
:
2217 strcat (buf
, ", Version5 EABI");
2222 /* Process flags one bit at a time. */
2223 flag
= e_flags
& - e_flags
;
2229 strcat (buf
, ", BE8");
2233 strcat (buf
, ", LE8");
2236 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2237 strcat (buf
, ", soft-float ABI");
2240 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2241 strcat (buf
, ", hard-float ABI");
2251 case EF_ARM_EABI_UNKNOWN
:
2252 strcat (buf
, ", GNU EABI");
2257 /* Process flags one bit at a time. */
2258 flag
= e_flags
& - e_flags
;
2263 case EF_ARM_INTERWORK
:
2264 strcat (buf
, ", interworking enabled");
2267 case EF_ARM_APCS_26
:
2268 strcat (buf
, ", uses APCS/26");
2271 case EF_ARM_APCS_FLOAT
:
2272 strcat (buf
, ", uses APCS/float");
2276 strcat (buf
, ", position independent");
2280 strcat (buf
, ", 8 bit structure alignment");
2283 case EF_ARM_NEW_ABI
:
2284 strcat (buf
, ", uses new ABI");
2287 case EF_ARM_OLD_ABI
:
2288 strcat (buf
, ", uses old ABI");
2291 case EF_ARM_SOFT_FLOAT
:
2292 strcat (buf
, ", software FP");
2295 case EF_ARM_VFP_FLOAT
:
2296 strcat (buf
, ", VFP");
2299 case EF_ARM_MAVERICK_FLOAT
:
2300 strcat (buf
, ", Maverick FP");
2311 strcat (buf
,_(", <unknown>"));
2315 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2324 static const char *ABI_STRINGS
[] =
2326 "ABI v0", /* use r5 as return register; only used in N1213HC */
2327 "ABI v1", /* use r0 as return register */
2328 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2329 "ABI v2fp", /* for FPU */
2333 static const char *VER_STRINGS
[] =
2335 "Andes ELF V1.3 or older",
2339 static const char *ARCH_STRINGS
[] =
2348 abi
= EF_NDS_ABI
& e_flags
;
2349 arch
= EF_NDS_ARCH
& e_flags
;
2350 config
= EF_NDS_INST
& e_flags
;
2351 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2353 memset (buf
, 0, size
);
2360 case E_NDS_ABI_V2FP
:
2361 case E_NDS_ABI_AABI
:
2362 case E_NDS_ABI_V2FP_PLUS
:
2363 /* In case there are holes in the array. */
2364 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2368 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2374 case E_NDS32_ELF_VER_1_2
:
2375 case E_NDS32_ELF_VER_1_3
:
2376 case E_NDS32_ELF_VER_1_4
:
2377 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2381 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2385 if (E_NDS_ABI_V0
== abi
)
2387 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2388 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2389 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2390 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2396 case E_NDS_ARCH_STAR_V1_0
:
2397 case E_NDS_ARCH_STAR_V2_0
:
2398 case E_NDS_ARCH_STAR_V3_0
:
2399 case E_NDS_ARCH_STAR_V3_M
:
2400 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2404 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2405 /* ARCH version determines how the e_flags are interpreted.
2406 If it is unknown, we cannot proceed. */
2410 /* Newer ABI; Now handle architecture specific flags. */
2411 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2413 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2414 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2416 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2417 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2419 if (config
& E_NDS32_HAS_DIV_INST
)
2420 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2422 if (config
& E_NDS32_HAS_16BIT_INST
)
2423 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2427 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2429 if (version
<= E_NDS32_ELF_VER_1_3
)
2430 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2432 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2435 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2436 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2438 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2439 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2441 if (config
& E_NDS32_HAS_16BIT_INST
)
2443 if (version
<= E_NDS32_ELF_VER_1_3
)
2444 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2446 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2450 if (config
& E_NDS32_HAS_EXT_INST
)
2451 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2453 if (config
& E_NDS32_HAS_EXT2_INST
)
2454 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2456 if (config
& E_NDS32_HAS_FPU_INST
)
2459 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2462 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2465 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2468 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2471 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2476 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2478 case E_NDS32_FPU_REG_8SP_4DP
:
2479 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2481 case E_NDS32_FPU_REG_16SP_8DP
:
2482 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2484 case E_NDS32_FPU_REG_32SP_16DP
:
2485 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2487 case E_NDS32_FPU_REG_32SP_32DP
:
2488 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2493 if (config
& E_NDS32_HAS_AUDIO_INST
)
2494 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2496 if (config
& E_NDS32_HAS_STRING_INST
)
2497 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2499 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2500 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2502 if (config
& E_NDS32_HAS_VIDEO_INST
)
2504 if (version
<= E_NDS32_ELF_VER_1_3
)
2505 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2507 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2510 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2511 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2513 if (config
& E_NDS32_HAS_L2C_INST
)
2514 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2518 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2520 static char buf
[1024];
2532 decode_ARM_machine_flags (e_flags
, buf
);
2536 if (e_flags
& EF_BFIN_PIC
)
2537 strcat (buf
, ", PIC");
2539 if (e_flags
& EF_BFIN_FDPIC
)
2540 strcat (buf
, ", FDPIC");
2542 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2543 strcat (buf
, ", code in L1");
2545 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2546 strcat (buf
, ", data in L1");
2551 switch (e_flags
& EF_FRV_CPU_MASK
)
2553 case EF_FRV_CPU_GENERIC
:
2557 strcat (buf
, ", fr???");
2560 case EF_FRV_CPU_FR300
:
2561 strcat (buf
, ", fr300");
2564 case EF_FRV_CPU_FR400
:
2565 strcat (buf
, ", fr400");
2567 case EF_FRV_CPU_FR405
:
2568 strcat (buf
, ", fr405");
2571 case EF_FRV_CPU_FR450
:
2572 strcat (buf
, ", fr450");
2575 case EF_FRV_CPU_FR500
:
2576 strcat (buf
, ", fr500");
2578 case EF_FRV_CPU_FR550
:
2579 strcat (buf
, ", fr550");
2582 case EF_FRV_CPU_SIMPLE
:
2583 strcat (buf
, ", simple");
2585 case EF_FRV_CPU_TOMCAT
:
2586 strcat (buf
, ", tomcat");
2592 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2593 strcat (buf
, ", m68000");
2594 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2595 strcat (buf
, ", cpu32");
2596 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2597 strcat (buf
, ", fido_a");
2600 char const * isa
= _("unknown");
2601 char const * mac
= _("unknown mac");
2602 char const * additional
= NULL
;
2604 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2606 case EF_M68K_CF_ISA_A_NODIV
:
2608 additional
= ", nodiv";
2610 case EF_M68K_CF_ISA_A
:
2613 case EF_M68K_CF_ISA_A_PLUS
:
2616 case EF_M68K_CF_ISA_B_NOUSP
:
2618 additional
= ", nousp";
2620 case EF_M68K_CF_ISA_B
:
2623 case EF_M68K_CF_ISA_C
:
2626 case EF_M68K_CF_ISA_C_NODIV
:
2628 additional
= ", nodiv";
2631 strcat (buf
, ", cf, isa ");
2634 strcat (buf
, additional
);
2635 if (e_flags
& EF_M68K_CF_FLOAT
)
2636 strcat (buf
, ", float");
2637 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2642 case EF_M68K_CF_MAC
:
2645 case EF_M68K_CF_EMAC
:
2648 case EF_M68K_CF_EMAC_B
:
2661 if (e_flags
& EF_PPC_EMB
)
2662 strcat (buf
, ", emb");
2664 if (e_flags
& EF_PPC_RELOCATABLE
)
2665 strcat (buf
, _(", relocatable"));
2667 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2668 strcat (buf
, _(", relocatable-lib"));
2672 if (e_flags
& EF_PPC64_ABI
)
2674 char abi
[] = ", abiv0";
2676 abi
[6] += e_flags
& EF_PPC64_ABI
;
2682 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2683 strcat (buf
, ", RH850 ABI");
2685 if (e_flags
& EF_V800_850E3
)
2686 strcat (buf
, ", V3 architecture");
2688 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2689 strcat (buf
, ", FPU not used");
2691 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2692 strcat (buf
, ", regmode: COMMON");
2694 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2695 strcat (buf
, ", r4 not used");
2697 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2698 strcat (buf
, ", r30 not used");
2700 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2701 strcat (buf
, ", r5 not used");
2703 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2704 strcat (buf
, ", r2 not used");
2706 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2708 switch (e_flags
& - e_flags
)
2710 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2711 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2712 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2713 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2714 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2715 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2716 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2717 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2718 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2719 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2720 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2721 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2722 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2723 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2724 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2725 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2732 case EM_CYGNUS_V850
:
2733 switch (e_flags
& EF_V850_ARCH
)
2735 case E_V850E3V5_ARCH
:
2736 strcat (buf
, ", v850e3v5");
2738 case E_V850E2V3_ARCH
:
2739 strcat (buf
, ", v850e2v3");
2742 strcat (buf
, ", v850e2");
2745 strcat (buf
, ", v850e1");
2748 strcat (buf
, ", v850e");
2751 strcat (buf
, ", v850");
2754 strcat (buf
, _(", unknown v850 architecture variant"));
2760 case EM_CYGNUS_M32R
:
2761 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2762 strcat (buf
, ", m32r");
2766 case EM_MIPS_RS3_LE
:
2767 if (e_flags
& EF_MIPS_NOREORDER
)
2768 strcat (buf
, ", noreorder");
2770 if (e_flags
& EF_MIPS_PIC
)
2771 strcat (buf
, ", pic");
2773 if (e_flags
& EF_MIPS_CPIC
)
2774 strcat (buf
, ", cpic");
2776 if (e_flags
& EF_MIPS_UCODE
)
2777 strcat (buf
, ", ugen_reserved");
2779 if (e_flags
& EF_MIPS_ABI2
)
2780 strcat (buf
, ", abi2");
2782 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2783 strcat (buf
, ", odk first");
2785 if (e_flags
& EF_MIPS_32BITMODE
)
2786 strcat (buf
, ", 32bitmode");
2788 if (e_flags
& EF_MIPS_NAN2008
)
2789 strcat (buf
, ", nan2008");
2791 if (e_flags
& EF_MIPS_FP64
)
2792 strcat (buf
, ", fp64");
2794 switch ((e_flags
& EF_MIPS_MACH
))
2796 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2797 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2798 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2799 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2800 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2801 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2802 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2803 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2804 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2805 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2806 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2807 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2808 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2809 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2810 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2811 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2812 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2814 /* We simply ignore the field in this case to avoid confusion:
2815 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2818 default: strcat (buf
, _(", unknown CPU")); break;
2821 switch ((e_flags
& EF_MIPS_ABI
))
2823 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2824 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2825 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2826 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2828 /* We simply ignore the field in this case to avoid confusion:
2829 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2830 This means it is likely to be an o32 file, but not for
2833 default: strcat (buf
, _(", unknown ABI")); break;
2836 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2837 strcat (buf
, ", mdmx");
2839 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2840 strcat (buf
, ", mips16");
2842 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2843 strcat (buf
, ", micromips");
2845 switch ((e_flags
& EF_MIPS_ARCH
))
2847 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2848 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2849 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2850 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2851 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2852 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2853 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2854 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
2855 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2856 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2857 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
2858 default: strcat (buf
, _(", unknown ISA")); break;
2863 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2867 switch ((e_flags
& EF_SH_MACH_MASK
))
2869 case EF_SH1
: strcat (buf
, ", sh1"); break;
2870 case EF_SH2
: strcat (buf
, ", sh2"); break;
2871 case EF_SH3
: strcat (buf
, ", sh3"); break;
2872 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2873 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2874 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2875 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2876 case EF_SH4
: strcat (buf
, ", sh4"); break;
2877 case EF_SH5
: strcat (buf
, ", sh5"); break;
2878 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2879 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2880 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2881 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2882 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2883 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2884 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2885 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2886 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2887 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2888 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2889 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2890 default: strcat (buf
, _(", unknown ISA")); break;
2893 if (e_flags
& EF_SH_PIC
)
2894 strcat (buf
, ", pic");
2896 if (e_flags
& EF_SH_FDPIC
)
2897 strcat (buf
, ", fdpic");
2901 if (e_flags
& EF_OR1K_NODELAY
)
2902 strcat (buf
, ", no delay");
2906 if (e_flags
& EF_SPARC_32PLUS
)
2907 strcat (buf
, ", v8+");
2909 if (e_flags
& EF_SPARC_SUN_US1
)
2910 strcat (buf
, ", ultrasparcI");
2912 if (e_flags
& EF_SPARC_SUN_US3
)
2913 strcat (buf
, ", ultrasparcIII");
2915 if (e_flags
& EF_SPARC_HAL_R1
)
2916 strcat (buf
, ", halr1");
2918 if (e_flags
& EF_SPARC_LEDATA
)
2919 strcat (buf
, ", ledata");
2921 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2922 strcat (buf
, ", tso");
2924 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2925 strcat (buf
, ", pso");
2927 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2928 strcat (buf
, ", rmo");
2932 switch (e_flags
& EF_PARISC_ARCH
)
2934 case EFA_PARISC_1_0
:
2935 strcpy (buf
, ", PA-RISC 1.0");
2937 case EFA_PARISC_1_1
:
2938 strcpy (buf
, ", PA-RISC 1.1");
2940 case EFA_PARISC_2_0
:
2941 strcpy (buf
, ", PA-RISC 2.0");
2946 if (e_flags
& EF_PARISC_TRAPNIL
)
2947 strcat (buf
, ", trapnil");
2948 if (e_flags
& EF_PARISC_EXT
)
2949 strcat (buf
, ", ext");
2950 if (e_flags
& EF_PARISC_LSB
)
2951 strcat (buf
, ", lsb");
2952 if (e_flags
& EF_PARISC_WIDE
)
2953 strcat (buf
, ", wide");
2954 if (e_flags
& EF_PARISC_NO_KABP
)
2955 strcat (buf
, ", no kabp");
2956 if (e_flags
& EF_PARISC_LAZYSWAP
)
2957 strcat (buf
, ", lazyswap");
2962 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2963 strcat (buf
, ", new calling convention");
2965 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2966 strcat (buf
, ", gnu calling convention");
2970 if ((e_flags
& EF_IA_64_ABI64
))
2971 strcat (buf
, ", 64-bit");
2973 strcat (buf
, ", 32-bit");
2974 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2975 strcat (buf
, ", reduced fp model");
2976 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2977 strcat (buf
, ", no function descriptors, constant gp");
2978 else if ((e_flags
& EF_IA_64_CONS_GP
))
2979 strcat (buf
, ", constant gp");
2980 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2981 strcat (buf
, ", absolute");
2982 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2984 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2985 strcat (buf
, ", vms_linkages");
2986 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2988 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2990 case EF_IA_64_VMS_COMCOD_WARNING
:
2991 strcat (buf
, ", warning");
2993 case EF_IA_64_VMS_COMCOD_ERROR
:
2994 strcat (buf
, ", error");
2996 case EF_IA_64_VMS_COMCOD_ABORT
:
2997 strcat (buf
, ", abort");
3006 if ((e_flags
& EF_VAX_NONPIC
))
3007 strcat (buf
, ", non-PIC");
3008 if ((e_flags
& EF_VAX_DFLOAT
))
3009 strcat (buf
, ", D-Float");
3010 if ((e_flags
& EF_VAX_GFLOAT
))
3011 strcat (buf
, ", G-Float");
3015 if (e_flags
& E_FLAG_RL78_G10
)
3016 strcat (buf
, ", G10");
3017 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3018 strcat (buf
, ", 64-bit doubles");
3022 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3023 strcat (buf
, ", 64-bit doubles");
3024 if (e_flags
& E_FLAG_RX_DSP
)
3025 strcat (buf
, ", dsp");
3026 if (e_flags
& E_FLAG_RX_PID
)
3027 strcat (buf
, ", pid");
3028 if (e_flags
& E_FLAG_RX_ABI
)
3029 strcat (buf
, ", RX ABI");
3033 if (e_flags
& EF_S390_HIGH_GPRS
)
3034 strcat (buf
, ", highgprs");
3038 if ((e_flags
& EF_C6000_REL
))
3039 strcat (buf
, ", relocatable module");
3043 strcat (buf
, _(": architecture variant: "));
3044 switch (e_flags
& EF_MSP430_MACH
)
3046 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3047 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3048 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3049 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3050 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3051 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3052 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3053 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3054 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3055 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3056 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3057 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3058 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3059 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3060 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3062 strcat (buf
, _(": unknown")); break;
3065 if (e_flags
& ~ EF_MSP430_MACH
)
3066 strcat (buf
, _(": unknown extra flag bits also present"));
3074 get_osabi_name (unsigned int osabi
)
3076 static char buff
[32];
3080 case ELFOSABI_NONE
: return "UNIX - System V";
3081 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3082 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3083 case ELFOSABI_GNU
: return "UNIX - GNU";
3084 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3085 case ELFOSABI_AIX
: return "UNIX - AIX";
3086 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3087 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3088 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3089 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3090 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3091 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3092 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3093 case ELFOSABI_AROS
: return "AROS";
3094 case ELFOSABI_FENIXOS
: return "FenixOS";
3097 switch (elf_header
.e_machine
)
3102 case ELFOSABI_ARM
: return "ARM";
3112 case ELFOSABI_STANDALONE
: return _("Standalone App");
3121 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3122 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3131 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3137 get_aarch64_segment_type (unsigned long type
)
3141 case PT_AARCH64_ARCHEXT
:
3142 return "AARCH64_ARCHEXT";
3151 get_arm_segment_type (unsigned long type
)
3165 get_mips_segment_type (unsigned long type
)
3169 case PT_MIPS_REGINFO
:
3171 case PT_MIPS_RTPROC
:
3173 case PT_MIPS_OPTIONS
:
3175 case PT_MIPS_ABIFLAGS
:
3185 get_parisc_segment_type (unsigned long type
)
3189 case PT_HP_TLS
: return "HP_TLS";
3190 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3191 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3192 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3193 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3194 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3195 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3196 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3197 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3198 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3199 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3200 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3201 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3202 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3203 case PT_HP_STACK
: return "HP_STACK";
3204 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3205 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3206 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3207 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3216 get_ia64_segment_type (unsigned long type
)
3220 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3221 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3222 case PT_HP_TLS
: return "HP_TLS";
3223 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3224 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3225 case PT_IA_64_HP_STACK
: return "HP_STACK";
3234 get_tic6x_segment_type (unsigned long type
)
3238 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3247 get_segment_type (unsigned long p_type
)
3249 static char buff
[32];
3253 case PT_NULL
: return "NULL";
3254 case PT_LOAD
: return "LOAD";
3255 case PT_DYNAMIC
: return "DYNAMIC";
3256 case PT_INTERP
: return "INTERP";
3257 case PT_NOTE
: return "NOTE";
3258 case PT_SHLIB
: return "SHLIB";
3259 case PT_PHDR
: return "PHDR";
3260 case PT_TLS
: return "TLS";
3262 case PT_GNU_EH_FRAME
:
3263 return "GNU_EH_FRAME";
3264 case PT_GNU_STACK
: return "GNU_STACK";
3265 case PT_GNU_RELRO
: return "GNU_RELRO";
3268 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3270 const char * result
;
3272 switch (elf_header
.e_machine
)
3275 result
= get_aarch64_segment_type (p_type
);
3278 result
= get_arm_segment_type (p_type
);
3281 case EM_MIPS_RS3_LE
:
3282 result
= get_mips_segment_type (p_type
);
3285 result
= get_parisc_segment_type (p_type
);
3288 result
= get_ia64_segment_type (p_type
);
3291 result
= get_tic6x_segment_type (p_type
);
3301 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3303 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3305 const char * result
;
3307 switch (elf_header
.e_machine
)
3310 result
= get_parisc_segment_type (p_type
);
3313 result
= get_ia64_segment_type (p_type
);
3323 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3326 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3333 get_mips_section_type_name (unsigned int sh_type
)
3337 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3338 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3339 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3340 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3341 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3342 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3343 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3344 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3345 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3346 case SHT_MIPS_RELD
: return "MIPS_RELD";
3347 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3348 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3349 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3350 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3351 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3352 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3353 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3354 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3355 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3356 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3357 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3358 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3359 case SHT_MIPS_LINE
: return "MIPS_LINE";
3360 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3361 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3362 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3363 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3364 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3365 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3366 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3367 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3368 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3369 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3370 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3371 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3372 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3373 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3374 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3375 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3376 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3384 get_parisc_section_type_name (unsigned int sh_type
)
3388 case SHT_PARISC_EXT
: return "PARISC_EXT";
3389 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3390 case SHT_PARISC_DOC
: return "PARISC_DOC";
3391 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3392 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3393 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3394 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3402 get_ia64_section_type_name (unsigned int sh_type
)
3404 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3405 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3406 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3410 case SHT_IA_64_EXT
: return "IA_64_EXT";
3411 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3412 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3413 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3414 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3415 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3416 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3417 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3418 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3419 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3427 get_x86_64_section_type_name (unsigned int sh_type
)
3431 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3439 get_aarch64_section_type_name (unsigned int sh_type
)
3443 case SHT_AARCH64_ATTRIBUTES
:
3444 return "AARCH64_ATTRIBUTES";
3452 get_arm_section_type_name (unsigned int sh_type
)
3456 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3457 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3458 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3459 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3460 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3468 get_tic6x_section_type_name (unsigned int sh_type
)
3472 case SHT_C6000_UNWIND
:
3473 return "C6000_UNWIND";
3474 case SHT_C6000_PREEMPTMAP
:
3475 return "C6000_PREEMPTMAP";
3476 case SHT_C6000_ATTRIBUTES
:
3477 return "C6000_ATTRIBUTES";
3482 case SHT_TI_HANDLER
:
3483 return "TI_HANDLER";
3484 case SHT_TI_INITINFO
:
3485 return "TI_INITINFO";
3486 case SHT_TI_PHATTRS
:
3487 return "TI_PHATTRS";
3495 get_msp430x_section_type_name (unsigned int sh_type
)
3499 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3500 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3501 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3502 default: return NULL
;
3507 get_section_type_name (unsigned int sh_type
)
3509 static char buff
[32];
3513 case SHT_NULL
: return "NULL";
3514 case SHT_PROGBITS
: return "PROGBITS";
3515 case SHT_SYMTAB
: return "SYMTAB";
3516 case SHT_STRTAB
: return "STRTAB";
3517 case SHT_RELA
: return "RELA";
3518 case SHT_HASH
: return "HASH";
3519 case SHT_DYNAMIC
: return "DYNAMIC";
3520 case SHT_NOTE
: return "NOTE";
3521 case SHT_NOBITS
: return "NOBITS";
3522 case SHT_REL
: return "REL";
3523 case SHT_SHLIB
: return "SHLIB";
3524 case SHT_DYNSYM
: return "DYNSYM";
3525 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3526 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3527 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3528 case SHT_GNU_HASH
: return "GNU_HASH";
3529 case SHT_GROUP
: return "GROUP";
3530 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3531 case SHT_GNU_verdef
: return "VERDEF";
3532 case SHT_GNU_verneed
: return "VERNEED";
3533 case SHT_GNU_versym
: return "VERSYM";
3534 case 0x6ffffff0: return "VERSYM";
3535 case 0x6ffffffc: return "VERDEF";
3536 case 0x7ffffffd: return "AUXILIARY";
3537 case 0x7fffffff: return "FILTER";
3538 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3541 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3543 const char * result
;
3545 switch (elf_header
.e_machine
)
3548 case EM_MIPS_RS3_LE
:
3549 result
= get_mips_section_type_name (sh_type
);
3552 result
= get_parisc_section_type_name (sh_type
);
3555 result
= get_ia64_section_type_name (sh_type
);
3560 result
= get_x86_64_section_type_name (sh_type
);
3563 result
= get_aarch64_section_type_name (sh_type
);
3566 result
= get_arm_section_type_name (sh_type
);
3569 result
= get_tic6x_section_type_name (sh_type
);
3572 result
= get_msp430x_section_type_name (sh_type
);
3582 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3584 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3586 const char * result
;
3588 switch (elf_header
.e_machine
)
3591 result
= get_ia64_section_type_name (sh_type
);
3601 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3603 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3604 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3606 /* This message is probably going to be displayed in a 15
3607 character wide field, so put the hex value first. */
3608 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3614 #define OPTION_DEBUG_DUMP 512
3615 #define OPTION_DYN_SYMS 513
3616 #define OPTION_DWARF_DEPTH 514
3617 #define OPTION_DWARF_START 515
3618 #define OPTION_DWARF_CHECK 516
3620 static struct option options
[] =
3622 {"all", no_argument
, 0, 'a'},
3623 {"file-header", no_argument
, 0, 'h'},
3624 {"program-headers", no_argument
, 0, 'l'},
3625 {"headers", no_argument
, 0, 'e'},
3626 {"histogram", no_argument
, 0, 'I'},
3627 {"segments", no_argument
, 0, 'l'},
3628 {"sections", no_argument
, 0, 'S'},
3629 {"section-headers", no_argument
, 0, 'S'},
3630 {"section-groups", no_argument
, 0, 'g'},
3631 {"section-details", no_argument
, 0, 't'},
3632 {"full-section-name",no_argument
, 0, 'N'},
3633 {"symbols", no_argument
, 0, 's'},
3634 {"syms", no_argument
, 0, 's'},
3635 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3636 {"relocs", no_argument
, 0, 'r'},
3637 {"notes", no_argument
, 0, 'n'},
3638 {"dynamic", no_argument
, 0, 'd'},
3639 {"arch-specific", no_argument
, 0, 'A'},
3640 {"version-info", no_argument
, 0, 'V'},
3641 {"use-dynamic", no_argument
, 0, 'D'},
3642 {"unwind", no_argument
, 0, 'u'},
3643 {"archive-index", no_argument
, 0, 'c'},
3644 {"hex-dump", required_argument
, 0, 'x'},
3645 {"relocated-dump", required_argument
, 0, 'R'},
3646 {"string-dump", required_argument
, 0, 'p'},
3647 #ifdef SUPPORT_DISASSEMBLY
3648 {"instruction-dump", required_argument
, 0, 'i'},
3650 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3652 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3653 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3654 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3656 {"version", no_argument
, 0, 'v'},
3657 {"wide", no_argument
, 0, 'W'},
3658 {"help", no_argument
, 0, 'H'},
3659 {0, no_argument
, 0, 0}
3663 usage (FILE * stream
)
3665 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3666 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3667 fprintf (stream
, _(" Options are:\n\
3668 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3669 -h --file-header Display the ELF file header\n\
3670 -l --program-headers Display the program headers\n\
3671 --segments An alias for --program-headers\n\
3672 -S --section-headers Display the sections' header\n\
3673 --sections An alias for --section-headers\n\
3674 -g --section-groups Display the section groups\n\
3675 -t --section-details Display the section details\n\
3676 -e --headers Equivalent to: -h -l -S\n\
3677 -s --syms Display the symbol table\n\
3678 --symbols An alias for --syms\n\
3679 --dyn-syms Display the dynamic symbol table\n\
3680 -n --notes Display the core notes (if present)\n\
3681 -r --relocs Display the relocations (if present)\n\
3682 -u --unwind Display the unwind info (if present)\n\
3683 -d --dynamic Display the dynamic section (if present)\n\
3684 -V --version-info Display the version sections (if present)\n\
3685 -A --arch-specific Display architecture specific information (if any)\n\
3686 -c --archive-index Display the symbol/file index in an archive\n\
3687 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3688 -x --hex-dump=<number|name>\n\
3689 Dump the contents of section <number|name> as bytes\n\
3690 -p --string-dump=<number|name>\n\
3691 Dump the contents of section <number|name> as strings\n\
3692 -R --relocated-dump=<number|name>\n\
3693 Dump the contents of section <number|name> as relocated bytes\n\
3694 -w[lLiaprmfFsoRt] or\n\
3695 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3696 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3697 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3699 Display the contents of DWARF2 debug sections\n"));
3700 fprintf (stream
, _("\
3701 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3702 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3704 #ifdef SUPPORT_DISASSEMBLY
3705 fprintf (stream
, _("\
3706 -i --instruction-dump=<number|name>\n\
3707 Disassemble the contents of section <number|name>\n"));
3709 fprintf (stream
, _("\
3710 -I --histogram Display histogram of bucket list lengths\n\
3711 -W --wide Allow output width to exceed 80 characters\n\
3712 @<file> Read options from <file>\n\
3713 -H --help Display this information\n\
3714 -v --version Display the version number of readelf\n"));
3716 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3717 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3719 exit (stream
== stdout
? 0 : 1);
3722 /* Record the fact that the user wants the contents of section number
3723 SECTION to be displayed using the method(s) encoded as flags bits
3724 in TYPE. Note, TYPE can be zero if we are creating the array for
3728 request_dump_bynumber (unsigned int section
, dump_type type
)
3730 if (section
>= num_dump_sects
)
3732 dump_type
* new_dump_sects
;
3734 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3735 sizeof (* dump_sects
));
3737 if (new_dump_sects
== NULL
)
3738 error (_("Out of memory allocating dump request table.\n"));
3741 /* Copy current flag settings. */
3742 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3746 dump_sects
= new_dump_sects
;
3747 num_dump_sects
= section
+ 1;
3752 dump_sects
[section
] |= type
;
3757 /* Request a dump by section name. */
3760 request_dump_byname (const char * section
, dump_type type
)
3762 struct dump_list_entry
* new_request
;
3764 new_request
= (struct dump_list_entry
*)
3765 malloc (sizeof (struct dump_list_entry
));
3767 error (_("Out of memory allocating dump request table.\n"));
3769 new_request
->name
= strdup (section
);
3770 if (!new_request
->name
)
3771 error (_("Out of memory allocating dump request table.\n"));
3773 new_request
->type
= type
;
3775 new_request
->next
= dump_sects_byname
;
3776 dump_sects_byname
= new_request
;
3780 request_dump (dump_type type
)
3786 section
= strtoul (optarg
, & cp
, 0);
3788 if (! *cp
&& section
>= 0)
3789 request_dump_bynumber (section
, type
);
3791 request_dump_byname (optarg
, type
);
3796 parse_args (int argc
, char ** argv
)
3803 while ((c
= getopt_long
3804 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3822 do_section_groups
++;
3830 do_section_groups
++;
3835 do_section_details
++;
3879 request_dump (HEX_DUMP
);
3882 request_dump (STRING_DUMP
);
3885 request_dump (RELOC_DUMP
);
3892 dwarf_select_sections_all ();
3897 dwarf_select_sections_by_letters (optarg
);
3900 case OPTION_DEBUG_DUMP
:
3907 dwarf_select_sections_by_names (optarg
);
3910 case OPTION_DWARF_DEPTH
:
3914 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3917 case OPTION_DWARF_START
:
3921 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3924 case OPTION_DWARF_CHECK
:
3927 case OPTION_DYN_SYMS
:
3930 #ifdef SUPPORT_DISASSEMBLY
3932 request_dump (DISASS_DUMP
);
3936 print_version (program_name
);
3945 /* xgettext:c-format */
3946 error (_("Invalid option '-%c'\n"), c
);
3953 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3954 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3955 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3956 && !do_section_groups
&& !do_archive_index
3961 warn (_("Nothing to do.\n"));
3967 get_elf_class (unsigned int elf_class
)
3969 static char buff
[32];
3973 case ELFCLASSNONE
: return _("none");
3974 case ELFCLASS32
: return "ELF32";
3975 case ELFCLASS64
: return "ELF64";
3977 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3983 get_data_encoding (unsigned int encoding
)
3985 static char buff
[32];
3989 case ELFDATANONE
: return _("none");
3990 case ELFDATA2LSB
: return _("2's complement, little endian");
3991 case ELFDATA2MSB
: return _("2's complement, big endian");
3993 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3998 /* Decode the data held in 'elf_header'. */
4001 process_file_header (void)
4003 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4004 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4005 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4006 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4009 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4013 init_dwarf_regnames (elf_header
.e_machine
);
4019 printf (_("ELF Header:\n"));
4020 printf (_(" Magic: "));
4021 for (i
= 0; i
< EI_NIDENT
; i
++)
4022 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4024 printf (_(" Class: %s\n"),
4025 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4026 printf (_(" Data: %s\n"),
4027 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4028 printf (_(" Version: %d %s\n"),
4029 elf_header
.e_ident
[EI_VERSION
],
4030 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4032 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4033 ? _("<unknown: %lx>")
4035 printf (_(" OS/ABI: %s\n"),
4036 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4037 printf (_(" ABI Version: %d\n"),
4038 elf_header
.e_ident
[EI_ABIVERSION
]);
4039 printf (_(" Type: %s\n"),
4040 get_file_type (elf_header
.e_type
));
4041 printf (_(" Machine: %s\n"),
4042 get_machine_name (elf_header
.e_machine
));
4043 printf (_(" Version: 0x%lx\n"),
4044 (unsigned long) elf_header
.e_version
);
4046 printf (_(" Entry point address: "));
4047 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4048 printf (_("\n Start of program headers: "));
4049 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4050 printf (_(" (bytes into file)\n Start of section headers: "));
4051 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4052 printf (_(" (bytes into file)\n"));
4054 printf (_(" Flags: 0x%lx%s\n"),
4055 (unsigned long) elf_header
.e_flags
,
4056 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4057 printf (_(" Size of this header: %ld (bytes)\n"),
4058 (long) elf_header
.e_ehsize
);
4059 printf (_(" Size of program headers: %ld (bytes)\n"),
4060 (long) elf_header
.e_phentsize
);
4061 printf (_(" Number of program headers: %ld"),
4062 (long) elf_header
.e_phnum
);
4063 if (section_headers
!= NULL
4064 && elf_header
.e_phnum
== PN_XNUM
4065 && section_headers
[0].sh_info
!= 0)
4066 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4067 putc ('\n', stdout
);
4068 printf (_(" Size of section headers: %ld (bytes)\n"),
4069 (long) elf_header
.e_shentsize
);
4070 printf (_(" Number of section headers: %ld"),
4071 (long) elf_header
.e_shnum
);
4072 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4073 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4074 putc ('\n', stdout
);
4075 printf (_(" Section header string table index: %ld"),
4076 (long) elf_header
.e_shstrndx
);
4077 if (section_headers
!= NULL
4078 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4079 printf (" (%u)", section_headers
[0].sh_link
);
4080 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4081 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4082 printf (_(" <corrupt: out of range>"));
4083 putc ('\n', stdout
);
4086 if (section_headers
!= NULL
)
4088 if (elf_header
.e_phnum
== PN_XNUM
4089 && section_headers
[0].sh_info
!= 0)
4090 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4091 if (elf_header
.e_shnum
== SHN_UNDEF
)
4092 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4093 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4094 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4095 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4096 elf_header
.e_shstrndx
= SHN_UNDEF
;
4097 free (section_headers
);
4098 section_headers
= NULL
;
4106 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4108 Elf32_External_Phdr
* phdrs
;
4109 Elf32_External_Phdr
* external
;
4110 Elf_Internal_Phdr
* internal
;
4113 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4114 elf_header
.e_phentsize
,
4116 _("program headers"));
4120 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4121 i
< elf_header
.e_phnum
;
4122 i
++, internal
++, external
++)
4124 internal
->p_type
= BYTE_GET (external
->p_type
);
4125 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4126 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4127 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4128 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4129 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4130 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4131 internal
->p_align
= BYTE_GET (external
->p_align
);
4140 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4142 Elf64_External_Phdr
* phdrs
;
4143 Elf64_External_Phdr
* external
;
4144 Elf_Internal_Phdr
* internal
;
4147 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4148 elf_header
.e_phentsize
,
4150 _("program headers"));
4154 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4155 i
< elf_header
.e_phnum
;
4156 i
++, internal
++, external
++)
4158 internal
->p_type
= BYTE_GET (external
->p_type
);
4159 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4160 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4161 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4162 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4163 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4164 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4165 internal
->p_align
= BYTE_GET (external
->p_align
);
4173 /* Returns 1 if the program headers were read into `program_headers'. */
4176 get_program_headers (FILE * file
)
4178 Elf_Internal_Phdr
* phdrs
;
4180 /* Check cache of prior read. */
4181 if (program_headers
!= NULL
)
4184 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4185 sizeof (Elf_Internal_Phdr
));
4189 error (_("Out of memory\n"));
4194 ? get_32bit_program_headers (file
, phdrs
)
4195 : get_64bit_program_headers (file
, phdrs
))
4197 program_headers
= phdrs
;
4205 /* Returns 1 if the program headers were loaded. */
4208 process_program_headers (FILE * file
)
4210 Elf_Internal_Phdr
* segment
;
4213 if (elf_header
.e_phnum
== 0)
4215 /* PR binutils/12467. */
4216 if (elf_header
.e_phoff
!= 0)
4217 warn (_("possibly corrupt ELF header - it has a non-zero program"
4218 " header offset, but no program headers"));
4219 else if (do_segments
)
4220 printf (_("\nThere are no program headers in this file.\n"));
4224 if (do_segments
&& !do_header
)
4226 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4227 printf (_("Entry point "));
4228 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4229 printf (_("\nThere are %d program headers, starting at offset "),
4230 elf_header
.e_phnum
);
4231 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4235 if (! get_program_headers (file
))
4240 if (elf_header
.e_phnum
> 1)
4241 printf (_("\nProgram Headers:\n"));
4243 printf (_("\nProgram Headers:\n"));
4247 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4250 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4254 (_(" Type Offset VirtAddr PhysAddr\n"));
4256 (_(" FileSiz MemSiz Flags Align\n"));
4263 for (i
= 0, segment
= program_headers
;
4264 i
< elf_header
.e_phnum
;
4269 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4273 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4274 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4275 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4276 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4277 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4279 (segment
->p_flags
& PF_R
? 'R' : ' '),
4280 (segment
->p_flags
& PF_W
? 'W' : ' '),
4281 (segment
->p_flags
& PF_X
? 'E' : ' '));
4282 printf ("%#lx", (unsigned long) segment
->p_align
);
4286 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4287 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4290 print_vma (segment
->p_offset
, FULL_HEX
);
4294 print_vma (segment
->p_vaddr
, FULL_HEX
);
4296 print_vma (segment
->p_paddr
, FULL_HEX
);
4299 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4300 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4303 print_vma (segment
->p_filesz
, FULL_HEX
);
4307 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4308 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4311 print_vma (segment
->p_memsz
, FULL_HEX
);
4315 (segment
->p_flags
& PF_R
? 'R' : ' '),
4316 (segment
->p_flags
& PF_W
? 'W' : ' '),
4317 (segment
->p_flags
& PF_X
? 'E' : ' '));
4319 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4320 printf ("%#lx", (unsigned long) segment
->p_align
);
4323 print_vma (segment
->p_align
, PREFIX_HEX
);
4328 print_vma (segment
->p_offset
, FULL_HEX
);
4330 print_vma (segment
->p_vaddr
, FULL_HEX
);
4332 print_vma (segment
->p_paddr
, FULL_HEX
);
4334 print_vma (segment
->p_filesz
, FULL_HEX
);
4336 print_vma (segment
->p_memsz
, FULL_HEX
);
4338 (segment
->p_flags
& PF_R
? 'R' : ' '),
4339 (segment
->p_flags
& PF_W
? 'W' : ' '),
4340 (segment
->p_flags
& PF_X
? 'E' : ' '));
4341 print_vma (segment
->p_align
, HEX
);
4346 putc ('\n', stdout
);
4348 switch (segment
->p_type
)
4352 error (_("more than one dynamic segment\n"));
4354 /* By default, assume that the .dynamic section is the first
4355 section in the DYNAMIC segment. */
4356 dynamic_addr
= segment
->p_offset
;
4357 dynamic_size
= segment
->p_filesz
;
4358 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4359 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4361 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4362 dynamic_addr
= dynamic_size
= 0;
4365 /* Try to locate the .dynamic section. If there is
4366 a section header table, we can easily locate it. */
4367 if (section_headers
!= NULL
)
4369 Elf_Internal_Shdr
* sec
;
4371 sec
= find_section (".dynamic");
4372 if (sec
== NULL
|| sec
->sh_size
== 0)
4374 /* A corresponding .dynamic section is expected, but on
4375 IA-64/OpenVMS it is OK for it to be missing. */
4376 if (!is_ia64_vms ())
4377 error (_("no .dynamic section in the dynamic segment\n"));
4381 if (sec
->sh_type
== SHT_NOBITS
)
4387 dynamic_addr
= sec
->sh_offset
;
4388 dynamic_size
= sec
->sh_size
;
4390 if (dynamic_addr
< segment
->p_offset
4391 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4392 warn (_("the .dynamic section is not contained"
4393 " within the dynamic segment\n"));
4394 else if (dynamic_addr
> segment
->p_offset
)
4395 warn (_("the .dynamic section is not the first section"
4396 " in the dynamic segment.\n"));
4401 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4403 error (_("Unable to find program interpreter name\n"));
4407 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4409 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4410 error (_("Internal error: failed to create format string to display program interpreter\n"));
4412 program_interpreter
[0] = 0;
4413 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4414 error (_("Unable to read program interpreter name\n"));
4417 printf (_(" [Requesting program interpreter: %s]\n"),
4418 program_interpreter
);
4424 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4426 printf (_("\n Section to Segment mapping:\n"));
4427 printf (_(" Segment Sections...\n"));
4429 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4432 Elf_Internal_Shdr
* section
;
4434 segment
= program_headers
+ i
;
4435 section
= section_headers
+ 1;
4437 printf (" %2.2d ", i
);
4439 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4441 if (!ELF_TBSS_SPECIAL (section
, segment
)
4442 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4443 printf ("%s ", SECTION_NAME (section
));
4454 /* Find the file offset corresponding to VMA by using the program headers. */
4457 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4459 Elf_Internal_Phdr
* seg
;
4461 if (! get_program_headers (file
))
4463 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4467 for (seg
= program_headers
;
4468 seg
< program_headers
+ elf_header
.e_phnum
;
4471 if (seg
->p_type
!= PT_LOAD
)
4474 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4475 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4476 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4479 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4480 (unsigned long) vma
);
4486 get_32bit_section_headers (FILE * file
, unsigned int num
)
4488 Elf32_External_Shdr
* shdrs
;
4489 Elf_Internal_Shdr
* internal
;
4492 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4493 elf_header
.e_shentsize
, num
,
4494 _("section headers"));
4498 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4499 sizeof (Elf_Internal_Shdr
));
4501 if (section_headers
== NULL
)
4503 error (_("Out of memory\n"));
4507 for (i
= 0, internal
= section_headers
;
4511 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4512 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4513 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4514 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4515 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4516 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4517 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4518 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4519 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4520 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4529 get_64bit_section_headers (FILE * file
, unsigned int num
)
4531 Elf64_External_Shdr
* shdrs
;
4532 Elf_Internal_Shdr
* internal
;
4535 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4536 elf_header
.e_shentsize
, num
,
4537 _("section headers"));
4541 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4542 sizeof (Elf_Internal_Shdr
));
4544 if (section_headers
== NULL
)
4546 error (_("Out of memory\n"));
4550 for (i
= 0, internal
= section_headers
;
4554 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4555 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4556 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4557 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4558 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4559 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4560 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4561 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4562 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4563 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4571 static Elf_Internal_Sym
*
4572 get_32bit_elf_symbols (FILE * file
,
4573 Elf_Internal_Shdr
* section
,
4574 unsigned long * num_syms_return
)
4576 unsigned long number
= 0;
4577 Elf32_External_Sym
* esyms
= NULL
;
4578 Elf_External_Sym_Shndx
* shndx
= NULL
;
4579 Elf_Internal_Sym
* isyms
= NULL
;
4580 Elf_Internal_Sym
* psym
;
4583 /* Run some sanity checks first. */
4584 if (section
->sh_entsize
== 0)
4586 error (_("sh_entsize is zero\n"));
4590 if (section
->sh_size
> current_file_size
)
4592 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4593 SECTION_NAME (section
), section
->sh_size
);
4597 number
= section
->sh_size
/ section
->sh_entsize
;
4599 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4601 error (_("Invalid sh_entsize\n"));
4605 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4606 section
->sh_size
, _("symbols"));
4611 if (symtab_shndx_hdr
!= NULL
4612 && (symtab_shndx_hdr
->sh_link
4613 == (unsigned long) (section
- section_headers
)))
4615 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4616 symtab_shndx_hdr
->sh_offset
,
4617 1, symtab_shndx_hdr
->sh_size
,
4618 _("symbol table section indicies"));
4623 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4627 error (_("Out of memory\n"));
4631 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4633 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4634 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4635 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4636 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4637 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4639 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4640 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4641 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4642 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4643 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4652 if (num_syms_return
!= NULL
)
4653 * num_syms_return
= isyms
== NULL
? 0 : number
;
4658 static Elf_Internal_Sym
*
4659 get_64bit_elf_symbols (FILE * file
,
4660 Elf_Internal_Shdr
* section
,
4661 unsigned long * num_syms_return
)
4663 unsigned long number
= 0;
4664 Elf64_External_Sym
* esyms
= NULL
;
4665 Elf_External_Sym_Shndx
* shndx
= NULL
;
4666 Elf_Internal_Sym
* isyms
= NULL
;
4667 Elf_Internal_Sym
* psym
;
4670 /* Run some sanity checks first. */
4671 if (section
->sh_entsize
== 0)
4673 error (_("sh_entsize is zero\n"));
4677 if (section
->sh_size
> current_file_size
)
4679 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4680 SECTION_NAME (section
), section
->sh_size
);
4684 number
= section
->sh_size
/ section
->sh_entsize
;
4686 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4688 error (_("Invalid sh_entsize\n"));
4692 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4693 section
->sh_size
, _("symbols"));
4697 if (symtab_shndx_hdr
!= NULL
4698 && (symtab_shndx_hdr
->sh_link
4699 == (unsigned long) (section
- section_headers
)))
4701 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4702 symtab_shndx_hdr
->sh_offset
,
4703 1, symtab_shndx_hdr
->sh_size
,
4704 _("symbol table section indicies"));
4709 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4713 error (_("Out of memory\n"));
4717 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4719 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4720 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4721 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4722 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4724 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4726 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4727 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4728 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4730 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4731 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4740 if (num_syms_return
!= NULL
)
4741 * num_syms_return
= isyms
== NULL
? 0 : number
;
4747 get_elf_section_flags (bfd_vma sh_flags
)
4749 static char buff
[1024];
4751 int field_size
= is_32bit_elf
? 8 : 16;
4753 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4754 bfd_vma os_flags
= 0;
4755 bfd_vma proc_flags
= 0;
4756 bfd_vma unknown_flags
= 0;
4764 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4765 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4766 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4767 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4768 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4769 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4770 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4771 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4772 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4773 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4774 /* IA-64 specific. */
4775 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4776 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4777 /* IA-64 OpenVMS specific. */
4778 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4779 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4780 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4781 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4782 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4783 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4785 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4786 /* SPARC specific. */
4787 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4790 if (do_section_details
)
4792 sprintf (buff
, "[%*.*lx]: ",
4793 field_size
, field_size
, (unsigned long) sh_flags
);
4794 p
+= field_size
+ 4;
4801 flag
= sh_flags
& - sh_flags
;
4804 if (do_section_details
)
4808 case SHF_WRITE
: sindex
= 0; break;
4809 case SHF_ALLOC
: sindex
= 1; break;
4810 case SHF_EXECINSTR
: sindex
= 2; break;
4811 case SHF_MERGE
: sindex
= 3; break;
4812 case SHF_STRINGS
: sindex
= 4; break;
4813 case SHF_INFO_LINK
: sindex
= 5; break;
4814 case SHF_LINK_ORDER
: sindex
= 6; break;
4815 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4816 case SHF_GROUP
: sindex
= 8; break;
4817 case SHF_TLS
: sindex
= 9; break;
4818 case SHF_EXCLUDE
: sindex
= 18; break;
4822 switch (elf_header
.e_machine
)
4825 if (flag
== SHF_IA_64_SHORT
)
4827 else if (flag
== SHF_IA_64_NORECOV
)
4830 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4833 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4834 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4835 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4836 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4837 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4838 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4849 case EM_OLD_SPARCV9
:
4850 case EM_SPARC32PLUS
:
4853 if (flag
== SHF_ORDERED
)
4863 if (p
!= buff
+ field_size
+ 4)
4865 if (size
< (10 + 2))
4872 size
-= flags
[sindex
].len
;
4873 p
= stpcpy (p
, flags
[sindex
].str
);
4875 else if (flag
& SHF_MASKOS
)
4877 else if (flag
& SHF_MASKPROC
)
4880 unknown_flags
|= flag
;
4886 case SHF_WRITE
: *p
= 'W'; break;
4887 case SHF_ALLOC
: *p
= 'A'; break;
4888 case SHF_EXECINSTR
: *p
= 'X'; break;
4889 case SHF_MERGE
: *p
= 'M'; break;
4890 case SHF_STRINGS
: *p
= 'S'; break;
4891 case SHF_INFO_LINK
: *p
= 'I'; break;
4892 case SHF_LINK_ORDER
: *p
= 'L'; break;
4893 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4894 case SHF_GROUP
: *p
= 'G'; break;
4895 case SHF_TLS
: *p
= 'T'; break;
4896 case SHF_EXCLUDE
: *p
= 'E'; break;
4899 if ((elf_header
.e_machine
== EM_X86_64
4900 || elf_header
.e_machine
== EM_L1OM
4901 || elf_header
.e_machine
== EM_K1OM
)
4902 && flag
== SHF_X86_64_LARGE
)
4904 else if (flag
& SHF_MASKOS
)
4907 sh_flags
&= ~ SHF_MASKOS
;
4909 else if (flag
& SHF_MASKPROC
)
4912 sh_flags
&= ~ SHF_MASKPROC
;
4922 if (do_section_details
)
4926 size
-= 5 + field_size
;
4927 if (p
!= buff
+ field_size
+ 4)
4935 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4936 (unsigned long) os_flags
);
4937 p
+= 5 + field_size
;
4941 size
-= 7 + field_size
;
4942 if (p
!= buff
+ field_size
+ 4)
4950 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4951 (unsigned long) proc_flags
);
4952 p
+= 7 + field_size
;
4956 size
-= 10 + field_size
;
4957 if (p
!= buff
+ field_size
+ 4)
4965 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4966 (unsigned long) unknown_flags
);
4967 p
+= 10 + field_size
;
4976 process_section_headers (FILE * file
)
4978 Elf_Internal_Shdr
* section
;
4981 section_headers
= NULL
;
4983 if (elf_header
.e_shnum
== 0)
4985 /* PR binutils/12467. */
4986 if (elf_header
.e_shoff
!= 0)
4987 warn (_("possibly corrupt ELF file header - it has a non-zero"
4988 " section header offset, but no section headers\n"));
4989 else if (do_sections
)
4990 printf (_("\nThere are no sections in this file.\n"));
4995 if (do_sections
&& !do_header
)
4996 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4997 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5001 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
5004 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
5007 /* Read in the string table, so that we have names to display. */
5008 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5009 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5011 section
= section_headers
+ elf_header
.e_shstrndx
;
5013 if (section
->sh_size
!= 0)
5015 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5016 1, section
->sh_size
,
5019 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5023 /* Scan the sections for the dynamic symbol table
5024 and dynamic string table and debug sections. */
5025 dynamic_symbols
= NULL
;
5026 dynamic_strings
= NULL
;
5027 dynamic_syminfo
= NULL
;
5028 symtab_shndx_hdr
= NULL
;
5030 eh_addr_size
= is_32bit_elf
? 4 : 8;
5031 switch (elf_header
.e_machine
)
5034 case EM_MIPS_RS3_LE
:
5035 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5036 FDE addresses. However, the ABI also has a semi-official ILP32
5037 variant for which the normal FDE address size rules apply.
5039 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5040 section, where XX is the size of longs in bits. Unfortunately,
5041 earlier compilers provided no way of distinguishing ILP32 objects
5042 from LP64 objects, so if there's any doubt, we should assume that
5043 the official LP64 form is being used. */
5044 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5045 && find_section (".gcc_compiled_long32") == NULL
)
5051 switch (elf_header
.e_flags
& EF_H8_MACH
)
5053 case E_H8_MACH_H8300
:
5054 case E_H8_MACH_H8300HN
:
5055 case E_H8_MACH_H8300SN
:
5056 case E_H8_MACH_H8300SXN
:
5059 case E_H8_MACH_H8300H
:
5060 case E_H8_MACH_H8300S
:
5061 case E_H8_MACH_H8300SX
:
5069 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5071 case EF_M32C_CPU_M16C
:
5078 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5081 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5082 if (section->sh_entsize != expected_entsize) \
5085 sprintf_vma (buf, section->sh_entsize); \
5086 /* Note: coded this way so that there is a single string for \
5088 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5089 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5090 (unsigned) expected_entsize); \
5091 section->sh_entsize = expected_entsize; \
5096 #define CHECK_ENTSIZE(section, i, type) \
5097 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5098 sizeof (Elf64_External_##type))
5100 for (i
= 0, section
= section_headers
;
5101 i
< elf_header
.e_shnum
;
5104 char * name
= SECTION_NAME (section
);
5106 if (section
->sh_type
== SHT_DYNSYM
)
5108 if (dynamic_symbols
!= NULL
)
5110 error (_("File contains multiple dynamic symbol tables\n"));
5114 CHECK_ENTSIZE (section
, i
, Sym
);
5115 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5117 else if (section
->sh_type
== SHT_STRTAB
5118 && streq (name
, ".dynstr"))
5120 if (dynamic_strings
!= NULL
)
5122 error (_("File contains multiple dynamic string tables\n"));
5126 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5127 1, section
->sh_size
,
5128 _("dynamic strings"));
5129 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5131 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5133 if (symtab_shndx_hdr
!= NULL
)
5135 error (_("File contains multiple symtab shndx tables\n"));
5138 symtab_shndx_hdr
= section
;
5140 else if (section
->sh_type
== SHT_SYMTAB
)
5141 CHECK_ENTSIZE (section
, i
, Sym
);
5142 else if (section
->sh_type
== SHT_GROUP
)
5143 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5144 else if (section
->sh_type
== SHT_REL
)
5145 CHECK_ENTSIZE (section
, i
, Rel
);
5146 else if (section
->sh_type
== SHT_RELA
)
5147 CHECK_ENTSIZE (section
, i
, Rela
);
5148 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5149 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5150 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5151 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5152 || do_debug_addr
|| do_debug_cu_index
)
5153 && (const_strneq (name
, ".debug_")
5154 || const_strneq (name
, ".zdebug_")))
5157 name
+= sizeof (".zdebug_") - 1;
5159 name
+= sizeof (".debug_") - 1;
5162 || (do_debug_info
&& const_strneq (name
, "info"))
5163 || (do_debug_info
&& const_strneq (name
, "types"))
5164 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5165 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5166 || (do_debug_lines
&& const_strneq (name
, "line."))
5167 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5168 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5169 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5170 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5171 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5172 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5173 || (do_debug_frames
&& const_strneq (name
, "frame"))
5174 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5175 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5176 || (do_debug_str
&& const_strneq (name
, "str"))
5177 || (do_debug_loc
&& const_strneq (name
, "loc"))
5178 || (do_debug_addr
&& const_strneq (name
, "addr"))
5179 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5180 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5182 request_dump_bynumber (i
, DEBUG_DUMP
);
5184 /* Linkonce section to be combined with .debug_info at link time. */
5185 else if ((do_debugging
|| do_debug_info
)
5186 && const_strneq (name
, ".gnu.linkonce.wi."))
5187 request_dump_bynumber (i
, DEBUG_DUMP
);
5188 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5189 request_dump_bynumber (i
, DEBUG_DUMP
);
5190 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5191 request_dump_bynumber (i
, DEBUG_DUMP
);
5192 /* Trace sections for Itanium VMS. */
5193 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5194 || do_trace_aranges
)
5195 && const_strneq (name
, ".trace_"))
5197 name
+= sizeof (".trace_") - 1;
5200 || (do_trace_info
&& streq (name
, "info"))
5201 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5202 || (do_trace_aranges
&& streq (name
, "aranges"))
5204 request_dump_bynumber (i
, DEBUG_DUMP
);
5212 if (elf_header
.e_shnum
> 1)
5213 printf (_("\nSection Headers:\n"));
5215 printf (_("\nSection Header:\n"));
5219 if (do_section_details
)
5221 printf (_(" [Nr] Name\n"));
5222 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5226 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5230 if (do_section_details
)
5232 printf (_(" [Nr] Name\n"));
5233 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5237 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5241 if (do_section_details
)
5243 printf (_(" [Nr] Name\n"));
5244 printf (_(" Type Address Offset Link\n"));
5245 printf (_(" Size EntSize Info Align\n"));
5249 printf (_(" [Nr] Name Type Address Offset\n"));
5250 printf (_(" Size EntSize Flags Link Info Align\n"));
5254 if (do_section_details
)
5255 printf (_(" Flags\n"));
5257 for (i
= 0, section
= section_headers
;
5258 i
< elf_header
.e_shnum
;
5261 printf (" [%2u] ", i
);
5262 if (do_section_details
)
5264 print_symbol (INT_MAX
, SECTION_NAME (section
));
5269 print_symbol (-17, SECTION_NAME (section
));
5272 printf (do_wide
? " %-15s " : " %-15.15s ",
5273 get_section_type_name (section
->sh_type
));
5277 const char * link_too_big
= NULL
;
5279 print_vma (section
->sh_addr
, LONG_HEX
);
5281 printf ( " %6.6lx %6.6lx %2.2lx",
5282 (unsigned long) section
->sh_offset
,
5283 (unsigned long) section
->sh_size
,
5284 (unsigned long) section
->sh_entsize
);
5286 if (do_section_details
)
5287 fputs (" ", stdout
);
5289 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5291 if (section
->sh_link
>= elf_header
.e_shnum
)
5294 /* The sh_link value is out of range. Normally this indicates
5295 an error but it can have special values in Solaris binaries. */
5296 switch (elf_header
.e_machine
)
5303 case EM_OLD_SPARCV9
:
5304 case EM_SPARC32PLUS
:
5307 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5308 link_too_big
= "BEFORE";
5309 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5310 link_too_big
= "AFTER";
5317 if (do_section_details
)
5319 if (link_too_big
!= NULL
&& * link_too_big
)
5320 printf ("<%s> ", link_too_big
);
5322 printf ("%2u ", section
->sh_link
);
5323 printf ("%3u %2lu\n", section
->sh_info
,
5324 (unsigned long) section
->sh_addralign
);
5327 printf ("%2u %3u %2lu\n",
5330 (unsigned long) section
->sh_addralign
);
5332 if (link_too_big
&& ! * link_too_big
)
5333 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5334 i
, section
->sh_link
);
5338 print_vma (section
->sh_addr
, LONG_HEX
);
5340 if ((long) section
->sh_offset
== section
->sh_offset
)
5341 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5345 print_vma (section
->sh_offset
, LONG_HEX
);
5348 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5349 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5353 print_vma (section
->sh_size
, LONG_HEX
);
5356 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5357 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5361 print_vma (section
->sh_entsize
, LONG_HEX
);
5364 if (do_section_details
)
5365 fputs (" ", stdout
);
5367 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5369 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5371 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5372 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5375 print_vma (section
->sh_addralign
, DEC
);
5379 else if (do_section_details
)
5381 printf (" %-15.15s ",
5382 get_section_type_name (section
->sh_type
));
5383 print_vma (section
->sh_addr
, LONG_HEX
);
5384 if ((long) section
->sh_offset
== section
->sh_offset
)
5385 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5389 print_vma (section
->sh_offset
, LONG_HEX
);
5391 printf (" %u\n ", section
->sh_link
);
5392 print_vma (section
->sh_size
, LONG_HEX
);
5394 print_vma (section
->sh_entsize
, LONG_HEX
);
5396 printf (" %-16u %lu\n",
5398 (unsigned long) section
->sh_addralign
);
5403 print_vma (section
->sh_addr
, LONG_HEX
);
5404 if ((long) section
->sh_offset
== section
->sh_offset
)
5405 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5409 print_vma (section
->sh_offset
, LONG_HEX
);
5412 print_vma (section
->sh_size
, LONG_HEX
);
5414 print_vma (section
->sh_entsize
, LONG_HEX
);
5416 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5418 printf (" %2u %3u %lu\n",
5421 (unsigned long) section
->sh_addralign
);
5424 if (do_section_details
)
5425 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5428 if (!do_section_details
)
5430 if (elf_header
.e_machine
== EM_X86_64
5431 || elf_header
.e_machine
== EM_L1OM
5432 || elf_header
.e_machine
== EM_K1OM
)
5433 printf (_("Key to Flags:\n\
5434 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5435 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5436 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5438 printf (_("Key to Flags:\n\
5439 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5440 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5441 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5448 get_group_flags (unsigned int flags
)
5450 static char buff
[32];
5460 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5467 process_section_groups (FILE * file
)
5469 Elf_Internal_Shdr
* section
;
5471 struct group
* group
;
5472 Elf_Internal_Shdr
* symtab_sec
;
5473 Elf_Internal_Shdr
* strtab_sec
;
5474 Elf_Internal_Sym
* symtab
;
5475 unsigned long num_syms
;
5479 /* Don't process section groups unless needed. */
5480 if (!do_unwind
&& !do_section_groups
)
5483 if (elf_header
.e_shnum
== 0)
5485 if (do_section_groups
)
5486 printf (_("\nThere are no sections to group in this file.\n"));
5491 if (section_headers
== NULL
)
5493 error (_("Section headers are not available!\n"));
5494 /* PR 13622: This can happen with a corrupt ELF header. */
5498 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5499 sizeof (struct group
*));
5501 if (section_headers_groups
== NULL
)
5503 error (_("Out of memory\n"));
5507 /* Scan the sections for the group section. */
5509 for (i
= 0, section
= section_headers
;
5510 i
< elf_header
.e_shnum
;
5512 if (section
->sh_type
== SHT_GROUP
)
5515 if (group_count
== 0)
5517 if (do_section_groups
)
5518 printf (_("\nThere are no section groups in this file.\n"));
5523 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5525 if (section_groups
== NULL
)
5527 error (_("Out of memory\n"));
5537 for (i
= 0, section
= section_headers
, group
= section_groups
;
5538 i
< elf_header
.e_shnum
;
5541 if (section
->sh_type
== SHT_GROUP
)
5543 char * name
= SECTION_NAME (section
);
5545 unsigned char * start
;
5546 unsigned char * indices
;
5547 unsigned int entry
, j
, size
;
5548 Elf_Internal_Shdr
* sec
;
5549 Elf_Internal_Sym
* sym
;
5551 /* Get the symbol table. */
5552 if (section
->sh_link
>= elf_header
.e_shnum
5553 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5556 error (_("Bad sh_link in group section `%s'\n"), name
);
5560 if (symtab_sec
!= sec
)
5565 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5570 error (_("Corrupt header in group section `%s'\n"), name
);
5574 if (section
->sh_info
>= num_syms
)
5576 error (_("Bad sh_info in group section `%s'\n"), name
);
5580 sym
= symtab
+ section
->sh_info
;
5582 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5584 if (sym
->st_shndx
== 0
5585 || sym
->st_shndx
>= elf_header
.e_shnum
)
5587 error (_("Bad sh_info in group section `%s'\n"), name
);
5591 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5600 /* Get the string table. */
5601 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5610 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5615 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5616 1, strtab_sec
->sh_size
,
5618 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5620 group_name
= sym
->st_name
< strtab_size
5621 ? strtab
+ sym
->st_name
: _("<corrupt>");
5624 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5625 1, section
->sh_size
,
5631 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5632 entry
= byte_get (indices
, 4);
5635 if (do_section_groups
)
5637 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5638 get_group_flags (entry
), i
, name
, group_name
, size
);
5640 printf (_(" [Index] Name\n"));
5643 group
->group_index
= i
;
5645 for (j
= 0; j
< size
; j
++)
5647 struct group_list
* g
;
5649 entry
= byte_get (indices
, 4);
5652 if (entry
>= elf_header
.e_shnum
)
5654 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5655 entry
, i
, elf_header
.e_shnum
- 1);
5659 if (section_headers_groups
[entry
] != NULL
)
5663 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5665 section_headers_groups
[entry
]->group_index
);
5670 /* Intel C/C++ compiler may put section 0 in a
5671 section group. We just warn it the first time
5672 and ignore it afterwards. */
5673 static int warned
= 0;
5676 error (_("section 0 in group section [%5u]\n"),
5677 section_headers_groups
[entry
]->group_index
);
5683 section_headers_groups
[entry
] = group
;
5685 if (do_section_groups
)
5687 sec
= section_headers
+ entry
;
5688 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5691 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5692 g
->section_index
= entry
;
5693 g
->next
= group
->root
;
5711 /* Data used to display dynamic fixups. */
5713 struct ia64_vms_dynfixup
5715 bfd_vma needed_ident
; /* Library ident number. */
5716 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5717 bfd_vma fixup_needed
; /* Index of the library. */
5718 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5719 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5722 /* Data used to display dynamic relocations. */
5724 struct ia64_vms_dynimgrela
5726 bfd_vma img_rela_cnt
; /* Number of relocations. */
5727 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5730 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5734 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5735 const char *strtab
, unsigned int strtab_sz
)
5737 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5739 const char *lib_name
;
5741 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5742 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5743 _("dynamic section image fixups"));
5747 if (fixup
->needed
< strtab_sz
)
5748 lib_name
= strtab
+ fixup
->needed
;
5751 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5752 (unsigned long) fixup
->needed
);
5755 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5756 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5758 (_("Seg Offset Type SymVec DataType\n"));
5760 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5765 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5766 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5767 type
= BYTE_GET (imfs
[i
].type
);
5768 rtype
= elf_ia64_reloc_type (type
);
5770 printf (" 0x%08x ", type
);
5772 printf (" %-32s ", rtype
);
5773 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5774 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5780 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5783 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5785 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5788 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5789 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5790 _("dynamic section image relocations"));
5794 printf (_("\nImage relocs\n"));
5796 (_("Seg Offset Type Addend Seg Sym Off\n"));
5798 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5803 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5804 printf ("%08" BFD_VMA_FMT
"x ",
5805 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5806 type
= BYTE_GET (imrs
[i
].type
);
5807 rtype
= elf_ia64_reloc_type (type
);
5809 printf ("0x%08x ", type
);
5811 printf ("%-31s ", rtype
);
5812 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5813 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5814 printf ("%08" BFD_VMA_FMT
"x\n",
5815 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5821 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5824 process_ia64_vms_dynamic_relocs (FILE *file
)
5826 struct ia64_vms_dynfixup fixup
;
5827 struct ia64_vms_dynimgrela imgrela
;
5828 Elf_Internal_Dyn
*entry
;
5830 bfd_vma strtab_off
= 0;
5831 bfd_vma strtab_sz
= 0;
5832 char *strtab
= NULL
;
5834 memset (&fixup
, 0, sizeof (fixup
));
5835 memset (&imgrela
, 0, sizeof (imgrela
));
5837 /* Note: the order of the entries is specified by the OpenVMS specs. */
5838 for (entry
= dynamic_section
;
5839 entry
< dynamic_section
+ dynamic_nent
;
5842 switch (entry
->d_tag
)
5844 case DT_IA_64_VMS_STRTAB_OFFSET
:
5845 strtab_off
= entry
->d_un
.d_val
;
5848 strtab_sz
= entry
->d_un
.d_val
;
5850 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5851 1, strtab_sz
, _("dynamic string section"));
5854 case DT_IA_64_VMS_NEEDED_IDENT
:
5855 fixup
.needed_ident
= entry
->d_un
.d_val
;
5858 fixup
.needed
= entry
->d_un
.d_val
;
5860 case DT_IA_64_VMS_FIXUP_NEEDED
:
5861 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5863 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5864 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5866 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5867 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5869 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5872 case DT_IA_64_VMS_IMG_RELA_CNT
:
5873 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5875 case DT_IA_64_VMS_IMG_RELA_OFF
:
5876 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5878 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5898 } dynamic_relocations
[] =
5900 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5901 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5902 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5905 /* Process the reloc section. */
5908 process_relocs (FILE * file
)
5910 unsigned long rel_size
;
5911 unsigned long rel_offset
;
5917 if (do_using_dynamic
)
5921 int has_dynamic_reloc
;
5924 has_dynamic_reloc
= 0;
5926 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5928 is_rela
= dynamic_relocations
[i
].rela
;
5929 name
= dynamic_relocations
[i
].name
;
5930 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5931 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5933 has_dynamic_reloc
|= rel_size
;
5935 if (is_rela
== UNKNOWN
)
5937 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5938 switch (dynamic_info
[DT_PLTREL
])
5952 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5953 name
, rel_offset
, rel_size
);
5955 dump_relocations (file
,
5956 offset_from_vma (file
, rel_offset
, rel_size
),
5958 dynamic_symbols
, num_dynamic_syms
,
5959 dynamic_strings
, dynamic_strings_length
, is_rela
);
5964 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5966 if (! has_dynamic_reloc
)
5967 printf (_("\nThere are no dynamic relocations in this file.\n"));
5971 Elf_Internal_Shdr
* section
;
5975 for (i
= 0, section
= section_headers
;
5976 i
< elf_header
.e_shnum
;
5979 if ( section
->sh_type
!= SHT_RELA
5980 && section
->sh_type
!= SHT_REL
)
5983 rel_offset
= section
->sh_offset
;
5984 rel_size
= section
->sh_size
;
5988 Elf_Internal_Shdr
* strsec
;
5991 printf (_("\nRelocation section "));
5993 if (string_table
== NULL
)
5994 printf ("%d", section
->sh_name
);
5996 printf ("'%s'", SECTION_NAME (section
));
5998 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5999 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6001 is_rela
= section
->sh_type
== SHT_RELA
;
6003 if (section
->sh_link
!= 0
6004 && section
->sh_link
< elf_header
.e_shnum
)
6006 Elf_Internal_Shdr
* symsec
;
6007 Elf_Internal_Sym
* symtab
;
6008 unsigned long nsyms
;
6009 unsigned long strtablen
= 0;
6010 char * strtab
= NULL
;
6012 symsec
= section_headers
+ section
->sh_link
;
6013 if (symsec
->sh_type
!= SHT_SYMTAB
6014 && symsec
->sh_type
!= SHT_DYNSYM
)
6017 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6022 if (symsec
->sh_link
!= 0
6023 && symsec
->sh_link
< elf_header
.e_shnum
)
6025 strsec
= section_headers
+ symsec
->sh_link
;
6027 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6030 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6033 dump_relocations (file
, rel_offset
, rel_size
,
6034 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6040 dump_relocations (file
, rel_offset
, rel_size
,
6041 NULL
, 0, NULL
, 0, is_rela
);
6048 printf (_("\nThere are no relocations in this file.\n"));
6054 /* Process the unwind section. */
6056 #include "unwind-ia64.h"
6058 /* An absolute address consists of a section and an offset. If the
6059 section is NULL, the offset itself is the address, otherwise, the
6060 address equals to LOAD_ADDRESS(section) + offset. */
6064 unsigned short section
;
6068 #define ABSADDR(a) \
6070 ? section_headers [(a).section].sh_addr + (a).offset \
6073 struct ia64_unw_table_entry
6075 struct absaddr start
;
6077 struct absaddr info
;
6080 struct ia64_unw_aux_info
6083 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6084 unsigned long table_len
; /* Length of unwind table. */
6085 unsigned char * info
; /* Unwind info. */
6086 unsigned long info_size
; /* Size of unwind info. */
6087 bfd_vma info_addr
; /* starting address of unwind info. */
6088 bfd_vma seg_base
; /* Starting address of segment. */
6089 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6090 unsigned long nsyms
; /* Number of symbols. */
6091 char * strtab
; /* The string table. */
6092 unsigned long strtab_size
; /* Size of string table. */
6096 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6097 unsigned long nsyms
,
6098 const char * strtab
,
6099 unsigned long strtab_size
,
6100 struct absaddr addr
,
6101 const char ** symname
,
6104 bfd_vma dist
= 0x100000;
6105 Elf_Internal_Sym
* sym
;
6106 Elf_Internal_Sym
* best
= NULL
;
6109 REMOVE_ARCH_BITS (addr
.offset
);
6111 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6113 bfd_vma value
= sym
->st_value
;
6115 REMOVE_ARCH_BITS (value
);
6117 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6118 && sym
->st_name
!= 0
6119 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6120 && addr
.offset
>= value
6121 && addr
.offset
- value
< dist
)
6124 dist
= addr
.offset
- value
;
6132 *symname
= (best
->st_name
>= strtab_size
6133 ? _("<corrupt>") : strtab
+ best
->st_name
);
6139 *offset
= addr
.offset
;
6143 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6145 struct ia64_unw_table_entry
* tp
;
6148 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6152 const unsigned char * dp
;
6153 const unsigned char * head
;
6154 const char * procname
;
6156 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6157 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6159 fputs ("\n<", stdout
);
6163 fputs (procname
, stdout
);
6166 printf ("+%lx", (unsigned long) offset
);
6169 fputs (">: [", stdout
);
6170 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6171 fputc ('-', stdout
);
6172 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6173 printf ("], info at +0x%lx\n",
6174 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6176 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6177 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6179 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6180 (unsigned) UNW_VER (stamp
),
6181 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6182 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6183 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6184 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6186 if (UNW_VER (stamp
) != 1)
6188 printf (_("\tUnknown version.\n"));
6193 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6194 dp
= unw_decode (dp
, in_body
, & in_body
);
6199 slurp_ia64_unwind_table (FILE * file
,
6200 struct ia64_unw_aux_info
* aux
,
6201 Elf_Internal_Shdr
* sec
)
6203 unsigned long size
, nrelas
, i
;
6204 Elf_Internal_Phdr
* seg
;
6205 struct ia64_unw_table_entry
* tep
;
6206 Elf_Internal_Shdr
* relsec
;
6207 Elf_Internal_Rela
* rela
;
6208 Elf_Internal_Rela
* rp
;
6209 unsigned char * table
;
6211 Elf_Internal_Sym
* sym
;
6212 const char * relname
;
6214 /* First, find the starting address of the segment that includes
6217 if (elf_header
.e_phnum
)
6219 if (! get_program_headers (file
))
6222 for (seg
= program_headers
;
6223 seg
< program_headers
+ elf_header
.e_phnum
;
6226 if (seg
->p_type
!= PT_LOAD
)
6229 if (sec
->sh_addr
>= seg
->p_vaddr
6230 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6232 aux
->seg_base
= seg
->p_vaddr
;
6238 /* Second, build the unwind table from the contents of the unwind section: */
6239 size
= sec
->sh_size
;
6240 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6245 aux
->table
= (struct ia64_unw_table_entry
*)
6246 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6248 for (tp
= table
; tp
< table
+ size
; ++tep
)
6250 tep
->start
.section
= SHN_UNDEF
;
6251 tep
->end
.section
= SHN_UNDEF
;
6252 tep
->info
.section
= SHN_UNDEF
;
6253 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6254 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6255 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6256 tep
->start
.offset
+= aux
->seg_base
;
6257 tep
->end
.offset
+= aux
->seg_base
;
6258 tep
->info
.offset
+= aux
->seg_base
;
6262 /* Third, apply any relocations to the unwind table: */
6263 for (relsec
= section_headers
;
6264 relsec
< section_headers
+ elf_header
.e_shnum
;
6267 if (relsec
->sh_type
!= SHT_RELA
6268 || relsec
->sh_info
>= elf_header
.e_shnum
6269 || section_headers
+ relsec
->sh_info
!= sec
)
6272 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6276 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6278 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6279 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6281 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6283 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6287 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6289 switch (rp
->r_offset
/eh_addr_size
% 3)
6292 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6293 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6296 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6297 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6300 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6301 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6311 aux
->table_len
= size
/ (3 * eh_addr_size
);
6316 ia64_process_unwind (FILE * file
)
6318 Elf_Internal_Shdr
* sec
;
6319 Elf_Internal_Shdr
* unwsec
= NULL
;
6320 Elf_Internal_Shdr
* strsec
;
6321 unsigned long i
, unwcount
= 0, unwstart
= 0;
6322 struct ia64_unw_aux_info aux
;
6324 memset (& aux
, 0, sizeof (aux
));
6326 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6328 if (sec
->sh_type
== SHT_SYMTAB
6329 && sec
->sh_link
< elf_header
.e_shnum
)
6331 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6333 strsec
= section_headers
+ sec
->sh_link
;
6334 assert (aux
.strtab
== NULL
);
6335 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6338 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6340 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6345 printf (_("\nThere are no unwind sections in this file.\n"));
6347 while (unwcount
-- > 0)
6352 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6353 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6354 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6361 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6363 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6365 /* We need to find which section group it is in. */
6366 struct group_list
* g
= section_headers_groups
[i
]->root
;
6368 for (; g
!= NULL
; g
= g
->next
)
6370 sec
= section_headers
+ g
->section_index
;
6372 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6377 i
= elf_header
.e_shnum
;
6379 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6381 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6382 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6383 suffix
= SECTION_NAME (unwsec
) + len
;
6384 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6386 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6387 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6392 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6393 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6394 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6395 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6397 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6398 suffix
= SECTION_NAME (unwsec
) + len
;
6399 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6401 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6402 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6406 if (i
== elf_header
.e_shnum
)
6408 printf (_("\nCould not find unwind info section for "));
6410 if (string_table
== NULL
)
6411 printf ("%d", unwsec
->sh_name
);
6413 printf (_("'%s'"), SECTION_NAME (unwsec
));
6417 aux
.info_addr
= sec
->sh_addr
;
6418 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6421 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6423 printf (_("\nUnwind section "));
6425 if (string_table
== NULL
)
6426 printf ("%d", unwsec
->sh_name
);
6428 printf (_("'%s'"), SECTION_NAME (unwsec
));
6430 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6431 (unsigned long) unwsec
->sh_offset
,
6432 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6434 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6436 if (aux
.table_len
> 0)
6437 dump_ia64_unwind (& aux
);
6440 free ((char *) aux
.table
);
6442 free ((char *) aux
.info
);
6451 free ((char *) aux
.strtab
);
6454 struct hppa_unw_table_entry
6456 struct absaddr start
;
6458 unsigned int Cannot_unwind
:1; /* 0 */
6459 unsigned int Millicode
:1; /* 1 */
6460 unsigned int Millicode_save_sr0
:1; /* 2 */
6461 unsigned int Region_description
:2; /* 3..4 */
6462 unsigned int reserved1
:1; /* 5 */
6463 unsigned int Entry_SR
:1; /* 6 */
6464 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6465 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6466 unsigned int Args_stored
:1; /* 16 */
6467 unsigned int Variable_Frame
:1; /* 17 */
6468 unsigned int Separate_Package_Body
:1; /* 18 */
6469 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6470 unsigned int Stack_Overflow_Check
:1; /* 20 */
6471 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6472 unsigned int Ada_Region
:1; /* 22 */
6473 unsigned int cxx_info
:1; /* 23 */
6474 unsigned int cxx_try_catch
:1; /* 24 */
6475 unsigned int sched_entry_seq
:1; /* 25 */
6476 unsigned int reserved2
:1; /* 26 */
6477 unsigned int Save_SP
:1; /* 27 */
6478 unsigned int Save_RP
:1; /* 28 */
6479 unsigned int Save_MRP_in_frame
:1; /* 29 */
6480 unsigned int extn_ptr_defined
:1; /* 30 */
6481 unsigned int Cleanup_defined
:1; /* 31 */
6483 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6484 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6485 unsigned int Large_frame
:1; /* 2 */
6486 unsigned int Pseudo_SP_Set
:1; /* 3 */
6487 unsigned int reserved4
:1; /* 4 */
6488 unsigned int Total_frame_size
:27; /* 5..31 */
6491 struct hppa_unw_aux_info
6493 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6494 unsigned long table_len
; /* Length of unwind table. */
6495 bfd_vma seg_base
; /* Starting address of segment. */
6496 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6497 unsigned long nsyms
; /* Number of symbols. */
6498 char * strtab
; /* The string table. */
6499 unsigned long strtab_size
; /* Size of string table. */
6503 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6505 struct hppa_unw_table_entry
* tp
;
6507 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6510 const char * procname
;
6512 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6513 aux
->strtab_size
, tp
->start
, &procname
,
6516 fputs ("\n<", stdout
);
6520 fputs (procname
, stdout
);
6523 printf ("+%lx", (unsigned long) offset
);
6526 fputs (">: [", stdout
);
6527 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6528 fputc ('-', stdout
);
6529 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6532 #define PF(_m) if (tp->_m) printf (#_m " ");
6533 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6536 PF(Millicode_save_sr0
);
6537 /* PV(Region_description); */
6543 PF(Separate_Package_Body
);
6544 PF(Frame_Extension_Millicode
);
6545 PF(Stack_Overflow_Check
);
6546 PF(Two_Instruction_SP_Increment
);
6550 PF(sched_entry_seq
);
6553 PF(Save_MRP_in_frame
);
6554 PF(extn_ptr_defined
);
6555 PF(Cleanup_defined
);
6556 PF(MPE_XL_interrupt_marker
);
6557 PF(HP_UX_interrupt_marker
);
6560 PV(Total_frame_size
);
6569 slurp_hppa_unwind_table (FILE * file
,
6570 struct hppa_unw_aux_info
* aux
,
6571 Elf_Internal_Shdr
* sec
)
6573 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6574 Elf_Internal_Phdr
* seg
;
6575 struct hppa_unw_table_entry
* tep
;
6576 Elf_Internal_Shdr
* relsec
;
6577 Elf_Internal_Rela
* rela
;
6578 Elf_Internal_Rela
* rp
;
6579 unsigned char * table
;
6581 Elf_Internal_Sym
* sym
;
6582 const char * relname
;
6584 /* First, find the starting address of the segment that includes
6587 if (elf_header
.e_phnum
)
6589 if (! get_program_headers (file
))
6592 for (seg
= program_headers
;
6593 seg
< program_headers
+ elf_header
.e_phnum
;
6596 if (seg
->p_type
!= PT_LOAD
)
6599 if (sec
->sh_addr
>= seg
->p_vaddr
6600 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6602 aux
->seg_base
= seg
->p_vaddr
;
6608 /* Second, build the unwind table from the contents of the unwind
6610 size
= sec
->sh_size
;
6611 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6617 nentries
= size
/ unw_ent_size
;
6618 size
= unw_ent_size
* nentries
;
6620 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6621 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6623 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6625 unsigned int tmp1
, tmp2
;
6627 tep
->start
.section
= SHN_UNDEF
;
6628 tep
->end
.section
= SHN_UNDEF
;
6630 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6631 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6632 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6633 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6635 tep
->start
.offset
+= aux
->seg_base
;
6636 tep
->end
.offset
+= aux
->seg_base
;
6638 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6639 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6640 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6641 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6642 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6643 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6644 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6645 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6646 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6647 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6648 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6649 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6650 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6651 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6652 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6653 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6654 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6655 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6656 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6657 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6658 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6659 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6660 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6661 tep
->Cleanup_defined
= tmp1
& 0x1;
6663 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6664 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6665 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6666 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6667 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6668 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6672 /* Third, apply any relocations to the unwind table. */
6673 for (relsec
= section_headers
;
6674 relsec
< section_headers
+ elf_header
.e_shnum
;
6677 if (relsec
->sh_type
!= SHT_RELA
6678 || relsec
->sh_info
>= elf_header
.e_shnum
6679 || section_headers
+ relsec
->sh_info
!= sec
)
6682 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6686 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6688 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6689 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6691 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6692 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6694 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6698 i
= rp
->r_offset
/ unw_ent_size
;
6700 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6703 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6704 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6707 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6708 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6718 aux
->table_len
= nentries
;
6724 hppa_process_unwind (FILE * file
)
6726 struct hppa_unw_aux_info aux
;
6727 Elf_Internal_Shdr
* unwsec
= NULL
;
6728 Elf_Internal_Shdr
* strsec
;
6729 Elf_Internal_Shdr
* sec
;
6732 if (string_table
== NULL
)
6735 memset (& aux
, 0, sizeof (aux
));
6737 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6739 if (sec
->sh_type
== SHT_SYMTAB
6740 && sec
->sh_link
< elf_header
.e_shnum
)
6742 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6744 strsec
= section_headers
+ sec
->sh_link
;
6745 assert (aux
.strtab
== NULL
);
6746 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6749 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6751 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6756 printf (_("\nThere are no unwind sections in this file.\n"));
6758 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6760 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6762 printf (_("\nUnwind section "));
6763 printf (_("'%s'"), SECTION_NAME (sec
));
6765 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6766 (unsigned long) sec
->sh_offset
,
6767 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6769 slurp_hppa_unwind_table (file
, &aux
, sec
);
6770 if (aux
.table_len
> 0)
6771 dump_hppa_unwind (&aux
);
6774 free ((char *) aux
.table
);
6782 free ((char *) aux
.strtab
);
6787 unsigned char * data
; /* The unwind data. */
6788 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6789 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6790 unsigned long nrelas
; /* The number of relocations. */
6791 unsigned int rel_type
; /* REL or RELA ? */
6792 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6795 struct arm_unw_aux_info
6797 FILE * file
; /* The file containing the unwind sections. */
6798 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6799 unsigned long nsyms
; /* Number of symbols. */
6800 char * strtab
; /* The file's string table. */
6801 unsigned long strtab_size
; /* Size of string table. */
6805 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6806 bfd_vma fn
, struct absaddr addr
)
6808 const char *procname
;
6811 if (addr
.section
== SHN_UNDEF
)
6814 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6815 aux
->strtab_size
, addr
, &procname
,
6818 print_vma (fn
, PREFIX_HEX
);
6822 fputs (" <", stdout
);
6823 fputs (procname
, stdout
);
6826 printf ("+0x%lx", (unsigned long) sym_offset
);
6827 fputc ('>', stdout
);
6834 arm_free_section (struct arm_section
*arm_sec
)
6836 if (arm_sec
->data
!= NULL
)
6837 free (arm_sec
->data
);
6839 if (arm_sec
->rela
!= NULL
)
6840 free (arm_sec
->rela
);
6843 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6844 cached section and install SEC instead.
6845 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6846 and return its valued in * WORDP, relocating if necessary.
6847 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6848 relocation's offset in ADDR.
6849 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6850 into the string table of the symbol associated with the reloc. If no
6851 reloc was applied store -1 there.
6852 5) Return TRUE upon success, FALSE otherwise. */
6855 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6856 struct arm_section
* arm_sec
,
6857 Elf_Internal_Shdr
* sec
,
6858 bfd_vma word_offset
,
6859 unsigned int * wordp
,
6860 struct absaddr
* addr
,
6863 Elf_Internal_Rela
*rp
;
6864 Elf_Internal_Sym
*sym
;
6865 const char * relname
;
6867 bfd_boolean wrapped
;
6869 addr
->section
= SHN_UNDEF
;
6872 if (sym_name
!= NULL
)
6873 *sym_name
= (bfd_vma
) -1;
6875 /* If necessary, update the section cache. */
6876 if (sec
!= arm_sec
->sec
)
6878 Elf_Internal_Shdr
*relsec
;
6880 arm_free_section (arm_sec
);
6883 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6884 sec
->sh_size
, _("unwind data"));
6885 arm_sec
->rela
= NULL
;
6886 arm_sec
->nrelas
= 0;
6888 for (relsec
= section_headers
;
6889 relsec
< section_headers
+ elf_header
.e_shnum
;
6892 if (relsec
->sh_info
>= elf_header
.e_shnum
6893 || section_headers
+ relsec
->sh_info
!= sec
6894 /* PR 15745: Check the section type as well. */
6895 || (relsec
->sh_type
!= SHT_REL
6896 && relsec
->sh_type
!= SHT_RELA
))
6899 arm_sec
->rel_type
= relsec
->sh_type
;
6900 if (relsec
->sh_type
== SHT_REL
)
6902 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6904 & arm_sec
->rela
, & arm_sec
->nrelas
))
6907 else /* relsec->sh_type == SHT_RELA */
6909 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6911 & arm_sec
->rela
, & arm_sec
->nrelas
))
6917 arm_sec
->next_rela
= arm_sec
->rela
;
6920 /* If there is no unwind data we can do nothing. */
6921 if (arm_sec
->data
== NULL
)
6924 /* Get the word at the required offset. */
6925 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6927 /* Look through the relocs to find the one that applies to the provided offset. */
6929 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6931 bfd_vma prelval
, offset
;
6933 if (rp
->r_offset
> word_offset
&& !wrapped
)
6938 if (rp
->r_offset
> word_offset
)
6941 if (rp
->r_offset
& 3)
6943 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6944 (unsigned long) rp
->r_offset
);
6948 if (rp
->r_offset
< word_offset
)
6951 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6953 if (arm_sec
->rel_type
== SHT_REL
)
6955 offset
= word
& 0x7fffffff;
6956 if (offset
& 0x40000000)
6957 offset
|= ~ (bfd_vma
) 0x7fffffff;
6959 else if (arm_sec
->rel_type
== SHT_RELA
)
6960 offset
= rp
->r_addend
;
6964 offset
+= sym
->st_value
;
6965 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6967 /* Check that we are processing the expected reloc type. */
6968 if (elf_header
.e_machine
== EM_ARM
)
6970 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6972 if (streq (relname
, "R_ARM_NONE"))
6975 if (! streq (relname
, "R_ARM_PREL31"))
6977 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6981 else if (elf_header
.e_machine
== EM_TI_C6000
)
6983 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6985 if (streq (relname
, "R_C6000_NONE"))
6988 if (! streq (relname
, "R_C6000_PREL31"))
6990 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6997 /* This function currently only supports ARM and TI unwinders. */
7000 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7001 addr
->section
= sym
->st_shndx
;
7002 addr
->offset
= offset
;
7004 * sym_name
= sym
->st_name
;
7009 arm_sec
->next_rela
= rp
;
7014 static const char *tic6x_unwind_regnames
[16] =
7016 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7017 "A14", "A13", "A12", "A11", "A10",
7018 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7022 decode_tic6x_unwind_regmask (unsigned int mask
)
7026 for (i
= 12; mask
; mask
>>= 1, i
--)
7030 fputs (tic6x_unwind_regnames
[i
], stdout
);
7032 fputs (", ", stdout
);
7038 if (remaining == 0 && more_words) \
7041 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7042 data_offset, & word, & addr, NULL)) \
7048 #define GET_OP(OP) \
7053 (OP) = word >> 24; \
7058 printf (_("[Truncated opcode]\n")); \
7061 printf ("0x%02x ", OP)
7064 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7065 unsigned int word
, unsigned int remaining
,
7066 unsigned int more_words
,
7067 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7068 struct arm_section
*data_arm_sec
)
7070 struct absaddr addr
;
7072 /* Decode the unwinding instructions. */
7075 unsigned int op
, op2
;
7084 printf (" 0x%02x ", op
);
7086 if ((op
& 0xc0) == 0x00)
7088 int offset
= ((op
& 0x3f) << 2) + 4;
7090 printf (" vsp = vsp + %d", offset
);
7092 else if ((op
& 0xc0) == 0x40)
7094 int offset
= ((op
& 0x3f) << 2) + 4;
7096 printf (" vsp = vsp - %d", offset
);
7098 else if ((op
& 0xf0) == 0x80)
7101 if (op
== 0x80 && op2
== 0)
7102 printf (_("Refuse to unwind"));
7105 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7110 for (i
= 0; i
< 12; i
++)
7111 if (mask
& (1 << i
))
7117 printf ("r%d", 4 + i
);
7122 else if ((op
& 0xf0) == 0x90)
7124 if (op
== 0x9d || op
== 0x9f)
7125 printf (_(" [Reserved]"));
7127 printf (" vsp = r%d", op
& 0x0f);
7129 else if ((op
& 0xf0) == 0xa0)
7131 int end
= 4 + (op
& 0x07);
7136 for (i
= 4; i
<= end
; i
++)
7152 else if (op
== 0xb0)
7153 printf (_(" finish"));
7154 else if (op
== 0xb1)
7157 if (op2
== 0 || (op2
& 0xf0) != 0)
7158 printf (_("[Spare]"));
7161 unsigned int mask
= op2
& 0x0f;
7166 for (i
= 0; i
< 12; i
++)
7167 if (mask
& (1 << i
))
7178 else if (op
== 0xb2)
7180 unsigned char buf
[9];
7181 unsigned int i
, len
;
7182 unsigned long offset
;
7184 for (i
= 0; i
< sizeof (buf
); i
++)
7187 if ((buf
[i
] & 0x80) == 0)
7190 assert (i
< sizeof (buf
));
7191 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7192 assert (len
== i
+ 1);
7193 offset
= offset
* 4 + 0x204;
7194 printf ("vsp = vsp + %ld", offset
);
7196 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7198 unsigned int first
, last
;
7205 printf ("pop {D%d", first
);
7207 printf ("-D%d", first
+ last
);
7210 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7212 unsigned int count
= op
& 0x07;
7216 printf ("-D%d", 8 + count
);
7219 else if (op
>= 0xc0 && op
<= 0xc5)
7221 unsigned int count
= op
& 0x07;
7223 printf (" pop {wR10");
7225 printf ("-wR%d", 10 + count
);
7228 else if (op
== 0xc6)
7230 unsigned int first
, last
;
7235 printf ("pop {wR%d", first
);
7237 printf ("-wR%d", first
+ last
);
7240 else if (op
== 0xc7)
7243 if (op2
== 0 || (op2
& 0xf0) != 0)
7244 printf (_("[Spare]"));
7247 unsigned int mask
= op2
& 0x0f;
7252 for (i
= 0; i
< 4; i
++)
7253 if (mask
& (1 << i
))
7259 printf ("wCGR%d", i
);
7265 printf (_(" [unsupported opcode]"));
7271 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7272 unsigned int word
, unsigned int remaining
,
7273 unsigned int more_words
,
7274 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7275 struct arm_section
*data_arm_sec
)
7277 struct absaddr addr
;
7279 /* Decode the unwinding instructions. */
7282 unsigned int op
, op2
;
7291 printf (" 0x%02x ", op
);
7293 if ((op
& 0xc0) == 0x00)
7295 int offset
= ((op
& 0x3f) << 3) + 8;
7296 printf (" sp = sp + %d", offset
);
7298 else if ((op
& 0xc0) == 0x80)
7301 if (op
== 0x80 && op2
== 0)
7302 printf (_("Refuse to unwind"));
7305 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7307 printf ("pop compact {");
7311 decode_tic6x_unwind_regmask (mask
);
7315 else if ((op
& 0xf0) == 0xc0)
7323 unsigned int offset
;
7327 /* Scan entire instruction first so that GET_OP output is not
7328 interleaved with disassembly. */
7330 for (i
= 0; nregs
< (op
& 0xf); i
++)
7336 regpos
[nregs
].offset
= i
* 2;
7337 regpos
[nregs
].reg
= reg
;
7344 regpos
[nregs
].offset
= i
* 2 + 1;
7345 regpos
[nregs
].reg
= reg
;
7350 printf (_("pop frame {"));
7352 for (i
= i
* 2; i
> 0; i
--)
7354 if (regpos
[reg
].offset
== i
- 1)
7356 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7363 fputs (name
, stdout
);
7370 else if (op
== 0xd0)
7371 printf (" MOV FP, SP");
7372 else if (op
== 0xd1)
7373 printf (" __c6xabi_pop_rts");
7374 else if (op
== 0xd2)
7376 unsigned char buf
[9];
7377 unsigned int i
, len
;
7378 unsigned long offset
;
7380 for (i
= 0; i
< sizeof (buf
); i
++)
7383 if ((buf
[i
] & 0x80) == 0)
7386 assert (i
< sizeof (buf
));
7387 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7388 assert (len
== i
+ 1);
7389 offset
= offset
* 8 + 0x408;
7390 printf (_("sp = sp + %ld"), offset
);
7392 else if ((op
& 0xf0) == 0xe0)
7394 if ((op
& 0x0f) == 7)
7397 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7401 printf (_(" [unsupported opcode]"));
7408 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7412 offset
= word
& 0x7fffffff;
7413 if (offset
& 0x40000000)
7414 offset
|= ~ (bfd_vma
) 0x7fffffff;
7416 if (elf_header
.e_machine
== EM_TI_C6000
)
7419 return offset
+ where
;
7423 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7425 unsigned int remaining
,
7426 bfd_vma data_offset
,
7427 Elf_Internal_Shdr
* data_sec
,
7428 struct arm_section
* data_arm_sec
)
7431 unsigned int more_words
= 0;
7432 struct absaddr addr
;
7433 bfd_vma sym_name
= (bfd_vma
) -1;
7437 /* Fetch the first word.
7438 Note - when decoding an object file the address extracted
7439 here will always be 0. So we also pass in the sym_name
7440 parameter so that we can find the symbol associated with
7441 the personality routine. */
7442 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7443 & word
, & addr
, & sym_name
))
7449 if ((word
& 0x80000000) == 0)
7451 /* Expand prel31 for personality routine. */
7453 const char *procname
;
7455 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7456 printf (_(" Personality routine: "));
7458 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7459 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7461 procname
= aux
->strtab
+ sym_name
;
7462 print_vma (fn
, PREFIX_HEX
);
7465 fputs (" <", stdout
);
7466 fputs (procname
, stdout
);
7467 fputc ('>', stdout
);
7471 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7472 fputc ('\n', stdout
);
7474 /* The GCC personality routines use the standard compact
7475 encoding, starting with one byte giving the number of
7477 if (procname
!= NULL
7478 && (const_strneq (procname
, "__gcc_personality_v0")
7479 || const_strneq (procname
, "__gxx_personality_v0")
7480 || const_strneq (procname
, "__gcj_personality_v0")
7481 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7488 printf (_(" [Truncated data]\n"));
7491 more_words
= word
>> 24;
7501 /* ARM EHABI Section 6.3:
7503 An exception-handling table entry for the compact model looks like:
7507 1 0 index Data for personalityRoutine[index] */
7509 if (elf_header
.e_machine
== EM_ARM
7510 && (word
& 0x70000000))
7511 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7513 per_index
= (word
>> 24) & 0x7f;
7514 printf (_(" Compact model index: %d\n"), per_index
);
7521 else if (per_index
< 3)
7523 more_words
= (word
>> 16) & 0xff;
7529 switch (elf_header
.e_machine
)
7534 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7535 data_offset
, data_sec
, data_arm_sec
);
7539 warn (_("Unknown ARM compact model index encountered\n"));
7540 printf (_(" [reserved]\n"));
7547 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7548 data_offset
, data_sec
, data_arm_sec
);
7550 else if (per_index
< 5)
7552 if (((word
>> 17) & 0x7f) == 0x7f)
7553 printf (_(" Restore stack from frame pointer\n"));
7555 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7556 printf (_(" Registers restored: "));
7558 printf (" (compact) ");
7559 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7561 printf (_(" Return register: %s\n"),
7562 tic6x_unwind_regnames
[word
& 0xf]);
7565 printf (_(" [reserved (%d)]\n"), per_index
);
7569 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7570 elf_header
.e_machine
);
7573 /* Decode the descriptors. Not implemented. */
7577 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7579 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7580 unsigned int i
, exidx_len
;
7582 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7583 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7584 exidx_len
= exidx_sec
->sh_size
/ 8;
7586 for (i
= 0; i
< exidx_len
; i
++)
7588 unsigned int exidx_fn
, exidx_entry
;
7589 struct absaddr fn_addr
, entry_addr
;
7592 fputc ('\n', stdout
);
7594 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7595 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7596 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7597 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7599 arm_free_section (& exidx_arm_sec
);
7600 arm_free_section (& extab_arm_sec
);
7604 /* ARM EHABI, Section 5:
7605 An index table entry consists of 2 words.
7606 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7607 if (exidx_fn
& 0x80000000)
7608 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7610 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7612 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7613 fputs (": ", stdout
);
7615 if (exidx_entry
== 1)
7617 print_vma (exidx_entry
, PREFIX_HEX
);
7618 fputs (" [cantunwind]\n", stdout
);
7620 else if (exidx_entry
& 0x80000000)
7622 print_vma (exidx_entry
, PREFIX_HEX
);
7623 fputc ('\n', stdout
);
7624 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7628 bfd_vma table
, table_offset
= 0;
7629 Elf_Internal_Shdr
*table_sec
;
7631 fputs ("@", stdout
);
7632 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7633 print_vma (table
, PREFIX_HEX
);
7636 /* Locate the matching .ARM.extab. */
7637 if (entry_addr
.section
!= SHN_UNDEF
7638 && entry_addr
.section
< elf_header
.e_shnum
)
7640 table_sec
= section_headers
+ entry_addr
.section
;
7641 table_offset
= entry_addr
.offset
;
7645 table_sec
= find_section_by_address (table
);
7646 if (table_sec
!= NULL
)
7647 table_offset
= table
- table_sec
->sh_addr
;
7649 if (table_sec
== NULL
)
7651 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7652 (unsigned long) table
);
7655 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7662 arm_free_section (&exidx_arm_sec
);
7663 arm_free_section (&extab_arm_sec
);
7666 /* Used for both ARM and C6X unwinding tables. */
7669 arm_process_unwind (FILE *file
)
7671 struct arm_unw_aux_info aux
;
7672 Elf_Internal_Shdr
*unwsec
= NULL
;
7673 Elf_Internal_Shdr
*strsec
;
7674 Elf_Internal_Shdr
*sec
;
7676 unsigned int sec_type
;
7678 switch (elf_header
.e_machine
)
7681 sec_type
= SHT_ARM_EXIDX
;
7685 sec_type
= SHT_C6000_UNWIND
;
7689 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7690 elf_header
.e_machine
);
7694 if (string_table
== NULL
)
7697 memset (& aux
, 0, sizeof (aux
));
7700 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7702 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7704 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7706 strsec
= section_headers
+ sec
->sh_link
;
7707 assert (aux
.strtab
== NULL
);
7708 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7709 1, strsec
->sh_size
, _("string table"));
7710 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7712 else if (sec
->sh_type
== sec_type
)
7717 printf (_("\nThere are no unwind sections in this file.\n"));
7719 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7721 if (sec
->sh_type
== sec_type
)
7723 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7725 (unsigned long) sec
->sh_offset
,
7726 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7728 dump_arm_unwind (&aux
, sec
);
7735 free ((char *) aux
.strtab
);
7739 process_unwind (FILE * file
)
7741 struct unwind_handler
7744 void (* handler
)(FILE *);
7747 { EM_ARM
, arm_process_unwind
},
7748 { EM_IA_64
, ia64_process_unwind
},
7749 { EM_PARISC
, hppa_process_unwind
},
7750 { EM_TI_C6000
, arm_process_unwind
},
7758 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7759 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7761 handlers
[i
].handler (file
);
7765 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7766 get_machine_name (elf_header
.e_machine
));
7770 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7772 switch (entry
->d_tag
)
7775 if (entry
->d_un
.d_val
== 0)
7779 static const char * opts
[] =
7781 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7782 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7783 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7784 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7790 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7791 if (entry
->d_un
.d_val
& (1 << cnt
))
7793 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7799 case DT_MIPS_IVERSION
:
7800 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7801 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7805 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
7806 /* Note: coded this way so that there is a single string for translation. */
7807 printf (_("<corrupt: %s>"), buf
);
7811 case DT_MIPS_TIME_STAMP
:
7816 time_t atime
= entry
->d_un
.d_val
;
7817 tmp
= gmtime (&atime
);
7818 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7819 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7820 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7821 printf (_("Time Stamp: %s"), timebuf
);
7825 case DT_MIPS_RLD_VERSION
:
7826 case DT_MIPS_LOCAL_GOTNO
:
7827 case DT_MIPS_CONFLICTNO
:
7828 case DT_MIPS_LIBLISTNO
:
7829 case DT_MIPS_SYMTABNO
:
7830 case DT_MIPS_UNREFEXTNO
:
7831 case DT_MIPS_HIPAGENO
:
7832 case DT_MIPS_DELTA_CLASS_NO
:
7833 case DT_MIPS_DELTA_INSTANCE_NO
:
7834 case DT_MIPS_DELTA_RELOC_NO
:
7835 case DT_MIPS_DELTA_SYM_NO
:
7836 case DT_MIPS_DELTA_CLASSSYM_NO
:
7837 case DT_MIPS_COMPACT_SIZE
:
7838 print_vma (entry
->d_un
.d_ptr
, DEC
);
7842 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7848 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7850 switch (entry
->d_tag
)
7852 case DT_HP_DLD_FLAGS
:
7861 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7862 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7863 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7864 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7865 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7866 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7867 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7868 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7869 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7870 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7871 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7872 { DT_HP_GST
, "HP_GST" },
7873 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7874 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7875 { DT_HP_NODELETE
, "HP_NODELETE" },
7876 { DT_HP_GROUP
, "HP_GROUP" },
7877 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7881 bfd_vma val
= entry
->d_un
.d_val
;
7883 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7884 if (val
& flags
[cnt
].bit
)
7888 fputs (flags
[cnt
].str
, stdout
);
7890 val
^= flags
[cnt
].bit
;
7893 if (val
!= 0 || first
)
7897 print_vma (val
, HEX
);
7903 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7911 /* VMS vs Unix time offset and factor. */
7913 #define VMS_EPOCH_OFFSET 35067168000000000LL
7914 #define VMS_GRANULARITY_FACTOR 10000000
7916 /* Display a VMS time in a human readable format. */
7919 print_vms_time (bfd_int64_t vmstime
)
7924 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7925 tm
= gmtime (&unxtime
);
7926 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7927 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7928 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7933 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7935 switch (entry
->d_tag
)
7937 case DT_IA_64_PLT_RESERVE
:
7938 /* First 3 slots reserved. */
7939 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7941 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7944 case DT_IA_64_VMS_LINKTIME
:
7946 print_vms_time (entry
->d_un
.d_val
);
7950 case DT_IA_64_VMS_LNKFLAGS
:
7951 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7952 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7953 printf (" CALL_DEBUG");
7954 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7955 printf (" NOP0BUFS");
7956 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7957 printf (" P0IMAGE");
7958 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7959 printf (" MKTHREADS");
7960 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7961 printf (" UPCALLS");
7962 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7964 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7965 printf (" INITIALIZE");
7966 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7968 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7969 printf (" EXE_INIT");
7970 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7971 printf (" TBK_IN_IMG");
7972 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7973 printf (" DBG_IN_IMG");
7974 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7975 printf (" TBK_IN_DSF");
7976 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7977 printf (" DBG_IN_DSF");
7978 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7979 printf (" SIGNATURES");
7980 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7981 printf (" REL_SEG_OFF");
7985 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7992 get_32bit_dynamic_section (FILE * file
)
7994 Elf32_External_Dyn
* edyn
;
7995 Elf32_External_Dyn
* ext
;
7996 Elf_Internal_Dyn
* entry
;
7998 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7999 dynamic_size
, _("dynamic section"));
8003 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8004 might not have the luxury of section headers. Look for the DT_NULL
8005 terminator to determine the number of entries. */
8006 for (ext
= edyn
, dynamic_nent
= 0;
8007 (char *) ext
< (char *) edyn
+ dynamic_size
;
8011 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8015 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8017 if (dynamic_section
== NULL
)
8019 error (_("Out of memory\n"));
8024 for (ext
= edyn
, entry
= dynamic_section
;
8025 entry
< dynamic_section
+ dynamic_nent
;
8028 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8029 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8038 get_64bit_dynamic_section (FILE * file
)
8040 Elf64_External_Dyn
* edyn
;
8041 Elf64_External_Dyn
* ext
;
8042 Elf_Internal_Dyn
* entry
;
8044 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8045 dynamic_size
, _("dynamic section"));
8049 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8050 might not have the luxury of section headers. Look for the DT_NULL
8051 terminator to determine the number of entries. */
8052 for (ext
= edyn
, dynamic_nent
= 0;
8053 (char *) ext
< (char *) edyn
+ dynamic_size
;
8057 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8061 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8063 if (dynamic_section
== NULL
)
8065 error (_("Out of memory\n"));
8070 for (ext
= edyn
, entry
= dynamic_section
;
8071 entry
< dynamic_section
+ dynamic_nent
;
8074 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8075 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8084 print_dynamic_flags (bfd_vma flags
)
8092 flag
= flags
& - flags
;
8102 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8103 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8104 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8105 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8106 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8107 default: fputs (_("unknown"), stdout
); break;
8113 /* Parse and display the contents of the dynamic section. */
8116 process_dynamic_section (FILE * file
)
8118 Elf_Internal_Dyn
* entry
;
8120 if (dynamic_size
== 0)
8123 printf (_("\nThere is no dynamic section in this file.\n"));
8130 if (! get_32bit_dynamic_section (file
))
8133 else if (! get_64bit_dynamic_section (file
))
8136 /* Find the appropriate symbol table. */
8137 if (dynamic_symbols
== NULL
)
8139 for (entry
= dynamic_section
;
8140 entry
< dynamic_section
+ dynamic_nent
;
8143 Elf_Internal_Shdr section
;
8145 if (entry
->d_tag
!= DT_SYMTAB
)
8148 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8150 /* Since we do not know how big the symbol table is,
8151 we default to reading in the entire file (!) and
8152 processing that. This is overkill, I know, but it
8154 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8156 if (archive_file_offset
!= 0)
8157 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8160 if (fseek (file
, 0, SEEK_END
))
8161 error (_("Unable to seek to end of file!\n"));
8163 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8167 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8169 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8171 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8172 if (num_dynamic_syms
< 1)
8174 error (_("Unable to determine the number of symbols to load\n"));
8180 /* Similarly find a string table. */
8181 if (dynamic_strings
== NULL
)
8183 for (entry
= dynamic_section
;
8184 entry
< dynamic_section
+ dynamic_nent
;
8187 unsigned long offset
;
8190 if (entry
->d_tag
!= DT_STRTAB
)
8193 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8195 /* Since we do not know how big the string table is,
8196 we default to reading in the entire file (!) and
8197 processing that. This is overkill, I know, but it
8200 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8202 if (archive_file_offset
!= 0)
8203 str_tab_len
= archive_file_size
- offset
;
8206 if (fseek (file
, 0, SEEK_END
))
8207 error (_("Unable to seek to end of file\n"));
8208 str_tab_len
= ftell (file
) - offset
;
8211 if (str_tab_len
< 1)
8214 (_("Unable to determine the length of the dynamic string table\n"));
8218 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8220 _("dynamic string table"));
8221 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8226 /* And find the syminfo section if available. */
8227 if (dynamic_syminfo
== NULL
)
8229 unsigned long syminsz
= 0;
8231 for (entry
= dynamic_section
;
8232 entry
< dynamic_section
+ dynamic_nent
;
8235 if (entry
->d_tag
== DT_SYMINENT
)
8237 /* Note: these braces are necessary to avoid a syntax
8238 error from the SunOS4 C compiler. */
8239 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
8241 else if (entry
->d_tag
== DT_SYMINSZ
)
8242 syminsz
= entry
->d_un
.d_val
;
8243 else if (entry
->d_tag
== DT_SYMINFO
)
8244 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8248 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8250 Elf_External_Syminfo
* extsyminfo
;
8251 Elf_External_Syminfo
* extsym
;
8252 Elf_Internal_Syminfo
* syminfo
;
8254 /* There is a syminfo section. Read the data. */
8255 extsyminfo
= (Elf_External_Syminfo
*)
8256 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8257 _("symbol information"));
8261 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8262 if (dynamic_syminfo
== NULL
)
8264 error (_("Out of memory\n"));
8268 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8269 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8270 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8271 ++syminfo
, ++extsym
)
8273 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8274 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8281 if (do_dynamic
&& dynamic_addr
)
8282 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8283 dynamic_addr
, dynamic_nent
);
8285 printf (_(" Tag Type Name/Value\n"));
8287 for (entry
= dynamic_section
;
8288 entry
< dynamic_section
+ dynamic_nent
;
8296 print_vma (entry
->d_tag
, FULL_HEX
);
8297 dtype
= get_dynamic_type (entry
->d_tag
);
8298 printf (" (%s)%*s", dtype
,
8299 ((is_32bit_elf
? 27 : 19)
8300 - (int) strlen (dtype
)),
8304 switch (entry
->d_tag
)
8308 print_dynamic_flags (entry
->d_un
.d_val
);
8318 switch (entry
->d_tag
)
8321 printf (_("Auxiliary library"));
8325 printf (_("Filter library"));
8329 printf (_("Configuration file"));
8333 printf (_("Dependency audit library"));
8337 printf (_("Audit library"));
8341 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8342 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8346 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8355 printf (_("Flags:"));
8357 if (entry
->d_un
.d_val
== 0)
8358 printf (_(" None\n"));
8361 unsigned long int val
= entry
->d_un
.d_val
;
8363 if (val
& DTF_1_PARINIT
)
8365 printf (" PARINIT");
8366 val
^= DTF_1_PARINIT
;
8368 if (val
& DTF_1_CONFEXP
)
8370 printf (" CONFEXP");
8371 val
^= DTF_1_CONFEXP
;
8374 printf (" %lx", val
);
8383 printf (_("Flags:"));
8385 if (entry
->d_un
.d_val
== 0)
8386 printf (_(" None\n"));
8389 unsigned long int val
= entry
->d_un
.d_val
;
8391 if (val
& DF_P1_LAZYLOAD
)
8393 printf (" LAZYLOAD");
8394 val
^= DF_P1_LAZYLOAD
;
8396 if (val
& DF_P1_GROUPPERM
)
8398 printf (" GROUPPERM");
8399 val
^= DF_P1_GROUPPERM
;
8402 printf (" %lx", val
);
8411 printf (_("Flags:"));
8412 if (entry
->d_un
.d_val
== 0)
8413 printf (_(" None\n"));
8416 unsigned long int val
= entry
->d_un
.d_val
;
8423 if (val
& DF_1_GLOBAL
)
8428 if (val
& DF_1_GROUP
)
8433 if (val
& DF_1_NODELETE
)
8435 printf (" NODELETE");
8436 val
^= DF_1_NODELETE
;
8438 if (val
& DF_1_LOADFLTR
)
8440 printf (" LOADFLTR");
8441 val
^= DF_1_LOADFLTR
;
8443 if (val
& DF_1_INITFIRST
)
8445 printf (" INITFIRST");
8446 val
^= DF_1_INITFIRST
;
8448 if (val
& DF_1_NOOPEN
)
8453 if (val
& DF_1_ORIGIN
)
8458 if (val
& DF_1_DIRECT
)
8463 if (val
& DF_1_TRANS
)
8468 if (val
& DF_1_INTERPOSE
)
8470 printf (" INTERPOSE");
8471 val
^= DF_1_INTERPOSE
;
8473 if (val
& DF_1_NODEFLIB
)
8475 printf (" NODEFLIB");
8476 val
^= DF_1_NODEFLIB
;
8478 if (val
& DF_1_NODUMP
)
8483 if (val
& DF_1_CONFALT
)
8485 printf (" CONFALT");
8486 val
^= DF_1_CONFALT
;
8488 if (val
& DF_1_ENDFILTEE
)
8490 printf (" ENDFILTEE");
8491 val
^= DF_1_ENDFILTEE
;
8493 if (val
& DF_1_DISPRELDNE
)
8495 printf (" DISPRELDNE");
8496 val
^= DF_1_DISPRELDNE
;
8498 if (val
& DF_1_DISPRELPND
)
8500 printf (" DISPRELPND");
8501 val
^= DF_1_DISPRELPND
;
8503 if (val
& DF_1_NODIRECT
)
8505 printf (" NODIRECT");
8506 val
^= DF_1_NODIRECT
;
8508 if (val
& DF_1_IGNMULDEF
)
8510 printf (" IGNMULDEF");
8511 val
^= DF_1_IGNMULDEF
;
8513 if (val
& DF_1_NOKSYMS
)
8515 printf (" NOKSYMS");
8516 val
^= DF_1_NOKSYMS
;
8518 if (val
& DF_1_NOHDR
)
8523 if (val
& DF_1_EDITED
)
8528 if (val
& DF_1_NORELOC
)
8530 printf (" NORELOC");
8531 val
^= DF_1_NORELOC
;
8533 if (val
& DF_1_SYMINTPOSE
)
8535 printf (" SYMINTPOSE");
8536 val
^= DF_1_SYMINTPOSE
;
8538 if (val
& DF_1_GLOBAUDIT
)
8540 printf (" GLOBAUDIT");
8541 val
^= DF_1_GLOBAUDIT
;
8543 if (val
& DF_1_SINGLETON
)
8545 printf (" SINGLETON");
8546 val
^= DF_1_SINGLETON
;
8549 printf (" %lx", val
);
8556 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8558 puts (get_dynamic_type (entry
->d_un
.d_val
));
8578 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8584 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8585 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8591 switch (entry
->d_tag
)
8594 printf (_("Shared library: [%s]"), name
);
8596 if (streq (name
, program_interpreter
))
8597 printf (_(" program interpreter"));
8601 printf (_("Library soname: [%s]"), name
);
8605 printf (_("Library rpath: [%s]"), name
);
8609 printf (_("Library runpath: [%s]"), name
);
8613 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8618 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8631 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8635 case DT_INIT_ARRAYSZ
:
8636 case DT_FINI_ARRAYSZ
:
8637 case DT_GNU_CONFLICTSZ
:
8638 case DT_GNU_LIBLISTSZ
:
8641 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8642 printf (_(" (bytes)\n"));
8652 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8665 if (entry
->d_tag
== DT_USED
8666 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8668 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8672 printf (_("Not needed object: [%s]\n"), name
);
8677 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8683 /* The value of this entry is ignored. */
8688 case DT_GNU_PRELINKED
:
8692 time_t atime
= entry
->d_un
.d_val
;
8694 tmp
= gmtime (&atime
);
8695 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8696 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8697 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8703 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8706 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8712 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8713 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8718 switch (elf_header
.e_machine
)
8721 case EM_MIPS_RS3_LE
:
8722 dynamic_section_mips_val (entry
);
8725 dynamic_section_parisc_val (entry
);
8728 dynamic_section_ia64_val (entry
);
8731 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8743 get_ver_flags (unsigned int flags
)
8745 static char buff
[32];
8752 if (flags
& VER_FLG_BASE
)
8753 strcat (buff
, "BASE ");
8755 if (flags
& VER_FLG_WEAK
)
8757 if (flags
& VER_FLG_BASE
)
8758 strcat (buff
, "| ");
8760 strcat (buff
, "WEAK ");
8763 if (flags
& VER_FLG_INFO
)
8765 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8766 strcat (buff
, "| ");
8768 strcat (buff
, "INFO ");
8771 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8772 strcat (buff
, _("| <unknown>"));
8777 /* Display the contents of the version sections. */
8780 process_version_sections (FILE * file
)
8782 Elf_Internal_Shdr
* section
;
8789 for (i
= 0, section
= section_headers
;
8790 i
< elf_header
.e_shnum
;
8793 switch (section
->sh_type
)
8795 case SHT_GNU_verdef
:
8797 Elf_External_Verdef
* edefs
;
8805 (_("\nVersion definition section '%s' contains %u entries:\n"),
8806 SECTION_NAME (section
), section
->sh_info
);
8808 printf (_(" Addr: 0x"));
8809 printf_vma (section
->sh_addr
);
8810 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8811 (unsigned long) section
->sh_offset
, section
->sh_link
,
8812 section
->sh_link
< elf_header
.e_shnum
8813 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8816 edefs
= (Elf_External_Verdef
*)
8817 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8818 _("version definition section"));
8821 endbuf
= (char *) edefs
+ section
->sh_size
;
8823 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8826 Elf_External_Verdef
* edef
;
8827 Elf_Internal_Verdef ent
;
8828 Elf_External_Verdaux
* eaux
;
8829 Elf_Internal_Verdaux aux
;
8833 /* Check for very large indicies. */
8834 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8837 vstart
= ((char *) edefs
) + idx
;
8838 if (vstart
+ sizeof (*edef
) > endbuf
)
8841 edef
= (Elf_External_Verdef
*) vstart
;
8843 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8844 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8845 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8846 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8847 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8848 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8849 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8851 printf (_(" %#06x: Rev: %d Flags: %s"),
8852 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8854 printf (_(" Index: %d Cnt: %d "),
8855 ent
.vd_ndx
, ent
.vd_cnt
);
8857 /* Check for overflow. */
8858 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8861 vstart
+= ent
.vd_aux
;
8863 eaux
= (Elf_External_Verdaux
*) vstart
;
8865 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8866 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8868 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8869 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8871 printf (_("Name index: %ld\n"), aux
.vda_name
);
8873 isum
= idx
+ ent
.vd_aux
;
8875 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8877 /* Check for overflow. */
8878 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8881 isum
+= aux
.vda_next
;
8882 vstart
+= aux
.vda_next
;
8884 eaux
= (Elf_External_Verdaux
*) vstart
;
8885 if (vstart
+ sizeof (*eaux
) > endbuf
)
8888 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8889 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8891 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8892 printf (_(" %#06x: Parent %d: %s\n"),
8893 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8895 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8896 isum
, j
, aux
.vda_name
);
8900 printf (_(" Version def aux past end of section\n"));
8905 if (cnt
< section
->sh_info
)
8906 printf (_(" Version definition past end of section\n"));
8912 case SHT_GNU_verneed
:
8914 Elf_External_Verneed
* eneed
;
8921 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8922 SECTION_NAME (section
), section
->sh_info
);
8924 printf (_(" Addr: 0x"));
8925 printf_vma (section
->sh_addr
);
8926 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8927 (unsigned long) section
->sh_offset
, section
->sh_link
,
8928 section
->sh_link
< elf_header
.e_shnum
8929 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8932 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8933 section
->sh_offset
, 1,
8935 _("Version Needs section"));
8938 endbuf
= (char *) eneed
+ section
->sh_size
;
8940 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8942 Elf_External_Verneed
* entry
;
8943 Elf_Internal_Verneed ent
;
8948 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8951 vstart
= ((char *) eneed
) + idx
;
8952 if (vstart
+ sizeof (*entry
) > endbuf
)
8955 entry
= (Elf_External_Verneed
*) vstart
;
8957 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8958 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8959 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8960 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8961 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8963 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8965 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8966 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8968 printf (_(" File: %lx"), ent
.vn_file
);
8970 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8972 /* Check for overflow. */
8973 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8976 vstart
+= ent
.vn_aux
;
8978 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8980 Elf_External_Vernaux
* eaux
;
8981 Elf_Internal_Vernaux aux
;
8983 if (vstart
+ sizeof (*eaux
) > endbuf
)
8985 eaux
= (Elf_External_Vernaux
*) vstart
;
8987 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8988 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8989 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8990 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8991 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8993 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8994 printf (_(" %#06x: Name: %s"),
8995 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8997 printf (_(" %#06x: Name index: %lx"),
8998 isum
, aux
.vna_name
);
9000 printf (_(" Flags: %s Version: %d\n"),
9001 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9003 /* Check for overflow. */
9004 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9007 isum
+= aux
.vna_next
;
9008 vstart
+= aux
.vna_next
;
9012 warn (_("Missing Version Needs auxillary information\n"));
9014 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9016 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9017 cnt
= section
->sh_info
;
9023 if (cnt
< section
->sh_info
)
9024 warn (_("Missing Version Needs information\n"));
9030 case SHT_GNU_versym
:
9032 Elf_Internal_Shdr
* link_section
;
9035 unsigned char * edata
;
9036 unsigned short * data
;
9038 Elf_Internal_Sym
* symbols
;
9039 Elf_Internal_Shdr
* string_sec
;
9040 unsigned long num_syms
;
9043 if (section
->sh_link
>= elf_header
.e_shnum
)
9046 link_section
= section_headers
+ section
->sh_link
;
9047 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9049 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9054 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9055 if (symbols
== NULL
)
9058 string_sec
= section_headers
+ link_section
->sh_link
;
9060 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9061 string_sec
->sh_size
,
9062 _("version string table"));
9069 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9070 SECTION_NAME (section
), total
);
9072 printf (_(" Addr: "));
9073 printf_vma (section
->sh_addr
);
9074 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9075 (unsigned long) section
->sh_offset
, section
->sh_link
,
9076 SECTION_NAME (link_section
));
9078 off
= offset_from_vma (file
,
9079 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9080 total
* sizeof (short));
9081 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9083 _("version symbol data"));
9091 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9093 for (cnt
= total
; cnt
--;)
9094 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9099 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9102 int check_def
, check_need
;
9105 printf (" %03x:", cnt
);
9107 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9108 switch (data
[cnt
+ j
])
9111 fputs (_(" 0 (*local*) "), stdout
);
9115 fputs (_(" 1 (*global*) "), stdout
);
9119 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9120 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9122 /* If this index value is greater than the size of the symbols
9123 array, break to avoid an out-of-bounds read. */
9124 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9126 warn (_("invalid index into symbol array\n"));
9132 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9133 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9136 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9143 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9145 Elf_Internal_Verneed ivn
;
9146 unsigned long offset
;
9148 offset
= offset_from_vma
9149 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9150 sizeof (Elf_External_Verneed
));
9154 Elf_Internal_Vernaux ivna
;
9155 Elf_External_Verneed evn
;
9156 Elf_External_Vernaux evna
;
9157 unsigned long a_off
;
9159 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9160 _("version need")) == NULL
)
9163 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9164 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9166 a_off
= offset
+ ivn
.vn_aux
;
9170 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9171 1, _("version need aux (2)")) == NULL
)
9178 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9179 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9182 a_off
+= ivna
.vna_next
;
9184 while (ivna
.vna_other
!= data
[cnt
+ j
]
9185 && ivna
.vna_next
!= 0);
9187 if (ivna
.vna_other
== data
[cnt
+ j
])
9189 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9191 if (ivna
.vna_name
>= string_sec
->sh_size
)
9192 name
= _("*invalid*");
9194 name
= strtab
+ ivna
.vna_name
;
9195 nn
+= printf ("(%s%-*s",
9197 12 - (int) strlen (name
),
9203 offset
+= ivn
.vn_next
;
9205 while (ivn
.vn_next
);
9208 if (check_def
&& data
[cnt
+ j
] != 0x8001
9209 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9211 Elf_Internal_Verdef ivd
;
9212 Elf_External_Verdef evd
;
9213 unsigned long offset
;
9215 offset
= offset_from_vma
9216 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9221 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9222 _("version def")) == NULL
)
9229 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9230 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9233 offset
+= ivd
.vd_next
;
9235 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9236 && ivd
.vd_next
!= 0);
9238 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9240 Elf_External_Verdaux evda
;
9241 Elf_Internal_Verdaux ivda
;
9243 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9245 if (get_data (&evda
, file
,
9246 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9248 _("version def aux")) == NULL
)
9251 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9253 if (ivda
.vda_name
>= string_sec
->sh_size
)
9254 name
= _("*invalid*");
9256 name
= strtab
+ ivda
.vda_name
;
9257 nn
+= printf ("(%s%-*s",
9259 12 - (int) strlen (name
),
9265 printf ("%*c", 18 - nn
, ' ');
9283 printf (_("\nNo version information found in this file.\n"));
9289 get_symbol_binding (unsigned int binding
)
9291 static char buff
[32];
9295 case STB_LOCAL
: return "LOCAL";
9296 case STB_GLOBAL
: return "GLOBAL";
9297 case STB_WEAK
: return "WEAK";
9299 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9300 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9302 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9304 if (binding
== STB_GNU_UNIQUE
9305 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9306 /* GNU is still using the default value 0. */
9307 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9309 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9312 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9318 get_symbol_type (unsigned int type
)
9320 static char buff
[32];
9324 case STT_NOTYPE
: return "NOTYPE";
9325 case STT_OBJECT
: return "OBJECT";
9326 case STT_FUNC
: return "FUNC";
9327 case STT_SECTION
: return "SECTION";
9328 case STT_FILE
: return "FILE";
9329 case STT_COMMON
: return "COMMON";
9330 case STT_TLS
: return "TLS";
9331 case STT_RELC
: return "RELC";
9332 case STT_SRELC
: return "SRELC";
9334 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9336 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9337 return "THUMB_FUNC";
9339 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9342 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9343 return "PARISC_MILLI";
9345 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9347 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9349 if (elf_header
.e_machine
== EM_PARISC
)
9351 if (type
== STT_HP_OPAQUE
)
9353 if (type
== STT_HP_STUB
)
9357 if (type
== STT_GNU_IFUNC
9358 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9359 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9360 /* GNU is still using the default value 0. */
9361 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9364 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9367 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9373 get_symbol_visibility (unsigned int visibility
)
9377 case STV_DEFAULT
: return "DEFAULT";
9378 case STV_INTERNAL
: return "INTERNAL";
9379 case STV_HIDDEN
: return "HIDDEN";
9380 case STV_PROTECTED
: return "PROTECTED";
9386 get_mips_symbol_other (unsigned int other
)
9398 case STO_MICROMIPS
| STO_MIPS_PIC
:
9399 return "MICROMIPS, MIPS PIC";
9408 get_ia64_symbol_other (unsigned int other
)
9412 static char res
[32];
9416 /* Function types is for images and .STB files only. */
9417 switch (elf_header
.e_type
)
9421 switch (VMS_ST_FUNC_TYPE (other
))
9423 case VMS_SFT_CODE_ADDR
:
9424 strcat (res
, " CA");
9426 case VMS_SFT_SYMV_IDX
:
9427 strcat (res
, " VEC");
9430 strcat (res
, " FD");
9432 case VMS_SFT_RESERVE
:
9433 strcat (res
, " RSV");
9442 switch (VMS_ST_LINKAGE (other
))
9444 case VMS_STL_IGNORE
:
9445 strcat (res
, " IGN");
9447 case VMS_STL_RESERVE
:
9448 strcat (res
, " RSV");
9451 strcat (res
, " STD");
9454 strcat (res
, " LNK");
9469 get_ppc64_symbol_other (unsigned int other
)
9471 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9473 static char buf
[32];
9474 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9475 PPC64_LOCAL_ENTRY_OFFSET (other
));
9482 get_symbol_other (unsigned int other
)
9484 const char * result
= NULL
;
9485 static char buff
[32];
9490 switch (elf_header
.e_machine
)
9493 result
= get_mips_symbol_other (other
);
9496 result
= get_ia64_symbol_other (other
);
9499 result
= get_ppc64_symbol_other (other
);
9508 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9513 get_symbol_index_type (unsigned int type
)
9515 static char buff
[32];
9519 case SHN_UNDEF
: return "UND";
9520 case SHN_ABS
: return "ABS";
9521 case SHN_COMMON
: return "COM";
9523 if (type
== SHN_IA_64_ANSI_COMMON
9524 && elf_header
.e_machine
== EM_IA_64
9525 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9527 else if ((elf_header
.e_machine
== EM_X86_64
9528 || elf_header
.e_machine
== EM_L1OM
9529 || elf_header
.e_machine
== EM_K1OM
)
9530 && type
== SHN_X86_64_LCOMMON
)
9532 else if ((type
== SHN_MIPS_SCOMMON
9533 && elf_header
.e_machine
== EM_MIPS
)
9534 || (type
== SHN_TIC6X_SCOMMON
9535 && elf_header
.e_machine
== EM_TI_C6000
))
9537 else if (type
== SHN_MIPS_SUNDEFINED
9538 && elf_header
.e_machine
== EM_MIPS
)
9540 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9541 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9542 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9543 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9544 else if (type
>= SHN_LORESERVE
)
9545 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9546 else if (type
>= elf_header
.e_shnum
)
9547 sprintf (buff
, "bad section index[%3d]", type
);
9549 sprintf (buff
, "%3d", type
);
9557 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9559 unsigned char * e_data
;
9562 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9566 error (_("Out of memory\n"));
9570 if (fread (e_data
, ent_size
, number
, file
) != number
)
9572 error (_("Unable to read in dynamic data\n"));
9576 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9580 error (_("Out of memory\n"));
9586 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9594 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9596 Elf_Internal_Sym
* psym
;
9599 psym
= dynamic_symbols
+ si
;
9601 n
= print_vma (si
, DEC_5
);
9603 fputs (&" "[n
], stdout
);
9604 printf (" %3lu: ", hn
);
9605 print_vma (psym
->st_value
, LONG_HEX
);
9607 print_vma (psym
->st_size
, DEC_5
);
9609 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9610 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9611 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9612 /* Check to see if any other bits in the st_other field are set.
9613 Note - displaying this information disrupts the layout of the
9614 table being generated, but for the moment this case is very
9616 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9617 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9618 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9619 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9620 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9622 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9626 /* Dump the symbol table. */
9628 process_symbol_table (FILE * file
)
9630 Elf_Internal_Shdr
* section
;
9631 bfd_vma nbuckets
= 0;
9632 bfd_vma nchains
= 0;
9633 bfd_vma
* buckets
= NULL
;
9634 bfd_vma
* chains
= NULL
;
9635 bfd_vma ngnubuckets
= 0;
9636 bfd_vma
* gnubuckets
= NULL
;
9637 bfd_vma
* gnuchains
= NULL
;
9638 bfd_vma gnusymidx
= 0;
9640 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9643 if (dynamic_info
[DT_HASH
]
9645 || (do_using_dynamic
9647 && dynamic_strings
!= NULL
)))
9649 unsigned char nb
[8];
9650 unsigned char nc
[8];
9651 int hash_ent_size
= 4;
9653 if ((elf_header
.e_machine
== EM_ALPHA
9654 || elf_header
.e_machine
== EM_S390
9655 || elf_header
.e_machine
== EM_S390_OLD
)
9656 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9660 (archive_file_offset
9661 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9662 sizeof nb
+ sizeof nc
)),
9665 error (_("Unable to seek to start of dynamic information\n"));
9669 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9671 error (_("Failed to read in number of buckets\n"));
9675 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9677 error (_("Failed to read in number of chains\n"));
9681 nbuckets
= byte_get (nb
, hash_ent_size
);
9682 nchains
= byte_get (nc
, hash_ent_size
);
9684 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9685 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9688 if (buckets
== NULL
|| chains
== NULL
)
9690 if (do_using_dynamic
)
9701 if (dynamic_info_DT_GNU_HASH
9703 || (do_using_dynamic
9705 && dynamic_strings
!= NULL
)))
9707 unsigned char nb
[16];
9708 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9709 bfd_vma buckets_vma
;
9712 (archive_file_offset
9713 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9717 error (_("Unable to seek to start of dynamic information\n"));
9721 if (fread (nb
, 16, 1, file
) != 1)
9723 error (_("Failed to read in number of buckets\n"));
9727 ngnubuckets
= byte_get (nb
, 4);
9728 gnusymidx
= byte_get (nb
+ 4, 4);
9729 bitmaskwords
= byte_get (nb
+ 8, 4);
9730 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9732 buckets_vma
+= bitmaskwords
* 4;
9734 buckets_vma
+= bitmaskwords
* 8;
9737 (archive_file_offset
9738 + offset_from_vma (file
, buckets_vma
, 4)),
9741 error (_("Unable to seek to start of dynamic information\n"));
9745 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9747 if (gnubuckets
== NULL
)
9750 for (i
= 0; i
< ngnubuckets
; i
++)
9751 if (gnubuckets
[i
] != 0)
9753 if (gnubuckets
[i
] < gnusymidx
)
9756 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9757 maxchain
= gnubuckets
[i
];
9760 if (maxchain
== 0xffffffff)
9763 maxchain
-= gnusymidx
;
9766 (archive_file_offset
9767 + offset_from_vma (file
, buckets_vma
9768 + 4 * (ngnubuckets
+ maxchain
), 4)),
9771 error (_("Unable to seek to start of dynamic information\n"));
9777 if (fread (nb
, 4, 1, file
) != 1)
9779 error (_("Failed to determine last chain length\n"));
9783 if (maxchain
+ 1 == 0)
9788 while ((byte_get (nb
, 4) & 1) == 0);
9791 (archive_file_offset
9792 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9795 error (_("Unable to seek to start of dynamic information\n"));
9799 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9802 if (gnuchains
== NULL
)
9807 if (do_using_dynamic
)
9812 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9815 && dynamic_strings
!= NULL
)
9819 if (dynamic_info
[DT_HASH
])
9823 printf (_("\nSymbol table for image:\n"));
9825 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9827 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9829 for (hn
= 0; hn
< nbuckets
; hn
++)
9834 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9835 print_dynamic_symbol (si
, hn
);
9839 if (dynamic_info_DT_GNU_HASH
)
9841 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9843 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9845 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9847 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9848 if (gnubuckets
[hn
] != 0)
9850 bfd_vma si
= gnubuckets
[hn
];
9851 bfd_vma off
= si
- gnusymidx
;
9855 print_dynamic_symbol (si
, hn
);
9858 while ((gnuchains
[off
++] & 1) == 0);
9862 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9866 for (i
= 0, section
= section_headers
;
9867 i
< elf_header
.e_shnum
;
9871 char * strtab
= NULL
;
9872 unsigned long int strtab_size
= 0;
9873 Elf_Internal_Sym
* symtab
;
9874 Elf_Internal_Sym
* psym
;
9875 unsigned long num_syms
;
9877 if ((section
->sh_type
!= SHT_SYMTAB
9878 && section
->sh_type
!= SHT_DYNSYM
)
9880 && section
->sh_type
== SHT_SYMTAB
))
9883 if (section
->sh_entsize
== 0)
9885 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9886 SECTION_NAME (section
));
9890 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9891 SECTION_NAME (section
),
9892 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9895 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9897 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9899 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9903 if (section
->sh_link
== elf_header
.e_shstrndx
)
9905 strtab
= string_table
;
9906 strtab_size
= string_table_length
;
9908 else if (section
->sh_link
< elf_header
.e_shnum
)
9910 Elf_Internal_Shdr
* string_sec
;
9912 string_sec
= section_headers
+ section
->sh_link
;
9914 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9915 1, string_sec
->sh_size
,
9917 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9920 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9922 printf ("%6d: ", si
);
9923 print_vma (psym
->st_value
, LONG_HEX
);
9925 print_vma (psym
->st_size
, DEC_5
);
9926 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9927 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9928 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9929 /* Check to see if any other bits in the st_other field are set.
9930 Note - displaying this information disrupts the layout of the
9931 table being generated, but for the moment this case is very rare. */
9932 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9933 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9934 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9935 print_symbol (25, psym
->st_name
< strtab_size
9936 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9938 if (section
->sh_type
== SHT_DYNSYM
9939 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9941 unsigned char data
[2];
9942 unsigned short vers_data
;
9943 unsigned long offset
;
9947 offset
= offset_from_vma
9948 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9949 sizeof data
+ si
* sizeof (vers_data
));
9951 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9952 sizeof (data
), 1, _("version data")) == NULL
)
9955 vers_data
= byte_get (data
, 2);
9957 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9958 && section_headers
[psym
->st_shndx
].sh_type
9961 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9963 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9965 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9966 && (is_nobits
|| ! check_def
))
9968 Elf_External_Verneed evn
;
9969 Elf_Internal_Verneed ivn
;
9970 Elf_Internal_Vernaux ivna
;
9972 /* We must test both. */
9973 offset
= offset_from_vma
9974 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9979 unsigned long vna_off
;
9981 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9982 _("version need")) == NULL
)
9990 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9991 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9993 vna_off
= offset
+ ivn
.vn_aux
;
9997 Elf_External_Vernaux evna
;
9999 if (get_data (&evna
, file
, vna_off
,
10001 _("version need aux (3)")) == NULL
)
10004 ivna
.vna_other
= 0;
10009 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10010 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10011 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10014 vna_off
+= ivna
.vna_next
;
10016 while (ivna
.vna_other
!= vers_data
10017 && ivna
.vna_next
!= 0);
10019 if (ivna
.vna_other
== vers_data
)
10022 offset
+= ivn
.vn_next
;
10024 while (ivn
.vn_next
!= 0);
10026 if (ivna
.vna_other
== vers_data
)
10028 printf ("@%s (%d)",
10029 ivna
.vna_name
< strtab_size
10030 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10034 else if (! is_nobits
)
10035 error (_("bad dynamic symbol\n"));
10042 if (vers_data
!= 0x8001
10043 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10045 Elf_Internal_Verdef ivd
;
10046 Elf_Internal_Verdaux ivda
;
10047 Elf_External_Verdaux evda
;
10050 off
= offset_from_vma
10052 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10053 sizeof (Elf_External_Verdef
));
10057 Elf_External_Verdef evd
;
10059 if (get_data (&evd
, file
, off
, sizeof (evd
),
10060 1, _("version def")) == NULL
)
10068 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10069 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10070 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10073 off
+= ivd
.vd_next
;
10075 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10076 && ivd
.vd_next
!= 0);
10078 off
-= ivd
.vd_next
;
10081 if (get_data (&evda
, file
, off
, sizeof (evda
),
10082 1, _("version def aux")) == NULL
)
10085 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10087 if (psym
->st_name
!= ivda
.vda_name
)
10088 printf ((vers_data
& VERSYM_HIDDEN
)
10090 ivda
.vda_name
< strtab_size
10091 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10101 if (strtab
!= string_table
)
10107 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10109 if (do_histogram
&& buckets
!= NULL
)
10111 unsigned long * lengths
;
10112 unsigned long * counts
;
10115 unsigned long maxlength
= 0;
10116 unsigned long nzero_counts
= 0;
10117 unsigned long nsyms
= 0;
10119 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10120 (unsigned long) nbuckets
);
10121 printf (_(" Length Number %% of total Coverage\n"));
10123 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10124 if (lengths
== NULL
)
10126 error (_("Out of memory\n"));
10129 for (hn
= 0; hn
< nbuckets
; ++hn
)
10131 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10134 if (maxlength
< ++lengths
[hn
])
10139 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10140 if (counts
== NULL
)
10143 error (_("Out of memory\n"));
10147 for (hn
= 0; hn
< nbuckets
; ++hn
)
10148 ++counts
[lengths
[hn
]];
10153 printf (" 0 %-10lu (%5.1f%%)\n",
10154 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10155 for (i
= 1; i
<= maxlength
; ++i
)
10157 nzero_counts
+= counts
[i
] * i
;
10158 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10159 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10160 (nzero_counts
* 100.0) / nsyms
);
10168 if (buckets
!= NULL
)
10174 if (do_histogram
&& gnubuckets
!= NULL
)
10176 unsigned long * lengths
;
10177 unsigned long * counts
;
10179 unsigned long maxlength
= 0;
10180 unsigned long nzero_counts
= 0;
10181 unsigned long nsyms
= 0;
10183 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10184 if (lengths
== NULL
)
10186 error (_("Out of memory\n"));
10190 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10191 (unsigned long) ngnubuckets
);
10192 printf (_(" Length Number %% of total Coverage\n"));
10194 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10195 if (gnubuckets
[hn
] != 0)
10197 bfd_vma off
, length
= 1;
10199 for (off
= gnubuckets
[hn
] - gnusymidx
;
10200 (gnuchains
[off
] & 1) == 0; ++off
)
10202 lengths
[hn
] = length
;
10203 if (length
> maxlength
)
10204 maxlength
= length
;
10208 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10209 if (counts
== NULL
)
10212 error (_("Out of memory\n"));
10216 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10217 ++counts
[lengths
[hn
]];
10219 if (ngnubuckets
> 0)
10222 printf (" 0 %-10lu (%5.1f%%)\n",
10223 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10224 for (j
= 1; j
<= maxlength
; ++j
)
10226 nzero_counts
+= counts
[j
] * j
;
10227 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10228 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10229 (nzero_counts
* 100.0) / nsyms
);
10243 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10247 if (dynamic_syminfo
== NULL
10249 /* No syminfo, this is ok. */
10252 /* There better should be a dynamic symbol section. */
10253 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10257 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10258 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10260 printf (_(" Num: Name BoundTo Flags\n"));
10261 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10263 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10265 printf ("%4d: ", i
);
10266 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10267 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10269 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10272 switch (dynamic_syminfo
[i
].si_boundto
)
10274 case SYMINFO_BT_SELF
:
10275 fputs ("SELF ", stdout
);
10277 case SYMINFO_BT_PARENT
:
10278 fputs ("PARENT ", stdout
);
10281 if (dynamic_syminfo
[i
].si_boundto
> 0
10282 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10283 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10285 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10289 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10293 if (flags
& SYMINFO_FLG_DIRECT
)
10294 printf (" DIRECT");
10295 if (flags
& SYMINFO_FLG_PASSTHRU
)
10296 printf (" PASSTHRU");
10297 if (flags
& SYMINFO_FLG_COPY
)
10299 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10300 printf (" LAZYLOAD");
10308 /* Check to see if the given reloc needs to be handled in a target specific
10309 manner. If so then process the reloc and return TRUE otherwise return
10313 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10314 unsigned char * start
,
10315 Elf_Internal_Sym
* symtab
)
10317 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10319 switch (elf_header
.e_machine
)
10322 case EM_MSP430_OLD
:
10324 static Elf_Internal_Sym
* saved_sym
= NULL
;
10326 switch (reloc_type
)
10328 case 10: /* R_MSP430_SYM_DIFF */
10329 if (uses_msp430x_relocs ())
10331 case 21: /* R_MSP430X_SYM_DIFF */
10332 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10335 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10336 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10337 goto handle_sym_diff
;
10339 case 5: /* R_MSP430_16_BYTE */
10340 case 9: /* R_MSP430_8 */
10341 if (uses_msp430x_relocs ())
10343 goto handle_sym_diff
;
10345 case 2: /* R_MSP430_ABS16 */
10346 case 15: /* R_MSP430X_ABS16 */
10347 if (! uses_msp430x_relocs ())
10349 goto handle_sym_diff
;
10352 if (saved_sym
!= NULL
)
10356 value
= reloc
->r_addend
10357 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10358 - saved_sym
->st_value
);
10360 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10368 if (saved_sym
!= NULL
)
10369 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10376 case EM_CYGNUS_MN10300
:
10378 static Elf_Internal_Sym
* saved_sym
= NULL
;
10380 switch (reloc_type
)
10382 case 34: /* R_MN10300_ALIGN */
10384 case 33: /* R_MN10300_SYM_DIFF */
10385 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10387 case 1: /* R_MN10300_32 */
10388 case 2: /* R_MN10300_16 */
10389 if (saved_sym
!= NULL
)
10393 value
= reloc
->r_addend
10394 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10395 - saved_sym
->st_value
);
10397 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10404 if (saved_sym
!= NULL
)
10405 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10415 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10416 DWARF debug sections. This is a target specific test. Note - we do not
10417 go through the whole including-target-headers-multiple-times route, (as
10418 we have already done with <elf/h8.h>) because this would become very
10419 messy and even then this function would have to contain target specific
10420 information (the names of the relocs instead of their numeric values).
10421 FIXME: This is not the correct way to solve this problem. The proper way
10422 is to have target specific reloc sizing and typing functions created by
10423 the reloc-macros.h header, in the same way that it already creates the
10424 reloc naming functions. */
10427 is_32bit_abs_reloc (unsigned int reloc_type
)
10429 switch (elf_header
.e_machine
)
10433 return reloc_type
== 1; /* R_386_32. */
10435 return reloc_type
== 1; /* R_68K_32. */
10437 return reloc_type
== 1; /* R_860_32. */
10439 return reloc_type
== 2; /* R_960_32. */
10441 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10443 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10445 return reloc_type
== 1; /* R_ARC_32. */
10447 return reloc_type
== 2; /* R_ARM_ABS32 */
10450 return reloc_type
== 1;
10451 case EM_ADAPTEVA_EPIPHANY
:
10452 return reloc_type
== 3;
10454 return reloc_type
== 0x12; /* R_byte4_data. */
10456 return reloc_type
== 3; /* R_CRIS_32. */
10458 return reloc_type
== 3; /* R_CR16_NUM32. */
10460 return reloc_type
== 15; /* R_CRX_NUM32. */
10461 case EM_CYGNUS_FRV
:
10462 return reloc_type
== 1;
10463 case EM_CYGNUS_D10V
:
10465 return reloc_type
== 6; /* R_D10V_32. */
10466 case EM_CYGNUS_D30V
:
10468 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10470 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10471 case EM_CYGNUS_FR30
:
10473 return reloc_type
== 3; /* R_FR30_32. */
10477 return reloc_type
== 1; /* R_H8_DIR32. */
10479 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10482 return reloc_type
== 2; /* R_IP2K_32. */
10484 return reloc_type
== 2; /* R_IQ2000_32. */
10485 case EM_LATTICEMICO32
:
10486 return reloc_type
== 3; /* R_LM32_32. */
10489 return reloc_type
== 3; /* R_M32C_32. */
10491 return reloc_type
== 34; /* R_M32R_32_RELA. */
10493 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10494 case EM_CYGNUS_MEP
:
10495 return reloc_type
== 4; /* R_MEP_32. */
10497 return reloc_type
== 2; /* R_METAG_ADDR32. */
10498 case EM_MICROBLAZE
:
10499 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10501 return reloc_type
== 2; /* R_MIPS_32. */
10503 return reloc_type
== 4; /* R_MMIX_32. */
10504 case EM_CYGNUS_MN10200
:
10506 return reloc_type
== 1; /* R_MN10200_32. */
10507 case EM_CYGNUS_MN10300
:
10509 return reloc_type
== 1; /* R_MN10300_32. */
10511 return reloc_type
== 1; /* R_MOXIE_32. */
10512 case EM_MSP430_OLD
:
10514 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10516 return reloc_type
== 2; /* R_MT_32. */
10518 return reloc_type
== 20; /* R_NDS32_RELA. */
10519 case EM_ALTERA_NIOS2
:
10520 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10522 return reloc_type
== 1; /* R_NIOS_32. */
10524 return reloc_type
== 1; /* R_OR1K_32. */
10526 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10527 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10530 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10532 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10534 return reloc_type
== 1; /* R_PPC_ADDR32. */
10536 return reloc_type
== 1; /* R_RL78_DIR32. */
10538 return reloc_type
== 1; /* R_RX_DIR32. */
10540 return reloc_type
== 1; /* R_I370_ADDR31. */
10543 return reloc_type
== 4; /* R_S390_32. */
10545 return reloc_type
== 8; /* R_SCORE_ABS32. */
10547 return reloc_type
== 1; /* R_SH_DIR32. */
10548 case EM_SPARC32PLUS
:
10551 return reloc_type
== 3 /* R_SPARC_32. */
10552 || reloc_type
== 23; /* R_SPARC_UA32. */
10554 return reloc_type
== 6; /* R_SPU_ADDR32 */
10556 return reloc_type
== 1; /* R_C6000_ABS32. */
10558 return reloc_type
== 2; /* R_TILEGX_32. */
10560 return reloc_type
== 1; /* R_TILEPRO_32. */
10561 case EM_CYGNUS_V850
:
10563 return reloc_type
== 6; /* R_V850_ABS32. */
10565 return reloc_type
== 0x33; /* R_V810_WORD. */
10567 return reloc_type
== 1; /* R_VAX_32. */
10571 return reloc_type
== 10; /* R_X86_64_32. */
10574 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10576 return reloc_type
== 4; /* R_XGATE_32. */
10578 return reloc_type
== 1; /* R_XSTROMY16_32. */
10579 case EM_XTENSA_OLD
:
10581 return reloc_type
== 1; /* R_XTENSA_32. */
10583 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10584 elf_header
.e_machine
);
10589 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10590 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10593 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10595 switch (elf_header
.e_machine
)
10599 return reloc_type
== 2; /* R_386_PC32. */
10601 return reloc_type
== 4; /* R_68K_PC32. */
10603 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10604 case EM_ADAPTEVA_EPIPHANY
:
10605 return reloc_type
== 6;
10607 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10609 return reloc_type
== 3; /* R_ARM_REL32 */
10610 case EM_MICROBLAZE
:
10611 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10613 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10615 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10617 return reloc_type
== 26; /* R_PPC_REL32. */
10619 return reloc_type
== 26; /* R_PPC64_REL32. */
10622 return reloc_type
== 5; /* R_390_PC32. */
10624 return reloc_type
== 2; /* R_SH_REL32. */
10625 case EM_SPARC32PLUS
:
10628 return reloc_type
== 6; /* R_SPARC_DISP32. */
10630 return reloc_type
== 13; /* R_SPU_REL32. */
10632 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10634 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10638 return reloc_type
== 2; /* R_X86_64_PC32. */
10639 case EM_XTENSA_OLD
:
10641 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10643 /* Do not abort or issue an error message here. Not all targets use
10644 pc-relative 32-bit relocs in their DWARF debug information and we
10645 have already tested for target coverage in is_32bit_abs_reloc. A
10646 more helpful warning message will be generated by apply_relocations
10647 anyway, so just return. */
10652 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10653 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10656 is_64bit_abs_reloc (unsigned int reloc_type
)
10658 switch (elf_header
.e_machine
)
10661 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10663 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10665 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10667 return reloc_type
== 80; /* R_PARISC_DIR64. */
10669 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10670 case EM_SPARC32PLUS
:
10673 return reloc_type
== 54; /* R_SPARC_UA64. */
10677 return reloc_type
== 1; /* R_X86_64_64. */
10680 return reloc_type
== 22; /* R_S390_64. */
10682 return reloc_type
== 1; /* R_TILEGX_64. */
10684 return reloc_type
== 18; /* R_MIPS_64. */
10690 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10691 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10694 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10696 switch (elf_header
.e_machine
)
10699 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10701 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10703 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10705 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10707 return reloc_type
== 44; /* R_PPC64_REL64. */
10708 case EM_SPARC32PLUS
:
10711 return reloc_type
== 46; /* R_SPARC_DISP64. */
10715 return reloc_type
== 24; /* R_X86_64_PC64. */
10718 return reloc_type
== 23; /* R_S390_PC64. */
10720 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10726 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10727 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10730 is_24bit_abs_reloc (unsigned int reloc_type
)
10732 switch (elf_header
.e_machine
)
10734 case EM_CYGNUS_MN10200
:
10736 return reloc_type
== 4; /* R_MN10200_24. */
10742 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10743 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10746 is_16bit_abs_reloc (unsigned int reloc_type
)
10748 switch (elf_header
.e_machine
)
10752 return reloc_type
== 4; /* R_AVR_16. */
10753 case EM_ADAPTEVA_EPIPHANY
:
10754 return reloc_type
== 5;
10755 case EM_CYGNUS_D10V
:
10757 return reloc_type
== 3; /* R_D10V_16. */
10761 return reloc_type
== R_H8_DIR16
;
10764 return reloc_type
== 1; /* R_IP2K_16. */
10767 return reloc_type
== 1; /* R_M32C_16 */
10769 if (uses_msp430x_relocs ())
10770 return reloc_type
== 2; /* R_MSP430_ABS16. */
10771 case EM_MSP430_OLD
:
10772 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10774 return reloc_type
== 19; /* R_NDS32_RELA. */
10775 case EM_ALTERA_NIOS2
:
10776 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10778 return reloc_type
== 9; /* R_NIOS_16. */
10780 return reloc_type
== 2; /* R_OR1K_16. */
10782 return reloc_type
== 2; /* R_C6000_ABS16. */
10785 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10786 case EM_CYGNUS_MN10200
:
10788 return reloc_type
== 2; /* R_MN10200_16. */
10789 case EM_CYGNUS_MN10300
:
10791 return reloc_type
== 2; /* R_MN10300_16. */
10793 return reloc_type
== 3; /* R_XGATE_16. */
10799 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10800 relocation entries (possibly formerly used for SHT_GROUP sections). */
10803 is_none_reloc (unsigned int reloc_type
)
10805 switch (elf_header
.e_machine
)
10807 case EM_68K
: /* R_68K_NONE. */
10808 case EM_386
: /* R_386_NONE. */
10809 case EM_SPARC32PLUS
:
10811 case EM_SPARC
: /* R_SPARC_NONE. */
10812 case EM_MIPS
: /* R_MIPS_NONE. */
10813 case EM_PARISC
: /* R_PARISC_NONE. */
10814 case EM_ALPHA
: /* R_ALPHA_NONE. */
10815 case EM_ADAPTEVA_EPIPHANY
:
10816 case EM_PPC
: /* R_PPC_NONE. */
10817 case EM_PPC64
: /* R_PPC64_NONE. */
10818 case EM_ARM
: /* R_ARM_NONE. */
10819 case EM_IA_64
: /* R_IA64_NONE. */
10820 case EM_SH
: /* R_SH_NONE. */
10822 case EM_S390
: /* R_390_NONE. */
10823 case EM_CRIS
: /* R_CRIS_NONE. */
10824 case EM_X86_64
: /* R_X86_64_NONE. */
10825 case EM_L1OM
: /* R_X86_64_NONE. */
10826 case EM_K1OM
: /* R_X86_64_NONE. */
10827 case EM_MN10300
: /* R_MN10300_NONE. */
10828 case EM_MOXIE
: /* R_MOXIE_NONE. */
10829 case EM_M32R
: /* R_M32R_NONE. */
10830 case EM_TI_C6000
:/* R_C6000_NONE. */
10831 case EM_TILEGX
: /* R_TILEGX_NONE. */
10832 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10834 case EM_C166
: /* R_XC16X_NONE. */
10835 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10836 case EM_NIOS32
: /* R_NIOS_NONE. */
10837 case EM_OR1K
: /* R_OR1K_NONE. */
10838 return reloc_type
== 0;
10840 return reloc_type
== 0 || reloc_type
== 256;
10842 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10843 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10844 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10845 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10846 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10847 case EM_XTENSA_OLD
:
10849 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10850 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10851 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10852 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10854 return reloc_type
== 3; /* R_METAG_NONE. */
10859 /* Apply relocations to a section.
10860 Note: So far support has been added only for those relocations
10861 which can be found in debug sections.
10862 FIXME: Add support for more relocations ? */
10865 apply_relocations (void * file
,
10866 Elf_Internal_Shdr
* section
,
10867 unsigned char * start
)
10869 Elf_Internal_Shdr
* relsec
;
10870 unsigned char * end
= start
+ section
->sh_size
;
10872 if (elf_header
.e_type
!= ET_REL
)
10875 /* Find the reloc section associated with the section. */
10876 for (relsec
= section_headers
;
10877 relsec
< section_headers
+ elf_header
.e_shnum
;
10880 bfd_boolean is_rela
;
10881 unsigned long num_relocs
;
10882 Elf_Internal_Rela
* relocs
;
10883 Elf_Internal_Rela
* rp
;
10884 Elf_Internal_Shdr
* symsec
;
10885 Elf_Internal_Sym
* symtab
;
10886 unsigned long num_syms
;
10887 Elf_Internal_Sym
* sym
;
10889 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10890 || relsec
->sh_info
>= elf_header
.e_shnum
10891 || section_headers
+ relsec
->sh_info
!= section
10892 || relsec
->sh_size
== 0
10893 || relsec
->sh_link
>= elf_header
.e_shnum
)
10896 is_rela
= relsec
->sh_type
== SHT_RELA
;
10900 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10901 relsec
->sh_size
, & relocs
, & num_relocs
))
10906 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10907 relsec
->sh_size
, & relocs
, & num_relocs
))
10911 /* SH uses RELA but uses in place value instead of the addend field. */
10912 if (elf_header
.e_machine
== EM_SH
)
10915 symsec
= section_headers
+ relsec
->sh_link
;
10916 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10918 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10921 unsigned int reloc_type
;
10922 unsigned int reloc_size
;
10923 unsigned char * rloc
;
10924 unsigned long sym_index
;
10926 reloc_type
= get_reloc_type (rp
->r_info
);
10928 if (target_specific_reloc_handling (rp
, start
, symtab
))
10930 else if (is_none_reloc (reloc_type
))
10932 else if (is_32bit_abs_reloc (reloc_type
)
10933 || is_32bit_pcrel_reloc (reloc_type
))
10935 else if (is_64bit_abs_reloc (reloc_type
)
10936 || is_64bit_pcrel_reloc (reloc_type
))
10938 else if (is_24bit_abs_reloc (reloc_type
))
10940 else if (is_16bit_abs_reloc (reloc_type
))
10944 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10945 reloc_type
, SECTION_NAME (section
));
10949 rloc
= start
+ rp
->r_offset
;
10950 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
10952 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10953 (unsigned long) rp
->r_offset
,
10954 SECTION_NAME (section
));
10958 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10959 if (sym_index
>= num_syms
)
10961 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10962 sym_index
, SECTION_NAME (section
));
10965 sym
= symtab
+ sym_index
;
10967 /* If the reloc has a symbol associated with it,
10968 make sure that it is of an appropriate type.
10970 Relocations against symbols without type can happen.
10971 Gcc -feliminate-dwarf2-dups may generate symbols
10972 without type for debug info.
10974 Icc generates relocations against function symbols
10975 instead of local labels.
10977 Relocations against object symbols can happen, eg when
10978 referencing a global array. For an example of this see
10979 the _clz.o binary in libgcc.a. */
10981 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10983 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10984 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10985 (long int)(rp
- relocs
),
10986 SECTION_NAME (relsec
));
10992 addend
+= rp
->r_addend
;
10993 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10994 partial_inplace. */
10996 || (elf_header
.e_machine
== EM_XTENSA
10997 && reloc_type
== 1)
10998 || ((elf_header
.e_machine
== EM_PJ
10999 || elf_header
.e_machine
== EM_PJ_OLD
)
11000 && reloc_type
== 1)
11001 || ((elf_header
.e_machine
== EM_D30V
11002 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11003 && reloc_type
== 12))
11004 addend
+= byte_get (rloc
, reloc_size
);
11006 if (is_32bit_pcrel_reloc (reloc_type
)
11007 || is_64bit_pcrel_reloc (reloc_type
))
11009 /* On HPPA, all pc-relative relocations are biased by 8. */
11010 if (elf_header
.e_machine
== EM_PARISC
)
11012 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11016 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11025 #ifdef SUPPORT_DISASSEMBLY
11027 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11029 printf (_("\nAssembly dump of section %s\n"),
11030 SECTION_NAME (section
));
11032 /* XXX -- to be done --- XXX */
11038 /* Reads in the contents of SECTION from FILE, returning a pointer
11039 to a malloc'ed buffer or NULL if something went wrong. */
11042 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11044 bfd_size_type num_bytes
;
11046 num_bytes
= section
->sh_size
;
11048 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11050 printf (_("\nSection '%s' has no data to dump.\n"),
11051 SECTION_NAME (section
));
11055 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11056 _("section contents"));
11061 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11063 Elf_Internal_Shdr
* relsec
;
11064 bfd_size_type num_bytes
;
11068 char * name
= SECTION_NAME (section
);
11069 bfd_boolean some_strings_shown
;
11071 start
= get_section_contents (section
, file
);
11075 printf (_("\nString dump of section '%s':\n"), name
);
11077 /* If the section being dumped has relocations against it the user might
11078 be expecting these relocations to have been applied. Check for this
11079 case and issue a warning message in order to avoid confusion.
11080 FIXME: Maybe we ought to have an option that dumps a section with
11081 relocs applied ? */
11082 for (relsec
= section_headers
;
11083 relsec
< section_headers
+ elf_header
.e_shnum
;
11086 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11087 || relsec
->sh_info
>= elf_header
.e_shnum
11088 || section_headers
+ relsec
->sh_info
!= section
11089 || relsec
->sh_size
== 0
11090 || relsec
->sh_link
>= elf_header
.e_shnum
)
11093 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11097 num_bytes
= section
->sh_size
;
11099 end
= start
+ num_bytes
;
11100 some_strings_shown
= FALSE
;
11104 while (!ISPRINT (* data
))
11105 if (++ data
>= end
)
11111 /* PR 11128: Use two separate invocations in order to work
11112 around bugs in the Solaris 8 implementation of printf. */
11113 printf (" [%6tx] ", data
- start
);
11114 printf ("%s\n", data
);
11116 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11118 data
+= strlen (data
);
11119 some_strings_shown
= TRUE
;
11123 if (! some_strings_shown
)
11124 printf (_(" No strings found in this section."));
11132 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11134 bfd_boolean relocate
)
11136 Elf_Internal_Shdr
* relsec
;
11137 bfd_size_type bytes
;
11139 unsigned char * data
;
11140 unsigned char * start
;
11142 start
= (unsigned char *) get_section_contents (section
, file
);
11146 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11150 apply_relocations (file
, section
, start
);
11154 /* If the section being dumped has relocations against it the user might
11155 be expecting these relocations to have been applied. Check for this
11156 case and issue a warning message in order to avoid confusion.
11157 FIXME: Maybe we ought to have an option that dumps a section with
11158 relocs applied ? */
11159 for (relsec
= section_headers
;
11160 relsec
< section_headers
+ elf_header
.e_shnum
;
11163 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11164 || relsec
->sh_info
>= elf_header
.e_shnum
11165 || section_headers
+ relsec
->sh_info
!= section
11166 || relsec
->sh_size
== 0
11167 || relsec
->sh_link
>= elf_header
.e_shnum
)
11170 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11175 addr
= section
->sh_addr
;
11176 bytes
= section
->sh_size
;
11185 lbytes
= (bytes
> 16 ? 16 : bytes
);
11187 printf (" 0x%8.8lx ", (unsigned long) addr
);
11189 for (j
= 0; j
< 16; j
++)
11192 printf ("%2.2x", data
[j
]);
11200 for (j
= 0; j
< lbytes
; j
++)
11203 if (k
>= ' ' && k
< 0x7f)
11221 /* Uncompresses a section that was compressed using zlib, in place. */
11224 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11225 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11227 #ifndef HAVE_ZLIB_H
11230 dwarf_size_type compressed_size
= *size
;
11231 unsigned char * compressed_buffer
= *buffer
;
11232 dwarf_size_type uncompressed_size
;
11233 unsigned char * uncompressed_buffer
;
11236 dwarf_size_type header_size
= 12;
11238 /* Read the zlib header. In this case, it should be "ZLIB" followed
11239 by the uncompressed section size, 8 bytes in big-endian order. */
11240 if (compressed_size
< header_size
11241 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11244 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11245 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11246 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11247 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11248 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11249 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11250 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11251 uncompressed_size
+= compressed_buffer
[11];
11253 /* It is possible the section consists of several compressed
11254 buffers concatenated together, so we uncompress in a loop. */
11255 strm
.zalloc
= NULL
;
11257 strm
.opaque
= NULL
;
11258 strm
.avail_in
= compressed_size
- header_size
;
11259 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11260 strm
.avail_out
= uncompressed_size
;
11261 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11263 rc
= inflateInit (& strm
);
11264 while (strm
.avail_in
> 0)
11268 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11269 + (uncompressed_size
- strm
.avail_out
));
11270 rc
= inflate (&strm
, Z_FINISH
);
11271 if (rc
!= Z_STREAM_END
)
11273 rc
= inflateReset (& strm
);
11275 rc
= inflateEnd (& strm
);
11277 || strm
.avail_out
!= 0)
11280 free (compressed_buffer
);
11281 *buffer
= uncompressed_buffer
;
11282 *size
= uncompressed_size
;
11286 free (uncompressed_buffer
);
11287 /* Indicate decompression failure. */
11290 #endif /* HAVE_ZLIB_H */
11294 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11295 Elf_Internal_Shdr
* sec
, void * file
)
11297 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11300 /* If it is already loaded, do nothing. */
11301 if (section
->start
!= NULL
)
11304 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11305 section
->address
= sec
->sh_addr
;
11306 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11308 sec
->sh_size
, buf
);
11309 if (section
->start
== NULL
)
11313 section
->size
= sec
->sh_size
;
11314 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11315 sec
->sh_size
= section
->size
;
11318 if (section
->start
== NULL
)
11321 if (debug_displays
[debug
].relocate
)
11322 apply_relocations ((FILE *) file
, sec
, section
->start
);
11327 /* If this is not NULL, load_debug_section will only look for sections
11328 within the list of sections given here. */
11329 unsigned int *section_subset
= NULL
;
11332 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11334 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11335 Elf_Internal_Shdr
* sec
;
11337 /* Locate the debug section. */
11338 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11340 section
->name
= section
->uncompressed_name
;
11343 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11345 section
->name
= section
->compressed_name
;
11350 /* If we're loading from a subset of sections, and we've loaded
11351 a section matching this name before, it's likely that it's a
11353 if (section_subset
!= NULL
)
11354 free_debug_section (debug
);
11356 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11360 free_debug_section (enum dwarf_section_display_enum debug
)
11362 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11364 if (section
->start
== NULL
)
11367 free ((char *) section
->start
);
11368 section
->start
= NULL
;
11369 section
->address
= 0;
11374 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11376 char * name
= SECTION_NAME (section
);
11377 bfd_size_type length
;
11381 length
= section
->sh_size
;
11384 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11387 if (section
->sh_type
== SHT_NOBITS
)
11389 /* There is no point in dumping the contents of a debugging section
11390 which has the NOBITS type - the bits in the file will be random.
11391 This can happen when a file containing a .eh_frame section is
11392 stripped with the --only-keep-debug command line option. */
11393 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11397 if (const_strneq (name
, ".gnu.linkonce.wi."))
11398 name
= ".debug_info";
11400 /* See if we know how to display the contents of this section. */
11401 for (i
= 0; i
< max
; i
++)
11402 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11403 || (i
== line
&& const_strneq (name
, ".debug_line."))
11404 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11406 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11407 int secondary
= (section
!= find_section (name
));
11410 free_debug_section ((enum dwarf_section_display_enum
) i
);
11412 if (i
== line
&& const_strneq (name
, ".debug_line."))
11414 else if (streq (sec
->uncompressed_name
, name
))
11415 sec
->name
= sec
->uncompressed_name
;
11417 sec
->name
= sec
->compressed_name
;
11418 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11421 /* If this debug section is part of a CU/TU set in a .dwp file,
11422 restrict load_debug_section to the sections in that set. */
11423 section_subset
= find_cu_tu_set (file
, shndx
);
11425 result
&= debug_displays
[i
].display (sec
, file
);
11427 section_subset
= NULL
;
11429 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11430 free_debug_section ((enum dwarf_section_display_enum
) i
);
11438 printf (_("Unrecognized debug section: %s\n"), name
);
11445 /* Set DUMP_SECTS for all sections where dumps were requested
11446 based on section name. */
11449 initialise_dumps_byname (void)
11451 struct dump_list_entry
* cur
;
11453 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11458 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11459 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11461 request_dump_bynumber (i
, cur
->type
);
11466 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11472 process_section_contents (FILE * file
)
11474 Elf_Internal_Shdr
* section
;
11480 initialise_dumps_byname ();
11482 for (i
= 0, section
= section_headers
;
11483 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11486 #ifdef SUPPORT_DISASSEMBLY
11487 if (dump_sects
[i
] & DISASS_DUMP
)
11488 disassemble_section (section
, file
);
11490 if (dump_sects
[i
] & HEX_DUMP
)
11491 dump_section_as_bytes (section
, file
, FALSE
);
11493 if (dump_sects
[i
] & RELOC_DUMP
)
11494 dump_section_as_bytes (section
, file
, TRUE
);
11496 if (dump_sects
[i
] & STRING_DUMP
)
11497 dump_section_as_strings (section
, file
);
11499 if (dump_sects
[i
] & DEBUG_DUMP
)
11500 display_debug_section (i
, section
, file
);
11503 /* Check to see if the user requested a
11504 dump of a section that does not exist. */
11505 while (i
++ < num_dump_sects
)
11507 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11511 process_mips_fpe_exception (int mask
)
11516 if (mask
& OEX_FPU_INEX
)
11517 fputs ("INEX", stdout
), first
= 0;
11518 if (mask
& OEX_FPU_UFLO
)
11519 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11520 if (mask
& OEX_FPU_OFLO
)
11521 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11522 if (mask
& OEX_FPU_DIV0
)
11523 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11524 if (mask
& OEX_FPU_INVAL
)
11525 printf ("%sINVAL", first
? "" : "|");
11528 fputs ("0", stdout
);
11531 /* Display's the value of TAG at location P. If TAG is
11532 greater than 0 it is assumed to be an unknown tag, and
11533 a message is printed to this effect. Otherwise it is
11534 assumed that a message has already been printed.
11536 If the bottom bit of TAG is set it assumed to have a
11537 string value, otherwise it is assumed to have an integer
11540 Returns an updated P pointing to the first unread byte
11541 beyond the end of TAG's value.
11543 Reads at or beyond END will not be made. */
11545 static unsigned char *
11546 display_tag_value (int tag
,
11548 const unsigned char * const end
)
11553 printf (" Tag_unknown_%d: ", tag
);
11557 warn (_("corrupt tag\n"));
11561 /* FIXME: we could read beyond END here. */
11562 printf ("\"%s\"\n", p
);
11563 p
+= strlen ((char *) p
) + 1;
11569 val
= read_uleb128 (p
, &len
, end
);
11571 printf ("%ld (0x%lx)\n", val
, val
);
11577 /* ARM EABI attributes section. */
11582 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11584 const char ** table
;
11585 } arm_attr_public_tag
;
11587 static const char * arm_attr_tag_CPU_arch
[] =
11588 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11589 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11590 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11591 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11592 {"No", "Thumb-1", "Thumb-2"};
11593 static const char * arm_attr_tag_FP_arch
[] =
11594 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11596 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11597 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11598 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11599 static const char * arm_attr_tag_PCS_config
[] =
11600 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11601 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11602 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11603 {"V6", "SB", "TLS", "Unused"};
11604 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11605 {"Absolute", "PC-relative", "SB-relative", "None"};
11606 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11607 {"Absolute", "PC-relative", "None"};
11608 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11609 {"None", "direct", "GOT-indirect"};
11610 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11611 {"None", "??? 1", "2", "??? 3", "4"};
11612 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11613 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11614 {"Unused", "Needed", "Sign only"};
11615 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11616 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11617 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11618 {"Unused", "Finite", "RTABI", "IEEE 754"};
11619 static const char * arm_attr_tag_ABI_enum_size
[] =
11620 {"Unused", "small", "int", "forced to int"};
11621 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11622 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11623 static const char * arm_attr_tag_ABI_VFP_args
[] =
11624 {"AAPCS", "VFP registers", "custom"};
11625 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11626 {"AAPCS", "WMMX registers", "custom"};
11627 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11628 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11629 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11630 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11631 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11632 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11633 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11634 static const char * arm_attr_tag_FP_HP_extension
[] =
11635 {"Not Allowed", "Allowed"};
11636 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11637 {"None", "IEEE 754", "Alternative Format"};
11638 static const char * arm_attr_tag_MPextension_use
[] =
11639 {"Not Allowed", "Allowed"};
11640 static const char * arm_attr_tag_DIV_use
[] =
11641 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11642 "Allowed in v7-A with integer division extension"};
11643 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11644 static const char * arm_attr_tag_Virtualization_use
[] =
11645 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11646 "TrustZone and Virtualization Extensions"};
11647 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11648 {"Not Allowed", "Allowed"};
11650 #define LOOKUP(id, name) \
11651 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11652 static arm_attr_public_tag arm_attr_public_tags
[] =
11654 {4, "CPU_raw_name", 1, NULL
},
11655 {5, "CPU_name", 1, NULL
},
11656 LOOKUP(6, CPU_arch
),
11657 {7, "CPU_arch_profile", 0, NULL
},
11658 LOOKUP(8, ARM_ISA_use
),
11659 LOOKUP(9, THUMB_ISA_use
),
11660 LOOKUP(10, FP_arch
),
11661 LOOKUP(11, WMMX_arch
),
11662 LOOKUP(12, Advanced_SIMD_arch
),
11663 LOOKUP(13, PCS_config
),
11664 LOOKUP(14, ABI_PCS_R9_use
),
11665 LOOKUP(15, ABI_PCS_RW_data
),
11666 LOOKUP(16, ABI_PCS_RO_data
),
11667 LOOKUP(17, ABI_PCS_GOT_use
),
11668 LOOKUP(18, ABI_PCS_wchar_t
),
11669 LOOKUP(19, ABI_FP_rounding
),
11670 LOOKUP(20, ABI_FP_denormal
),
11671 LOOKUP(21, ABI_FP_exceptions
),
11672 LOOKUP(22, ABI_FP_user_exceptions
),
11673 LOOKUP(23, ABI_FP_number_model
),
11674 {24, "ABI_align_needed", 0, NULL
},
11675 {25, "ABI_align_preserved", 0, NULL
},
11676 LOOKUP(26, ABI_enum_size
),
11677 LOOKUP(27, ABI_HardFP_use
),
11678 LOOKUP(28, ABI_VFP_args
),
11679 LOOKUP(29, ABI_WMMX_args
),
11680 LOOKUP(30, ABI_optimization_goals
),
11681 LOOKUP(31, ABI_FP_optimization_goals
),
11682 {32, "compatibility", 0, NULL
},
11683 LOOKUP(34, CPU_unaligned_access
),
11684 LOOKUP(36, FP_HP_extension
),
11685 LOOKUP(38, ABI_FP_16bit_format
),
11686 LOOKUP(42, MPextension_use
),
11687 LOOKUP(44, DIV_use
),
11688 {64, "nodefaults", 0, NULL
},
11689 {65, "also_compatible_with", 0, NULL
},
11690 LOOKUP(66, T2EE_use
),
11691 {67, "conformance", 1, NULL
},
11692 LOOKUP(68, Virtualization_use
),
11693 LOOKUP(70, MPextension_use_legacy
)
11697 static unsigned char *
11698 display_arm_attribute (unsigned char * p
,
11699 const unsigned char * const end
)
11704 arm_attr_public_tag
* attr
;
11708 tag
= read_uleb128 (p
, &len
, end
);
11711 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11713 if (arm_attr_public_tags
[i
].tag
== tag
)
11715 attr
= &arm_attr_public_tags
[i
];
11722 printf (" Tag_%s: ", attr
->name
);
11723 switch (attr
->type
)
11728 case 7: /* Tag_CPU_arch_profile. */
11729 val
= read_uleb128 (p
, &len
, end
);
11733 case 0: printf (_("None\n")); break;
11734 case 'A': printf (_("Application\n")); break;
11735 case 'R': printf (_("Realtime\n")); break;
11736 case 'M': printf (_("Microcontroller\n")); break;
11737 case 'S': printf (_("Application or Realtime\n")); break;
11738 default: printf ("??? (%d)\n", val
); break;
11742 case 24: /* Tag_align_needed. */
11743 val
= read_uleb128 (p
, &len
, end
);
11747 case 0: printf (_("None\n")); break;
11748 case 1: printf (_("8-byte\n")); break;
11749 case 2: printf (_("4-byte\n")); break;
11750 case 3: printf ("??? 3\n"); break;
11753 printf (_("8-byte and up to %d-byte extended\n"),
11756 printf ("??? (%d)\n", val
);
11761 case 25: /* Tag_align_preserved. */
11762 val
= read_uleb128 (p
, &len
, end
);
11766 case 0: printf (_("None\n")); break;
11767 case 1: printf (_("8-byte, except leaf SP\n")); break;
11768 case 2: printf (_("8-byte\n")); break;
11769 case 3: printf ("??? 3\n"); break;
11772 printf (_("8-byte and up to %d-byte extended\n"),
11775 printf ("??? (%d)\n", val
);
11780 case 32: /* Tag_compatibility. */
11781 val
= read_uleb128 (p
, &len
, end
);
11783 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11784 p
+= strlen ((char *) p
) + 1;
11787 case 64: /* Tag_nodefaults. */
11789 printf (_("True\n"));
11792 case 65: /* Tag_also_compatible_with. */
11793 val
= read_uleb128 (p
, &len
, end
);
11795 if (val
== 6 /* Tag_CPU_arch. */)
11797 val
= read_uleb128 (p
, &len
, end
);
11799 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11800 printf ("??? (%d)\n", val
);
11802 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11806 while (*(p
++) != '\0' /* NUL terminator. */);
11815 return display_tag_value (-1, p
, end
);
11817 return display_tag_value (0, p
, end
);
11820 assert (attr
->type
& 0x80);
11821 val
= read_uleb128 (p
, &len
, end
);
11823 type
= attr
->type
& 0x7f;
11825 printf ("??? (%d)\n", val
);
11827 printf ("%s\n", attr
->table
[val
]);
11832 return display_tag_value (tag
, p
, end
);
11835 static unsigned char *
11836 display_gnu_attribute (unsigned char * p
,
11837 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11838 const unsigned char * const end
)
11844 tag
= read_uleb128 (p
, &len
, end
);
11847 /* Tag_compatibility is the only generic GNU attribute defined at
11851 val
= read_uleb128 (p
, &len
, end
);
11855 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11856 warn (_("corrupt vendor attribute\n"));
11860 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11861 p
+= strlen ((char *) p
) + 1;
11866 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11867 return display_proc_gnu_attribute (p
, tag
, end
);
11869 return display_tag_value (tag
, p
, end
);
11872 static unsigned char *
11873 display_power_gnu_attribute (unsigned char * p
,
11875 const unsigned char * const end
)
11880 if (tag
== Tag_GNU_Power_ABI_FP
)
11882 val
= read_uleb128 (p
, &len
, end
);
11884 printf (" Tag_GNU_Power_ABI_FP: ");
11889 printf (_("Hard or soft float\n"));
11892 printf (_("Hard float\n"));
11895 printf (_("Soft float\n"));
11898 printf (_("Single-precision hard float\n"));
11901 printf ("??? (%d)\n", val
);
11907 if (tag
== Tag_GNU_Power_ABI_Vector
)
11909 val
= read_uleb128 (p
, &len
, end
);
11911 printf (" Tag_GNU_Power_ABI_Vector: ");
11915 printf (_("Any\n"));
11918 printf (_("Generic\n"));
11921 printf ("AltiVec\n");
11927 printf ("??? (%d)\n", val
);
11933 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11937 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11941 val
= read_uleb128 (p
, &len
, end
);
11943 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11947 printf (_("Any\n"));
11950 printf ("r3/r4\n");
11953 printf (_("Memory\n"));
11956 printf ("??? (%d)\n", val
);
11962 return display_tag_value (tag
& 1, p
, end
);
11966 display_sparc_hwcaps (int mask
)
11971 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11972 fputs ("mul32", stdout
), first
= 0;
11973 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11974 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11975 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11976 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11977 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11978 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11979 if (mask
& ELF_SPARC_HWCAP_POPC
)
11980 printf ("%spopc", first
? "" : "|"), first
= 0;
11981 if (mask
& ELF_SPARC_HWCAP_VIS
)
11982 printf ("%svis", first
? "" : "|"), first
= 0;
11983 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11984 printf ("%svis2", first
? "" : "|"), first
= 0;
11985 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11986 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11987 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11988 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11989 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11990 printf ("%svis3", first
? "" : "|"), first
= 0;
11991 if (mask
& ELF_SPARC_HWCAP_HPC
)
11992 printf ("%shpc", first
? "" : "|"), first
= 0;
11993 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11994 printf ("%srandom", first
? "" : "|"), first
= 0;
11995 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11996 printf ("%strans", first
? "" : "|"), first
= 0;
11997 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11998 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11999 if (mask
& ELF_SPARC_HWCAP_IMA
)
12000 printf ("%sima", first
? "" : "|"), first
= 0;
12001 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12002 printf ("%scspare", first
? "" : "|"), first
= 0;
12005 fputc('0', stdout
);
12006 fputc('\n', stdout
);
12010 display_sparc_hwcaps2 (int mask
)
12015 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12016 fputs ("fjathplus", stdout
), first
= 0;
12017 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12018 printf ("%svis3b", first
? "" : "|"), first
= 0;
12019 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12020 printf ("%sadp", first
? "" : "|"), first
= 0;
12021 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12022 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12023 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12024 printf ("%smwait", first
? "" : "|"), first
= 0;
12025 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12026 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12027 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12028 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12029 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12030 printf ("%snsec", first
? "" : "|"), first
= 0;
12031 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12032 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12033 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12034 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12035 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12036 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12039 fputc('0', stdout
);
12040 fputc('\n', stdout
);
12043 static unsigned char *
12044 display_sparc_gnu_attribute (unsigned char * p
,
12046 const unsigned char * const end
)
12051 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12053 val
= read_uleb128 (p
, &len
, end
);
12055 printf (" Tag_GNU_Sparc_HWCAPS: ");
12056 display_sparc_hwcaps (val
);
12059 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12061 val
= read_uleb128 (p
, &len
, end
);
12063 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12064 display_sparc_hwcaps2 (val
);
12068 return display_tag_value (tag
, p
, end
);
12072 print_mips_fp_abi_value (int val
)
12076 case Val_GNU_MIPS_ABI_FP_ANY
:
12077 printf (_("Hard or soft float\n"));
12079 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12080 printf (_("Hard float (double precision)\n"));
12082 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12083 printf (_("Hard float (single precision)\n"));
12085 case Val_GNU_MIPS_ABI_FP_SOFT
:
12086 printf (_("Soft float\n"));
12088 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12089 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12091 case Val_GNU_MIPS_ABI_FP_XX
:
12092 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12094 case Val_GNU_MIPS_ABI_FP_64
:
12095 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12097 case Val_GNU_MIPS_ABI_FP_64A
:
12098 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12101 printf ("??? (%d)\n", val
);
12106 static unsigned char *
12107 display_mips_gnu_attribute (unsigned char * p
,
12109 const unsigned char * const end
)
12111 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12116 val
= read_uleb128 (p
, &len
, end
);
12118 printf (" Tag_GNU_MIPS_ABI_FP: ");
12120 print_mips_fp_abi_value (val
);
12125 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12130 val
= read_uleb128 (p
, &len
, end
);
12132 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12136 case Val_GNU_MIPS_ABI_MSA_ANY
:
12137 printf (_("Any MSA or not\n"));
12139 case Val_GNU_MIPS_ABI_MSA_128
:
12140 printf (_("128-bit MSA\n"));
12143 printf ("??? (%d)\n", val
);
12149 return display_tag_value (tag
& 1, p
, end
);
12152 static unsigned char *
12153 display_tic6x_attribute (unsigned char * p
,
12154 const unsigned char * const end
)
12160 tag
= read_uleb128 (p
, &len
, end
);
12166 val
= read_uleb128 (p
, &len
, end
);
12168 printf (" Tag_ISA: ");
12172 case C6XABI_Tag_ISA_none
:
12173 printf (_("None\n"));
12175 case C6XABI_Tag_ISA_C62X
:
12178 case C6XABI_Tag_ISA_C67X
:
12181 case C6XABI_Tag_ISA_C67XP
:
12182 printf ("C67x+\n");
12184 case C6XABI_Tag_ISA_C64X
:
12187 case C6XABI_Tag_ISA_C64XP
:
12188 printf ("C64x+\n");
12190 case C6XABI_Tag_ISA_C674X
:
12191 printf ("C674x\n");
12194 printf ("??? (%d)\n", val
);
12199 case Tag_ABI_wchar_t
:
12200 val
= read_uleb128 (p
, &len
, end
);
12202 printf (" Tag_ABI_wchar_t: ");
12206 printf (_("Not used\n"));
12209 printf (_("2 bytes\n"));
12212 printf (_("4 bytes\n"));
12215 printf ("??? (%d)\n", val
);
12220 case Tag_ABI_stack_align_needed
:
12221 val
= read_uleb128 (p
, &len
, end
);
12223 printf (" Tag_ABI_stack_align_needed: ");
12227 printf (_("8-byte\n"));
12230 printf (_("16-byte\n"));
12233 printf ("??? (%d)\n", val
);
12238 case Tag_ABI_stack_align_preserved
:
12239 val
= read_uleb128 (p
, &len
, end
);
12241 printf (" Tag_ABI_stack_align_preserved: ");
12245 printf (_("8-byte\n"));
12248 printf (_("16-byte\n"));
12251 printf ("??? (%d)\n", val
);
12257 val
= read_uleb128 (p
, &len
, end
);
12259 printf (" Tag_ABI_DSBT: ");
12263 printf (_("DSBT addressing not used\n"));
12266 printf (_("DSBT addressing used\n"));
12269 printf ("??? (%d)\n", val
);
12275 val
= read_uleb128 (p
, &len
, end
);
12277 printf (" Tag_ABI_PID: ");
12281 printf (_("Data addressing position-dependent\n"));
12284 printf (_("Data addressing position-independent, GOT near DP\n"));
12287 printf (_("Data addressing position-independent, GOT far from DP\n"));
12290 printf ("??? (%d)\n", val
);
12296 val
= read_uleb128 (p
, &len
, end
);
12298 printf (" Tag_ABI_PIC: ");
12302 printf (_("Code addressing position-dependent\n"));
12305 printf (_("Code addressing position-independent\n"));
12308 printf ("??? (%d)\n", val
);
12313 case Tag_ABI_array_object_alignment
:
12314 val
= read_uleb128 (p
, &len
, end
);
12316 printf (" Tag_ABI_array_object_alignment: ");
12320 printf (_("8-byte\n"));
12323 printf (_("4-byte\n"));
12326 printf (_("16-byte\n"));
12329 printf ("??? (%d)\n", val
);
12334 case Tag_ABI_array_object_align_expected
:
12335 val
= read_uleb128 (p
, &len
, end
);
12337 printf (" Tag_ABI_array_object_align_expected: ");
12341 printf (_("8-byte\n"));
12344 printf (_("4-byte\n"));
12347 printf (_("16-byte\n"));
12350 printf ("??? (%d)\n", val
);
12355 case Tag_ABI_compatibility
:
12356 val
= read_uleb128 (p
, &len
, end
);
12358 printf (" Tag_ABI_compatibility: ");
12359 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12360 p
+= strlen ((char *) p
) + 1;
12363 case Tag_ABI_conformance
:
12364 printf (" Tag_ABI_conformance: ");
12365 printf ("\"%s\"\n", p
);
12366 p
+= strlen ((char *) p
) + 1;
12370 return display_tag_value (tag
, p
, end
);
12374 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12376 unsigned long addr
= 0;
12377 size_t bytes
= end
- p
;
12383 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12385 printf (" 0x%8.8lx ", addr
);
12387 for (j
= 0; j
< 16; j
++)
12390 printf ("%2.2x", p
[j
]);
12398 for (j
= 0; j
< lbytes
; j
++)
12401 if (k
>= ' ' && k
< 0x7f)
12417 static unsigned char *
12418 display_msp430x_attribute (unsigned char * p
,
12419 const unsigned char * const end
)
12425 tag
= read_uleb128 (p
, & len
, end
);
12430 case OFBA_MSPABI_Tag_ISA
:
12431 val
= read_uleb128 (p
, &len
, end
);
12433 printf (" Tag_ISA: ");
12436 case 0: printf (_("None\n")); break;
12437 case 1: printf (_("MSP430\n")); break;
12438 case 2: printf (_("MSP430X\n")); break;
12439 default: printf ("??? (%d)\n", val
); break;
12443 case OFBA_MSPABI_Tag_Code_Model
:
12444 val
= read_uleb128 (p
, &len
, end
);
12446 printf (" Tag_Code_Model: ");
12449 case 0: printf (_("None\n")); break;
12450 case 1: printf (_("Small\n")); break;
12451 case 2: printf (_("Large\n")); break;
12452 default: printf ("??? (%d)\n", val
); break;
12456 case OFBA_MSPABI_Tag_Data_Model
:
12457 val
= read_uleb128 (p
, &len
, end
);
12459 printf (" Tag_Data_Model: ");
12462 case 0: printf (_("None\n")); break;
12463 case 1: printf (_("Small\n")); break;
12464 case 2: printf (_("Large\n")); break;
12465 case 3: printf (_("Restricted Large\n")); break;
12466 default: printf ("??? (%d)\n", val
); break;
12471 printf (_(" <unknown tag %d>: "), tag
);
12475 printf ("\"%s\"\n", p
);
12476 p
+= strlen ((char *) p
) + 1;
12480 val
= read_uleb128 (p
, &len
, end
);
12482 printf ("%d (0x%x)\n", val
, val
);
12491 process_attributes (FILE * file
,
12492 const char * public_name
,
12493 unsigned int proc_type
,
12494 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12495 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12497 Elf_Internal_Shdr
* sect
;
12498 unsigned char * contents
;
12500 unsigned char * end
;
12501 bfd_vma section_len
;
12505 /* Find the section header so that we get the size. */
12506 for (i
= 0, sect
= section_headers
;
12507 i
< elf_header
.e_shnum
;
12510 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12513 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12514 sect
->sh_size
, _("attributes"));
12515 if (contents
== NULL
)
12521 len
= sect
->sh_size
- 1;
12526 unsigned int namelen
;
12527 bfd_boolean public_section
;
12528 bfd_boolean gnu_section
;
12530 section_len
= byte_get (p
, 4);
12533 if (section_len
> len
)
12535 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12536 (unsigned) section_len
, (unsigned) len
);
12540 len
-= section_len
;
12543 namelen
= strnlen ((char *) p
, section_len
) + 1;
12544 if (namelen
== 0 || namelen
>= section_len
)
12546 error (_("Corrupt attribute section name\n"));
12550 printf (_("Attribute Section: %s\n"), p
);
12552 if (public_name
&& streq ((char *) p
, public_name
))
12553 public_section
= TRUE
;
12555 public_section
= FALSE
;
12557 if (streq ((char *) p
, "gnu"))
12558 gnu_section
= TRUE
;
12560 gnu_section
= FALSE
;
12563 section_len
-= namelen
;
12564 while (section_len
> 0)
12570 size
= byte_get (p
, 4);
12571 if (size
> section_len
)
12573 error (_("Bad subsection length (%u > %u)\n"),
12574 (unsigned) size
, (unsigned) section_len
);
12575 size
= section_len
;
12578 section_len
-= size
;
12579 end
= p
+ size
- 1;
12585 printf (_("File Attributes\n"));
12588 printf (_("Section Attributes:"));
12591 printf (_("Symbol Attributes:"));
12597 val
= read_uleb128 (p
, &j
, end
);
12601 printf (" %d", val
);
12606 printf (_("Unknown tag: %d\n"), tag
);
12607 public_section
= FALSE
;
12611 if (public_section
)
12614 p
= display_pub_attribute (p
, end
);
12616 else if (gnu_section
)
12619 p
= display_gnu_attribute (p
,
12620 display_proc_gnu_attribute
,
12625 printf (_(" Unknown section contexts\n"));
12626 display_raw_attribute (p
, end
);
12633 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12641 process_arm_specific (FILE * file
)
12643 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12644 display_arm_attribute
, NULL
);
12648 process_power_specific (FILE * file
)
12650 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12651 display_power_gnu_attribute
);
12655 process_sparc_specific (FILE * file
)
12657 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12658 display_sparc_gnu_attribute
);
12662 process_tic6x_specific (FILE * file
)
12664 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12665 display_tic6x_attribute
, NULL
);
12669 process_msp430x_specific (FILE * file
)
12671 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12672 display_msp430x_attribute
, NULL
);
12675 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12676 Print the Address, Access and Initial fields of an entry at VMA ADDR
12677 and return the VMA of the next entry. */
12680 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12683 print_vma (addr
, LONG_HEX
);
12685 if (addr
< pltgot
+ 0xfff0)
12686 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12688 printf ("%10s", "");
12691 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12696 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12697 print_vma (entry
, LONG_HEX
);
12699 return addr
+ (is_32bit_elf
? 4 : 8);
12702 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12703 PLTGOT. Print the Address and Initial fields of an entry at VMA
12704 ADDR and return the VMA of the next entry. */
12707 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12710 print_vma (addr
, LONG_HEX
);
12713 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12718 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12719 print_vma (entry
, LONG_HEX
);
12721 return addr
+ (is_32bit_elf
? 4 : 8);
12725 print_mips_ases (unsigned int mask
)
12727 if (mask
& AFL_ASE_DSP
)
12728 fputs ("\n\tDSP ASE", stdout
);
12729 if (mask
& AFL_ASE_DSPR2
)
12730 fputs ("\n\tDSP R2 ASE", stdout
);
12731 if (mask
& AFL_ASE_EVA
)
12732 fputs ("\n\tEnhanced VA Scheme", stdout
);
12733 if (mask
& AFL_ASE_MCU
)
12734 fputs ("\n\tMCU (MicroController) ASE", stdout
);
12735 if (mask
& AFL_ASE_MDMX
)
12736 fputs ("\n\tMDMX ASE", stdout
);
12737 if (mask
& AFL_ASE_MIPS3D
)
12738 fputs ("\n\tMIPS-3D ASE", stdout
);
12739 if (mask
& AFL_ASE_MT
)
12740 fputs ("\n\tMT ASE", stdout
);
12741 if (mask
& AFL_ASE_SMARTMIPS
)
12742 fputs ("\n\tSmartMIPS ASE", stdout
);
12743 if (mask
& AFL_ASE_VIRT
)
12744 fputs ("\n\tVZ ASE", stdout
);
12745 if (mask
& AFL_ASE_MSA
)
12746 fputs ("\n\tMSA ASE", stdout
);
12747 if (mask
& AFL_ASE_MIPS16
)
12748 fputs ("\n\tMIPS16 ASE", stdout
);
12749 if (mask
& AFL_ASE_MICROMIPS
)
12750 fputs ("\n\tMICROMIPS ASE", stdout
);
12751 if (mask
& AFL_ASE_XPA
)
12752 fputs ("\n\tXPA ASE", stdout
);
12754 fprintf (stdout
, "\n\t%s", _("None"));
12755 else if ((mask
& ~AFL_ASE_MASK
) != 0)
12756 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
12760 print_mips_isa_ext (unsigned int isa_ext
)
12765 fputs (_("None"), stdout
);
12768 fputs ("RMI XLR", stdout
);
12770 case AFL_EXT_OCTEON2
:
12771 fputs ("Cavium Networks Octeon2", stdout
);
12773 case AFL_EXT_OCTEONP
:
12774 fputs ("Cavium Networks OcteonP", stdout
);
12776 case AFL_EXT_LOONGSON_3A
:
12777 fputs ("Loongson 3A", stdout
);
12779 case AFL_EXT_OCTEON
:
12780 fputs ("Cavium Networks Octeon", stdout
);
12783 fputs ("Toshiba R5900", stdout
);
12786 fputs ("MIPS R4650", stdout
);
12789 fputs ("LSI R4010", stdout
);
12792 fputs ("NEC VR4100", stdout
);
12795 fputs ("Toshiba R3900", stdout
);
12797 case AFL_EXT_10000
:
12798 fputs ("MIPS R10000", stdout
);
12801 fputs ("Broadcom SB-1", stdout
);
12804 fputs ("NEC VR4111/VR4181", stdout
);
12807 fputs ("NEC VR4120", stdout
);
12810 fputs ("NEC VR5400", stdout
);
12813 fputs ("NEC VR5500", stdout
);
12815 case AFL_EXT_LOONGSON_2E
:
12816 fputs ("ST Microelectronics Loongson 2E", stdout
);
12818 case AFL_EXT_LOONGSON_2F
:
12819 fputs ("ST Microelectronics Loongson 2F", stdout
);
12822 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
12827 get_mips_reg_size (int reg_size
)
12829 return (reg_size
== AFL_REG_NONE
) ? 0
12830 : (reg_size
== AFL_REG_32
) ? 32
12831 : (reg_size
== AFL_REG_64
) ? 64
12832 : (reg_size
== AFL_REG_128
) ? 128
12837 process_mips_specific (FILE * file
)
12839 Elf_Internal_Dyn
* entry
;
12840 Elf_Internal_Shdr
*sect
= NULL
;
12841 size_t liblist_offset
= 0;
12842 size_t liblistno
= 0;
12843 size_t conflictsno
= 0;
12844 size_t options_offset
= 0;
12845 size_t conflicts_offset
= 0;
12846 size_t pltrelsz
= 0;
12848 bfd_vma pltgot
= 0;
12849 bfd_vma mips_pltgot
= 0;
12850 bfd_vma jmprel
= 0;
12851 bfd_vma local_gotno
= 0;
12852 bfd_vma gotsym
= 0;
12853 bfd_vma symtabno
= 0;
12855 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12856 display_mips_gnu_attribute
);
12858 sect
= find_section (".MIPS.abiflags");
12862 Elf_External_ABIFlags_v0
*abiflags_ext
;
12863 Elf_Internal_ABIFlags_v0 abiflags_in
;
12865 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
12866 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
12869 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
12870 sect
->sh_size
, _("MIPS ABI Flags section"));
12873 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
12874 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
12875 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
12876 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
12877 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
12878 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
12879 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
12880 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
12881 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
12882 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
12883 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
12885 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
12886 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
12887 if (abiflags_in
.isa_rev
> 1)
12888 printf ("r%d", abiflags_in
.isa_rev
);
12889 printf ("\nGPR size: %d",
12890 get_mips_reg_size (abiflags_in
.gpr_size
));
12891 printf ("\nCPR1 size: %d",
12892 get_mips_reg_size (abiflags_in
.cpr1_size
));
12893 printf ("\nCPR2 size: %d",
12894 get_mips_reg_size (abiflags_in
.cpr2_size
));
12895 fputs ("\nFP ABI: ", stdout
);
12896 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
12897 fputs ("ISA Extension: ", stdout
);
12898 print_mips_isa_ext (abiflags_in
.isa_ext
);
12899 fputs ("\nASEs:", stdout
);
12900 print_mips_ases (abiflags_in
.ases
);
12901 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
12902 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
12903 fputc ('\n', stdout
);
12904 free (abiflags_ext
);
12909 /* We have a lot of special sections. Thanks SGI! */
12910 if (dynamic_section
== NULL
)
12911 /* No information available. */
12914 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12915 switch (entry
->d_tag
)
12917 case DT_MIPS_LIBLIST
:
12919 = offset_from_vma (file
, entry
->d_un
.d_val
,
12920 liblistno
* sizeof (Elf32_External_Lib
));
12922 case DT_MIPS_LIBLISTNO
:
12923 liblistno
= entry
->d_un
.d_val
;
12925 case DT_MIPS_OPTIONS
:
12926 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12928 case DT_MIPS_CONFLICT
:
12930 = offset_from_vma (file
, entry
->d_un
.d_val
,
12931 conflictsno
* sizeof (Elf32_External_Conflict
));
12933 case DT_MIPS_CONFLICTNO
:
12934 conflictsno
= entry
->d_un
.d_val
;
12937 pltgot
= entry
->d_un
.d_ptr
;
12939 case DT_MIPS_LOCAL_GOTNO
:
12940 local_gotno
= entry
->d_un
.d_val
;
12942 case DT_MIPS_GOTSYM
:
12943 gotsym
= entry
->d_un
.d_val
;
12945 case DT_MIPS_SYMTABNO
:
12946 symtabno
= entry
->d_un
.d_val
;
12948 case DT_MIPS_PLTGOT
:
12949 mips_pltgot
= entry
->d_un
.d_ptr
;
12952 pltrel
= entry
->d_un
.d_val
;
12955 pltrelsz
= entry
->d_un
.d_val
;
12958 jmprel
= entry
->d_un
.d_ptr
;
12964 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12966 Elf32_External_Lib
* elib
;
12969 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12971 sizeof (Elf32_External_Lib
),
12972 _("liblist section data"));
12975 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12976 (unsigned long) liblistno
);
12977 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12980 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12987 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12988 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12989 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12990 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12991 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12993 tmp
= gmtime (&atime
);
12994 snprintf (timebuf
, sizeof (timebuf
),
12995 "%04u-%02u-%02uT%02u:%02u:%02u",
12996 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12997 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12999 printf ("%3lu: ", (unsigned long) cnt
);
13000 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13001 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13003 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13004 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13005 liblist
.l_version
);
13007 if (liblist
.l_flags
== 0)
13011 static const struct
13018 { " EXACT_MATCH", LL_EXACT_MATCH
},
13019 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13020 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13021 { " EXPORTS", LL_EXPORTS
},
13022 { " DELAY_LOAD", LL_DELAY_LOAD
},
13023 { " DELTA", LL_DELTA
}
13025 int flags
= liblist
.l_flags
;
13028 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13029 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13031 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13032 flags
^= l_flags_vals
[fcnt
].bit
;
13035 printf (" %#x", (unsigned int) flags
);
13045 if (options_offset
!= 0)
13047 Elf_External_Options
* eopt
;
13048 Elf_Internal_Options
* iopt
;
13049 Elf_Internal_Options
* option
;
13052 sect
= section_headers
;
13054 /* Find the section header so that we get the size. */
13055 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
13058 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13059 sect
->sh_size
, _("options"));
13062 iopt
= (Elf_Internal_Options
*)
13063 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13066 error (_("Out of memory\n"));
13073 while (offset
< sect
->sh_size
)
13075 Elf_External_Options
* eoption
;
13077 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13079 option
->kind
= BYTE_GET (eoption
->kind
);
13080 option
->size
= BYTE_GET (eoption
->size
);
13081 option
->section
= BYTE_GET (eoption
->section
);
13082 option
->info
= BYTE_GET (eoption
->info
);
13084 offset
+= option
->size
;
13090 printf (_("\nSection '%s' contains %d entries:\n"),
13091 SECTION_NAME (sect
), cnt
);
13099 switch (option
->kind
)
13102 /* This shouldn't happen. */
13103 printf (" NULL %d %lx", option
->section
, option
->info
);
13106 printf (" REGINFO ");
13107 if (elf_header
.e_machine
== EM_MIPS
)
13110 Elf32_External_RegInfo
* ereg
;
13111 Elf32_RegInfo reginfo
;
13113 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13114 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13115 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13116 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13117 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13118 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13119 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13121 printf ("GPR %08lx GP 0x%lx\n",
13122 reginfo
.ri_gprmask
,
13123 (unsigned long) reginfo
.ri_gp_value
);
13124 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13125 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13126 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13131 Elf64_External_RegInfo
* ereg
;
13132 Elf64_Internal_RegInfo reginfo
;
13134 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13135 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13136 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13137 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13138 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13139 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13140 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13142 printf ("GPR %08lx GP 0x",
13143 reginfo
.ri_gprmask
);
13144 printf_vma (reginfo
.ri_gp_value
);
13147 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13148 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13149 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13153 case ODK_EXCEPTIONS
:
13154 fputs (" EXCEPTIONS fpe_min(", stdout
);
13155 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13156 fputs (") fpe_max(", stdout
);
13157 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13158 fputs (")", stdout
);
13160 if (option
->info
& OEX_PAGE0
)
13161 fputs (" PAGE0", stdout
);
13162 if (option
->info
& OEX_SMM
)
13163 fputs (" SMM", stdout
);
13164 if (option
->info
& OEX_FPDBUG
)
13165 fputs (" FPDBUG", stdout
);
13166 if (option
->info
& OEX_DISMISS
)
13167 fputs (" DISMISS", stdout
);
13170 fputs (" PAD ", stdout
);
13171 if (option
->info
& OPAD_PREFIX
)
13172 fputs (" PREFIX", stdout
);
13173 if (option
->info
& OPAD_POSTFIX
)
13174 fputs (" POSTFIX", stdout
);
13175 if (option
->info
& OPAD_SYMBOL
)
13176 fputs (" SYMBOL", stdout
);
13179 fputs (" HWPATCH ", stdout
);
13180 if (option
->info
& OHW_R4KEOP
)
13181 fputs (" R4KEOP", stdout
);
13182 if (option
->info
& OHW_R8KPFETCH
)
13183 fputs (" R8KPFETCH", stdout
);
13184 if (option
->info
& OHW_R5KEOP
)
13185 fputs (" R5KEOP", stdout
);
13186 if (option
->info
& OHW_R5KCVTL
)
13187 fputs (" R5KCVTL", stdout
);
13190 fputs (" FILL ", stdout
);
13191 /* XXX Print content of info word? */
13194 fputs (" TAGS ", stdout
);
13195 /* XXX Print content of info word? */
13198 fputs (" HWAND ", stdout
);
13199 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13200 fputs (" R4KEOP_CHECKED", stdout
);
13201 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13202 fputs (" R4KEOP_CLEAN", stdout
);
13205 fputs (" HWOR ", stdout
);
13206 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13207 fputs (" R4KEOP_CHECKED", stdout
);
13208 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13209 fputs (" R4KEOP_CLEAN", stdout
);
13212 printf (" GP_GROUP %#06lx self-contained %#06lx",
13213 option
->info
& OGP_GROUP
,
13214 (option
->info
& OGP_SELF
) >> 16);
13217 printf (" IDENT %#06lx self-contained %#06lx",
13218 option
->info
& OGP_GROUP
,
13219 (option
->info
& OGP_SELF
) >> 16);
13222 /* This shouldn't happen. */
13223 printf (" %3d ??? %d %lx",
13224 option
->kind
, option
->section
, option
->info
);
13228 len
= sizeof (* eopt
);
13229 while (len
< option
->size
)
13230 if (((char *) option
)[len
] >= ' '
13231 && ((char *) option
)[len
] < 0x7f)
13232 printf ("%c", ((char *) option
)[len
++]);
13234 printf ("\\%03o", ((char *) option
)[len
++]);
13236 fputs ("\n", stdout
);
13244 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13246 Elf32_Conflict
* iconf
;
13249 if (dynamic_symbols
== NULL
)
13251 error (_("conflict list found without a dynamic symbol table\n"));
13255 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13258 error (_("Out of memory\n"));
13264 Elf32_External_Conflict
* econf32
;
13266 econf32
= (Elf32_External_Conflict
*)
13267 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13268 sizeof (* econf32
), _("conflict"));
13272 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13273 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13279 Elf64_External_Conflict
* econf64
;
13281 econf64
= (Elf64_External_Conflict
*)
13282 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13283 sizeof (* econf64
), _("conflict"));
13287 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13288 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13293 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13294 (unsigned long) conflictsno
);
13295 puts (_(" Num: Index Value Name"));
13297 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13299 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13301 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13302 print_vma (psym
->st_value
, FULL_HEX
);
13304 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13305 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13307 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13314 if (pltgot
!= 0 && local_gotno
!= 0)
13316 bfd_vma ent
, local_end
, global_end
;
13318 unsigned char * data
;
13322 addr_size
= (is_32bit_elf
? 4 : 8);
13323 local_end
= pltgot
+ local_gotno
* addr_size
;
13324 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13326 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13327 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13328 global_end
- pltgot
, 1,
13329 _("Global Offset Table data"));
13333 printf (_("\nPrimary GOT:\n"));
13334 printf (_(" Canonical gp value: "));
13335 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13338 printf (_(" Reserved entries:\n"));
13339 printf (_(" %*s %10s %*s Purpose\n"),
13340 addr_size
* 2, _("Address"), _("Access"),
13341 addr_size
* 2, _("Initial"));
13342 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13343 printf (_(" Lazy resolver\n"));
13345 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13346 >> (addr_size
* 8 - 1)) != 0)
13348 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13349 printf (_(" Module pointer (GNU extension)\n"));
13353 if (ent
< local_end
)
13355 printf (_(" Local entries:\n"));
13356 printf (" %*s %10s %*s\n",
13357 addr_size
* 2, _("Address"), _("Access"),
13358 addr_size
* 2, _("Initial"));
13359 while (ent
< local_end
)
13361 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13367 if (gotsym
< symtabno
)
13371 printf (_(" Global entries:\n"));
13372 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13373 addr_size
* 2, _("Address"),
13375 addr_size
* 2, _("Initial"),
13376 addr_size
* 2, _("Sym.Val."),
13378 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13379 _("Ndx"), _("Name"));
13381 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13382 for (i
= gotsym
; i
< symtabno
; i
++)
13384 Elf_Internal_Sym
* psym
;
13386 psym
= dynamic_symbols
+ i
;
13387 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13389 print_vma (psym
->st_value
, LONG_HEX
);
13390 printf (" %-7s %3s ",
13391 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13392 get_symbol_index_type (psym
->st_shndx
));
13393 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13394 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13396 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13406 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13409 size_t offset
, rel_offset
;
13410 unsigned long count
, i
;
13411 unsigned char * data
;
13412 int addr_size
, sym_width
;
13413 Elf_Internal_Rela
* rels
;
13415 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13416 if (pltrel
== DT_RELA
)
13418 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13423 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13428 addr_size
= (is_32bit_elf
? 4 : 8);
13429 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13431 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13432 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13433 1, _("Procedure Linkage Table data"));
13437 printf ("\nPLT GOT:\n\n");
13438 printf (_(" Reserved entries:\n"));
13439 printf (_(" %*s %*s Purpose\n"),
13440 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13441 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13442 printf (_(" PLT lazy resolver\n"));
13443 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13444 printf (_(" Module pointer\n"));
13447 printf (_(" Entries:\n"));
13448 printf (" %*s %*s %*s %-7s %3s %s\n",
13449 addr_size
* 2, _("Address"),
13450 addr_size
* 2, _("Initial"),
13451 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13452 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13453 for (i
= 0; i
< count
; i
++)
13455 Elf_Internal_Sym
* psym
;
13457 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13458 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13460 print_vma (psym
->st_value
, LONG_HEX
);
13461 printf (" %-7s %3s ",
13462 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13463 get_symbol_index_type (psym
->st_shndx
));
13464 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13465 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13467 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13481 process_nds32_specific (FILE * file
)
13483 Elf_Internal_Shdr
*sect
= NULL
;
13485 sect
= find_section (".nds32_e_flags");
13488 unsigned int *flag
;
13490 printf ("\nNDS32 elf flags section:\n");
13491 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13492 sect
->sh_size
, _("NDS32 elf flags section"));
13494 switch ((*flag
) & 0x3)
13497 printf ("(VEC_SIZE):\tNo entry.\n");
13500 printf ("(VEC_SIZE):\t4 bytes\n");
13503 printf ("(VEC_SIZE):\t16 bytes\n");
13506 printf ("(VEC_SIZE):\treserved\n");
13515 process_gnu_liblist (FILE * file
)
13517 Elf_Internal_Shdr
* section
;
13518 Elf_Internal_Shdr
* string_sec
;
13519 Elf32_External_Lib
* elib
;
13521 size_t strtab_size
;
13528 for (i
= 0, section
= section_headers
;
13529 i
< elf_header
.e_shnum
;
13532 switch (section
->sh_type
)
13534 case SHT_GNU_LIBLIST
:
13535 if (section
->sh_link
>= elf_header
.e_shnum
)
13538 elib
= (Elf32_External_Lib
*)
13539 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13540 _("liblist section data"));
13544 string_sec
= section_headers
+ section
->sh_link
;
13546 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13547 string_sec
->sh_size
,
13548 _("liblist string table"));
13550 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13556 strtab_size
= string_sec
->sh_size
;
13558 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13559 SECTION_NAME (section
),
13560 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13562 puts (_(" Library Time Stamp Checksum Version Flags"));
13564 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13572 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13573 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13574 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13575 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13576 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13578 tmp
= gmtime (&atime
);
13579 snprintf (timebuf
, sizeof (timebuf
),
13580 "%04u-%02u-%02uT%02u:%02u:%02u",
13581 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13582 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13584 printf ("%3lu: ", (unsigned long) cnt
);
13586 printf ("%-20s", liblist
.l_name
< strtab_size
13587 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13589 printf ("%-20.20s", liblist
.l_name
< strtab_size
13590 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13591 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13592 liblist
.l_version
, liblist
.l_flags
);
13603 static const char *
13604 get_note_type (unsigned e_type
)
13606 static char buff
[64];
13608 if (elf_header
.e_type
== ET_CORE
)
13612 return _("NT_AUXV (auxiliary vector)");
13614 return _("NT_PRSTATUS (prstatus structure)");
13616 return _("NT_FPREGSET (floating point registers)");
13618 return _("NT_PRPSINFO (prpsinfo structure)");
13619 case NT_TASKSTRUCT
:
13620 return _("NT_TASKSTRUCT (task structure)");
13622 return _("NT_PRXFPREG (user_xfpregs structure)");
13624 return _("NT_PPC_VMX (ppc Altivec registers)");
13626 return _("NT_PPC_VSX (ppc VSX registers)");
13628 return _("NT_386_TLS (x86 TLS information)");
13629 case NT_386_IOPERM
:
13630 return _("NT_386_IOPERM (x86 I/O permissions)");
13631 case NT_X86_XSTATE
:
13632 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13633 case NT_S390_HIGH_GPRS
:
13634 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13635 case NT_S390_TIMER
:
13636 return _("NT_S390_TIMER (s390 timer register)");
13637 case NT_S390_TODCMP
:
13638 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13639 case NT_S390_TODPREG
:
13640 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13642 return _("NT_S390_CTRS (s390 control registers)");
13643 case NT_S390_PREFIX
:
13644 return _("NT_S390_PREFIX (s390 prefix register)");
13645 case NT_S390_LAST_BREAK
:
13646 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13647 case NT_S390_SYSTEM_CALL
:
13648 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13650 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13652 return _("NT_ARM_VFP (arm VFP registers)");
13654 return _("NT_ARM_TLS (AArch TLS registers)");
13655 case NT_ARM_HW_BREAK
:
13656 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13657 case NT_ARM_HW_WATCH
:
13658 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13660 return _("NT_PSTATUS (pstatus structure)");
13662 return _("NT_FPREGS (floating point registers)");
13664 return _("NT_PSINFO (psinfo structure)");
13666 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13668 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13669 case NT_WIN32PSTATUS
:
13670 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13672 return _("NT_SIGINFO (siginfo_t data)");
13674 return _("NT_FILE (mapped files)");
13682 return _("NT_VERSION (version)");
13684 return _("NT_ARCH (architecture)");
13689 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13694 print_core_note (Elf_Internal_Note
*pnote
)
13696 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13697 bfd_vma count
, page_size
;
13698 unsigned char *descdata
, *filenames
, *descend
;
13700 if (pnote
->type
!= NT_FILE
)
13706 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13707 /* Still "successful". */
13712 if (pnote
->descsz
< 2 * addr_size
)
13714 printf (_(" Malformed note - too short for header\n"));
13718 descdata
= (unsigned char *) pnote
->descdata
;
13719 descend
= descdata
+ pnote
->descsz
;
13721 if (descdata
[pnote
->descsz
- 1] != '\0')
13723 printf (_(" Malformed note - does not end with \\0\n"));
13727 count
= byte_get (descdata
, addr_size
);
13728 descdata
+= addr_size
;
13730 page_size
= byte_get (descdata
, addr_size
);
13731 descdata
+= addr_size
;
13733 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13735 printf (_(" Malformed note - too short for supplied file count\n"));
13739 printf (_(" Page size: "));
13740 print_vma (page_size
, DEC
);
13743 printf (_(" %*s%*s%*s\n"),
13744 (int) (2 + 2 * addr_size
), _("Start"),
13745 (int) (4 + 2 * addr_size
), _("End"),
13746 (int) (4 + 2 * addr_size
), _("Page Offset"));
13747 filenames
= descdata
+ count
* 3 * addr_size
;
13748 while (--count
> 0)
13750 bfd_vma start
, end
, file_ofs
;
13752 if (filenames
== descend
)
13754 printf (_(" Malformed note - filenames end too early\n"));
13758 start
= byte_get (descdata
, addr_size
);
13759 descdata
+= addr_size
;
13760 end
= byte_get (descdata
, addr_size
);
13761 descdata
+= addr_size
;
13762 file_ofs
= byte_get (descdata
, addr_size
);
13763 descdata
+= addr_size
;
13766 print_vma (start
, FULL_HEX
);
13768 print_vma (end
, FULL_HEX
);
13770 print_vma (file_ofs
, FULL_HEX
);
13771 printf ("\n %s\n", filenames
);
13773 filenames
+= 1 + strlen ((char *) filenames
);
13779 static const char *
13780 get_gnu_elf_note_type (unsigned e_type
)
13782 static char buff
[64];
13786 case NT_GNU_ABI_TAG
:
13787 return _("NT_GNU_ABI_TAG (ABI version tag)");
13789 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13790 case NT_GNU_BUILD_ID
:
13791 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13792 case NT_GNU_GOLD_VERSION
:
13793 return _("NT_GNU_GOLD_VERSION (gold version)");
13798 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13803 print_gnu_note (Elf_Internal_Note
*pnote
)
13805 switch (pnote
->type
)
13807 case NT_GNU_BUILD_ID
:
13811 printf (_(" Build ID: "));
13812 for (i
= 0; i
< pnote
->descsz
; ++i
)
13813 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13818 case NT_GNU_ABI_TAG
:
13820 unsigned long os
, major
, minor
, subminor
;
13821 const char *osname
;
13823 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13824 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13825 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13826 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13830 case GNU_ABI_TAG_LINUX
:
13833 case GNU_ABI_TAG_HURD
:
13836 case GNU_ABI_TAG_SOLARIS
:
13837 osname
= "Solaris";
13839 case GNU_ABI_TAG_FREEBSD
:
13840 osname
= "FreeBSD";
13842 case GNU_ABI_TAG_NETBSD
:
13846 osname
= "Unknown";
13850 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13851 major
, minor
, subminor
);
13855 case NT_GNU_GOLD_VERSION
:
13859 printf (_(" Version: "));
13860 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13861 printf ("%c", pnote
->descdata
[i
]);
13870 static const char *
13871 get_netbsd_elfcore_note_type (unsigned e_type
)
13873 static char buff
[64];
13875 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13877 /* NetBSD core "procinfo" structure. */
13878 return _("NetBSD procinfo structure");
13881 /* As of Jan 2002 there are no other machine-independent notes
13882 defined for NetBSD core files. If the note type is less
13883 than the start of the machine-dependent note types, we don't
13886 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13888 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13892 switch (elf_header
.e_machine
)
13894 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13895 and PT_GETFPREGS == mach+2. */
13900 case EM_SPARC32PLUS
:
13904 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13905 return _("PT_GETREGS (reg structure)");
13906 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13907 return _("PT_GETFPREGS (fpreg structure)");
13913 /* On all other arch's, PT_GETREGS == mach+1 and
13914 PT_GETFPREGS == mach+3. */
13918 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13919 return _("PT_GETREGS (reg structure)");
13920 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13921 return _("PT_GETFPREGS (fpreg structure)");
13927 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13928 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13932 static const char *
13933 get_stapsdt_note_type (unsigned e_type
)
13935 static char buff
[64];
13940 return _("NT_STAPSDT (SystemTap probe descriptors)");
13946 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13951 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13953 int addr_size
= is_32bit_elf
? 4 : 8;
13954 char *data
= pnote
->descdata
;
13955 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13956 bfd_vma pc
, base_addr
, semaphore
;
13957 char *provider
, *probe
, *arg_fmt
;
13959 pc
= byte_get ((unsigned char *) data
, addr_size
);
13961 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13963 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13967 data
+= strlen (data
) + 1;
13969 data
+= strlen (data
) + 1;
13971 data
+= strlen (data
) + 1;
13973 printf (_(" Provider: %s\n"), provider
);
13974 printf (_(" Name: %s\n"), probe
);
13975 printf (_(" Location: "));
13976 print_vma (pc
, FULL_HEX
);
13977 printf (_(", Base: "));
13978 print_vma (base_addr
, FULL_HEX
);
13979 printf (_(", Semaphore: "));
13980 print_vma (semaphore
, FULL_HEX
);
13982 printf (_(" Arguments: %s\n"), arg_fmt
);
13984 return data
== data_end
;
13987 static const char *
13988 get_ia64_vms_note_type (unsigned e_type
)
13990 static char buff
[64];
13995 return _("NT_VMS_MHD (module header)");
13997 return _("NT_VMS_LNM (language name)");
13999 return _("NT_VMS_SRC (source files)");
14001 return "NT_VMS_TITLE";
14003 return _("NT_VMS_EIDC (consistency check)");
14004 case NT_VMS_FPMODE
:
14005 return _("NT_VMS_FPMODE (FP mode)");
14006 case NT_VMS_LINKTIME
:
14007 return "NT_VMS_LINKTIME";
14008 case NT_VMS_IMGNAM
:
14009 return _("NT_VMS_IMGNAM (image name)");
14011 return _("NT_VMS_IMGID (image id)");
14012 case NT_VMS_LINKID
:
14013 return _("NT_VMS_LINKID (link id)");
14014 case NT_VMS_IMGBID
:
14015 return _("NT_VMS_IMGBID (build id)");
14016 case NT_VMS_GSTNAM
:
14017 return _("NT_VMS_GSTNAM (sym table name)");
14018 case NT_VMS_ORIG_DYN
:
14019 return "NT_VMS_ORIG_DYN";
14020 case NT_VMS_PATCHTIME
:
14021 return "NT_VMS_PATCHTIME";
14023 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14029 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14031 switch (pnote
->type
)
14034 if (pnote
->descsz
> 36)
14036 size_t l
= strlen (pnote
->descdata
+ 34);
14037 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14038 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14039 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14040 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14043 printf (_(" Invalid size\n"));
14046 printf (_(" Language: %s\n"), pnote
->descdata
);
14049 case NT_VMS_FPMODE
:
14050 printf (_(" Floating Point mode: "));
14051 printf ("0x%016" BFD_VMA_FMT
"x\n",
14052 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14054 case NT_VMS_LINKTIME
:
14055 printf (_(" Link time: "));
14057 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14060 case NT_VMS_PATCHTIME
:
14061 printf (_(" Patch time: "));
14063 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14066 case NT_VMS_ORIG_DYN
:
14067 printf (_(" Major id: %u, minor id: %u\n"),
14068 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14069 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14070 printf (_(" Last modified : "));
14072 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14073 printf (_("\n Link flags : "));
14074 printf ("0x%016" BFD_VMA_FMT
"x\n",
14075 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14076 printf (_(" Header flags: 0x%08x\n"),
14077 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14078 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14081 case NT_VMS_IMGNAM
:
14082 printf (_(" Image name: %s\n"), pnote
->descdata
);
14084 case NT_VMS_GSTNAM
:
14085 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14088 printf (_(" Image id: %s\n"), pnote
->descdata
);
14090 case NT_VMS_LINKID
:
14091 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14099 /* Note that by the ELF standard, the name field is already null byte
14100 terminated, and namesz includes the terminating null byte.
14101 I.E. the value of namesz for the name "FSF" is 4.
14103 If the value of namesz is zero, there is no name present. */
14105 process_note (Elf_Internal_Note
* pnote
)
14107 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14110 if (pnote
->namesz
== 0)
14111 /* If there is no note name, then use the default set of
14112 note type strings. */
14113 nt
= get_note_type (pnote
->type
);
14115 else if (const_strneq (pnote
->namedata
, "GNU"))
14116 /* GNU-specific object file notes. */
14117 nt
= get_gnu_elf_note_type (pnote
->type
);
14119 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14120 /* NetBSD-specific core file notes. */
14121 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14123 else if (strneq (pnote
->namedata
, "SPU/", 4))
14125 /* SPU-specific core file notes. */
14126 nt
= pnote
->namedata
+ 4;
14130 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14131 /* VMS/ia64-specific file notes. */
14132 nt
= get_ia64_vms_note_type (pnote
->type
);
14134 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14135 nt
= get_stapsdt_note_type (pnote
->type
);
14138 /* Don't recognize this note name; just use the default set of
14139 note type strings. */
14140 nt
= get_note_type (pnote
->type
);
14142 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14144 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14145 return print_ia64_vms_note (pnote
);
14146 else if (const_strneq (pnote
->namedata
, "GNU"))
14147 return print_gnu_note (pnote
);
14148 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14149 return print_stapsdt_note (pnote
);
14150 else if (const_strneq (pnote
->namedata
, "CORE"))
14151 return print_core_note (pnote
);
14158 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14160 Elf_External_Note
* pnotes
;
14161 Elf_External_Note
* external
;
14167 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14169 if (pnotes
== NULL
)
14174 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14175 (unsigned long) offset
, (unsigned long) length
);
14176 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14178 while ((char *) external
< (char *) pnotes
+ length
)
14180 Elf_Internal_Note inote
;
14183 char * temp
= NULL
;
14184 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14186 if (!is_ia64_vms ())
14188 /* PR binutils/15191
14189 Make sure that there is enough data to read. */
14190 min_notesz
= offsetof (Elf_External_Note
, name
);
14191 if (data_remaining
< min_notesz
)
14193 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14194 (int) data_remaining
);
14197 inote
.type
= BYTE_GET (external
->type
);
14198 inote
.namesz
= BYTE_GET (external
->namesz
);
14199 inote
.namedata
= external
->name
;
14200 inote
.descsz
= BYTE_GET (external
->descsz
);
14201 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14202 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14203 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14207 Elf64_External_VMS_Note
*vms_external
;
14209 /* PR binutils/15191
14210 Make sure that there is enough data to read. */
14211 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14212 if (data_remaining
< min_notesz
)
14214 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14215 (int) data_remaining
);
14219 vms_external
= (Elf64_External_VMS_Note
*) external
;
14220 inote
.type
= BYTE_GET (vms_external
->type
);
14221 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14222 inote
.namedata
= vms_external
->name
;
14223 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14224 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14225 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14226 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14229 if (inote
.descdata
< (char *) external
+ min_notesz
14230 || next
< (char *) external
+ min_notesz
14231 || data_remaining
< (size_t)(next
- (char *) external
))
14233 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14234 (unsigned long) ((char *) external
- (char *) pnotes
));
14235 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14236 inote
.type
, inote
.namesz
, inote
.descsz
);
14240 external
= (Elf_External_Note
*) next
;
14242 /* Verify that name is null terminated. It appears that at least
14243 one version of Linux (RedHat 6.0) generates corefiles that don't
14244 comply with the ELF spec by failing to include the null byte in
14246 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14248 temp
= (char *) malloc (inote
.namesz
+ 1);
14252 error (_("Out of memory\n"));
14257 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14258 temp
[inote
.namesz
] = 0;
14260 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14261 inote
.namedata
= temp
;
14264 res
&= process_note (& inote
);
14279 process_corefile_note_segments (FILE * file
)
14281 Elf_Internal_Phdr
* segment
;
14285 if (! get_program_headers (file
))
14288 for (i
= 0, segment
= program_headers
;
14289 i
< elf_header
.e_phnum
;
14292 if (segment
->p_type
== PT_NOTE
)
14293 res
&= process_corefile_note_segment (file
,
14294 (bfd_vma
) segment
->p_offset
,
14295 (bfd_vma
) segment
->p_filesz
);
14302 process_note_sections (FILE * file
)
14304 Elf_Internal_Shdr
* section
;
14309 for (i
= 0, section
= section_headers
;
14310 i
< elf_header
.e_shnum
&& section
!= NULL
;
14312 if (section
->sh_type
== SHT_NOTE
)
14314 res
&= process_corefile_note_segment (file
,
14315 (bfd_vma
) section
->sh_offset
,
14316 (bfd_vma
) section
->sh_size
);
14321 /* Try processing NOTE segments instead. */
14322 return process_corefile_note_segments (file
);
14328 process_notes (FILE * file
)
14330 /* If we have not been asked to display the notes then do nothing. */
14334 if (elf_header
.e_type
!= ET_CORE
)
14335 return process_note_sections (file
);
14337 /* No program headers means no NOTE segment. */
14338 if (elf_header
.e_phnum
> 0)
14339 return process_corefile_note_segments (file
);
14341 printf (_("No note segments present in the core file.\n"));
14346 process_arch_specific (FILE * file
)
14351 switch (elf_header
.e_machine
)
14354 return process_arm_specific (file
);
14356 case EM_MIPS_RS3_LE
:
14357 return process_mips_specific (file
);
14360 return process_nds32_specific (file
);
14363 return process_power_specific (file
);
14366 case EM_SPARC32PLUS
:
14368 return process_sparc_specific (file
);
14371 return process_tic6x_specific (file
);
14374 return process_msp430x_specific (file
);
14382 get_file_header (FILE * file
)
14384 /* Read in the identity array. */
14385 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14388 /* Determine how to read the rest of the header. */
14389 switch (elf_header
.e_ident
[EI_DATA
])
14391 default: /* fall through */
14392 case ELFDATANONE
: /* fall through */
14394 byte_get
= byte_get_little_endian
;
14395 byte_put
= byte_put_little_endian
;
14398 byte_get
= byte_get_big_endian
;
14399 byte_put
= byte_put_big_endian
;
14403 /* For now we only support 32 bit and 64 bit ELF files. */
14404 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14406 /* Read in the rest of the header. */
14409 Elf32_External_Ehdr ehdr32
;
14411 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14414 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14415 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14416 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14417 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14418 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14419 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14420 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14421 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14422 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14423 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14424 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14425 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14426 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14430 Elf64_External_Ehdr ehdr64
;
14432 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14433 we will not be able to cope with the 64bit data found in
14434 64 ELF files. Detect this now and abort before we start
14435 overwriting things. */
14436 if (sizeof (bfd_vma
) < 8)
14438 error (_("This instance of readelf has been built without support for a\n\
14439 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14443 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14446 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14447 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14448 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14449 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14450 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14451 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14452 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14453 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14454 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14455 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14456 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14457 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14458 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14461 if (elf_header
.e_shoff
)
14463 /* There may be some extensions in the first section header. Don't
14464 bomb if we can't read it. */
14466 get_32bit_section_headers (file
, 1);
14468 get_64bit_section_headers (file
, 1);
14474 /* Process one ELF object file according to the command line options.
14475 This file may actually be stored in an archive. The file is
14476 positioned at the start of the ELF object. */
14479 process_object (char * file_name
, FILE * file
)
14483 if (! get_file_header (file
))
14485 error (_("%s: Failed to read file header\n"), file_name
);
14489 /* Initialise per file variables. */
14490 for (i
= ARRAY_SIZE (version_info
); i
--;)
14491 version_info
[i
] = 0;
14493 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14494 dynamic_info
[i
] = 0;
14495 dynamic_info_DT_GNU_HASH
= 0;
14497 /* Process the file. */
14499 printf (_("\nFile: %s\n"), file_name
);
14501 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14502 Note we do this even if cmdline_dump_sects is empty because we
14503 must make sure that the dump_sets array is zeroed out before each
14504 object file is processed. */
14505 if (num_dump_sects
> num_cmdline_dump_sects
)
14506 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14508 if (num_cmdline_dump_sects
> 0)
14510 if (num_dump_sects
== 0)
14511 /* A sneaky way of allocating the dump_sects array. */
14512 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14514 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14515 memcpy (dump_sects
, cmdline_dump_sects
,
14516 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14519 if (! process_file_header ())
14522 if (! process_section_headers (file
))
14524 /* Without loaded section headers we cannot process lots of
14526 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14528 if (! do_using_dynamic
)
14529 do_syms
= do_dyn_syms
= do_reloc
= 0;
14532 if (! process_section_groups (file
))
14534 /* Without loaded section groups we cannot process unwind. */
14538 if (process_program_headers (file
))
14539 process_dynamic_section (file
);
14541 process_relocs (file
);
14543 process_unwind (file
);
14545 process_symbol_table (file
);
14547 process_syminfo (file
);
14549 process_version_sections (file
);
14551 process_section_contents (file
);
14553 process_notes (file
);
14555 process_gnu_liblist (file
);
14557 process_arch_specific (file
);
14559 if (program_headers
)
14561 free (program_headers
);
14562 program_headers
= NULL
;
14565 if (section_headers
)
14567 free (section_headers
);
14568 section_headers
= NULL
;
14573 free (string_table
);
14574 string_table
= NULL
;
14575 string_table_length
= 0;
14578 if (dynamic_strings
)
14580 free (dynamic_strings
);
14581 dynamic_strings
= NULL
;
14582 dynamic_strings_length
= 0;
14585 if (dynamic_symbols
)
14587 free (dynamic_symbols
);
14588 dynamic_symbols
= NULL
;
14589 num_dynamic_syms
= 0;
14592 if (dynamic_syminfo
)
14594 free (dynamic_syminfo
);
14595 dynamic_syminfo
= NULL
;
14598 if (dynamic_section
)
14600 free (dynamic_section
);
14601 dynamic_section
= NULL
;
14604 if (section_headers_groups
)
14606 free (section_headers_groups
);
14607 section_headers_groups
= NULL
;
14610 if (section_groups
)
14612 struct group_list
* g
;
14613 struct group_list
* next
;
14615 for (i
= 0; i
< group_count
; i
++)
14617 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14624 free (section_groups
);
14625 section_groups
= NULL
;
14628 free_debug_memory ();
14633 /* Process an ELF archive.
14634 On entry the file is positioned just after the ARMAG string. */
14637 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14639 struct archive_info arch
;
14640 struct archive_info nested_arch
;
14646 /* The ARCH structure is used to hold information about this archive. */
14647 arch
.file_name
= NULL
;
14649 arch
.index_array
= NULL
;
14650 arch
.sym_table
= NULL
;
14651 arch
.longnames
= NULL
;
14653 /* The NESTED_ARCH structure is used as a single-item cache of information
14654 about a nested archive (when members of a thin archive reside within
14655 another regular archive file). */
14656 nested_arch
.file_name
= NULL
;
14657 nested_arch
.file
= NULL
;
14658 nested_arch
.index_array
= NULL
;
14659 nested_arch
.sym_table
= NULL
;
14660 nested_arch
.longnames
= NULL
;
14662 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14668 if (do_archive_index
)
14670 if (arch
.sym_table
== NULL
)
14671 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14675 unsigned long current_pos
;
14677 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14678 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14679 current_pos
= ftell (file
);
14681 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14683 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14685 char * member_name
;
14687 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14689 if (member_name
!= NULL
)
14691 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14693 if (qualified_name
!= NULL
)
14695 printf (_("Contents of binary %s at offset "), qualified_name
);
14696 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14698 free (qualified_name
);
14703 if (l
>= arch
.sym_size
)
14705 error (_("%s: end of the symbol table reached before the end of the index\n"),
14709 printf ("\t%s\n", arch
.sym_table
+ l
);
14710 l
+= strlen (arch
.sym_table
+ l
) + 1;
14713 if (arch
.uses_64bit_indicies
)
14718 if (l
< arch
.sym_size
)
14719 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14720 file_name
, arch
.sym_size
- l
);
14722 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14724 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14730 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14731 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14732 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14733 && !do_section_groups
&& !do_dyn_syms
)
14735 ret
= 0; /* Archive index only. */
14746 char * qualified_name
;
14748 /* Read the next archive header. */
14749 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14751 error (_("%s: failed to seek to next archive header\n"), file_name
);
14754 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14755 if (got
!= sizeof arch
.arhdr
)
14759 error (_("%s: failed to read archive header\n"), file_name
);
14763 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14765 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14770 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14772 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14773 if (archive_file_size
& 01)
14774 ++archive_file_size
;
14776 name
= get_archive_member_name (&arch
, &nested_arch
);
14779 error (_("%s: bad archive file name\n"), file_name
);
14783 namelen
= strlen (name
);
14785 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14786 if (qualified_name
== NULL
)
14788 error (_("%s: bad archive file name\n"), file_name
);
14793 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14795 /* This is a proxy for an external member of a thin archive. */
14796 FILE * member_file
;
14797 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14798 if (member_file_name
== NULL
)
14804 member_file
= fopen (member_file_name
, "rb");
14805 if (member_file
== NULL
)
14807 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14808 free (member_file_name
);
14813 archive_file_offset
= arch
.nested_member_origin
;
14815 ret
|= process_object (qualified_name
, member_file
);
14817 fclose (member_file
);
14818 free (member_file_name
);
14820 else if (is_thin_archive
)
14822 /* PR 15140: Allow for corrupt thin archives. */
14823 if (nested_arch
.file
== NULL
)
14825 error (_("%s: contains corrupt thin archive: %s\n"),
14831 /* This is a proxy for a member of a nested archive. */
14832 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14834 /* The nested archive file will have been opened and setup by
14835 get_archive_member_name. */
14836 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14838 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14843 ret
|= process_object (qualified_name
, nested_arch
.file
);
14847 archive_file_offset
= arch
.next_arhdr_offset
;
14848 arch
.next_arhdr_offset
+= archive_file_size
;
14850 ret
|= process_object (qualified_name
, file
);
14853 if (dump_sects
!= NULL
)
14857 num_dump_sects
= 0;
14860 free (qualified_name
);
14864 if (nested_arch
.file
!= NULL
)
14865 fclose (nested_arch
.file
);
14866 release_archive (&nested_arch
);
14867 release_archive (&arch
);
14873 process_file (char * file_name
)
14876 struct stat statbuf
;
14877 char armag
[SARMAG
];
14880 if (stat (file_name
, &statbuf
) < 0)
14882 if (errno
== ENOENT
)
14883 error (_("'%s': No such file\n"), file_name
);
14885 error (_("Could not locate '%s'. System error message: %s\n"),
14886 file_name
, strerror (errno
));
14890 if (! S_ISREG (statbuf
.st_mode
))
14892 error (_("'%s' is not an ordinary file\n"), file_name
);
14896 file
= fopen (file_name
, "rb");
14899 error (_("Input file '%s' is not readable.\n"), file_name
);
14903 if (fread (armag
, SARMAG
, 1, file
) != 1)
14905 error (_("%s: Failed to read file's magic number\n"), file_name
);
14910 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
14912 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14913 ret
= process_archive (file_name
, file
, FALSE
);
14914 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14915 ret
= process_archive (file_name
, file
, TRUE
);
14918 if (do_archive_index
)
14919 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14923 archive_file_size
= archive_file_offset
= 0;
14924 ret
= process_object (file_name
, file
);
14929 current_file_size
= 0;
14933 #ifdef SUPPORT_DISASSEMBLY
14934 /* Needed by the i386 disassembler. For extra credit, someone could
14935 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14939 print_address (unsigned int addr
, FILE * outfile
)
14941 fprintf (outfile
,"0x%8.8x", addr
);
14944 /* Needed by the i386 disassembler. */
14946 db_task_printsym (unsigned int addr
)
14948 print_address (addr
, stderr
);
14953 main (int argc
, char ** argv
)
14957 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14958 setlocale (LC_MESSAGES
, "");
14960 #if defined (HAVE_SETLOCALE)
14961 setlocale (LC_CTYPE
, "");
14963 bindtextdomain (PACKAGE
, LOCALEDIR
);
14964 textdomain (PACKAGE
);
14966 expandargv (&argc
, &argv
);
14968 parse_args (argc
, argv
);
14970 if (num_dump_sects
> 0)
14972 /* Make a copy of the dump_sects array. */
14973 cmdline_dump_sects
= (dump_type
*)
14974 malloc (num_dump_sects
* sizeof (* dump_sects
));
14975 if (cmdline_dump_sects
== NULL
)
14976 error (_("Out of memory allocating dump request table.\n"));
14979 memcpy (cmdline_dump_sects
, dump_sects
,
14980 num_dump_sects
* sizeof (* dump_sects
));
14981 num_cmdline_dump_sects
= num_dump_sects
;
14985 if (optind
< (argc
- 1))
14989 while (optind
< argc
)
14990 err
|= process_file (argv
[optind
++]);
14992 if (dump_sects
!= NULL
)
14994 if (cmdline_dump_sects
!= NULL
)
14995 free (cmdline_dump_sects
);