1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 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/visium.h"
153 #include "elf/x86-64.h"
154 #include "elf/xc16x.h"
155 #include "elf/xgate.h"
156 #include "elf/xstormy16.h"
157 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
162 #include "filenames.h"
165 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168 char * program_name
= "readelf";
169 static unsigned long archive_file_offset
;
170 static unsigned long archive_file_size
;
171 static bfd_size_type current_file_size
;
172 static unsigned long dynamic_addr
;
173 static bfd_size_type dynamic_size
;
174 static size_t dynamic_nent
;
175 static char * dynamic_strings
;
176 static unsigned long dynamic_strings_length
;
177 static char * string_table
;
178 static unsigned long string_table_length
;
179 static unsigned long num_dynamic_syms
;
180 static Elf_Internal_Sym
* dynamic_symbols
;
181 static Elf_Internal_Syminfo
* dynamic_syminfo
;
182 static unsigned long dynamic_syminfo_offset
;
183 static unsigned int dynamic_syminfo_nent
;
184 static char program_interpreter
[PATH_MAX
];
185 static bfd_vma dynamic_info
[DT_ENCODING
];
186 static bfd_vma dynamic_info_DT_GNU_HASH
;
187 static bfd_vma version_info
[16];
188 static Elf_Internal_Ehdr elf_header
;
189 static Elf_Internal_Shdr
* section_headers
;
190 static Elf_Internal_Phdr
* program_headers
;
191 static Elf_Internal_Dyn
* dynamic_section
;
192 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
193 static int show_name
;
194 static int do_dynamic
;
196 static int do_dyn_syms
;
198 static int do_sections
;
199 static int do_section_groups
;
200 static int do_section_details
;
201 static int do_segments
;
202 static int do_unwind
;
203 static int do_using_dynamic
;
204 static int do_header
;
206 static int do_version
;
207 static int do_histogram
;
208 static int do_debugging
;
211 static int do_archive_index
;
212 static int is_32bit_elf
;
216 struct group_list
* next
;
217 unsigned int section_index
;
222 struct group_list
* root
;
223 unsigned int group_index
;
226 static size_t group_count
;
227 static struct group
* section_groups
;
228 static struct group
** section_headers_groups
;
231 /* Flag bits indicating particular types of dump. */
232 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
233 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
236 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
238 typedef unsigned char dump_type
;
240 /* A linked list of the section names for which dumps were requested. */
241 struct dump_list_entry
245 struct dump_list_entry
* next
;
247 static struct dump_list_entry
* dump_sects_byname
;
249 /* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251 static dump_type
* cmdline_dump_sects
= NULL
;
252 static unsigned int num_cmdline_dump_sects
= 0;
254 /* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
259 static dump_type
* dump_sects
= NULL
;
260 static unsigned int num_dump_sects
= 0;
263 /* How to print a vma value. */
264 typedef enum print_mode
276 /* Versioned symbol info. */
277 enum versioned_symbol_info
284 static const char *get_symbol_version_string
285 (FILE *file
, int is_dynsym
, const char *strtab
,
286 unsigned long int strtab_size
, unsigned int si
,
287 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
288 unsigned short *vna_other
);
292 #define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
296 : string_table + (X)->sh_name))
298 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
300 #define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
304 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
309 #define REMOVE_ARCH_BITS(ADDR) \
312 if (elf_header.e_machine == EM_ARM) \
317 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
322 and REASON is not NULL then emit an error message using REASON as part of the
326 get_data (void * var
, FILE * file
, unsigned long offset
, size_t size
, size_t nmemb
,
330 size_t amt
= size
* nmemb
;
332 if (size
== 0 || nmemb
== 0)
335 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
336 attempting to allocate memory when the read is bound to fail. */
337 if (amt
> current_file_size
338 || offset
+ archive_file_offset
+ amt
> current_file_size
)
341 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
342 (unsigned long) amt
, reason
);
346 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
349 error (_("Unable to seek to 0x%lx for %s\n"),
350 (unsigned long) archive_file_offset
+ offset
, reason
);
357 /* Check for overflow. */
358 if (nmemb
< (~(size_t) 0 - 1) / size
)
359 /* + 1 so that we can '\0' terminate invalid string table sections. */
360 mvar
= malloc (size
* nmemb
+ 1);
365 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
366 (unsigned long)(size
* nmemb
), reason
);
370 ((char *) mvar
)[amt
] = '\0';
373 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
376 error (_("Unable to read in 0x%lx bytes of %s\n"),
377 (unsigned long) amt
, reason
);
386 /* Print a VMA value. */
389 print_vma (bfd_vma vma
, print_mode mode
)
402 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
409 return printf ("%5" BFD_VMA_FMT
"d", vma
);
417 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
420 return printf ("%" BFD_VMA_FMT
"d", vma
);
423 return printf ("%" BFD_VMA_FMT
"u", vma
);
428 /* Display a symbol on stdout. Handles the display of control characters and
429 multibye characters (assuming the host environment supports them).
431 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
433 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
434 padding as necessary.
436 Returns the number of emitted characters. */
439 print_symbol (int width
, const char *symbol
)
441 bfd_boolean extra_padding
= FALSE
;
443 #ifdef HAVE_MBSTATE_T
450 /* Keep the width positive. This also helps. */
452 extra_padding
= TRUE
;
457 /* Set the remaining width to a very large value.
458 This simplifies the code below. */
459 width_remaining
= INT_MAX
;
461 width_remaining
= width
;
463 #ifdef HAVE_MBSTATE_T
464 /* Initialise the multibyte conversion state. */
465 memset (& state
, 0, sizeof (state
));
468 while (width_remaining
)
471 const char c
= *symbol
++;
476 /* Do not print control characters directly as they can affect terminal
477 settings. Such characters usually appear in the names generated
478 by the assembler for local labels. */
481 if (width_remaining
< 2)
484 printf ("^%c", c
+ 0x40);
485 width_remaining
-= 2;
488 else if (ISPRINT (c
))
496 #ifdef HAVE_MBSTATE_T
499 /* Let printf do the hard work of displaying multibyte characters. */
500 printf ("%.1s", symbol
- 1);
504 #ifdef HAVE_MBSTATE_T
505 /* Try to find out how many bytes made up the character that was
506 just printed. Advance the symbol pointer past the bytes that
508 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
512 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
517 if (extra_padding
&& num_printed
< width
)
519 /* Fill in the remaining spaces. */
520 printf ("%-*s", width
- num_printed
, " ");
527 /* Returns a pointer to a static buffer containing a printable version of
528 the given section's name. Like print_symbol, except that it does not try
529 to print multibyte characters, it just interprets them as hex values. */
532 printable_section_name (Elf_Internal_Shdr
* sec
)
534 #define MAX_PRINT_SEC_NAME_LEN 128
535 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
536 const char * name
= SECTION_NAME (sec
);
537 char * buf
= sec_name_buf
;
539 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
541 while ((c
= * name
++) != 0)
552 else if (ISPRINT (c
))
559 static char hex
[17] = "0123456789ABCDEF";
564 * buf
++ = hex
[(c
& 0xf0) >> 4];
565 * buf
++ = hex
[c
& 0x0f];
579 printable_section_name_from_index (unsigned long ndx
)
581 if (ndx
>= elf_header
.e_shnum
)
582 return _("<corrupt>");
584 return printable_section_name (section_headers
+ ndx
);
587 /* Return a pointer to section NAME, or NULL if no such section exists. */
589 static Elf_Internal_Shdr
*
590 find_section (const char * name
)
594 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
595 if (streq (SECTION_NAME (section_headers
+ i
), name
))
596 return section_headers
+ i
;
601 /* Return a pointer to a section containing ADDR, or NULL if no such
604 static Elf_Internal_Shdr
*
605 find_section_by_address (bfd_vma addr
)
609 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
611 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
612 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
619 static Elf_Internal_Shdr
*
620 find_section_by_type (unsigned int type
)
624 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
626 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
627 if (sec
->sh_type
== type
)
634 /* Return a pointer to section NAME, or NULL if no such section exists,
635 restricted to the list of sections given in SET. */
637 static Elf_Internal_Shdr
*
638 find_section_in_set (const char * name
, unsigned int * set
)
644 while ((i
= *set
++) > 0)
645 if (streq (SECTION_NAME (section_headers
+ i
), name
))
646 return section_headers
+ i
;
649 return find_section (name
);
652 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
655 static inline unsigned long
656 read_uleb128 (unsigned char *data
,
657 unsigned int *length_return
,
658 const unsigned char * const end
)
660 return read_leb128 (data
, length_return
, FALSE
, end
);
663 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
664 This OS has so many departures from the ELF standard that we test it at
670 return elf_header
.e_machine
== EM_IA_64
671 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
674 /* Guess the relocation size commonly used by the specific machines. */
677 guess_is_rela (unsigned int e_machine
)
681 /* Targets that use REL relocations. */
696 /* Targets that use RELA relocations. */
700 case EM_ADAPTEVA_EPIPHANY
:
702 case EM_ALTERA_NIOS2
:
721 case EM_LATTICEMICO32
:
730 case EM_CYGNUS_MN10200
:
732 case EM_CYGNUS_MN10300
:
766 case EM_MICROBLAZE_OLD
:
787 warn (_("Don't know about relocations on this machine architecture\n"));
793 slurp_rela_relocs (FILE * file
,
794 unsigned long rel_offset
,
795 unsigned long rel_size
,
796 Elf_Internal_Rela
** relasp
,
797 unsigned long * nrelasp
)
799 Elf_Internal_Rela
* relas
;
805 Elf32_External_Rela
* erelas
;
807 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
808 rel_size
, _("32-bit relocation data"));
812 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
814 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
815 sizeof (Elf_Internal_Rela
));
820 error (_("out of memory parsing relocs\n"));
824 for (i
= 0; i
< nrelas
; i
++)
826 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
827 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
828 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
835 Elf64_External_Rela
* erelas
;
837 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
838 rel_size
, _("64-bit relocation data"));
842 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
844 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
845 sizeof (Elf_Internal_Rela
));
850 error (_("out of memory parsing relocs\n"));
854 for (i
= 0; i
< nrelas
; i
++)
856 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
857 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
858 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
860 /* The #ifdef BFD64 below is to prevent a compile time
861 warning. We know that if we do not have a 64 bit data
862 type that we will never execute this code anyway. */
864 if (elf_header
.e_machine
== EM_MIPS
865 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
867 /* In little-endian objects, r_info isn't really a
868 64-bit little-endian value: it has a 32-bit
869 little-endian symbol index followed by four
870 individual byte fields. Reorder INFO
872 bfd_vma inf
= relas
[i
].r_info
;
873 inf
= (((inf
& 0xffffffff) << 32)
874 | ((inf
>> 56) & 0xff)
875 | ((inf
>> 40) & 0xff00)
876 | ((inf
>> 24) & 0xff0000)
877 | ((inf
>> 8) & 0xff000000));
878 relas
[i
].r_info
= inf
;
891 slurp_rel_relocs (FILE * file
,
892 unsigned long rel_offset
,
893 unsigned long rel_size
,
894 Elf_Internal_Rela
** relsp
,
895 unsigned long * nrelsp
)
897 Elf_Internal_Rela
* rels
;
903 Elf32_External_Rel
* erels
;
905 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
906 rel_size
, _("32-bit relocation data"));
910 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
912 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
917 error (_("out of memory parsing relocs\n"));
921 for (i
= 0; i
< nrels
; i
++)
923 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
924 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
925 rels
[i
].r_addend
= 0;
932 Elf64_External_Rel
* erels
;
934 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
935 rel_size
, _("64-bit relocation data"));
939 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
941 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
946 error (_("out of memory parsing relocs\n"));
950 for (i
= 0; i
< nrels
; i
++)
952 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
953 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
954 rels
[i
].r_addend
= 0;
956 /* The #ifdef BFD64 below is to prevent a compile time
957 warning. We know that if we do not have a 64 bit data
958 type that we will never execute this code anyway. */
960 if (elf_header
.e_machine
== EM_MIPS
961 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
963 /* In little-endian objects, r_info isn't really a
964 64-bit little-endian value: it has a 32-bit
965 little-endian symbol index followed by four
966 individual byte fields. Reorder INFO
968 bfd_vma inf
= rels
[i
].r_info
;
969 inf
= (((inf
& 0xffffffff) << 32)
970 | ((inf
>> 56) & 0xff)
971 | ((inf
>> 40) & 0xff00)
972 | ((inf
>> 24) & 0xff0000)
973 | ((inf
>> 8) & 0xff000000));
974 rels
[i
].r_info
= inf
;
986 /* Returns the reloc type extracted from the reloc info field. */
989 get_reloc_type (bfd_vma reloc_info
)
992 return ELF32_R_TYPE (reloc_info
);
994 switch (elf_header
.e_machine
)
997 /* Note: We assume that reloc_info has already been adjusted for us. */
998 return ELF64_MIPS_R_TYPE (reloc_info
);
1001 return ELF64_R_TYPE_ID (reloc_info
);
1004 return ELF64_R_TYPE (reloc_info
);
1008 /* Return the symbol index extracted from the reloc info field. */
1011 get_reloc_symindex (bfd_vma reloc_info
)
1013 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1016 static inline bfd_boolean
1017 uses_msp430x_relocs (void)
1020 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1021 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1022 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1023 /* TI compiler uses ELFOSABI_NONE. */
1024 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1027 /* Display the contents of the relocation data found at the specified
1031 dump_relocations (FILE * file
,
1032 unsigned long rel_offset
,
1033 unsigned long rel_size
,
1034 Elf_Internal_Sym
* symtab
,
1035 unsigned long nsyms
,
1037 unsigned long strtablen
,
1042 Elf_Internal_Rela
* rels
;
1044 if (is_rela
== UNKNOWN
)
1045 is_rela
= guess_is_rela (elf_header
.e_machine
);
1049 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1054 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1063 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1065 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1070 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1072 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1080 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1082 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1087 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1089 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1093 for (i
= 0; i
< rel_size
; i
++)
1098 bfd_vma symtab_index
;
1101 offset
= rels
[i
].r_offset
;
1102 inf
= rels
[i
].r_info
;
1104 type
= get_reloc_type (inf
);
1105 symtab_index
= get_reloc_symindex (inf
);
1109 printf ("%8.8lx %8.8lx ",
1110 (unsigned long) offset
& 0xffffffff,
1111 (unsigned long) inf
& 0xffffffff);
1115 #if BFD_HOST_64BIT_LONG
1117 ? "%16.16lx %16.16lx "
1118 : "%12.12lx %12.12lx ",
1120 #elif BFD_HOST_64BIT_LONG_LONG
1123 ? "%16.16llx %16.16llx "
1124 : "%12.12llx %12.12llx ",
1128 ? "%16.16I64x %16.16I64x "
1129 : "%12.12I64x %12.12I64x ",
1134 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1135 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1136 _bfd_int64_high (offset
),
1137 _bfd_int64_low (offset
),
1138 _bfd_int64_high (inf
),
1139 _bfd_int64_low (inf
));
1143 switch (elf_header
.e_machine
)
1150 rtype
= elf_aarch64_reloc_type (type
);
1154 case EM_CYGNUS_M32R
:
1155 rtype
= elf_m32r_reloc_type (type
);
1160 rtype
= elf_i386_reloc_type (type
);
1165 rtype
= elf_m68hc11_reloc_type (type
);
1169 rtype
= elf_m68k_reloc_type (type
);
1173 rtype
= elf_i960_reloc_type (type
);
1178 rtype
= elf_avr_reloc_type (type
);
1181 case EM_OLD_SPARCV9
:
1182 case EM_SPARC32PLUS
:
1185 rtype
= elf_sparc_reloc_type (type
);
1189 rtype
= elf_spu_reloc_type (type
);
1193 rtype
= v800_reloc_type (type
);
1196 case EM_CYGNUS_V850
:
1197 rtype
= v850_reloc_type (type
);
1201 case EM_CYGNUS_D10V
:
1202 rtype
= elf_d10v_reloc_type (type
);
1206 case EM_CYGNUS_D30V
:
1207 rtype
= elf_d30v_reloc_type (type
);
1211 rtype
= elf_dlx_reloc_type (type
);
1215 rtype
= elf_sh_reloc_type (type
);
1219 case EM_CYGNUS_MN10300
:
1220 rtype
= elf_mn10300_reloc_type (type
);
1224 case EM_CYGNUS_MN10200
:
1225 rtype
= elf_mn10200_reloc_type (type
);
1229 case EM_CYGNUS_FR30
:
1230 rtype
= elf_fr30_reloc_type (type
);
1234 rtype
= elf_frv_reloc_type (type
);
1238 rtype
= elf_mcore_reloc_type (type
);
1242 rtype
= elf_mmix_reloc_type (type
);
1246 rtype
= elf_moxie_reloc_type (type
);
1250 if (uses_msp430x_relocs ())
1252 rtype
= elf_msp430x_reloc_type (type
);
1256 rtype
= elf_msp430_reloc_type (type
);
1260 rtype
= elf_nds32_reloc_type (type
);
1264 rtype
= elf_ppc_reloc_type (type
);
1268 rtype
= elf_ppc64_reloc_type (type
);
1272 case EM_MIPS_RS3_LE
:
1273 rtype
= elf_mips_reloc_type (type
);
1277 rtype
= elf_alpha_reloc_type (type
);
1281 rtype
= elf_arm_reloc_type (type
);
1285 rtype
= elf_arc_reloc_type (type
);
1289 rtype
= elf_hppa_reloc_type (type
);
1295 rtype
= elf_h8_reloc_type (type
);
1299 rtype
= elf_or1k_reloc_type (type
);
1304 rtype
= elf_pj_reloc_type (type
);
1307 rtype
= elf_ia64_reloc_type (type
);
1311 rtype
= elf_cris_reloc_type (type
);
1315 rtype
= elf_i860_reloc_type (type
);
1321 rtype
= elf_x86_64_reloc_type (type
);
1325 rtype
= i370_reloc_type (type
);
1330 rtype
= elf_s390_reloc_type (type
);
1334 rtype
= elf_score_reloc_type (type
);
1338 rtype
= elf_xstormy16_reloc_type (type
);
1342 rtype
= elf_crx_reloc_type (type
);
1346 rtype
= elf_vax_reloc_type (type
);
1350 rtype
= elf_visium_reloc_type (type
);
1353 case EM_ADAPTEVA_EPIPHANY
:
1354 rtype
= elf_epiphany_reloc_type (type
);
1359 rtype
= elf_ip2k_reloc_type (type
);
1363 rtype
= elf_iq2000_reloc_type (type
);
1368 rtype
= elf_xtensa_reloc_type (type
);
1371 case EM_LATTICEMICO32
:
1372 rtype
= elf_lm32_reloc_type (type
);
1377 rtype
= elf_m32c_reloc_type (type
);
1381 rtype
= elf_mt_reloc_type (type
);
1385 rtype
= elf_bfin_reloc_type (type
);
1389 rtype
= elf_mep_reloc_type (type
);
1393 rtype
= elf_cr16_reloc_type (type
);
1397 case EM_MICROBLAZE_OLD
:
1398 rtype
= elf_microblaze_reloc_type (type
);
1402 rtype
= elf_rl78_reloc_type (type
);
1406 rtype
= elf_rx_reloc_type (type
);
1410 rtype
= elf_metag_reloc_type (type
);
1415 rtype
= elf_xc16x_reloc_type (type
);
1419 rtype
= elf_tic6x_reloc_type (type
);
1423 rtype
= elf_tilegx_reloc_type (type
);
1427 rtype
= elf_tilepro_reloc_type (type
);
1431 rtype
= elf_xgate_reloc_type (type
);
1434 case EM_ALTERA_NIOS2
:
1435 rtype
= elf_nios2_reloc_type (type
);
1440 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1442 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1444 if (elf_header
.e_machine
== EM_ALPHA
1446 && streq (rtype
, "R_ALPHA_LITUSE")
1449 switch (rels
[i
].r_addend
)
1451 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1452 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1453 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1454 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1455 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1456 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1457 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1458 default: rtype
= NULL
;
1461 printf (" (%s)", rtype
);
1465 printf (_("<unknown addend: %lx>"),
1466 (unsigned long) rels
[i
].r_addend
);
1469 else if (symtab_index
)
1471 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1472 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1475 Elf_Internal_Sym
* psym
;
1476 const char * version_string
;
1477 enum versioned_symbol_info sym_info
;
1478 unsigned short vna_other
;
1480 psym
= symtab
+ symtab_index
;
1483 = get_symbol_version_string (file
, is_dynsym
,
1492 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1496 unsigned int width
= is_32bit_elf
? 8 : 14;
1498 /* Relocations against GNU_IFUNC symbols do not use the value
1499 of the symbol as the address to relocate against. Instead
1500 they invoke the function named by the symbol and use its
1501 result as the address for relocation.
1503 To indicate this to the user, do not display the value of
1504 the symbol in the "Symbols's Value" field. Instead show
1505 its name followed by () as a hint that the symbol is
1509 || psym
->st_name
== 0
1510 || psym
->st_name
>= strtablen
)
1513 name
= strtab
+ psym
->st_name
;
1515 len
= print_symbol (width
, name
);
1517 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1519 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1523 print_vma (psym
->st_value
, LONG_HEX
);
1525 printf (is_32bit_elf
? " " : " ");
1528 if (psym
->st_name
== 0)
1530 const char * sec_name
= "<null>";
1533 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1535 if (psym
->st_shndx
< elf_header
.e_shnum
)
1536 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1537 else if (psym
->st_shndx
== SHN_ABS
)
1539 else if (psym
->st_shndx
== SHN_COMMON
)
1540 sec_name
= "COMMON";
1541 else if ((elf_header
.e_machine
== EM_MIPS
1542 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1543 || (elf_header
.e_machine
== EM_TI_C6000
1544 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1545 sec_name
= "SCOMMON";
1546 else if (elf_header
.e_machine
== EM_MIPS
1547 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1548 sec_name
= "SUNDEF";
1549 else if ((elf_header
.e_machine
== EM_X86_64
1550 || elf_header
.e_machine
== EM_L1OM
1551 || elf_header
.e_machine
== EM_K1OM
)
1552 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1553 sec_name
= "LARGE_COMMON";
1554 else if (elf_header
.e_machine
== EM_IA_64
1555 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1556 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1557 sec_name
= "ANSI_COM";
1558 else if (is_ia64_vms ()
1559 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1560 sec_name
= "VMS_SYMVEC";
1563 sprintf (name_buf
, "<section 0x%x>",
1564 (unsigned int) psym
->st_shndx
);
1565 sec_name
= name_buf
;
1568 print_symbol (22, sec_name
);
1570 else if (strtab
== NULL
)
1571 printf (_("<string table index: %3ld>"), psym
->st_name
);
1572 else if (psym
->st_name
>= strtablen
)
1573 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1576 print_symbol (22, strtab
+ psym
->st_name
);
1578 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1584 bfd_signed_vma off
= rels
[i
].r_addend
;
1587 printf (" - %" BFD_VMA_FMT
"x", - off
);
1589 printf (" + %" BFD_VMA_FMT
"x", off
);
1595 bfd_signed_vma off
= rels
[i
].r_addend
;
1597 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1599 printf ("-%" BFD_VMA_FMT
"x", - off
);
1601 printf ("%" BFD_VMA_FMT
"x", off
);
1604 if (elf_header
.e_machine
== EM_SPARCV9
1606 && streq (rtype
, "R_SPARC_OLO10"))
1607 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1612 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1614 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1615 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1616 const char * rtype2
= elf_mips_reloc_type (type2
);
1617 const char * rtype3
= elf_mips_reloc_type (type3
);
1619 printf (" Type2: ");
1622 printf (_("unrecognized: %-7lx"),
1623 (unsigned long) type2
& 0xffffffff);
1625 printf ("%-17.17s", rtype2
);
1627 printf ("\n Type3: ");
1630 printf (_("unrecognized: %-7lx"),
1631 (unsigned long) type3
& 0xffffffff);
1633 printf ("%-17.17s", rtype3
);
1644 get_mips_dynamic_type (unsigned long type
)
1648 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1649 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1650 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1651 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1652 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1653 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1654 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1655 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1656 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1657 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1658 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1659 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1660 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1661 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1662 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1663 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1664 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1665 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1666 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1667 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1668 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1669 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1670 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1671 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1672 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1673 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1674 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1675 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1676 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1677 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1678 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1679 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1680 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1681 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1682 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1683 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1684 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1685 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1686 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1687 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1688 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1689 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1690 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1691 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1692 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1699 get_sparc64_dynamic_type (unsigned long type
)
1703 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1710 get_ppc_dynamic_type (unsigned long type
)
1714 case DT_PPC_GOT
: return "PPC_GOT";
1715 case DT_PPC_OPT
: return "PPC_OPT";
1722 get_ppc64_dynamic_type (unsigned long type
)
1726 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1727 case DT_PPC64_OPD
: return "PPC64_OPD";
1728 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1729 case DT_PPC64_OPT
: return "PPC64_OPT";
1736 get_parisc_dynamic_type (unsigned long type
)
1740 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1741 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1742 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1743 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1744 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1745 case DT_HP_PREINIT
: return "HP_PREINIT";
1746 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1747 case DT_HP_NEEDED
: return "HP_NEEDED";
1748 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1749 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1750 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1751 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1752 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1753 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1754 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1755 case DT_HP_FILTERED
: return "HP_FILTERED";
1756 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1757 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1758 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1759 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1760 case DT_PLT
: return "PLT";
1761 case DT_PLT_SIZE
: return "PLT_SIZE";
1762 case DT_DLT
: return "DLT";
1763 case DT_DLT_SIZE
: return "DLT_SIZE";
1770 get_ia64_dynamic_type (unsigned long type
)
1774 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1775 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1776 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1777 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1778 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1779 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1780 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1781 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1782 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1783 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1784 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1785 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1786 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1787 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1788 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1789 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1790 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1791 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1792 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1793 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1794 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1795 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1796 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1797 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1798 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1799 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1800 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1801 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1802 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1803 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1804 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1811 get_alpha_dynamic_type (unsigned long type
)
1815 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1822 get_score_dynamic_type (unsigned long type
)
1826 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1827 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1828 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1829 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1830 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1831 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1838 get_tic6x_dynamic_type (unsigned long type
)
1842 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1843 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1844 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1845 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1846 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1847 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1854 get_nios2_dynamic_type (unsigned long type
)
1858 case DT_NIOS2_GP
: return "NIOS2_GP";
1865 get_dynamic_type (unsigned long type
)
1867 static char buff
[64];
1871 case DT_NULL
: return "NULL";
1872 case DT_NEEDED
: return "NEEDED";
1873 case DT_PLTRELSZ
: return "PLTRELSZ";
1874 case DT_PLTGOT
: return "PLTGOT";
1875 case DT_HASH
: return "HASH";
1876 case DT_STRTAB
: return "STRTAB";
1877 case DT_SYMTAB
: return "SYMTAB";
1878 case DT_RELA
: return "RELA";
1879 case DT_RELASZ
: return "RELASZ";
1880 case DT_RELAENT
: return "RELAENT";
1881 case DT_STRSZ
: return "STRSZ";
1882 case DT_SYMENT
: return "SYMENT";
1883 case DT_INIT
: return "INIT";
1884 case DT_FINI
: return "FINI";
1885 case DT_SONAME
: return "SONAME";
1886 case DT_RPATH
: return "RPATH";
1887 case DT_SYMBOLIC
: return "SYMBOLIC";
1888 case DT_REL
: return "REL";
1889 case DT_RELSZ
: return "RELSZ";
1890 case DT_RELENT
: return "RELENT";
1891 case DT_PLTREL
: return "PLTREL";
1892 case DT_DEBUG
: return "DEBUG";
1893 case DT_TEXTREL
: return "TEXTREL";
1894 case DT_JMPREL
: return "JMPREL";
1895 case DT_BIND_NOW
: return "BIND_NOW";
1896 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1897 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1898 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1899 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1900 case DT_RUNPATH
: return "RUNPATH";
1901 case DT_FLAGS
: return "FLAGS";
1903 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1904 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1906 case DT_CHECKSUM
: return "CHECKSUM";
1907 case DT_PLTPADSZ
: return "PLTPADSZ";
1908 case DT_MOVEENT
: return "MOVEENT";
1909 case DT_MOVESZ
: return "MOVESZ";
1910 case DT_FEATURE
: return "FEATURE";
1911 case DT_POSFLAG_1
: return "POSFLAG_1";
1912 case DT_SYMINSZ
: return "SYMINSZ";
1913 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1915 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1916 case DT_CONFIG
: return "CONFIG";
1917 case DT_DEPAUDIT
: return "DEPAUDIT";
1918 case DT_AUDIT
: return "AUDIT";
1919 case DT_PLTPAD
: return "PLTPAD";
1920 case DT_MOVETAB
: return "MOVETAB";
1921 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1923 case DT_VERSYM
: return "VERSYM";
1925 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1926 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1927 case DT_RELACOUNT
: return "RELACOUNT";
1928 case DT_RELCOUNT
: return "RELCOUNT";
1929 case DT_FLAGS_1
: return "FLAGS_1";
1930 case DT_VERDEF
: return "VERDEF";
1931 case DT_VERDEFNUM
: return "VERDEFNUM";
1932 case DT_VERNEED
: return "VERNEED";
1933 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1935 case DT_AUXILIARY
: return "AUXILIARY";
1936 case DT_USED
: return "USED";
1937 case DT_FILTER
: return "FILTER";
1939 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1940 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1941 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1942 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1943 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1944 case DT_GNU_HASH
: return "GNU_HASH";
1947 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1949 const char * result
;
1951 switch (elf_header
.e_machine
)
1954 case EM_MIPS_RS3_LE
:
1955 result
= get_mips_dynamic_type (type
);
1958 result
= get_sparc64_dynamic_type (type
);
1961 result
= get_ppc_dynamic_type (type
);
1964 result
= get_ppc64_dynamic_type (type
);
1967 result
= get_ia64_dynamic_type (type
);
1970 result
= get_alpha_dynamic_type (type
);
1973 result
= get_score_dynamic_type (type
);
1976 result
= get_tic6x_dynamic_type (type
);
1978 case EM_ALTERA_NIOS2
:
1979 result
= get_nios2_dynamic_type (type
);
1989 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1991 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1992 || (elf_header
.e_machine
== EM_PARISC
1993 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1995 const char * result
;
1997 switch (elf_header
.e_machine
)
2000 result
= get_parisc_dynamic_type (type
);
2003 result
= get_ia64_dynamic_type (type
);
2013 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2017 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2024 get_file_type (unsigned e_type
)
2026 static char buff
[32];
2030 case ET_NONE
: return _("NONE (None)");
2031 case ET_REL
: return _("REL (Relocatable file)");
2032 case ET_EXEC
: return _("EXEC (Executable file)");
2033 case ET_DYN
: return _("DYN (Shared object file)");
2034 case ET_CORE
: return _("CORE (Core file)");
2037 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2038 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2039 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2040 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2042 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2048 get_machine_name (unsigned e_machine
)
2050 static char buff
[64]; /* XXX */
2054 case EM_NONE
: return _("None");
2055 case EM_AARCH64
: return "AArch64";
2056 case EM_M32
: return "WE32100";
2057 case EM_SPARC
: return "Sparc";
2058 case EM_SPU
: return "SPU";
2059 case EM_386
: return "Intel 80386";
2060 case EM_68K
: return "MC68000";
2061 case EM_88K
: return "MC88000";
2062 case EM_486
: return "Intel 80486";
2063 case EM_860
: return "Intel 80860";
2064 case EM_MIPS
: return "MIPS R3000";
2065 case EM_S370
: return "IBM System/370";
2066 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2067 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2068 case EM_PARISC
: return "HPPA";
2069 case EM_PPC_OLD
: return "Power PC (old)";
2070 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2071 case EM_960
: return "Intel 90860";
2072 case EM_PPC
: return "PowerPC";
2073 case EM_PPC64
: return "PowerPC64";
2074 case EM_FR20
: return "Fujitsu FR20";
2075 case EM_RH32
: return "TRW RH32";
2076 case EM_MCORE
: return "MCORE";
2077 case EM_ARM
: return "ARM";
2078 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2079 case EM_SH
: return "Renesas / SuperH SH";
2080 case EM_SPARCV9
: return "Sparc v9";
2081 case EM_TRICORE
: return "Siemens Tricore";
2082 case EM_ARC
: return "ARC";
2083 case EM_H8_300
: return "Renesas H8/300";
2084 case EM_H8_300H
: return "Renesas H8/300H";
2085 case EM_H8S
: return "Renesas H8S";
2086 case EM_H8_500
: return "Renesas H8/500";
2087 case EM_IA_64
: return "Intel IA-64";
2088 case EM_MIPS_X
: return "Stanford MIPS-X";
2089 case EM_COLDFIRE
: return "Motorola Coldfire";
2090 case EM_ALPHA
: return "Alpha";
2091 case EM_CYGNUS_D10V
:
2092 case EM_D10V
: return "d10v";
2093 case EM_CYGNUS_D30V
:
2094 case EM_D30V
: return "d30v";
2095 case EM_CYGNUS_M32R
:
2096 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2097 case EM_CYGNUS_V850
:
2098 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2099 case EM_V850
: return "Renesas V850";
2100 case EM_CYGNUS_MN10300
:
2101 case EM_MN10300
: return "mn10300";
2102 case EM_CYGNUS_MN10200
:
2103 case EM_MN10200
: return "mn10200";
2104 case EM_MOXIE
: return "Moxie";
2105 case EM_CYGNUS_FR30
:
2106 case EM_FR30
: return "Fujitsu FR30";
2107 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2109 case EM_PJ
: return "picoJava";
2110 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2111 case EM_PCP
: return "Siemens PCP";
2112 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2113 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2114 case EM_STARCORE
: return "Motorola Star*Core processor";
2115 case EM_ME16
: return "Toyota ME16 processor";
2116 case EM_ST100
: return "STMicroelectronics ST100 processor";
2117 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2118 case EM_PDSP
: return "Sony DSP processor";
2119 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2120 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2121 case EM_FX66
: return "Siemens FX66 microcontroller";
2122 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2123 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2124 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2125 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2126 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2127 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2128 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2129 case EM_SVX
: return "Silicon Graphics SVx";
2130 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2131 case EM_VAX
: return "Digital VAX";
2132 case EM_VISIUM
: return "CDS VISIUMcore processor";
2134 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2135 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2136 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2137 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2138 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2139 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2140 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2141 case EM_PRISM
: return "Vitesse Prism";
2142 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2143 case EM_L1OM
: return "Intel L1OM";
2144 case EM_K1OM
: return "Intel K1OM";
2146 case EM_S390
: return "IBM S/390";
2147 case EM_SCORE
: return "SUNPLUS S+Core";
2148 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2149 case EM_OR1K
: return "OpenRISC 1000";
2150 case EM_ARC_A5
: return "ARC International ARCompact processor";
2151 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2152 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2153 case EM_DLX
: return "OpenDLX";
2155 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2156 case EM_IQ2000
: return "Vitesse IQ2000";
2158 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2159 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2160 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2161 case EM_NS32K
: return "National Semiconductor 32000 series";
2162 case EM_TPC
: return "Tenor Network TPC processor";
2163 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2164 case EM_MAX
: return "MAX Processor";
2165 case EM_CR
: return "National Semiconductor CompactRISC";
2166 case EM_F2MC16
: return "Fujitsu F2MC16";
2167 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2168 case EM_LATTICEMICO32
: return "Lattice Mico32";
2170 case EM_M32C
: return "Renesas M32c";
2171 case EM_MT
: return "Morpho Techologies MT processor";
2172 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2173 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2174 case EM_SEP
: return "Sharp embedded microprocessor";
2175 case EM_ARCA
: return "Arca RISC microprocessor";
2176 case EM_UNICORE
: return "Unicore";
2177 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2178 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2179 case EM_NIOS32
: return "Altera Nios";
2180 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2182 case EM_XC16X
: return "Infineon Technologies xc16x";
2183 case EM_M16C
: return "Renesas M16C series microprocessors";
2184 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2185 case EM_CE
: return "Freescale Communication Engine RISC core";
2186 case EM_TSK3000
: return "Altium TSK3000 core";
2187 case EM_RS08
: return "Freescale RS08 embedded processor";
2188 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2189 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2190 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2191 case EM_SE_C17
: return "Seiko Epson C17 family";
2192 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2193 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2194 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2195 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2196 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2197 case EM_R32C
: return "Renesas R32C series microprocessors";
2198 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2199 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2200 case EM_8051
: return "Intel 8051 and variants";
2201 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2202 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2203 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2204 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2205 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2206 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2207 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2208 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2211 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2212 case EM_RL78
: return "Renesas RL78";
2213 case EM_RX
: return "Renesas RX";
2214 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2215 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2216 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2217 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2218 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2219 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2220 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2221 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2222 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2223 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2224 case EM_CUDA
: return "NVIDIA CUDA architecture";
2225 case EM_XGATE
: return "Motorola XGATE embedded processor";
2227 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2233 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2238 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2239 e_flags
&= ~ EF_ARM_EABIMASK
;
2241 /* Handle "generic" ARM flags. */
2242 if (e_flags
& EF_ARM_RELEXEC
)
2244 strcat (buf
, ", relocatable executable");
2245 e_flags
&= ~ EF_ARM_RELEXEC
;
2248 if (e_flags
& EF_ARM_HASENTRY
)
2250 strcat (buf
, ", has entry point");
2251 e_flags
&= ~ EF_ARM_HASENTRY
;
2254 /* Now handle EABI specific flags. */
2258 strcat (buf
, ", <unrecognized EABI>");
2263 case EF_ARM_EABI_VER1
:
2264 strcat (buf
, ", Version1 EABI");
2269 /* Process flags one bit at a time. */
2270 flag
= e_flags
& - e_flags
;
2275 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2276 strcat (buf
, ", sorted symbol tables");
2286 case EF_ARM_EABI_VER2
:
2287 strcat (buf
, ", Version2 EABI");
2292 /* Process flags one bit at a time. */
2293 flag
= e_flags
& - e_flags
;
2298 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2299 strcat (buf
, ", sorted symbol tables");
2302 case EF_ARM_DYNSYMSUSESEGIDX
:
2303 strcat (buf
, ", dynamic symbols use segment index");
2306 case EF_ARM_MAPSYMSFIRST
:
2307 strcat (buf
, ", mapping symbols precede others");
2317 case EF_ARM_EABI_VER3
:
2318 strcat (buf
, ", Version3 EABI");
2321 case EF_ARM_EABI_VER4
:
2322 strcat (buf
, ", Version4 EABI");
2327 /* Process flags one bit at a time. */
2328 flag
= e_flags
& - e_flags
;
2334 strcat (buf
, ", BE8");
2338 strcat (buf
, ", LE8");
2349 case EF_ARM_EABI_VER5
:
2350 strcat (buf
, ", Version5 EABI");
2355 /* Process flags one bit at a time. */
2356 flag
= e_flags
& - e_flags
;
2362 strcat (buf
, ", BE8");
2366 strcat (buf
, ", LE8");
2369 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2370 strcat (buf
, ", soft-float ABI");
2373 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2374 strcat (buf
, ", hard-float ABI");
2384 case EF_ARM_EABI_UNKNOWN
:
2385 strcat (buf
, ", GNU EABI");
2390 /* Process flags one bit at a time. */
2391 flag
= e_flags
& - e_flags
;
2396 case EF_ARM_INTERWORK
:
2397 strcat (buf
, ", interworking enabled");
2400 case EF_ARM_APCS_26
:
2401 strcat (buf
, ", uses APCS/26");
2404 case EF_ARM_APCS_FLOAT
:
2405 strcat (buf
, ", uses APCS/float");
2409 strcat (buf
, ", position independent");
2413 strcat (buf
, ", 8 bit structure alignment");
2416 case EF_ARM_NEW_ABI
:
2417 strcat (buf
, ", uses new ABI");
2420 case EF_ARM_OLD_ABI
:
2421 strcat (buf
, ", uses old ABI");
2424 case EF_ARM_SOFT_FLOAT
:
2425 strcat (buf
, ", software FP");
2428 case EF_ARM_VFP_FLOAT
:
2429 strcat (buf
, ", VFP");
2432 case EF_ARM_MAVERICK_FLOAT
:
2433 strcat (buf
, ", Maverick FP");
2444 strcat (buf
,_(", <unknown>"));
2448 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2450 --size
; /* Leave space for null terminator. */
2452 switch (e_flags
& EF_AVR_MACH
)
2454 case E_AVR_MACH_AVR1
:
2455 strncat (buf
, ", avr:1", size
);
2457 case E_AVR_MACH_AVR2
:
2458 strncat (buf
, ", avr:2", size
);
2460 case E_AVR_MACH_AVR25
:
2461 strncat (buf
, ", avr:25", size
);
2463 case E_AVR_MACH_AVR3
:
2464 strncat (buf
, ", avr:3", size
);
2466 case E_AVR_MACH_AVR31
:
2467 strncat (buf
, ", avr:31", size
);
2469 case E_AVR_MACH_AVR35
:
2470 strncat (buf
, ", avr:35", size
);
2472 case E_AVR_MACH_AVR4
:
2473 strncat (buf
, ", avr:4", size
);
2475 case E_AVR_MACH_AVR5
:
2476 strncat (buf
, ", avr:5", size
);
2478 case E_AVR_MACH_AVR51
:
2479 strncat (buf
, ", avr:51", size
);
2481 case E_AVR_MACH_AVR6
:
2482 strncat (buf
, ", avr:6", size
);
2484 case E_AVR_MACH_AVRTINY
:
2485 strncat (buf
, ", avr:100", size
);
2487 case E_AVR_MACH_XMEGA1
:
2488 strncat (buf
, ", avr:101", size
);
2490 case E_AVR_MACH_XMEGA2
:
2491 strncat (buf
, ", avr:102", size
);
2493 case E_AVR_MACH_XMEGA3
:
2494 strncat (buf
, ", avr:103", size
);
2496 case E_AVR_MACH_XMEGA4
:
2497 strncat (buf
, ", avr:104", size
);
2499 case E_AVR_MACH_XMEGA5
:
2500 strncat (buf
, ", avr:105", size
);
2502 case E_AVR_MACH_XMEGA6
:
2503 strncat (buf
, ", avr:106", size
);
2505 case E_AVR_MACH_XMEGA7
:
2506 strncat (buf
, ", avr:107", size
);
2509 strncat (buf
, ", avr:<unknown>", size
);
2513 size
-= strlen (buf
);
2514 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2515 strncat (buf
, ", link-relax", size
);
2519 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2528 static const char *ABI_STRINGS
[] =
2530 "ABI v0", /* use r5 as return register; only used in N1213HC */
2531 "ABI v1", /* use r0 as return register */
2532 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2533 "ABI v2fp", /* for FPU */
2537 static const char *VER_STRINGS
[] =
2539 "Andes ELF V1.3 or older",
2543 static const char *ARCH_STRINGS
[] =
2552 abi
= EF_NDS_ABI
& e_flags
;
2553 arch
= EF_NDS_ARCH
& e_flags
;
2554 config
= EF_NDS_INST
& e_flags
;
2555 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2557 memset (buf
, 0, size
);
2564 case E_NDS_ABI_V2FP
:
2565 case E_NDS_ABI_AABI
:
2566 case E_NDS_ABI_V2FP_PLUS
:
2567 /* In case there are holes in the array. */
2568 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2572 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2578 case E_NDS32_ELF_VER_1_2
:
2579 case E_NDS32_ELF_VER_1_3
:
2580 case E_NDS32_ELF_VER_1_4
:
2581 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2585 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2589 if (E_NDS_ABI_V0
== abi
)
2591 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2592 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2593 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2594 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2600 case E_NDS_ARCH_STAR_V1_0
:
2601 case E_NDS_ARCH_STAR_V2_0
:
2602 case E_NDS_ARCH_STAR_V3_0
:
2603 case E_NDS_ARCH_STAR_V3_M
:
2604 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2608 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2609 /* ARCH version determines how the e_flags are interpreted.
2610 If it is unknown, we cannot proceed. */
2614 /* Newer ABI; Now handle architecture specific flags. */
2615 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2617 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2618 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2620 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2621 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2623 if (config
& E_NDS32_HAS_DIV_INST
)
2624 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2626 if (config
& E_NDS32_HAS_16BIT_INST
)
2627 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2631 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2633 if (version
<= E_NDS32_ELF_VER_1_3
)
2634 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2636 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2639 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2640 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2642 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2643 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2645 if (config
& E_NDS32_HAS_16BIT_INST
)
2647 if (version
<= E_NDS32_ELF_VER_1_3
)
2648 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2650 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2654 if (config
& E_NDS32_HAS_EXT_INST
)
2655 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2657 if (config
& E_NDS32_HAS_EXT2_INST
)
2658 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2660 if (config
& E_NDS32_HAS_FPU_INST
)
2663 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2666 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2672 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2680 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2682 case E_NDS32_FPU_REG_8SP_4DP
:
2683 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2685 case E_NDS32_FPU_REG_16SP_8DP
:
2686 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2688 case E_NDS32_FPU_REG_32SP_16DP
:
2689 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2691 case E_NDS32_FPU_REG_32SP_32DP
:
2692 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2697 if (config
& E_NDS32_HAS_AUDIO_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2700 if (config
& E_NDS32_HAS_STRING_INST
)
2701 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2703 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2706 if (config
& E_NDS32_HAS_VIDEO_INST
)
2708 if (version
<= E_NDS32_ELF_VER_1_3
)
2709 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2711 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2714 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2715 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2717 if (config
& E_NDS32_HAS_L2C_INST
)
2718 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2722 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2724 static char buf
[1024];
2736 decode_ARM_machine_flags (e_flags
, buf
);
2740 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2744 if (e_flags
& EF_BFIN_PIC
)
2745 strcat (buf
, ", PIC");
2747 if (e_flags
& EF_BFIN_FDPIC
)
2748 strcat (buf
, ", FDPIC");
2750 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2751 strcat (buf
, ", code in L1");
2753 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2754 strcat (buf
, ", data in L1");
2759 switch (e_flags
& EF_FRV_CPU_MASK
)
2761 case EF_FRV_CPU_GENERIC
:
2765 strcat (buf
, ", fr???");
2768 case EF_FRV_CPU_FR300
:
2769 strcat (buf
, ", fr300");
2772 case EF_FRV_CPU_FR400
:
2773 strcat (buf
, ", fr400");
2775 case EF_FRV_CPU_FR405
:
2776 strcat (buf
, ", fr405");
2779 case EF_FRV_CPU_FR450
:
2780 strcat (buf
, ", fr450");
2783 case EF_FRV_CPU_FR500
:
2784 strcat (buf
, ", fr500");
2786 case EF_FRV_CPU_FR550
:
2787 strcat (buf
, ", fr550");
2790 case EF_FRV_CPU_SIMPLE
:
2791 strcat (buf
, ", simple");
2793 case EF_FRV_CPU_TOMCAT
:
2794 strcat (buf
, ", tomcat");
2800 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2801 strcat (buf
, ", m68000");
2802 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2803 strcat (buf
, ", cpu32");
2804 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2805 strcat (buf
, ", fido_a");
2808 char const * isa
= _("unknown");
2809 char const * mac
= _("unknown mac");
2810 char const * additional
= NULL
;
2812 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2814 case EF_M68K_CF_ISA_A_NODIV
:
2816 additional
= ", nodiv";
2818 case EF_M68K_CF_ISA_A
:
2821 case EF_M68K_CF_ISA_A_PLUS
:
2824 case EF_M68K_CF_ISA_B_NOUSP
:
2826 additional
= ", nousp";
2828 case EF_M68K_CF_ISA_B
:
2831 case EF_M68K_CF_ISA_C
:
2834 case EF_M68K_CF_ISA_C_NODIV
:
2836 additional
= ", nodiv";
2839 strcat (buf
, ", cf, isa ");
2842 strcat (buf
, additional
);
2843 if (e_flags
& EF_M68K_CF_FLOAT
)
2844 strcat (buf
, ", float");
2845 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2850 case EF_M68K_CF_MAC
:
2853 case EF_M68K_CF_EMAC
:
2856 case EF_M68K_CF_EMAC_B
:
2869 if (e_flags
& EF_PPC_EMB
)
2870 strcat (buf
, ", emb");
2872 if (e_flags
& EF_PPC_RELOCATABLE
)
2873 strcat (buf
, _(", relocatable"));
2875 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2876 strcat (buf
, _(", relocatable-lib"));
2880 if (e_flags
& EF_PPC64_ABI
)
2882 char abi
[] = ", abiv0";
2884 abi
[6] += e_flags
& EF_PPC64_ABI
;
2890 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2891 strcat (buf
, ", RH850 ABI");
2893 if (e_flags
& EF_V800_850E3
)
2894 strcat (buf
, ", V3 architecture");
2896 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2897 strcat (buf
, ", FPU not used");
2899 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2900 strcat (buf
, ", regmode: COMMON");
2902 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2903 strcat (buf
, ", r4 not used");
2905 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2906 strcat (buf
, ", r30 not used");
2908 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2909 strcat (buf
, ", r5 not used");
2911 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2912 strcat (buf
, ", r2 not used");
2914 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2916 switch (e_flags
& - e_flags
)
2918 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2919 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2920 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2921 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2922 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2923 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2924 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2925 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2926 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2927 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2928 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2929 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2930 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2931 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2932 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2933 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2940 case EM_CYGNUS_V850
:
2941 switch (e_flags
& EF_V850_ARCH
)
2943 case E_V850E3V5_ARCH
:
2944 strcat (buf
, ", v850e3v5");
2946 case E_V850E2V3_ARCH
:
2947 strcat (buf
, ", v850e2v3");
2950 strcat (buf
, ", v850e2");
2953 strcat (buf
, ", v850e1");
2956 strcat (buf
, ", v850e");
2959 strcat (buf
, ", v850");
2962 strcat (buf
, _(", unknown v850 architecture variant"));
2968 case EM_CYGNUS_M32R
:
2969 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2970 strcat (buf
, ", m32r");
2974 case EM_MIPS_RS3_LE
:
2975 if (e_flags
& EF_MIPS_NOREORDER
)
2976 strcat (buf
, ", noreorder");
2978 if (e_flags
& EF_MIPS_PIC
)
2979 strcat (buf
, ", pic");
2981 if (e_flags
& EF_MIPS_CPIC
)
2982 strcat (buf
, ", cpic");
2984 if (e_flags
& EF_MIPS_UCODE
)
2985 strcat (buf
, ", ugen_reserved");
2987 if (e_flags
& EF_MIPS_ABI2
)
2988 strcat (buf
, ", abi2");
2990 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2991 strcat (buf
, ", odk first");
2993 if (e_flags
& EF_MIPS_32BITMODE
)
2994 strcat (buf
, ", 32bitmode");
2996 if (e_flags
& EF_MIPS_NAN2008
)
2997 strcat (buf
, ", nan2008");
2999 if (e_flags
& EF_MIPS_FP64
)
3000 strcat (buf
, ", fp64");
3002 switch ((e_flags
& EF_MIPS_MACH
))
3004 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3005 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3006 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3007 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3008 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3009 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3010 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3011 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3012 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3013 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3014 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3015 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3016 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3017 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3018 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3019 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3020 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3022 /* We simply ignore the field in this case to avoid confusion:
3023 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3026 default: strcat (buf
, _(", unknown CPU")); break;
3029 switch ((e_flags
& EF_MIPS_ABI
))
3031 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3032 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3033 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3034 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3036 /* We simply ignore the field in this case to avoid confusion:
3037 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3038 This means it is likely to be an o32 file, but not for
3041 default: strcat (buf
, _(", unknown ABI")); break;
3044 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3045 strcat (buf
, ", mdmx");
3047 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3048 strcat (buf
, ", mips16");
3050 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3051 strcat (buf
, ", micromips");
3053 switch ((e_flags
& EF_MIPS_ARCH
))
3055 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3056 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3057 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3058 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3059 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3060 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3061 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3062 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3063 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3064 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3065 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3066 default: strcat (buf
, _(", unknown ISA")); break;
3071 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3075 switch ((e_flags
& EF_SH_MACH_MASK
))
3077 case EF_SH1
: strcat (buf
, ", sh1"); break;
3078 case EF_SH2
: strcat (buf
, ", sh2"); break;
3079 case EF_SH3
: strcat (buf
, ", sh3"); break;
3080 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3081 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3082 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3083 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3084 case EF_SH4
: strcat (buf
, ", sh4"); break;
3085 case EF_SH5
: strcat (buf
, ", sh5"); break;
3086 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3087 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3088 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3089 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3090 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3091 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3092 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3093 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3094 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3095 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3096 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3097 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3098 default: strcat (buf
, _(", unknown ISA")); break;
3101 if (e_flags
& EF_SH_PIC
)
3102 strcat (buf
, ", pic");
3104 if (e_flags
& EF_SH_FDPIC
)
3105 strcat (buf
, ", fdpic");
3109 if (e_flags
& EF_OR1K_NODELAY
)
3110 strcat (buf
, ", no delay");
3114 if (e_flags
& EF_SPARC_32PLUS
)
3115 strcat (buf
, ", v8+");
3117 if (e_flags
& EF_SPARC_SUN_US1
)
3118 strcat (buf
, ", ultrasparcI");
3120 if (e_flags
& EF_SPARC_SUN_US3
)
3121 strcat (buf
, ", ultrasparcIII");
3123 if (e_flags
& EF_SPARC_HAL_R1
)
3124 strcat (buf
, ", halr1");
3126 if (e_flags
& EF_SPARC_LEDATA
)
3127 strcat (buf
, ", ledata");
3129 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3130 strcat (buf
, ", tso");
3132 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3133 strcat (buf
, ", pso");
3135 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3136 strcat (buf
, ", rmo");
3140 switch (e_flags
& EF_PARISC_ARCH
)
3142 case EFA_PARISC_1_0
:
3143 strcpy (buf
, ", PA-RISC 1.0");
3145 case EFA_PARISC_1_1
:
3146 strcpy (buf
, ", PA-RISC 1.1");
3148 case EFA_PARISC_2_0
:
3149 strcpy (buf
, ", PA-RISC 2.0");
3154 if (e_flags
& EF_PARISC_TRAPNIL
)
3155 strcat (buf
, ", trapnil");
3156 if (e_flags
& EF_PARISC_EXT
)
3157 strcat (buf
, ", ext");
3158 if (e_flags
& EF_PARISC_LSB
)
3159 strcat (buf
, ", lsb");
3160 if (e_flags
& EF_PARISC_WIDE
)
3161 strcat (buf
, ", wide");
3162 if (e_flags
& EF_PARISC_NO_KABP
)
3163 strcat (buf
, ", no kabp");
3164 if (e_flags
& EF_PARISC_LAZYSWAP
)
3165 strcat (buf
, ", lazyswap");
3170 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3171 strcat (buf
, ", new calling convention");
3173 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3174 strcat (buf
, ", gnu calling convention");
3178 if ((e_flags
& EF_IA_64_ABI64
))
3179 strcat (buf
, ", 64-bit");
3181 strcat (buf
, ", 32-bit");
3182 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3183 strcat (buf
, ", reduced fp model");
3184 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3185 strcat (buf
, ", no function descriptors, constant gp");
3186 else if ((e_flags
& EF_IA_64_CONS_GP
))
3187 strcat (buf
, ", constant gp");
3188 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3189 strcat (buf
, ", absolute");
3190 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3192 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3193 strcat (buf
, ", vms_linkages");
3194 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3196 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3198 case EF_IA_64_VMS_COMCOD_WARNING
:
3199 strcat (buf
, ", warning");
3201 case EF_IA_64_VMS_COMCOD_ERROR
:
3202 strcat (buf
, ", error");
3204 case EF_IA_64_VMS_COMCOD_ABORT
:
3205 strcat (buf
, ", abort");
3208 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3209 e_flags
& EF_IA_64_VMS_COMCOD
);
3210 strcat (buf
, ", <unknown>");
3216 if ((e_flags
& EF_VAX_NONPIC
))
3217 strcat (buf
, ", non-PIC");
3218 if ((e_flags
& EF_VAX_DFLOAT
))
3219 strcat (buf
, ", D-Float");
3220 if ((e_flags
& EF_VAX_GFLOAT
))
3221 strcat (buf
, ", G-Float");
3225 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3226 strcat (buf
, ", mcm");
3227 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3228 strcat (buf
, ", mcm24");
3229 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3230 strcat (buf
, ", gr6");
3234 if (e_flags
& E_FLAG_RL78_G10
)
3235 strcat (buf
, ", G10");
3236 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3237 strcat (buf
, ", 64-bit doubles");
3241 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3242 strcat (buf
, ", 64-bit doubles");
3243 if (e_flags
& E_FLAG_RX_DSP
)
3244 strcat (buf
, ", dsp");
3245 if (e_flags
& E_FLAG_RX_PID
)
3246 strcat (buf
, ", pid");
3247 if (e_flags
& E_FLAG_RX_ABI
)
3248 strcat (buf
, ", RX ABI");
3252 if (e_flags
& EF_S390_HIGH_GPRS
)
3253 strcat (buf
, ", highgprs");
3257 if ((e_flags
& EF_C6000_REL
))
3258 strcat (buf
, ", relocatable module");
3262 strcat (buf
, _(": architecture variant: "));
3263 switch (e_flags
& EF_MSP430_MACH
)
3265 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3266 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3267 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3268 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3269 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3270 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3271 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3272 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3273 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3274 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3275 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3276 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3277 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3278 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3279 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3281 strcat (buf
, _(": unknown")); break;
3284 if (e_flags
& ~ EF_MSP430_MACH
)
3285 strcat (buf
, _(": unknown extra flag bits also present"));
3293 get_osabi_name (unsigned int osabi
)
3295 static char buff
[32];
3299 case ELFOSABI_NONE
: return "UNIX - System V";
3300 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3301 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3302 case ELFOSABI_GNU
: return "UNIX - GNU";
3303 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3304 case ELFOSABI_AIX
: return "UNIX - AIX";
3305 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3306 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3307 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3308 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3309 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3310 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3311 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3312 case ELFOSABI_AROS
: return "AROS";
3313 case ELFOSABI_FENIXOS
: return "FenixOS";
3316 switch (elf_header
.e_machine
)
3321 case ELFOSABI_ARM
: return "ARM";
3332 case ELFOSABI_STANDALONE
: return _("Standalone App");
3341 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3342 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3351 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3357 get_aarch64_segment_type (unsigned long type
)
3361 case PT_AARCH64_ARCHEXT
:
3362 return "AARCH64_ARCHEXT";
3371 get_arm_segment_type (unsigned long type
)
3385 get_mips_segment_type (unsigned long type
)
3389 case PT_MIPS_REGINFO
:
3391 case PT_MIPS_RTPROC
:
3393 case PT_MIPS_OPTIONS
:
3395 case PT_MIPS_ABIFLAGS
:
3405 get_parisc_segment_type (unsigned long type
)
3409 case PT_HP_TLS
: return "HP_TLS";
3410 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3411 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3412 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3413 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3414 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3415 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3416 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3417 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3418 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3419 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3420 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3421 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3422 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3423 case PT_HP_STACK
: return "HP_STACK";
3424 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3425 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3426 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3427 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3436 get_ia64_segment_type (unsigned long type
)
3440 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3441 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3442 case PT_HP_TLS
: return "HP_TLS";
3443 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3444 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3445 case PT_IA_64_HP_STACK
: return "HP_STACK";
3454 get_tic6x_segment_type (unsigned long type
)
3458 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3467 get_segment_type (unsigned long p_type
)
3469 static char buff
[32];
3473 case PT_NULL
: return "NULL";
3474 case PT_LOAD
: return "LOAD";
3475 case PT_DYNAMIC
: return "DYNAMIC";
3476 case PT_INTERP
: return "INTERP";
3477 case PT_NOTE
: return "NOTE";
3478 case PT_SHLIB
: return "SHLIB";
3479 case PT_PHDR
: return "PHDR";
3480 case PT_TLS
: return "TLS";
3482 case PT_GNU_EH_FRAME
:
3483 return "GNU_EH_FRAME";
3484 case PT_GNU_STACK
: return "GNU_STACK";
3485 case PT_GNU_RELRO
: return "GNU_RELRO";
3488 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3490 const char * result
;
3492 switch (elf_header
.e_machine
)
3495 result
= get_aarch64_segment_type (p_type
);
3498 result
= get_arm_segment_type (p_type
);
3501 case EM_MIPS_RS3_LE
:
3502 result
= get_mips_segment_type (p_type
);
3505 result
= get_parisc_segment_type (p_type
);
3508 result
= get_ia64_segment_type (p_type
);
3511 result
= get_tic6x_segment_type (p_type
);
3521 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3523 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3525 const char * result
;
3527 switch (elf_header
.e_machine
)
3530 result
= get_parisc_segment_type (p_type
);
3533 result
= get_ia64_segment_type (p_type
);
3543 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3546 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3553 get_mips_section_type_name (unsigned int sh_type
)
3557 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3558 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3559 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3560 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3561 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3562 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3563 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3564 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3565 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3566 case SHT_MIPS_RELD
: return "MIPS_RELD";
3567 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3568 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3569 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3570 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3571 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3572 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3573 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3574 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3575 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3576 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3577 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3578 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3579 case SHT_MIPS_LINE
: return "MIPS_LINE";
3580 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3581 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3582 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3583 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3584 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3585 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3586 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3587 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3588 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3589 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3590 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3591 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3592 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3593 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3594 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3595 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3596 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3604 get_parisc_section_type_name (unsigned int sh_type
)
3608 case SHT_PARISC_EXT
: return "PARISC_EXT";
3609 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3610 case SHT_PARISC_DOC
: return "PARISC_DOC";
3611 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3612 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3613 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3614 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3622 get_ia64_section_type_name (unsigned int sh_type
)
3624 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3625 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3626 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3630 case SHT_IA_64_EXT
: return "IA_64_EXT";
3631 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3632 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3633 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3634 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3635 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3636 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3637 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3638 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3639 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3647 get_x86_64_section_type_name (unsigned int sh_type
)
3651 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3659 get_aarch64_section_type_name (unsigned int sh_type
)
3663 case SHT_AARCH64_ATTRIBUTES
:
3664 return "AARCH64_ATTRIBUTES";
3672 get_arm_section_type_name (unsigned int sh_type
)
3676 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3677 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3678 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3679 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3680 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3688 get_tic6x_section_type_name (unsigned int sh_type
)
3692 case SHT_C6000_UNWIND
:
3693 return "C6000_UNWIND";
3694 case SHT_C6000_PREEMPTMAP
:
3695 return "C6000_PREEMPTMAP";
3696 case SHT_C6000_ATTRIBUTES
:
3697 return "C6000_ATTRIBUTES";
3702 case SHT_TI_HANDLER
:
3703 return "TI_HANDLER";
3704 case SHT_TI_INITINFO
:
3705 return "TI_INITINFO";
3706 case SHT_TI_PHATTRS
:
3707 return "TI_PHATTRS";
3715 get_msp430x_section_type_name (unsigned int sh_type
)
3719 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3720 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3721 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3722 default: return NULL
;
3727 get_section_type_name (unsigned int sh_type
)
3729 static char buff
[32];
3733 case SHT_NULL
: return "NULL";
3734 case SHT_PROGBITS
: return "PROGBITS";
3735 case SHT_SYMTAB
: return "SYMTAB";
3736 case SHT_STRTAB
: return "STRTAB";
3737 case SHT_RELA
: return "RELA";
3738 case SHT_HASH
: return "HASH";
3739 case SHT_DYNAMIC
: return "DYNAMIC";
3740 case SHT_NOTE
: return "NOTE";
3741 case SHT_NOBITS
: return "NOBITS";
3742 case SHT_REL
: return "REL";
3743 case SHT_SHLIB
: return "SHLIB";
3744 case SHT_DYNSYM
: return "DYNSYM";
3745 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3746 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3747 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3748 case SHT_GNU_HASH
: return "GNU_HASH";
3749 case SHT_GROUP
: return "GROUP";
3750 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3751 case SHT_GNU_verdef
: return "VERDEF";
3752 case SHT_GNU_verneed
: return "VERNEED";
3753 case SHT_GNU_versym
: return "VERSYM";
3754 case 0x6ffffff0: return "VERSYM";
3755 case 0x6ffffffc: return "VERDEF";
3756 case 0x7ffffffd: return "AUXILIARY";
3757 case 0x7fffffff: return "FILTER";
3758 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3761 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3763 const char * result
;
3765 switch (elf_header
.e_machine
)
3768 case EM_MIPS_RS3_LE
:
3769 result
= get_mips_section_type_name (sh_type
);
3772 result
= get_parisc_section_type_name (sh_type
);
3775 result
= get_ia64_section_type_name (sh_type
);
3780 result
= get_x86_64_section_type_name (sh_type
);
3783 result
= get_aarch64_section_type_name (sh_type
);
3786 result
= get_arm_section_type_name (sh_type
);
3789 result
= get_tic6x_section_type_name (sh_type
);
3792 result
= get_msp430x_section_type_name (sh_type
);
3802 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3804 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3806 const char * result
;
3808 switch (elf_header
.e_machine
)
3811 result
= get_ia64_section_type_name (sh_type
);
3821 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3823 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3824 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3826 /* This message is probably going to be displayed in a 15
3827 character wide field, so put the hex value first. */
3828 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3834 #define OPTION_DEBUG_DUMP 512
3835 #define OPTION_DYN_SYMS 513
3836 #define OPTION_DWARF_DEPTH 514
3837 #define OPTION_DWARF_START 515
3838 #define OPTION_DWARF_CHECK 516
3840 static struct option options
[] =
3842 {"all", no_argument
, 0, 'a'},
3843 {"file-header", no_argument
, 0, 'h'},
3844 {"program-headers", no_argument
, 0, 'l'},
3845 {"headers", no_argument
, 0, 'e'},
3846 {"histogram", no_argument
, 0, 'I'},
3847 {"segments", no_argument
, 0, 'l'},
3848 {"sections", no_argument
, 0, 'S'},
3849 {"section-headers", no_argument
, 0, 'S'},
3850 {"section-groups", no_argument
, 0, 'g'},
3851 {"section-details", no_argument
, 0, 't'},
3852 {"full-section-name",no_argument
, 0, 'N'},
3853 {"symbols", no_argument
, 0, 's'},
3854 {"syms", no_argument
, 0, 's'},
3855 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3856 {"relocs", no_argument
, 0, 'r'},
3857 {"notes", no_argument
, 0, 'n'},
3858 {"dynamic", no_argument
, 0, 'd'},
3859 {"arch-specific", no_argument
, 0, 'A'},
3860 {"version-info", no_argument
, 0, 'V'},
3861 {"use-dynamic", no_argument
, 0, 'D'},
3862 {"unwind", no_argument
, 0, 'u'},
3863 {"archive-index", no_argument
, 0, 'c'},
3864 {"hex-dump", required_argument
, 0, 'x'},
3865 {"relocated-dump", required_argument
, 0, 'R'},
3866 {"string-dump", required_argument
, 0, 'p'},
3867 #ifdef SUPPORT_DISASSEMBLY
3868 {"instruction-dump", required_argument
, 0, 'i'},
3870 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3872 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3873 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3874 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3876 {"version", no_argument
, 0, 'v'},
3877 {"wide", no_argument
, 0, 'W'},
3878 {"help", no_argument
, 0, 'H'},
3879 {0, no_argument
, 0, 0}
3883 usage (FILE * stream
)
3885 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3886 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3887 fprintf (stream
, _(" Options are:\n\
3888 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3889 -h --file-header Display the ELF file header\n\
3890 -l --program-headers Display the program headers\n\
3891 --segments An alias for --program-headers\n\
3892 -S --section-headers Display the sections' header\n\
3893 --sections An alias for --section-headers\n\
3894 -g --section-groups Display the section groups\n\
3895 -t --section-details Display the section details\n\
3896 -e --headers Equivalent to: -h -l -S\n\
3897 -s --syms Display the symbol table\n\
3898 --symbols An alias for --syms\n\
3899 --dyn-syms Display the dynamic symbol table\n\
3900 -n --notes Display the core notes (if present)\n\
3901 -r --relocs Display the relocations (if present)\n\
3902 -u --unwind Display the unwind info (if present)\n\
3903 -d --dynamic Display the dynamic section (if present)\n\
3904 -V --version-info Display the version sections (if present)\n\
3905 -A --arch-specific Display architecture specific information (if any)\n\
3906 -c --archive-index Display the symbol/file index in an archive\n\
3907 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3908 -x --hex-dump=<number|name>\n\
3909 Dump the contents of section <number|name> as bytes\n\
3910 -p --string-dump=<number|name>\n\
3911 Dump the contents of section <number|name> as strings\n\
3912 -R --relocated-dump=<number|name>\n\
3913 Dump the contents of section <number|name> as relocated bytes\n\
3914 -w[lLiaprmfFsoRt] or\n\
3915 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3916 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3917 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3919 Display the contents of DWARF2 debug sections\n"));
3920 fprintf (stream
, _("\
3921 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3922 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3924 #ifdef SUPPORT_DISASSEMBLY
3925 fprintf (stream
, _("\
3926 -i --instruction-dump=<number|name>\n\
3927 Disassemble the contents of section <number|name>\n"));
3929 fprintf (stream
, _("\
3930 -I --histogram Display histogram of bucket list lengths\n\
3931 -W --wide Allow output width to exceed 80 characters\n\
3932 @<file> Read options from <file>\n\
3933 -H --help Display this information\n\
3934 -v --version Display the version number of readelf\n"));
3936 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3937 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3939 exit (stream
== stdout
? 0 : 1);
3942 /* Record the fact that the user wants the contents of section number
3943 SECTION to be displayed using the method(s) encoded as flags bits
3944 in TYPE. Note, TYPE can be zero if we are creating the array for
3948 request_dump_bynumber (unsigned int section
, dump_type type
)
3950 if (section
>= num_dump_sects
)
3952 dump_type
* new_dump_sects
;
3954 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3955 sizeof (* dump_sects
));
3957 if (new_dump_sects
== NULL
)
3958 error (_("Out of memory allocating dump request table.\n"));
3961 /* Copy current flag settings. */
3962 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3966 dump_sects
= new_dump_sects
;
3967 num_dump_sects
= section
+ 1;
3972 dump_sects
[section
] |= type
;
3977 /* Request a dump by section name. */
3980 request_dump_byname (const char * section
, dump_type type
)
3982 struct dump_list_entry
* new_request
;
3984 new_request
= (struct dump_list_entry
*)
3985 malloc (sizeof (struct dump_list_entry
));
3987 error (_("Out of memory allocating dump request table.\n"));
3989 new_request
->name
= strdup (section
);
3990 if (!new_request
->name
)
3991 error (_("Out of memory allocating dump request table.\n"));
3993 new_request
->type
= type
;
3995 new_request
->next
= dump_sects_byname
;
3996 dump_sects_byname
= new_request
;
4000 request_dump (dump_type type
)
4006 section
= strtoul (optarg
, & cp
, 0);
4008 if (! *cp
&& section
>= 0)
4009 request_dump_bynumber (section
, type
);
4011 request_dump_byname (optarg
, type
);
4016 parse_args (int argc
, char ** argv
)
4023 while ((c
= getopt_long
4024 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4042 do_section_groups
++;
4050 do_section_groups
++;
4055 do_section_details
++;
4099 request_dump (HEX_DUMP
);
4102 request_dump (STRING_DUMP
);
4105 request_dump (RELOC_DUMP
);
4112 dwarf_select_sections_all ();
4117 dwarf_select_sections_by_letters (optarg
);
4120 case OPTION_DEBUG_DUMP
:
4127 dwarf_select_sections_by_names (optarg
);
4130 case OPTION_DWARF_DEPTH
:
4134 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4137 case OPTION_DWARF_START
:
4141 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4144 case OPTION_DWARF_CHECK
:
4147 case OPTION_DYN_SYMS
:
4150 #ifdef SUPPORT_DISASSEMBLY
4152 request_dump (DISASS_DUMP
);
4156 print_version (program_name
);
4165 /* xgettext:c-format */
4166 error (_("Invalid option '-%c'\n"), c
);
4173 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4174 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4175 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4176 && !do_section_groups
&& !do_archive_index
4181 warn (_("Nothing to do.\n"));
4187 get_elf_class (unsigned int elf_class
)
4189 static char buff
[32];
4193 case ELFCLASSNONE
: return _("none");
4194 case ELFCLASS32
: return "ELF32";
4195 case ELFCLASS64
: return "ELF64";
4197 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4203 get_data_encoding (unsigned int encoding
)
4205 static char buff
[32];
4209 case ELFDATANONE
: return _("none");
4210 case ELFDATA2LSB
: return _("2's complement, little endian");
4211 case ELFDATA2MSB
: return _("2's complement, big endian");
4213 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4218 /* Decode the data held in 'elf_header'. */
4221 process_file_header (void)
4223 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4224 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4225 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4226 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4229 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4233 init_dwarf_regnames (elf_header
.e_machine
);
4239 printf (_("ELF Header:\n"));
4240 printf (_(" Magic: "));
4241 for (i
= 0; i
< EI_NIDENT
; i
++)
4242 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4244 printf (_(" Class: %s\n"),
4245 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4246 printf (_(" Data: %s\n"),
4247 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4248 printf (_(" Version: %d %s\n"),
4249 elf_header
.e_ident
[EI_VERSION
],
4250 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4252 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4253 ? _("<unknown: %lx>")
4255 printf (_(" OS/ABI: %s\n"),
4256 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4257 printf (_(" ABI Version: %d\n"),
4258 elf_header
.e_ident
[EI_ABIVERSION
]);
4259 printf (_(" Type: %s\n"),
4260 get_file_type (elf_header
.e_type
));
4261 printf (_(" Machine: %s\n"),
4262 get_machine_name (elf_header
.e_machine
));
4263 printf (_(" Version: 0x%lx\n"),
4264 (unsigned long) elf_header
.e_version
);
4266 printf (_(" Entry point address: "));
4267 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4268 printf (_("\n Start of program headers: "));
4269 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4270 printf (_(" (bytes into file)\n Start of section headers: "));
4271 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4272 printf (_(" (bytes into file)\n"));
4274 printf (_(" Flags: 0x%lx%s\n"),
4275 (unsigned long) elf_header
.e_flags
,
4276 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4277 printf (_(" Size of this header: %ld (bytes)\n"),
4278 (long) elf_header
.e_ehsize
);
4279 printf (_(" Size of program headers: %ld (bytes)\n"),
4280 (long) elf_header
.e_phentsize
);
4281 printf (_(" Number of program headers: %ld"),
4282 (long) elf_header
.e_phnum
);
4283 if (section_headers
!= NULL
4284 && elf_header
.e_phnum
== PN_XNUM
4285 && section_headers
[0].sh_info
!= 0)
4286 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4287 putc ('\n', stdout
);
4288 printf (_(" Size of section headers: %ld (bytes)\n"),
4289 (long) elf_header
.e_shentsize
);
4290 printf (_(" Number of section headers: %ld"),
4291 (long) elf_header
.e_shnum
);
4292 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4293 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4294 putc ('\n', stdout
);
4295 printf (_(" Section header string table index: %ld"),
4296 (long) elf_header
.e_shstrndx
);
4297 if (section_headers
!= NULL
4298 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4299 printf (" (%u)", section_headers
[0].sh_link
);
4300 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4301 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4302 printf (_(" <corrupt: out of range>"));
4303 putc ('\n', stdout
);
4306 if (section_headers
!= NULL
)
4308 if (elf_header
.e_phnum
== PN_XNUM
4309 && section_headers
[0].sh_info
!= 0)
4310 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4311 if (elf_header
.e_shnum
== SHN_UNDEF
)
4312 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4313 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4314 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4315 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4316 elf_header
.e_shstrndx
= SHN_UNDEF
;
4317 free (section_headers
);
4318 section_headers
= NULL
;
4325 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4327 Elf32_External_Phdr
* phdrs
;
4328 Elf32_External_Phdr
* external
;
4329 Elf_Internal_Phdr
* internal
;
4331 unsigned int size
= elf_header
.e_phentsize
;
4332 unsigned int num
= elf_header
.e_phnum
;
4334 /* PR binutils/17531: Cope with unexpected section header sizes. */
4335 if (size
== 0 || num
== 0)
4337 if (size
< sizeof * phdrs
)
4339 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4342 if (size
> sizeof * phdrs
)
4343 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4345 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4346 size
, num
, _("program headers"));
4350 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4351 i
< elf_header
.e_phnum
;
4352 i
++, internal
++, external
++)
4354 internal
->p_type
= BYTE_GET (external
->p_type
);
4355 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4356 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4357 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4358 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4359 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4360 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4361 internal
->p_align
= BYTE_GET (external
->p_align
);
4369 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4371 Elf64_External_Phdr
* phdrs
;
4372 Elf64_External_Phdr
* external
;
4373 Elf_Internal_Phdr
* internal
;
4375 unsigned int size
= elf_header
.e_phentsize
;
4376 unsigned int num
= elf_header
.e_phnum
;
4378 /* PR binutils/17531: Cope with unexpected section header sizes. */
4379 if (size
== 0 || num
== 0)
4381 if (size
< sizeof * phdrs
)
4383 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4386 if (size
> sizeof * phdrs
)
4387 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4389 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4390 size
, num
, _("program headers"));
4394 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4395 i
< elf_header
.e_phnum
;
4396 i
++, internal
++, external
++)
4398 internal
->p_type
= BYTE_GET (external
->p_type
);
4399 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4400 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4401 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4402 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4403 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4404 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4405 internal
->p_align
= BYTE_GET (external
->p_align
);
4412 /* Returns 1 if the program headers were read into `program_headers'. */
4415 get_program_headers (FILE * file
)
4417 Elf_Internal_Phdr
* phdrs
;
4419 /* Check cache of prior read. */
4420 if (program_headers
!= NULL
)
4423 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4424 sizeof (Elf_Internal_Phdr
));
4428 error (_("Out of memory reading %u program headers\n"),
4429 elf_header
.e_phnum
);
4434 ? get_32bit_program_headers (file
, phdrs
)
4435 : get_64bit_program_headers (file
, phdrs
))
4437 program_headers
= phdrs
;
4445 /* Returns 1 if the program headers were loaded. */
4448 process_program_headers (FILE * file
)
4450 Elf_Internal_Phdr
* segment
;
4453 if (elf_header
.e_phnum
== 0)
4455 /* PR binutils/12467. */
4456 if (elf_header
.e_phoff
!= 0)
4457 warn (_("possibly corrupt ELF header - it has a non-zero program"
4458 " header offset, but no program headers"));
4459 else if (do_segments
)
4460 printf (_("\nThere are no program headers in this file.\n"));
4464 if (do_segments
&& !do_header
)
4466 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4467 printf (_("Entry point "));
4468 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4469 printf (_("\nThere are %d program headers, starting at offset "),
4470 elf_header
.e_phnum
);
4471 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4475 if (! get_program_headers (file
))
4480 if (elf_header
.e_phnum
> 1)
4481 printf (_("\nProgram Headers:\n"));
4483 printf (_("\nProgram Headers:\n"));
4487 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4490 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4494 (_(" Type Offset VirtAddr PhysAddr\n"));
4496 (_(" FileSiz MemSiz Flags Align\n"));
4503 for (i
= 0, segment
= program_headers
;
4504 i
< elf_header
.e_phnum
;
4509 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4513 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4514 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4515 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4516 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4517 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4519 (segment
->p_flags
& PF_R
? 'R' : ' '),
4520 (segment
->p_flags
& PF_W
? 'W' : ' '),
4521 (segment
->p_flags
& PF_X
? 'E' : ' '));
4522 printf ("%#lx", (unsigned long) segment
->p_align
);
4526 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4527 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4530 print_vma (segment
->p_offset
, FULL_HEX
);
4534 print_vma (segment
->p_vaddr
, FULL_HEX
);
4536 print_vma (segment
->p_paddr
, FULL_HEX
);
4539 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4540 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4543 print_vma (segment
->p_filesz
, FULL_HEX
);
4547 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4548 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4551 print_vma (segment
->p_memsz
, FULL_HEX
);
4555 (segment
->p_flags
& PF_R
? 'R' : ' '),
4556 (segment
->p_flags
& PF_W
? 'W' : ' '),
4557 (segment
->p_flags
& PF_X
? 'E' : ' '));
4559 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4560 printf ("%#lx", (unsigned long) segment
->p_align
);
4563 print_vma (segment
->p_align
, PREFIX_HEX
);
4568 print_vma (segment
->p_offset
, FULL_HEX
);
4570 print_vma (segment
->p_vaddr
, FULL_HEX
);
4572 print_vma (segment
->p_paddr
, FULL_HEX
);
4574 print_vma (segment
->p_filesz
, FULL_HEX
);
4576 print_vma (segment
->p_memsz
, FULL_HEX
);
4578 (segment
->p_flags
& PF_R
? 'R' : ' '),
4579 (segment
->p_flags
& PF_W
? 'W' : ' '),
4580 (segment
->p_flags
& PF_X
? 'E' : ' '));
4581 print_vma (segment
->p_align
, HEX
);
4586 putc ('\n', stdout
);
4588 switch (segment
->p_type
)
4592 error (_("more than one dynamic segment\n"));
4594 /* By default, assume that the .dynamic section is the first
4595 section in the DYNAMIC segment. */
4596 dynamic_addr
= segment
->p_offset
;
4597 dynamic_size
= segment
->p_filesz
;
4598 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4599 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4601 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4602 dynamic_addr
= dynamic_size
= 0;
4605 /* Try to locate the .dynamic section. If there is
4606 a section header table, we can easily locate it. */
4607 if (section_headers
!= NULL
)
4609 Elf_Internal_Shdr
* sec
;
4611 sec
= find_section (".dynamic");
4612 if (sec
== NULL
|| sec
->sh_size
== 0)
4614 /* A corresponding .dynamic section is expected, but on
4615 IA-64/OpenVMS it is OK for it to be missing. */
4616 if (!is_ia64_vms ())
4617 error (_("no .dynamic section in the dynamic segment\n"));
4621 if (sec
->sh_type
== SHT_NOBITS
)
4627 dynamic_addr
= sec
->sh_offset
;
4628 dynamic_size
= sec
->sh_size
;
4630 if (dynamic_addr
< segment
->p_offset
4631 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4632 warn (_("the .dynamic section is not contained"
4633 " within the dynamic segment\n"));
4634 else if (dynamic_addr
> segment
->p_offset
)
4635 warn (_("the .dynamic section is not the first section"
4636 " in the dynamic segment.\n"));
4641 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4643 error (_("Unable to find program interpreter name\n"));
4647 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4649 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4650 error (_("Internal error: failed to create format string to display program interpreter\n"));
4652 program_interpreter
[0] = 0;
4653 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4654 error (_("Unable to read program interpreter name\n"));
4657 printf (_(" [Requesting program interpreter: %s]\n"),
4658 program_interpreter
);
4664 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4666 printf (_("\n Section to Segment mapping:\n"));
4667 printf (_(" Segment Sections...\n"));
4669 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4672 Elf_Internal_Shdr
* section
;
4674 segment
= program_headers
+ i
;
4675 section
= section_headers
+ 1;
4677 printf (" %2.2d ", i
);
4679 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4681 if (!ELF_TBSS_SPECIAL (section
, segment
)
4682 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4683 printf ("%s ", printable_section_name (section
));
4694 /* Find the file offset corresponding to VMA by using the program headers. */
4697 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4699 Elf_Internal_Phdr
* seg
;
4701 if (! get_program_headers (file
))
4703 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4707 for (seg
= program_headers
;
4708 seg
< program_headers
+ elf_header
.e_phnum
;
4711 if (seg
->p_type
!= PT_LOAD
)
4714 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4715 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4716 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4719 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4720 (unsigned long) vma
);
4725 /* Allocate memory and load the sections headers into the global pointer
4726 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4727 generate any error messages if the load fails. */
4730 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4732 Elf32_External_Shdr
* shdrs
;
4733 Elf_Internal_Shdr
* internal
;
4735 unsigned int size
= elf_header
.e_shentsize
;
4736 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4738 /* PR binutils/17531: Cope with unexpected section header sizes. */
4739 if (size
== 0 || num
== 0)
4741 if (size
< sizeof * shdrs
)
4744 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4747 if (!probe
&& size
> sizeof * shdrs
)
4748 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4750 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4752 probe
? NULL
: _("section headers"));
4756 if (section_headers
!= NULL
)
4757 free (section_headers
);
4758 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4759 sizeof (Elf_Internal_Shdr
));
4760 if (section_headers
== NULL
)
4763 error (_("Out of memory reading %u section headers\n"), num
);
4767 for (i
= 0, internal
= section_headers
;
4771 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4772 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4773 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4774 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4775 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4776 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4777 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4778 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4779 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4780 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4788 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4790 Elf64_External_Shdr
* shdrs
;
4791 Elf_Internal_Shdr
* internal
;
4793 unsigned int size
= elf_header
.e_shentsize
;
4794 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4796 /* PR binutils/17531: Cope with unexpected section header sizes. */
4797 if (size
== 0 || num
== 0)
4799 if (size
< sizeof * shdrs
)
4802 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4805 if (! probe
&& size
> sizeof * shdrs
)
4806 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4808 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4810 probe
? NULL
: _("section headers"));
4814 if (section_headers
!= NULL
)
4815 free (section_headers
);
4816 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4817 sizeof (Elf_Internal_Shdr
));
4818 if (section_headers
== NULL
)
4821 error (_("Out of memory reading %u section headers\n"), num
);
4825 for (i
= 0, internal
= section_headers
;
4829 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4830 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4831 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4832 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4833 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4834 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4835 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4836 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4837 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4838 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4845 static Elf_Internal_Sym
*
4846 get_32bit_elf_symbols (FILE * file
,
4847 Elf_Internal_Shdr
* section
,
4848 unsigned long * num_syms_return
)
4850 unsigned long number
= 0;
4851 Elf32_External_Sym
* esyms
= NULL
;
4852 Elf_External_Sym_Shndx
* shndx
= NULL
;
4853 Elf_Internal_Sym
* isyms
= NULL
;
4854 Elf_Internal_Sym
* psym
;
4857 if (section
->sh_size
== 0)
4859 if (num_syms_return
!= NULL
)
4860 * num_syms_return
= 0;
4864 /* Run some sanity checks first. */
4865 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4867 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4868 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4872 if (section
->sh_size
> current_file_size
)
4874 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4875 printable_section_name (section
), (unsigned long) section
->sh_size
);
4879 number
= section
->sh_size
/ section
->sh_entsize
;
4881 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4883 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4884 (unsigned long) section
->sh_size
,
4885 printable_section_name (section
),
4886 (unsigned long) section
->sh_entsize
);
4890 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4891 section
->sh_size
, _("symbols"));
4896 if (symtab_shndx_hdr
!= NULL
4897 && (symtab_shndx_hdr
->sh_link
4898 == (unsigned long) (section
- section_headers
)))
4900 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4901 symtab_shndx_hdr
->sh_offset
,
4902 1, symtab_shndx_hdr
->sh_size
,
4903 _("symbol table section indicies"));
4906 /* PR17531: file: heap-buffer-overflow */
4907 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4909 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4910 printable_section_name (symtab_shndx_hdr
),
4911 (unsigned long) symtab_shndx_hdr
->sh_size
,
4912 (unsigned long) section
->sh_size
);
4917 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4921 error (_("Out of memory reading %lu symbols\n"),
4922 (unsigned long) number
);
4926 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4928 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4929 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4930 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4931 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4932 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4934 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4935 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4936 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4937 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4938 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4947 if (num_syms_return
!= NULL
)
4948 * num_syms_return
= isyms
== NULL
? 0 : number
;
4953 static Elf_Internal_Sym
*
4954 get_64bit_elf_symbols (FILE * file
,
4955 Elf_Internal_Shdr
* section
,
4956 unsigned long * num_syms_return
)
4958 unsigned long number
= 0;
4959 Elf64_External_Sym
* esyms
= NULL
;
4960 Elf_External_Sym_Shndx
* shndx
= NULL
;
4961 Elf_Internal_Sym
* isyms
= NULL
;
4962 Elf_Internal_Sym
* psym
;
4965 if (section
->sh_size
== 0)
4967 if (num_syms_return
!= NULL
)
4968 * num_syms_return
= 0;
4972 /* Run some sanity checks first. */
4973 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4975 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4976 printable_section_name (section
),
4977 (unsigned long) section
->sh_entsize
);
4981 if (section
->sh_size
> current_file_size
)
4983 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4984 printable_section_name (section
),
4985 (unsigned long) section
->sh_size
);
4989 number
= section
->sh_size
/ section
->sh_entsize
;
4991 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4993 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4994 (unsigned long) section
->sh_size
,
4995 printable_section_name (section
),
4996 (unsigned long) section
->sh_entsize
);
5000 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5001 section
->sh_size
, _("symbols"));
5005 if (symtab_shndx_hdr
!= NULL
5006 && (symtab_shndx_hdr
->sh_link
5007 == (unsigned long) (section
- section_headers
)))
5009 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5010 symtab_shndx_hdr
->sh_offset
,
5011 1, symtab_shndx_hdr
->sh_size
,
5012 _("symbol table section indicies"));
5015 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5017 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5018 printable_section_name (symtab_shndx_hdr
),
5019 (unsigned long) symtab_shndx_hdr
->sh_size
,
5020 (unsigned long) section
->sh_size
);
5025 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5029 error (_("Out of memory reading %lu symbols\n"),
5030 (unsigned long) number
);
5034 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5036 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5037 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5038 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5039 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5041 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5043 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5044 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5045 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5047 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5048 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5057 if (num_syms_return
!= NULL
)
5058 * num_syms_return
= isyms
== NULL
? 0 : number
;
5064 get_elf_section_flags (bfd_vma sh_flags
)
5066 static char buff
[1024];
5068 int field_size
= is_32bit_elf
? 8 : 16;
5070 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5071 bfd_vma os_flags
= 0;
5072 bfd_vma proc_flags
= 0;
5073 bfd_vma unknown_flags
= 0;
5081 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5082 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5083 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5084 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5085 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5086 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5087 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5088 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5089 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5090 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5091 /* IA-64 specific. */
5092 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5093 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5094 /* IA-64 OpenVMS specific. */
5095 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5096 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5097 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5098 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5099 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5100 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5102 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5103 /* SPARC specific. */
5104 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5107 if (do_section_details
)
5109 sprintf (buff
, "[%*.*lx]: ",
5110 field_size
, field_size
, (unsigned long) sh_flags
);
5111 p
+= field_size
+ 4;
5118 flag
= sh_flags
& - sh_flags
;
5121 if (do_section_details
)
5125 case SHF_WRITE
: sindex
= 0; break;
5126 case SHF_ALLOC
: sindex
= 1; break;
5127 case SHF_EXECINSTR
: sindex
= 2; break;
5128 case SHF_MERGE
: sindex
= 3; break;
5129 case SHF_STRINGS
: sindex
= 4; break;
5130 case SHF_INFO_LINK
: sindex
= 5; break;
5131 case SHF_LINK_ORDER
: sindex
= 6; break;
5132 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5133 case SHF_GROUP
: sindex
= 8; break;
5134 case SHF_TLS
: sindex
= 9; break;
5135 case SHF_EXCLUDE
: sindex
= 18; break;
5139 switch (elf_header
.e_machine
)
5142 if (flag
== SHF_IA_64_SHORT
)
5144 else if (flag
== SHF_IA_64_NORECOV
)
5147 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5150 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5151 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5152 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5153 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5154 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5155 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5166 case EM_OLD_SPARCV9
:
5167 case EM_SPARC32PLUS
:
5170 if (flag
== SHF_ORDERED
)
5180 if (p
!= buff
+ field_size
+ 4)
5182 if (size
< (10 + 2))
5184 warn (_("Internal error: not enough buffer room for section flag info"));
5185 return _("<unknown>");
5192 size
-= flags
[sindex
].len
;
5193 p
= stpcpy (p
, flags
[sindex
].str
);
5195 else if (flag
& SHF_MASKOS
)
5197 else if (flag
& SHF_MASKPROC
)
5200 unknown_flags
|= flag
;
5206 case SHF_WRITE
: *p
= 'W'; break;
5207 case SHF_ALLOC
: *p
= 'A'; break;
5208 case SHF_EXECINSTR
: *p
= 'X'; break;
5209 case SHF_MERGE
: *p
= 'M'; break;
5210 case SHF_STRINGS
: *p
= 'S'; break;
5211 case SHF_INFO_LINK
: *p
= 'I'; break;
5212 case SHF_LINK_ORDER
: *p
= 'L'; break;
5213 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5214 case SHF_GROUP
: *p
= 'G'; break;
5215 case SHF_TLS
: *p
= 'T'; break;
5216 case SHF_EXCLUDE
: *p
= 'E'; break;
5219 if ((elf_header
.e_machine
== EM_X86_64
5220 || elf_header
.e_machine
== EM_L1OM
5221 || elf_header
.e_machine
== EM_K1OM
)
5222 && flag
== SHF_X86_64_LARGE
)
5224 else if (flag
& SHF_MASKOS
)
5227 sh_flags
&= ~ SHF_MASKOS
;
5229 else if (flag
& SHF_MASKPROC
)
5232 sh_flags
&= ~ SHF_MASKPROC
;
5242 if (do_section_details
)
5246 size
-= 5 + field_size
;
5247 if (p
!= buff
+ field_size
+ 4)
5251 warn (_("Internal error: not enough buffer room for section flag info"));
5252 return _("<unknown>");
5258 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5259 (unsigned long) os_flags
);
5260 p
+= 5 + field_size
;
5264 size
-= 7 + field_size
;
5265 if (p
!= buff
+ field_size
+ 4)
5269 warn (_("Internal error: not enough buffer room for section flag info"));
5270 return _("<unknown>");
5276 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5277 (unsigned long) proc_flags
);
5278 p
+= 7 + field_size
;
5282 size
-= 10 + field_size
;
5283 if (p
!= buff
+ field_size
+ 4)
5287 warn (_("Internal error: not enough buffer room for section flag info"));
5288 return _("<unknown>");
5294 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5295 (unsigned long) unknown_flags
);
5296 p
+= 10 + field_size
;
5305 process_section_headers (FILE * file
)
5307 Elf_Internal_Shdr
* section
;
5310 section_headers
= NULL
;
5312 if (elf_header
.e_shnum
== 0)
5314 /* PR binutils/12467. */
5315 if (elf_header
.e_shoff
!= 0)
5316 warn (_("possibly corrupt ELF file header - it has a non-zero"
5317 " section header offset, but no section headers\n"));
5318 else if (do_sections
)
5319 printf (_("\nThere are no sections in this file.\n"));
5324 if (do_sections
&& !do_header
)
5325 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5326 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5330 if (! get_32bit_section_headers (file
, FALSE
))
5333 else if (! get_64bit_section_headers (file
, FALSE
))
5336 /* Read in the string table, so that we have names to display. */
5337 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5338 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5340 section
= section_headers
+ elf_header
.e_shstrndx
;
5342 if (section
->sh_size
!= 0)
5344 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5345 1, section
->sh_size
,
5348 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5352 /* Scan the sections for the dynamic symbol table
5353 and dynamic string table and debug sections. */
5354 dynamic_symbols
= NULL
;
5355 dynamic_strings
= NULL
;
5356 dynamic_syminfo
= NULL
;
5357 symtab_shndx_hdr
= NULL
;
5359 eh_addr_size
= is_32bit_elf
? 4 : 8;
5360 switch (elf_header
.e_machine
)
5363 case EM_MIPS_RS3_LE
:
5364 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5365 FDE addresses. However, the ABI also has a semi-official ILP32
5366 variant for which the normal FDE address size rules apply.
5368 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5369 section, where XX is the size of longs in bits. Unfortunately,
5370 earlier compilers provided no way of distinguishing ILP32 objects
5371 from LP64 objects, so if there's any doubt, we should assume that
5372 the official LP64 form is being used. */
5373 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5374 && find_section (".gcc_compiled_long32") == NULL
)
5380 switch (elf_header
.e_flags
& EF_H8_MACH
)
5382 case E_H8_MACH_H8300
:
5383 case E_H8_MACH_H8300HN
:
5384 case E_H8_MACH_H8300SN
:
5385 case E_H8_MACH_H8300SXN
:
5388 case E_H8_MACH_H8300H
:
5389 case E_H8_MACH_H8300S
:
5390 case E_H8_MACH_H8300SX
:
5398 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5400 case EF_M32C_CPU_M16C
:
5407 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5410 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5411 if (section->sh_entsize != expected_entsize) \
5414 sprintf_vma (buf, section->sh_entsize); \
5415 /* Note: coded this way so that there is a single string for \
5417 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5418 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5419 (unsigned) expected_entsize); \
5420 section->sh_entsize = expected_entsize; \
5425 #define CHECK_ENTSIZE(section, i, type) \
5426 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5427 sizeof (Elf64_External_##type))
5429 for (i
= 0, section
= section_headers
;
5430 i
< elf_header
.e_shnum
;
5433 char * name
= SECTION_NAME (section
);
5435 if (section
->sh_type
== SHT_DYNSYM
)
5437 if (dynamic_symbols
!= NULL
)
5439 error (_("File contains multiple dynamic symbol tables\n"));
5443 CHECK_ENTSIZE (section
, i
, Sym
);
5444 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5446 else if (section
->sh_type
== SHT_STRTAB
5447 && streq (name
, ".dynstr"))
5449 if (dynamic_strings
!= NULL
)
5451 error (_("File contains multiple dynamic string tables\n"));
5455 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5456 1, section
->sh_size
,
5457 _("dynamic strings"));
5458 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5460 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5462 if (symtab_shndx_hdr
!= NULL
)
5464 error (_("File contains multiple symtab shndx tables\n"));
5467 symtab_shndx_hdr
= section
;
5469 else if (section
->sh_type
== SHT_SYMTAB
)
5470 CHECK_ENTSIZE (section
, i
, Sym
);
5471 else if (section
->sh_type
== SHT_GROUP
)
5472 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5473 else if (section
->sh_type
== SHT_REL
)
5474 CHECK_ENTSIZE (section
, i
, Rel
);
5475 else if (section
->sh_type
== SHT_RELA
)
5476 CHECK_ENTSIZE (section
, i
, Rela
);
5477 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5478 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5479 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5480 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5481 || do_debug_addr
|| do_debug_cu_index
)
5482 && (const_strneq (name
, ".debug_")
5483 || const_strneq (name
, ".zdebug_")))
5486 name
+= sizeof (".zdebug_") - 1;
5488 name
+= sizeof (".debug_") - 1;
5491 || (do_debug_info
&& const_strneq (name
, "info"))
5492 || (do_debug_info
&& const_strneq (name
, "types"))
5493 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5494 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5495 || (do_debug_lines
&& const_strneq (name
, "line."))
5496 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5497 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5498 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5499 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5500 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5501 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5502 || (do_debug_frames
&& const_strneq (name
, "frame"))
5503 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5504 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5505 || (do_debug_str
&& const_strneq (name
, "str"))
5506 || (do_debug_loc
&& const_strneq (name
, "loc"))
5507 || (do_debug_addr
&& const_strneq (name
, "addr"))
5508 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5509 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5511 request_dump_bynumber (i
, DEBUG_DUMP
);
5513 /* Linkonce section to be combined with .debug_info at link time. */
5514 else if ((do_debugging
|| do_debug_info
)
5515 && const_strneq (name
, ".gnu.linkonce.wi."))
5516 request_dump_bynumber (i
, DEBUG_DUMP
);
5517 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5518 request_dump_bynumber (i
, DEBUG_DUMP
);
5519 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5520 request_dump_bynumber (i
, DEBUG_DUMP
);
5521 /* Trace sections for Itanium VMS. */
5522 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5523 || do_trace_aranges
)
5524 && const_strneq (name
, ".trace_"))
5526 name
+= sizeof (".trace_") - 1;
5529 || (do_trace_info
&& streq (name
, "info"))
5530 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5531 || (do_trace_aranges
&& streq (name
, "aranges"))
5533 request_dump_bynumber (i
, DEBUG_DUMP
);
5540 if (elf_header
.e_shnum
> 1)
5541 printf (_("\nSection Headers:\n"));
5543 printf (_("\nSection Header:\n"));
5547 if (do_section_details
)
5549 printf (_(" [Nr] Name\n"));
5550 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5554 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5558 if (do_section_details
)
5560 printf (_(" [Nr] Name\n"));
5561 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5565 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5569 if (do_section_details
)
5571 printf (_(" [Nr] Name\n"));
5572 printf (_(" Type Address Offset Link\n"));
5573 printf (_(" Size EntSize Info Align\n"));
5577 printf (_(" [Nr] Name Type Address Offset\n"));
5578 printf (_(" Size EntSize Flags Link Info Align\n"));
5582 if (do_section_details
)
5583 printf (_(" Flags\n"));
5585 for (i
= 0, section
= section_headers
;
5586 i
< elf_header
.e_shnum
;
5589 printf (" [%2u] ", i
);
5590 if (do_section_details
)
5591 printf ("%s\n ", printable_section_name (section
));
5593 print_symbol (-17, SECTION_NAME (section
));
5595 printf (do_wide
? " %-15s " : " %-15.15s ",
5596 get_section_type_name (section
->sh_type
));
5600 const char * link_too_big
= NULL
;
5602 print_vma (section
->sh_addr
, LONG_HEX
);
5604 printf ( " %6.6lx %6.6lx %2.2lx",
5605 (unsigned long) section
->sh_offset
,
5606 (unsigned long) section
->sh_size
,
5607 (unsigned long) section
->sh_entsize
);
5609 if (do_section_details
)
5610 fputs (" ", stdout
);
5612 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5614 if (section
->sh_link
>= elf_header
.e_shnum
)
5617 /* The sh_link value is out of range. Normally this indicates
5618 an error but it can have special values in Solaris binaries. */
5619 switch (elf_header
.e_machine
)
5626 case EM_OLD_SPARCV9
:
5627 case EM_SPARC32PLUS
:
5630 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5631 link_too_big
= "BEFORE";
5632 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5633 link_too_big
= "AFTER";
5640 if (do_section_details
)
5642 if (link_too_big
!= NULL
&& * link_too_big
)
5643 printf ("<%s> ", link_too_big
);
5645 printf ("%2u ", section
->sh_link
);
5646 printf ("%3u %2lu\n", section
->sh_info
,
5647 (unsigned long) section
->sh_addralign
);
5650 printf ("%2u %3u %2lu\n",
5653 (unsigned long) section
->sh_addralign
);
5655 if (link_too_big
&& ! * link_too_big
)
5656 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5657 i
, section
->sh_link
);
5661 print_vma (section
->sh_addr
, LONG_HEX
);
5663 if ((long) section
->sh_offset
== section
->sh_offset
)
5664 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5668 print_vma (section
->sh_offset
, LONG_HEX
);
5671 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5672 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5676 print_vma (section
->sh_size
, LONG_HEX
);
5679 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5680 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5684 print_vma (section
->sh_entsize
, LONG_HEX
);
5687 if (do_section_details
)
5688 fputs (" ", stdout
);
5690 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5692 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5694 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5695 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5698 print_vma (section
->sh_addralign
, DEC
);
5702 else if (do_section_details
)
5704 printf (" %-15.15s ",
5705 get_section_type_name (section
->sh_type
));
5706 print_vma (section
->sh_addr
, LONG_HEX
);
5707 if ((long) section
->sh_offset
== section
->sh_offset
)
5708 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5712 print_vma (section
->sh_offset
, LONG_HEX
);
5714 printf (" %u\n ", section
->sh_link
);
5715 print_vma (section
->sh_size
, LONG_HEX
);
5717 print_vma (section
->sh_entsize
, LONG_HEX
);
5719 printf (" %-16u %lu\n",
5721 (unsigned long) section
->sh_addralign
);
5726 print_vma (section
->sh_addr
, LONG_HEX
);
5727 if ((long) section
->sh_offset
== section
->sh_offset
)
5728 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5732 print_vma (section
->sh_offset
, LONG_HEX
);
5735 print_vma (section
->sh_size
, LONG_HEX
);
5737 print_vma (section
->sh_entsize
, LONG_HEX
);
5739 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5741 printf (" %2u %3u %lu\n",
5744 (unsigned long) section
->sh_addralign
);
5747 if (do_section_details
)
5748 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5751 if (!do_section_details
)
5753 if (elf_header
.e_machine
== EM_X86_64
5754 || elf_header
.e_machine
== EM_L1OM
5755 || elf_header
.e_machine
== EM_K1OM
)
5756 printf (_("Key to Flags:\n\
5757 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5758 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5759 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5761 printf (_("Key to Flags:\n\
5762 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5763 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5764 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5771 get_group_flags (unsigned int flags
)
5773 static char buff
[32];
5783 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5790 process_section_groups (FILE * file
)
5792 Elf_Internal_Shdr
* section
;
5794 struct group
* group
;
5795 Elf_Internal_Shdr
* symtab_sec
;
5796 Elf_Internal_Shdr
* strtab_sec
;
5797 Elf_Internal_Sym
* symtab
;
5798 unsigned long num_syms
;
5802 /* Don't process section groups unless needed. */
5803 if (!do_unwind
&& !do_section_groups
)
5806 if (elf_header
.e_shnum
== 0)
5808 if (do_section_groups
)
5809 printf (_("\nThere are no sections to group in this file.\n"));
5814 if (section_headers
== NULL
)
5816 error (_("Section headers are not available!\n"));
5817 /* PR 13622: This can happen with a corrupt ELF header. */
5821 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5822 sizeof (struct group
*));
5824 if (section_headers_groups
== NULL
)
5826 error (_("Out of memory reading %u section group headers\n"),
5827 elf_header
.e_shnum
);
5831 /* Scan the sections for the group section. */
5833 for (i
= 0, section
= section_headers
;
5834 i
< elf_header
.e_shnum
;
5836 if (section
->sh_type
== SHT_GROUP
)
5839 if (group_count
== 0)
5841 if (do_section_groups
)
5842 printf (_("\nThere are no section groups in this file.\n"));
5847 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5849 if (section_groups
== NULL
)
5851 error (_("Out of memory reading %lu groups\n"),
5852 (unsigned long) group_count
);
5862 for (i
= 0, section
= section_headers
, group
= section_groups
;
5863 i
< elf_header
.e_shnum
;
5866 if (section
->sh_type
== SHT_GROUP
)
5868 const char * name
= printable_section_name (section
);
5869 const char * group_name
;
5870 unsigned char * start
;
5871 unsigned char * indices
;
5872 unsigned int entry
, j
, size
;
5873 Elf_Internal_Shdr
* sec
;
5874 Elf_Internal_Sym
* sym
;
5876 /* Get the symbol table. */
5877 if (section
->sh_link
>= elf_header
.e_shnum
5878 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5881 error (_("Bad sh_link in group section `%s'\n"), name
);
5885 if (symtab_sec
!= sec
)
5890 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5895 error (_("Corrupt header in group section `%s'\n"), name
);
5899 if (section
->sh_info
>= num_syms
)
5901 error (_("Bad sh_info in group section `%s'\n"), name
);
5905 sym
= symtab
+ section
->sh_info
;
5907 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5909 if (sym
->st_shndx
== 0
5910 || sym
->st_shndx
>= elf_header
.e_shnum
)
5912 error (_("Bad sh_info in group section `%s'\n"), name
);
5916 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5925 /* Get the string table. */
5926 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5935 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5941 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5942 1, strtab_sec
->sh_size
,
5944 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5946 group_name
= sym
->st_name
< strtab_size
5947 ? strtab
+ sym
->st_name
: _("<corrupt>");
5950 /* PR 17531: file: loop. */
5951 if (section
->sh_entsize
> section
->sh_size
)
5953 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5954 printable_section_name (section
),
5955 (unsigned long) section
->sh_entsize
,
5956 (unsigned long) section
->sh_size
);
5960 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5961 1, section
->sh_size
,
5967 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5968 entry
= byte_get (indices
, 4);
5971 if (do_section_groups
)
5973 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5974 get_group_flags (entry
), i
, name
, group_name
, size
);
5976 printf (_(" [Index] Name\n"));
5979 group
->group_index
= i
;
5981 for (j
= 0; j
< size
; j
++)
5983 struct group_list
* g
;
5985 entry
= byte_get (indices
, 4);
5988 if (entry
>= elf_header
.e_shnum
)
5990 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5991 entry
, i
, elf_header
.e_shnum
- 1);
5995 if (section_headers_groups
[entry
] != NULL
)
5999 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6001 section_headers_groups
[entry
]->group_index
);
6006 /* Intel C/C++ compiler may put section 0 in a
6007 section group. We just warn it the first time
6008 and ignore it afterwards. */
6009 static int warned
= 0;
6012 error (_("section 0 in group section [%5u]\n"),
6013 section_headers_groups
[entry
]->group_index
);
6019 section_headers_groups
[entry
] = group
;
6021 if (do_section_groups
)
6023 sec
= section_headers
+ entry
;
6024 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6027 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6028 g
->section_index
= entry
;
6029 g
->next
= group
->root
;
6047 /* Data used to display dynamic fixups. */
6049 struct ia64_vms_dynfixup
6051 bfd_vma needed_ident
; /* Library ident number. */
6052 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6053 bfd_vma fixup_needed
; /* Index of the library. */
6054 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6055 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6058 /* Data used to display dynamic relocations. */
6060 struct ia64_vms_dynimgrela
6062 bfd_vma img_rela_cnt
; /* Number of relocations. */
6063 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6066 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6070 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6071 const char *strtab
, unsigned int strtab_sz
)
6073 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6075 const char *lib_name
;
6077 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6078 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6079 _("dynamic section image fixups"));
6083 if (fixup
->needed
< strtab_sz
)
6084 lib_name
= strtab
+ fixup
->needed
;
6087 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6088 (unsigned long) fixup
->needed
);
6091 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6092 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6094 (_("Seg Offset Type SymVec DataType\n"));
6096 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6101 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6102 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6103 type
= BYTE_GET (imfs
[i
].type
);
6104 rtype
= elf_ia64_reloc_type (type
);
6106 printf (" 0x%08x ", type
);
6108 printf (" %-32s ", rtype
);
6109 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6110 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6116 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6119 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6121 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6124 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6125 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6126 _("dynamic section image relocations"));
6130 printf (_("\nImage relocs\n"));
6132 (_("Seg Offset Type Addend Seg Sym Off\n"));
6134 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6139 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6140 printf ("%08" BFD_VMA_FMT
"x ",
6141 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6142 type
= BYTE_GET (imrs
[i
].type
);
6143 rtype
= elf_ia64_reloc_type (type
);
6145 printf ("0x%08x ", type
);
6147 printf ("%-31s ", rtype
);
6148 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6149 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6150 printf ("%08" BFD_VMA_FMT
"x\n",
6151 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6157 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6160 process_ia64_vms_dynamic_relocs (FILE *file
)
6162 struct ia64_vms_dynfixup fixup
;
6163 struct ia64_vms_dynimgrela imgrela
;
6164 Elf_Internal_Dyn
*entry
;
6166 bfd_vma strtab_off
= 0;
6167 bfd_vma strtab_sz
= 0;
6168 char *strtab
= NULL
;
6170 memset (&fixup
, 0, sizeof (fixup
));
6171 memset (&imgrela
, 0, sizeof (imgrela
));
6173 /* Note: the order of the entries is specified by the OpenVMS specs. */
6174 for (entry
= dynamic_section
;
6175 entry
< dynamic_section
+ dynamic_nent
;
6178 switch (entry
->d_tag
)
6180 case DT_IA_64_VMS_STRTAB_OFFSET
:
6181 strtab_off
= entry
->d_un
.d_val
;
6184 strtab_sz
= entry
->d_un
.d_val
;
6186 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6187 1, strtab_sz
, _("dynamic string section"));
6190 case DT_IA_64_VMS_NEEDED_IDENT
:
6191 fixup
.needed_ident
= entry
->d_un
.d_val
;
6194 fixup
.needed
= entry
->d_un
.d_val
;
6196 case DT_IA_64_VMS_FIXUP_NEEDED
:
6197 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6199 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6200 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6202 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6203 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6205 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6208 case DT_IA_64_VMS_IMG_RELA_CNT
:
6209 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6211 case DT_IA_64_VMS_IMG_RELA_OFF
:
6212 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6214 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6234 } dynamic_relocations
[] =
6236 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6237 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6238 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6241 /* Process the reloc section. */
6244 process_relocs (FILE * file
)
6246 unsigned long rel_size
;
6247 unsigned long rel_offset
;
6253 if (do_using_dynamic
)
6257 int has_dynamic_reloc
;
6260 has_dynamic_reloc
= 0;
6262 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6264 is_rela
= dynamic_relocations
[i
].rela
;
6265 name
= dynamic_relocations
[i
].name
;
6266 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6267 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6269 has_dynamic_reloc
|= rel_size
;
6271 if (is_rela
== UNKNOWN
)
6273 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6274 switch (dynamic_info
[DT_PLTREL
])
6288 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6289 name
, rel_offset
, rel_size
);
6291 dump_relocations (file
,
6292 offset_from_vma (file
, rel_offset
, rel_size
),
6294 dynamic_symbols
, num_dynamic_syms
,
6295 dynamic_strings
, dynamic_strings_length
,
6301 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6303 if (! has_dynamic_reloc
)
6304 printf (_("\nThere are no dynamic relocations in this file.\n"));
6308 Elf_Internal_Shdr
* section
;
6312 for (i
= 0, section
= section_headers
;
6313 i
< elf_header
.e_shnum
;
6316 if ( section
->sh_type
!= SHT_RELA
6317 && section
->sh_type
!= SHT_REL
)
6320 rel_offset
= section
->sh_offset
;
6321 rel_size
= section
->sh_size
;
6325 Elf_Internal_Shdr
* strsec
;
6328 printf (_("\nRelocation section "));
6330 if (string_table
== NULL
)
6331 printf ("%d", section
->sh_name
);
6333 printf ("'%s'", printable_section_name (section
));
6335 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6336 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6338 is_rela
= section
->sh_type
== SHT_RELA
;
6340 if (section
->sh_link
!= 0
6341 && section
->sh_link
< elf_header
.e_shnum
)
6343 Elf_Internal_Shdr
* symsec
;
6344 Elf_Internal_Sym
* symtab
;
6345 unsigned long nsyms
;
6346 unsigned long strtablen
= 0;
6347 char * strtab
= NULL
;
6349 symsec
= section_headers
+ section
->sh_link
;
6350 if (symsec
->sh_type
!= SHT_SYMTAB
6351 && symsec
->sh_type
!= SHT_DYNSYM
)
6354 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6359 if (symsec
->sh_link
!= 0
6360 && symsec
->sh_link
< elf_header
.e_shnum
)
6362 strsec
= section_headers
+ symsec
->sh_link
;
6364 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6367 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6370 dump_relocations (file
, rel_offset
, rel_size
,
6371 symtab
, nsyms
, strtab
, strtablen
,
6373 symsec
->sh_type
== SHT_DYNSYM
);
6379 dump_relocations (file
, rel_offset
, rel_size
,
6380 NULL
, 0, NULL
, 0, is_rela
, 0);
6387 printf (_("\nThere are no relocations in this file.\n"));
6393 /* Process the unwind section. */
6395 #include "unwind-ia64.h"
6397 /* An absolute address consists of a section and an offset. If the
6398 section is NULL, the offset itself is the address, otherwise, the
6399 address equals to LOAD_ADDRESS(section) + offset. */
6403 unsigned short section
;
6407 #define ABSADDR(a) \
6409 ? section_headers [(a).section].sh_addr + (a).offset \
6412 struct ia64_unw_table_entry
6414 struct absaddr start
;
6416 struct absaddr info
;
6419 struct ia64_unw_aux_info
6422 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6423 unsigned long table_len
; /* Length of unwind table. */
6424 unsigned char * info
; /* Unwind info. */
6425 unsigned long info_size
; /* Size of unwind info. */
6426 bfd_vma info_addr
; /* starting address of unwind info. */
6427 bfd_vma seg_base
; /* Starting address of segment. */
6428 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6429 unsigned long nsyms
; /* Number of symbols. */
6430 char * strtab
; /* The string table. */
6431 unsigned long strtab_size
; /* Size of string table. */
6435 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6436 unsigned long nsyms
,
6437 const char * strtab
,
6438 unsigned long strtab_size
,
6439 struct absaddr addr
,
6440 const char ** symname
,
6443 bfd_vma dist
= 0x100000;
6444 Elf_Internal_Sym
* sym
;
6445 Elf_Internal_Sym
* best
= NULL
;
6448 REMOVE_ARCH_BITS (addr
.offset
);
6450 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6452 bfd_vma value
= sym
->st_value
;
6454 REMOVE_ARCH_BITS (value
);
6456 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6457 && sym
->st_name
!= 0
6458 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6459 && addr
.offset
>= value
6460 && addr
.offset
- value
< dist
)
6463 dist
= addr
.offset
- value
;
6471 *symname
= (best
->st_name
>= strtab_size
6472 ? _("<corrupt>") : strtab
+ best
->st_name
);
6478 *offset
= addr
.offset
;
6482 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6484 struct ia64_unw_table_entry
* tp
;
6487 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6491 const unsigned char * dp
;
6492 const unsigned char * head
;
6493 const unsigned char * end
;
6494 const char * procname
;
6496 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6497 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6499 fputs ("\n<", stdout
);
6503 fputs (procname
, stdout
);
6506 printf ("+%lx", (unsigned long) offset
);
6509 fputs (">: [", stdout
);
6510 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6511 fputc ('-', stdout
);
6512 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6513 printf ("], info at +0x%lx\n",
6514 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6516 /* PR 17531: file: 86232b32. */
6517 if (aux
->info
== NULL
)
6520 /* PR 17531: file: 0997b4d1. */
6521 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6523 warn (_("Invalid offset %lx in table entry %ld\n"),
6524 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6528 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6529 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6531 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6532 (unsigned) UNW_VER (stamp
),
6533 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6534 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6535 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6536 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6538 if (UNW_VER (stamp
) != 1)
6540 printf (_("\tUnknown version.\n"));
6545 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6546 /* PR 17531: file: 16ceda89. */
6547 if (end
> aux
->info
+ aux
->info_size
)
6548 end
= aux
->info
+ aux
->info_size
;
6549 for (dp
= head
+ 8; dp
< end
;)
6550 dp
= unw_decode (dp
, in_body
, & in_body
);
6555 slurp_ia64_unwind_table (FILE * file
,
6556 struct ia64_unw_aux_info
* aux
,
6557 Elf_Internal_Shdr
* sec
)
6559 unsigned long size
, nrelas
, i
;
6560 Elf_Internal_Phdr
* seg
;
6561 struct ia64_unw_table_entry
* tep
;
6562 Elf_Internal_Shdr
* relsec
;
6563 Elf_Internal_Rela
* rela
;
6564 Elf_Internal_Rela
* rp
;
6565 unsigned char * table
;
6567 Elf_Internal_Sym
* sym
;
6568 const char * relname
;
6572 /* First, find the starting address of the segment that includes
6575 if (elf_header
.e_phnum
)
6577 if (! get_program_headers (file
))
6580 for (seg
= program_headers
;
6581 seg
< program_headers
+ elf_header
.e_phnum
;
6584 if (seg
->p_type
!= PT_LOAD
)
6587 if (sec
->sh_addr
>= seg
->p_vaddr
6588 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6590 aux
->seg_base
= seg
->p_vaddr
;
6596 /* Second, build the unwind table from the contents of the unwind section: */
6597 size
= sec
->sh_size
;
6598 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6603 aux
->table_len
= size
/ (3 * eh_addr_size
);
6604 aux
->table
= (struct ia64_unw_table_entry
*)
6605 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6608 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6610 tep
->start
.section
= SHN_UNDEF
;
6611 tep
->end
.section
= SHN_UNDEF
;
6612 tep
->info
.section
= SHN_UNDEF
;
6613 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6614 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6615 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6616 tep
->start
.offset
+= aux
->seg_base
;
6617 tep
->end
.offset
+= aux
->seg_base
;
6618 tep
->info
.offset
+= aux
->seg_base
;
6622 /* Third, apply any relocations to the unwind table: */
6623 for (relsec
= section_headers
;
6624 relsec
< section_headers
+ elf_header
.e_shnum
;
6627 if (relsec
->sh_type
!= SHT_RELA
6628 || relsec
->sh_info
>= elf_header
.e_shnum
6629 || section_headers
+ relsec
->sh_info
!= sec
)
6632 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6641 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6643 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6644 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6646 /* PR 17531: file: 9fa67536. */
6647 if (relname
== NULL
)
6649 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6653 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6655 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6659 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6661 /* PR 17531: file: 5bc8d9bf. */
6662 if (i
>= aux
->table_len
)
6664 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6668 switch (rp
->r_offset
/ eh_addr_size
% 3)
6671 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6672 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6675 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6676 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6679 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6680 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6694 ia64_process_unwind (FILE * file
)
6696 Elf_Internal_Shdr
* sec
;
6697 Elf_Internal_Shdr
* unwsec
= NULL
;
6698 Elf_Internal_Shdr
* strsec
;
6699 unsigned long i
, unwcount
= 0, unwstart
= 0;
6700 struct ia64_unw_aux_info aux
;
6702 memset (& aux
, 0, sizeof (aux
));
6704 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6706 if (sec
->sh_type
== SHT_SYMTAB
6707 && sec
->sh_link
< elf_header
.e_shnum
)
6709 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6711 strsec
= section_headers
+ sec
->sh_link
;
6712 if (aux
.strtab
!= NULL
)
6714 error (_("Multiple auxillary string tables encountered\n"));
6717 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6720 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6722 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6727 printf (_("\nThere are no unwind sections in this file.\n"));
6729 while (unwcount
-- > 0)
6734 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6735 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6736 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6741 /* We have already counted the number of SHT_IA64_UNWIND
6742 sections so the loop above should never fail. */
6743 assert (unwsec
!= NULL
);
6746 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6748 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6750 /* We need to find which section group it is in. */
6751 struct group_list
* g
;
6753 if (section_headers_groups
== NULL
6754 || section_headers_groups
[i
] == NULL
)
6755 i
= elf_header
.e_shnum
;
6758 g
= section_headers_groups
[i
]->root
;
6760 for (; g
!= NULL
; g
= g
->next
)
6762 sec
= section_headers
+ g
->section_index
;
6764 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6769 i
= elf_header
.e_shnum
;
6772 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6774 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6775 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6776 suffix
= SECTION_NAME (unwsec
) + len
;
6777 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6779 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6780 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6785 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6786 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6787 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6788 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6790 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6791 suffix
= SECTION_NAME (unwsec
) + len
;
6792 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6794 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6795 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6799 if (i
== elf_header
.e_shnum
)
6801 printf (_("\nCould not find unwind info section for "));
6803 if (string_table
== NULL
)
6804 printf ("%d", unwsec
->sh_name
);
6806 printf ("'%s'", printable_section_name (unwsec
));
6810 aux
.info_addr
= sec
->sh_addr
;
6811 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6814 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6816 printf (_("\nUnwind section "));
6818 if (string_table
== NULL
)
6819 printf ("%d", unwsec
->sh_name
);
6821 printf ("'%s'", printable_section_name (unwsec
));
6823 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6824 (unsigned long) unwsec
->sh_offset
,
6825 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6827 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
6828 && aux
.table_len
> 0)
6829 dump_ia64_unwind (& aux
);
6832 free ((char *) aux
.table
);
6834 free ((char *) aux
.info
);
6843 free ((char *) aux
.strtab
);
6846 struct hppa_unw_table_entry
6848 struct absaddr start
;
6850 unsigned int Cannot_unwind
:1; /* 0 */
6851 unsigned int Millicode
:1; /* 1 */
6852 unsigned int Millicode_save_sr0
:1; /* 2 */
6853 unsigned int Region_description
:2; /* 3..4 */
6854 unsigned int reserved1
:1; /* 5 */
6855 unsigned int Entry_SR
:1; /* 6 */
6856 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6857 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6858 unsigned int Args_stored
:1; /* 16 */
6859 unsigned int Variable_Frame
:1; /* 17 */
6860 unsigned int Separate_Package_Body
:1; /* 18 */
6861 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6862 unsigned int Stack_Overflow_Check
:1; /* 20 */
6863 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6864 unsigned int Ada_Region
:1; /* 22 */
6865 unsigned int cxx_info
:1; /* 23 */
6866 unsigned int cxx_try_catch
:1; /* 24 */
6867 unsigned int sched_entry_seq
:1; /* 25 */
6868 unsigned int reserved2
:1; /* 26 */
6869 unsigned int Save_SP
:1; /* 27 */
6870 unsigned int Save_RP
:1; /* 28 */
6871 unsigned int Save_MRP_in_frame
:1; /* 29 */
6872 unsigned int extn_ptr_defined
:1; /* 30 */
6873 unsigned int Cleanup_defined
:1; /* 31 */
6875 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6876 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6877 unsigned int Large_frame
:1; /* 2 */
6878 unsigned int Pseudo_SP_Set
:1; /* 3 */
6879 unsigned int reserved4
:1; /* 4 */
6880 unsigned int Total_frame_size
:27; /* 5..31 */
6883 struct hppa_unw_aux_info
6885 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6886 unsigned long table_len
; /* Length of unwind table. */
6887 bfd_vma seg_base
; /* Starting address of segment. */
6888 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6889 unsigned long nsyms
; /* Number of symbols. */
6890 char * strtab
; /* The string table. */
6891 unsigned long strtab_size
; /* Size of string table. */
6895 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6897 struct hppa_unw_table_entry
* tp
;
6899 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6902 const char * procname
;
6904 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6905 aux
->strtab_size
, tp
->start
, &procname
,
6908 fputs ("\n<", stdout
);
6912 fputs (procname
, stdout
);
6915 printf ("+%lx", (unsigned long) offset
);
6918 fputs (">: [", stdout
);
6919 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6920 fputc ('-', stdout
);
6921 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6924 #define PF(_m) if (tp->_m) printf (#_m " ");
6925 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6928 PF(Millicode_save_sr0
);
6929 /* PV(Region_description); */
6935 PF(Separate_Package_Body
);
6936 PF(Frame_Extension_Millicode
);
6937 PF(Stack_Overflow_Check
);
6938 PF(Two_Instruction_SP_Increment
);
6942 PF(sched_entry_seq
);
6945 PF(Save_MRP_in_frame
);
6946 PF(extn_ptr_defined
);
6947 PF(Cleanup_defined
);
6948 PF(MPE_XL_interrupt_marker
);
6949 PF(HP_UX_interrupt_marker
);
6952 PV(Total_frame_size
);
6961 slurp_hppa_unwind_table (FILE * file
,
6962 struct hppa_unw_aux_info
* aux
,
6963 Elf_Internal_Shdr
* sec
)
6965 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6966 Elf_Internal_Phdr
* seg
;
6967 struct hppa_unw_table_entry
* tep
;
6968 Elf_Internal_Shdr
* relsec
;
6969 Elf_Internal_Rela
* rela
;
6970 Elf_Internal_Rela
* rp
;
6971 unsigned char * table
;
6973 Elf_Internal_Sym
* sym
;
6974 const char * relname
;
6976 /* First, find the starting address of the segment that includes
6979 if (elf_header
.e_phnum
)
6981 if (! get_program_headers (file
))
6984 for (seg
= program_headers
;
6985 seg
< program_headers
+ elf_header
.e_phnum
;
6988 if (seg
->p_type
!= PT_LOAD
)
6991 if (sec
->sh_addr
>= seg
->p_vaddr
6992 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6994 aux
->seg_base
= seg
->p_vaddr
;
7000 /* Second, build the unwind table from the contents of the unwind
7002 size
= sec
->sh_size
;
7003 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7009 nentries
= size
/ unw_ent_size
;
7010 size
= unw_ent_size
* nentries
;
7012 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7013 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7015 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7017 unsigned int tmp1
, tmp2
;
7019 tep
->start
.section
= SHN_UNDEF
;
7020 tep
->end
.section
= SHN_UNDEF
;
7022 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7023 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7024 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7025 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7027 tep
->start
.offset
+= aux
->seg_base
;
7028 tep
->end
.offset
+= aux
->seg_base
;
7030 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7031 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7032 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7033 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7034 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7035 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7036 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7037 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7038 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7039 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7040 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7041 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7042 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7043 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7044 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7045 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7046 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7047 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7048 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7049 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7050 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7051 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7052 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7053 tep
->Cleanup_defined
= tmp1
& 0x1;
7055 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7056 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7057 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7058 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7059 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7060 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7064 /* Third, apply any relocations to the unwind table. */
7065 for (relsec
= section_headers
;
7066 relsec
< section_headers
+ elf_header
.e_shnum
;
7069 if (relsec
->sh_type
!= SHT_RELA
7070 || relsec
->sh_info
>= elf_header
.e_shnum
7071 || section_headers
+ relsec
->sh_info
!= sec
)
7074 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7078 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7080 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7081 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7083 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7084 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7086 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7090 i
= rp
->r_offset
/ unw_ent_size
;
7092 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7095 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7096 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7099 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7100 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7110 aux
->table_len
= nentries
;
7116 hppa_process_unwind (FILE * file
)
7118 struct hppa_unw_aux_info aux
;
7119 Elf_Internal_Shdr
* unwsec
= NULL
;
7120 Elf_Internal_Shdr
* strsec
;
7121 Elf_Internal_Shdr
* sec
;
7124 if (string_table
== NULL
)
7127 memset (& aux
, 0, sizeof (aux
));
7129 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7131 if (sec
->sh_type
== SHT_SYMTAB
7132 && sec
->sh_link
< elf_header
.e_shnum
)
7134 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7136 strsec
= section_headers
+ sec
->sh_link
;
7137 if (aux
.strtab
!= NULL
)
7139 error (_("Multiple auxillary string tables encountered\n"));
7142 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7145 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7147 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7152 printf (_("\nThere are no unwind sections in this file.\n"));
7154 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7156 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7158 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7159 printable_section_name (sec
),
7160 (unsigned long) sec
->sh_offset
,
7161 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7163 slurp_hppa_unwind_table (file
, &aux
, sec
);
7164 if (aux
.table_len
> 0)
7165 dump_hppa_unwind (&aux
);
7168 free ((char *) aux
.table
);
7176 free ((char *) aux
.strtab
);
7181 unsigned char * data
; /* The unwind data. */
7182 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7183 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7184 unsigned long nrelas
; /* The number of relocations. */
7185 unsigned int rel_type
; /* REL or RELA ? */
7186 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7189 struct arm_unw_aux_info
7191 FILE * file
; /* The file containing the unwind sections. */
7192 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7193 unsigned long nsyms
; /* Number of symbols. */
7194 char * strtab
; /* The file's string table. */
7195 unsigned long strtab_size
; /* Size of string table. */
7199 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7200 bfd_vma fn
, struct absaddr addr
)
7202 const char *procname
;
7205 if (addr
.section
== SHN_UNDEF
)
7208 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
7209 aux
->strtab_size
, addr
, &procname
,
7212 print_vma (fn
, PREFIX_HEX
);
7216 fputs (" <", stdout
);
7217 fputs (procname
, stdout
);
7220 printf ("+0x%lx", (unsigned long) sym_offset
);
7221 fputc ('>', stdout
);
7228 arm_free_section (struct arm_section
*arm_sec
)
7230 if (arm_sec
->data
!= NULL
)
7231 free (arm_sec
->data
);
7233 if (arm_sec
->rela
!= NULL
)
7234 free (arm_sec
->rela
);
7237 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7238 cached section and install SEC instead.
7239 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7240 and return its valued in * WORDP, relocating if necessary.
7241 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7242 relocation's offset in ADDR.
7243 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7244 into the string table of the symbol associated with the reloc. If no
7245 reloc was applied store -1 there.
7246 5) Return TRUE upon success, FALSE otherwise. */
7249 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7250 struct arm_section
* arm_sec
,
7251 Elf_Internal_Shdr
* sec
,
7252 bfd_vma word_offset
,
7253 unsigned int * wordp
,
7254 struct absaddr
* addr
,
7257 Elf_Internal_Rela
*rp
;
7258 Elf_Internal_Sym
*sym
;
7259 const char * relname
;
7261 bfd_boolean wrapped
;
7263 if (sec
== NULL
|| arm_sec
== NULL
)
7266 addr
->section
= SHN_UNDEF
;
7269 if (sym_name
!= NULL
)
7270 *sym_name
= (bfd_vma
) -1;
7272 /* If necessary, update the section cache. */
7273 if (sec
!= arm_sec
->sec
)
7275 Elf_Internal_Shdr
*relsec
;
7277 arm_free_section (arm_sec
);
7280 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7281 sec
->sh_size
, _("unwind data"));
7282 arm_sec
->rela
= NULL
;
7283 arm_sec
->nrelas
= 0;
7285 for (relsec
= section_headers
;
7286 relsec
< section_headers
+ elf_header
.e_shnum
;
7289 if (relsec
->sh_info
>= elf_header
.e_shnum
7290 || section_headers
+ relsec
->sh_info
!= sec
7291 /* PR 15745: Check the section type as well. */
7292 || (relsec
->sh_type
!= SHT_REL
7293 && relsec
->sh_type
!= SHT_RELA
))
7296 arm_sec
->rel_type
= relsec
->sh_type
;
7297 if (relsec
->sh_type
== SHT_REL
)
7299 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7301 & arm_sec
->rela
, & arm_sec
->nrelas
))
7304 else /* relsec->sh_type == SHT_RELA */
7306 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7308 & arm_sec
->rela
, & arm_sec
->nrelas
))
7314 arm_sec
->next_rela
= arm_sec
->rela
;
7317 /* If there is no unwind data we can do nothing. */
7318 if (arm_sec
->data
== NULL
)
7321 /* If the offset is invalid then fail. */
7322 if (word_offset
> sec
->sh_size
- 4)
7325 /* Get the word at the required offset. */
7326 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7328 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7329 if (arm_sec
->rela
== NULL
)
7335 /* Look through the relocs to find the one that applies to the provided offset. */
7337 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7339 bfd_vma prelval
, offset
;
7341 if (rp
->r_offset
> word_offset
&& !wrapped
)
7346 if (rp
->r_offset
> word_offset
)
7349 if (rp
->r_offset
& 3)
7351 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7352 (unsigned long) rp
->r_offset
);
7356 if (rp
->r_offset
< word_offset
)
7359 /* PR 17531: file: 027-161405-0.004 */
7360 if (aux
->symtab
== NULL
)
7363 if (arm_sec
->rel_type
== SHT_REL
)
7365 offset
= word
& 0x7fffffff;
7366 if (offset
& 0x40000000)
7367 offset
|= ~ (bfd_vma
) 0x7fffffff;
7369 else if (arm_sec
->rel_type
== SHT_RELA
)
7370 offset
= rp
->r_addend
;
7373 error (_("Unknown section relocation type %d encountered\n"),
7378 /* PR 17531 file: 027-1241568-0.004. */
7379 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7381 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7382 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7386 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7387 offset
+= sym
->st_value
;
7388 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7390 /* Check that we are processing the expected reloc type. */
7391 if (elf_header
.e_machine
== EM_ARM
)
7393 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7394 if (relname
== NULL
)
7396 warn (_("Skipping unknown ARM relocation type: %d\n"),
7397 (int) ELF32_R_TYPE (rp
->r_info
));
7401 if (streq (relname
, "R_ARM_NONE"))
7404 if (! streq (relname
, "R_ARM_PREL31"))
7406 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7410 else if (elf_header
.e_machine
== EM_TI_C6000
)
7412 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7413 if (relname
== NULL
)
7415 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7416 (int) ELF32_R_TYPE (rp
->r_info
));
7420 if (streq (relname
, "R_C6000_NONE"))
7423 if (! streq (relname
, "R_C6000_PREL31"))
7425 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7433 /* This function currently only supports ARM and TI unwinders. */
7434 warn (_("Only TI and ARM unwinders are currently supported\n"));
7438 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7439 addr
->section
= sym
->st_shndx
;
7440 addr
->offset
= offset
;
7443 * sym_name
= sym
->st_name
;
7448 arm_sec
->next_rela
= rp
;
7453 static const char *tic6x_unwind_regnames
[16] =
7455 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7456 "A14", "A13", "A12", "A11", "A10",
7457 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7461 decode_tic6x_unwind_regmask (unsigned int mask
)
7465 for (i
= 12; mask
; mask
>>= 1, i
--)
7469 fputs (tic6x_unwind_regnames
[i
], stdout
);
7471 fputs (", ", stdout
);
7477 if (remaining == 0 && more_words) \
7480 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7481 data_offset, & word, & addr, NULL)) \
7487 #define GET_OP(OP) \
7492 (OP) = word >> 24; \
7497 printf (_("[Truncated opcode]\n")); \
7500 printf ("0x%02x ", OP)
7503 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7504 unsigned int word
, unsigned int remaining
,
7505 unsigned int more_words
,
7506 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7507 struct arm_section
*data_arm_sec
)
7509 struct absaddr addr
;
7511 /* Decode the unwinding instructions. */
7514 unsigned int op
, op2
;
7523 printf (" 0x%02x ", op
);
7525 if ((op
& 0xc0) == 0x00)
7527 int offset
= ((op
& 0x3f) << 2) + 4;
7529 printf (" vsp = vsp + %d", offset
);
7531 else if ((op
& 0xc0) == 0x40)
7533 int offset
= ((op
& 0x3f) << 2) + 4;
7535 printf (" vsp = vsp - %d", offset
);
7537 else if ((op
& 0xf0) == 0x80)
7540 if (op
== 0x80 && op2
== 0)
7541 printf (_("Refuse to unwind"));
7544 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7549 for (i
= 0; i
< 12; i
++)
7550 if (mask
& (1 << i
))
7556 printf ("r%d", 4 + i
);
7561 else if ((op
& 0xf0) == 0x90)
7563 if (op
== 0x9d || op
== 0x9f)
7564 printf (_(" [Reserved]"));
7566 printf (" vsp = r%d", op
& 0x0f);
7568 else if ((op
& 0xf0) == 0xa0)
7570 int end
= 4 + (op
& 0x07);
7575 for (i
= 4; i
<= end
; i
++)
7591 else if (op
== 0xb0)
7592 printf (_(" finish"));
7593 else if (op
== 0xb1)
7596 if (op2
== 0 || (op2
& 0xf0) != 0)
7597 printf (_("[Spare]"));
7600 unsigned int mask
= op2
& 0x0f;
7605 for (i
= 0; i
< 12; i
++)
7606 if (mask
& (1 << i
))
7617 else if (op
== 0xb2)
7619 unsigned char buf
[9];
7620 unsigned int i
, len
;
7621 unsigned long offset
;
7623 for (i
= 0; i
< sizeof (buf
); i
++)
7626 if ((buf
[i
] & 0x80) == 0)
7629 if (i
== sizeof (buf
))
7630 printf (_("corrupt change to vsp"));
7633 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7634 assert (len
== i
+ 1);
7635 offset
= offset
* 4 + 0x204;
7636 printf ("vsp = vsp + %ld", offset
);
7639 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7641 unsigned int first
, last
;
7648 printf ("pop {D%d", first
);
7650 printf ("-D%d", first
+ last
);
7653 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7655 unsigned int count
= op
& 0x07;
7659 printf ("-D%d", 8 + count
);
7662 else if (op
>= 0xc0 && op
<= 0xc5)
7664 unsigned int count
= op
& 0x07;
7666 printf (" pop {wR10");
7668 printf ("-wR%d", 10 + count
);
7671 else if (op
== 0xc6)
7673 unsigned int first
, last
;
7678 printf ("pop {wR%d", first
);
7680 printf ("-wR%d", first
+ last
);
7683 else if (op
== 0xc7)
7686 if (op2
== 0 || (op2
& 0xf0) != 0)
7687 printf (_("[Spare]"));
7690 unsigned int mask
= op2
& 0x0f;
7695 for (i
= 0; i
< 4; i
++)
7696 if (mask
& (1 << i
))
7702 printf ("wCGR%d", i
);
7708 printf (_(" [unsupported opcode]"));
7714 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7715 unsigned int word
, unsigned int remaining
,
7716 unsigned int more_words
,
7717 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7718 struct arm_section
*data_arm_sec
)
7720 struct absaddr addr
;
7722 /* Decode the unwinding instructions. */
7725 unsigned int op
, op2
;
7734 printf (" 0x%02x ", op
);
7736 if ((op
& 0xc0) == 0x00)
7738 int offset
= ((op
& 0x3f) << 3) + 8;
7739 printf (" sp = sp + %d", offset
);
7741 else if ((op
& 0xc0) == 0x80)
7744 if (op
== 0x80 && op2
== 0)
7745 printf (_("Refuse to unwind"));
7748 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7750 printf ("pop compact {");
7754 decode_tic6x_unwind_regmask (mask
);
7758 else if ((op
& 0xf0) == 0xc0)
7766 unsigned int offset
;
7770 /* Scan entire instruction first so that GET_OP output is not
7771 interleaved with disassembly. */
7773 for (i
= 0; nregs
< (op
& 0xf); i
++)
7779 regpos
[nregs
].offset
= i
* 2;
7780 regpos
[nregs
].reg
= reg
;
7787 regpos
[nregs
].offset
= i
* 2 + 1;
7788 regpos
[nregs
].reg
= reg
;
7793 printf (_("pop frame {"));
7795 for (i
= i
* 2; i
> 0; i
--)
7797 if (regpos
[reg
].offset
== i
- 1)
7799 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7806 fputs (name
, stdout
);
7813 else if (op
== 0xd0)
7814 printf (" MOV FP, SP");
7815 else if (op
== 0xd1)
7816 printf (" __c6xabi_pop_rts");
7817 else if (op
== 0xd2)
7819 unsigned char buf
[9];
7820 unsigned int i
, len
;
7821 unsigned long offset
;
7823 for (i
= 0; i
< sizeof (buf
); i
++)
7826 if ((buf
[i
] & 0x80) == 0)
7829 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7830 if (i
== sizeof (buf
))
7832 printf ("<corrupt sp adjust>\n");
7833 warn (_("Corrupt stack pointer adjustment detected\n"));
7837 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7838 assert (len
== i
+ 1);
7839 offset
= offset
* 8 + 0x408;
7840 printf (_("sp = sp + %ld"), offset
);
7842 else if ((op
& 0xf0) == 0xe0)
7844 if ((op
& 0x0f) == 7)
7847 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7851 printf (_(" [unsupported opcode]"));
7858 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7862 offset
= word
& 0x7fffffff;
7863 if (offset
& 0x40000000)
7864 offset
|= ~ (bfd_vma
) 0x7fffffff;
7866 if (elf_header
.e_machine
== EM_TI_C6000
)
7869 return offset
+ where
;
7873 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7875 unsigned int remaining
,
7876 bfd_vma data_offset
,
7877 Elf_Internal_Shdr
* data_sec
,
7878 struct arm_section
* data_arm_sec
)
7881 unsigned int more_words
= 0;
7882 struct absaddr addr
;
7883 bfd_vma sym_name
= (bfd_vma
) -1;
7887 /* Fetch the first word.
7888 Note - when decoding an object file the address extracted
7889 here will always be 0. So we also pass in the sym_name
7890 parameter so that we can find the symbol associated with
7891 the personality routine. */
7892 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7893 & word
, & addr
, & sym_name
))
7899 if ((word
& 0x80000000) == 0)
7901 /* Expand prel31 for personality routine. */
7903 const char *procname
;
7905 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7906 printf (_(" Personality routine: "));
7908 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7909 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7911 procname
= aux
->strtab
+ sym_name
;
7912 print_vma (fn
, PREFIX_HEX
);
7915 fputs (" <", stdout
);
7916 fputs (procname
, stdout
);
7917 fputc ('>', stdout
);
7921 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7922 fputc ('\n', stdout
);
7924 /* The GCC personality routines use the standard compact
7925 encoding, starting with one byte giving the number of
7927 if (procname
!= NULL
7928 && (const_strneq (procname
, "__gcc_personality_v0")
7929 || const_strneq (procname
, "__gxx_personality_v0")
7930 || const_strneq (procname
, "__gcj_personality_v0")
7931 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7938 printf (_(" [Truncated data]\n"));
7941 more_words
= word
>> 24;
7951 /* ARM EHABI Section 6.3:
7953 An exception-handling table entry for the compact model looks like:
7957 1 0 index Data for personalityRoutine[index] */
7959 if (elf_header
.e_machine
== EM_ARM
7960 && (word
& 0x70000000))
7961 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7963 per_index
= (word
>> 24) & 0x7f;
7964 printf (_(" Compact model index: %d\n"), per_index
);
7971 else if (per_index
< 3)
7973 more_words
= (word
>> 16) & 0xff;
7979 switch (elf_header
.e_machine
)
7984 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7985 data_offset
, data_sec
, data_arm_sec
);
7989 warn (_("Unknown ARM compact model index encountered\n"));
7990 printf (_(" [reserved]\n"));
7997 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7998 data_offset
, data_sec
, data_arm_sec
);
8000 else if (per_index
< 5)
8002 if (((word
>> 17) & 0x7f) == 0x7f)
8003 printf (_(" Restore stack from frame pointer\n"));
8005 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8006 printf (_(" Registers restored: "));
8008 printf (" (compact) ");
8009 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8011 printf (_(" Return register: %s\n"),
8012 tic6x_unwind_regnames
[word
& 0xf]);
8015 printf (_(" [reserved (%d)]\n"), per_index
);
8019 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8020 elf_header
.e_machine
);
8023 /* Decode the descriptors. Not implemented. */
8027 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8029 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8030 unsigned int i
, exidx_len
;
8032 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8033 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8034 exidx_len
= exidx_sec
->sh_size
/ 8;
8036 for (i
= 0; i
< exidx_len
; i
++)
8038 unsigned int exidx_fn
, exidx_entry
;
8039 struct absaddr fn_addr
, entry_addr
;
8042 fputc ('\n', stdout
);
8044 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8045 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8046 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8047 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8049 arm_free_section (& exidx_arm_sec
);
8050 arm_free_section (& extab_arm_sec
);
8054 /* ARM EHABI, Section 5:
8055 An index table entry consists of 2 words.
8056 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8057 if (exidx_fn
& 0x80000000)
8058 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8060 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8062 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8063 fputs (": ", stdout
);
8065 if (exidx_entry
== 1)
8067 print_vma (exidx_entry
, PREFIX_HEX
);
8068 fputs (" [cantunwind]\n", stdout
);
8070 else if (exidx_entry
& 0x80000000)
8072 print_vma (exidx_entry
, PREFIX_HEX
);
8073 fputc ('\n', stdout
);
8074 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8078 bfd_vma table
, table_offset
= 0;
8079 Elf_Internal_Shdr
*table_sec
;
8081 fputs ("@", stdout
);
8082 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8083 print_vma (table
, PREFIX_HEX
);
8086 /* Locate the matching .ARM.extab. */
8087 if (entry_addr
.section
!= SHN_UNDEF
8088 && entry_addr
.section
< elf_header
.e_shnum
)
8090 table_sec
= section_headers
+ entry_addr
.section
;
8091 table_offset
= entry_addr
.offset
;
8095 table_sec
= find_section_by_address (table
);
8096 if (table_sec
!= NULL
)
8097 table_offset
= table
- table_sec
->sh_addr
;
8099 if (table_sec
== NULL
)
8101 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8102 (unsigned long) table
);
8105 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8112 arm_free_section (&exidx_arm_sec
);
8113 arm_free_section (&extab_arm_sec
);
8116 /* Used for both ARM and C6X unwinding tables. */
8119 arm_process_unwind (FILE *file
)
8121 struct arm_unw_aux_info aux
;
8122 Elf_Internal_Shdr
*unwsec
= NULL
;
8123 Elf_Internal_Shdr
*strsec
;
8124 Elf_Internal_Shdr
*sec
;
8126 unsigned int sec_type
;
8128 switch (elf_header
.e_machine
)
8131 sec_type
= SHT_ARM_EXIDX
;
8135 sec_type
= SHT_C6000_UNWIND
;
8139 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8140 elf_header
.e_machine
);
8144 if (string_table
== NULL
)
8147 memset (& aux
, 0, sizeof (aux
));
8150 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8152 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8154 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8156 strsec
= section_headers
+ sec
->sh_link
;
8158 /* PR binutils/17531 file: 011-12666-0.004. */
8159 if (aux
.strtab
!= NULL
)
8161 error (_("Multiple string tables found in file.\n"));
8164 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8165 1, strsec
->sh_size
, _("string table"));
8166 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8168 else if (sec
->sh_type
== sec_type
)
8173 printf (_("\nThere are no unwind sections in this file.\n"));
8175 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8177 if (sec
->sh_type
== sec_type
)
8179 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8180 printable_section_name (sec
),
8181 (unsigned long) sec
->sh_offset
,
8182 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8184 dump_arm_unwind (&aux
, sec
);
8191 free ((char *) aux
.strtab
);
8195 process_unwind (FILE * file
)
8197 struct unwind_handler
8200 void (* handler
)(FILE *);
8203 { EM_ARM
, arm_process_unwind
},
8204 { EM_IA_64
, ia64_process_unwind
},
8205 { EM_PARISC
, hppa_process_unwind
},
8206 { EM_TI_C6000
, arm_process_unwind
},
8214 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8215 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8217 handlers
[i
].handler (file
);
8221 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8222 get_machine_name (elf_header
.e_machine
));
8226 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8228 switch (entry
->d_tag
)
8231 if (entry
->d_un
.d_val
== 0)
8235 static const char * opts
[] =
8237 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8238 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8239 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8240 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8246 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8247 if (entry
->d_un
.d_val
& (1 << cnt
))
8249 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8255 case DT_MIPS_IVERSION
:
8256 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8257 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8261 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8262 /* Note: coded this way so that there is a single string for translation. */
8263 printf (_("<corrupt: %s>"), buf
);
8267 case DT_MIPS_TIME_STAMP
:
8271 time_t atime
= entry
->d_un
.d_val
;
8273 tmp
= gmtime (&atime
);
8274 /* PR 17531: file: 6accc532. */
8276 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8278 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8279 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8280 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8281 printf (_("Time Stamp: %s"), timebuf
);
8285 case DT_MIPS_RLD_VERSION
:
8286 case DT_MIPS_LOCAL_GOTNO
:
8287 case DT_MIPS_CONFLICTNO
:
8288 case DT_MIPS_LIBLISTNO
:
8289 case DT_MIPS_SYMTABNO
:
8290 case DT_MIPS_UNREFEXTNO
:
8291 case DT_MIPS_HIPAGENO
:
8292 case DT_MIPS_DELTA_CLASS_NO
:
8293 case DT_MIPS_DELTA_INSTANCE_NO
:
8294 case DT_MIPS_DELTA_RELOC_NO
:
8295 case DT_MIPS_DELTA_SYM_NO
:
8296 case DT_MIPS_DELTA_CLASSSYM_NO
:
8297 case DT_MIPS_COMPACT_SIZE
:
8298 print_vma (entry
->d_un
.d_ptr
, DEC
);
8302 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8308 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8310 switch (entry
->d_tag
)
8312 case DT_HP_DLD_FLAGS
:
8321 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8322 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8323 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8324 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8325 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8326 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8327 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8328 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8329 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8330 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8331 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8332 { DT_HP_GST
, "HP_GST" },
8333 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8334 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8335 { DT_HP_NODELETE
, "HP_NODELETE" },
8336 { DT_HP_GROUP
, "HP_GROUP" },
8337 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8341 bfd_vma val
= entry
->d_un
.d_val
;
8343 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8344 if (val
& flags
[cnt
].bit
)
8348 fputs (flags
[cnt
].str
, stdout
);
8350 val
^= flags
[cnt
].bit
;
8353 if (val
!= 0 || first
)
8357 print_vma (val
, HEX
);
8363 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8371 /* VMS vs Unix time offset and factor. */
8373 #define VMS_EPOCH_OFFSET 35067168000000000LL
8374 #define VMS_GRANULARITY_FACTOR 10000000
8376 /* Display a VMS time in a human readable format. */
8379 print_vms_time (bfd_int64_t vmstime
)
8384 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8385 tm
= gmtime (&unxtime
);
8386 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8387 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8388 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8393 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8395 switch (entry
->d_tag
)
8397 case DT_IA_64_PLT_RESERVE
:
8398 /* First 3 slots reserved. */
8399 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8401 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8404 case DT_IA_64_VMS_LINKTIME
:
8406 print_vms_time (entry
->d_un
.d_val
);
8410 case DT_IA_64_VMS_LNKFLAGS
:
8411 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8412 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8413 printf (" CALL_DEBUG");
8414 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8415 printf (" NOP0BUFS");
8416 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8417 printf (" P0IMAGE");
8418 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8419 printf (" MKTHREADS");
8420 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8421 printf (" UPCALLS");
8422 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8424 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8425 printf (" INITIALIZE");
8426 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8428 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8429 printf (" EXE_INIT");
8430 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8431 printf (" TBK_IN_IMG");
8432 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8433 printf (" DBG_IN_IMG");
8434 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8435 printf (" TBK_IN_DSF");
8436 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8437 printf (" DBG_IN_DSF");
8438 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8439 printf (" SIGNATURES");
8440 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8441 printf (" REL_SEG_OFF");
8445 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8452 get_32bit_dynamic_section (FILE * file
)
8454 Elf32_External_Dyn
* edyn
;
8455 Elf32_External_Dyn
* ext
;
8456 Elf_Internal_Dyn
* entry
;
8458 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8459 dynamic_size
, _("dynamic section"));
8463 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8464 might not have the luxury of section headers. Look for the DT_NULL
8465 terminator to determine the number of entries. */
8466 for (ext
= edyn
, dynamic_nent
= 0;
8467 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8471 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8475 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8477 if (dynamic_section
== NULL
)
8479 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8480 (unsigned long) dynamic_nent
);
8485 for (ext
= edyn
, entry
= dynamic_section
;
8486 entry
< dynamic_section
+ dynamic_nent
;
8489 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8490 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8499 get_64bit_dynamic_section (FILE * file
)
8501 Elf64_External_Dyn
* edyn
;
8502 Elf64_External_Dyn
* ext
;
8503 Elf_Internal_Dyn
* entry
;
8505 /* Read in the data. */
8506 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8507 dynamic_size
, _("dynamic section"));
8511 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8512 might not have the luxury of section headers. Look for the DT_NULL
8513 terminator to determine the number of entries. */
8514 for (ext
= edyn
, dynamic_nent
= 0;
8515 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8516 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8520 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8524 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8526 if (dynamic_section
== NULL
)
8528 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8529 (unsigned long) dynamic_nent
);
8534 /* Convert from external to internal formats. */
8535 for (ext
= edyn
, entry
= dynamic_section
;
8536 entry
< dynamic_section
+ dynamic_nent
;
8539 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8540 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8549 print_dynamic_flags (bfd_vma flags
)
8557 flag
= flags
& - flags
;
8567 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8568 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8569 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8570 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8571 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8572 default: fputs (_("unknown"), stdout
); break;
8578 /* Parse and display the contents of the dynamic section. */
8581 process_dynamic_section (FILE * file
)
8583 Elf_Internal_Dyn
* entry
;
8585 if (dynamic_size
== 0)
8588 printf (_("\nThere is no dynamic section in this file.\n"));
8595 if (! get_32bit_dynamic_section (file
))
8598 else if (! get_64bit_dynamic_section (file
))
8601 /* Find the appropriate symbol table. */
8602 if (dynamic_symbols
== NULL
)
8604 for (entry
= dynamic_section
;
8605 entry
< dynamic_section
+ dynamic_nent
;
8608 Elf_Internal_Shdr section
;
8610 if (entry
->d_tag
!= DT_SYMTAB
)
8613 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8615 /* Since we do not know how big the symbol table is,
8616 we default to reading in the entire file (!) and
8617 processing that. This is overkill, I know, but it
8619 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8621 if (archive_file_offset
!= 0)
8622 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8625 if (fseek (file
, 0, SEEK_END
))
8626 error (_("Unable to seek to end of file!\n"));
8628 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8632 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8634 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8635 section
.sh_name
= string_table_length
;
8637 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8638 if (num_dynamic_syms
< 1)
8640 error (_("Unable to determine the number of symbols to load\n"));
8646 /* Similarly find a string table. */
8647 if (dynamic_strings
== NULL
)
8649 for (entry
= dynamic_section
;
8650 entry
< dynamic_section
+ dynamic_nent
;
8653 unsigned long offset
;
8656 if (entry
->d_tag
!= DT_STRTAB
)
8659 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8661 /* Since we do not know how big the string table is,
8662 we default to reading in the entire file (!) and
8663 processing that. This is overkill, I know, but it
8666 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8668 if (archive_file_offset
!= 0)
8669 str_tab_len
= archive_file_size
- offset
;
8672 if (fseek (file
, 0, SEEK_END
))
8673 error (_("Unable to seek to end of file\n"));
8674 str_tab_len
= ftell (file
) - offset
;
8677 if (str_tab_len
< 1)
8680 (_("Unable to determine the length of the dynamic string table\n"));
8684 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8686 _("dynamic string table"));
8687 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8692 /* And find the syminfo section if available. */
8693 if (dynamic_syminfo
== NULL
)
8695 unsigned long syminsz
= 0;
8697 for (entry
= dynamic_section
;
8698 entry
< dynamic_section
+ dynamic_nent
;
8701 if (entry
->d_tag
== DT_SYMINENT
)
8703 /* Note: these braces are necessary to avoid a syntax
8704 error from the SunOS4 C compiler. */
8705 /* PR binutils/17531: A corrupt file can trigger this test.
8706 So do not use an assert, instead generate an error message. */
8707 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8708 error (_("Bad value (%d) for SYMINENT entry\n"),
8709 (int) entry
->d_un
.d_val
);
8711 else if (entry
->d_tag
== DT_SYMINSZ
)
8712 syminsz
= entry
->d_un
.d_val
;
8713 else if (entry
->d_tag
== DT_SYMINFO
)
8714 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8718 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8720 Elf_External_Syminfo
* extsyminfo
;
8721 Elf_External_Syminfo
* extsym
;
8722 Elf_Internal_Syminfo
* syminfo
;
8724 /* There is a syminfo section. Read the data. */
8725 extsyminfo
= (Elf_External_Syminfo
*)
8726 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8727 _("symbol information"));
8731 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8732 if (dynamic_syminfo
== NULL
)
8734 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8735 (unsigned long) syminsz
);
8739 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8740 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8741 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8742 ++syminfo
, ++extsym
)
8744 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8745 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8752 if (do_dynamic
&& dynamic_addr
)
8753 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8754 dynamic_addr
, (unsigned long) dynamic_nent
);
8756 printf (_(" Tag Type Name/Value\n"));
8758 for (entry
= dynamic_section
;
8759 entry
< dynamic_section
+ dynamic_nent
;
8767 print_vma (entry
->d_tag
, FULL_HEX
);
8768 dtype
= get_dynamic_type (entry
->d_tag
);
8769 printf (" (%s)%*s", dtype
,
8770 ((is_32bit_elf
? 27 : 19)
8771 - (int) strlen (dtype
)),
8775 switch (entry
->d_tag
)
8779 print_dynamic_flags (entry
->d_un
.d_val
);
8789 switch (entry
->d_tag
)
8792 printf (_("Auxiliary library"));
8796 printf (_("Filter library"));
8800 printf (_("Configuration file"));
8804 printf (_("Dependency audit library"));
8808 printf (_("Audit library"));
8812 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8813 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8817 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8826 printf (_("Flags:"));
8828 if (entry
->d_un
.d_val
== 0)
8829 printf (_(" None\n"));
8832 unsigned long int val
= entry
->d_un
.d_val
;
8834 if (val
& DTF_1_PARINIT
)
8836 printf (" PARINIT");
8837 val
^= DTF_1_PARINIT
;
8839 if (val
& DTF_1_CONFEXP
)
8841 printf (" CONFEXP");
8842 val
^= DTF_1_CONFEXP
;
8845 printf (" %lx", val
);
8854 printf (_("Flags:"));
8856 if (entry
->d_un
.d_val
== 0)
8857 printf (_(" None\n"));
8860 unsigned long int val
= entry
->d_un
.d_val
;
8862 if (val
& DF_P1_LAZYLOAD
)
8864 printf (" LAZYLOAD");
8865 val
^= DF_P1_LAZYLOAD
;
8867 if (val
& DF_P1_GROUPPERM
)
8869 printf (" GROUPPERM");
8870 val
^= DF_P1_GROUPPERM
;
8873 printf (" %lx", val
);
8882 printf (_("Flags:"));
8883 if (entry
->d_un
.d_val
== 0)
8884 printf (_(" None\n"));
8887 unsigned long int val
= entry
->d_un
.d_val
;
8894 if (val
& DF_1_GLOBAL
)
8899 if (val
& DF_1_GROUP
)
8904 if (val
& DF_1_NODELETE
)
8906 printf (" NODELETE");
8907 val
^= DF_1_NODELETE
;
8909 if (val
& DF_1_LOADFLTR
)
8911 printf (" LOADFLTR");
8912 val
^= DF_1_LOADFLTR
;
8914 if (val
& DF_1_INITFIRST
)
8916 printf (" INITFIRST");
8917 val
^= DF_1_INITFIRST
;
8919 if (val
& DF_1_NOOPEN
)
8924 if (val
& DF_1_ORIGIN
)
8929 if (val
& DF_1_DIRECT
)
8934 if (val
& DF_1_TRANS
)
8939 if (val
& DF_1_INTERPOSE
)
8941 printf (" INTERPOSE");
8942 val
^= DF_1_INTERPOSE
;
8944 if (val
& DF_1_NODEFLIB
)
8946 printf (" NODEFLIB");
8947 val
^= DF_1_NODEFLIB
;
8949 if (val
& DF_1_NODUMP
)
8954 if (val
& DF_1_CONFALT
)
8956 printf (" CONFALT");
8957 val
^= DF_1_CONFALT
;
8959 if (val
& DF_1_ENDFILTEE
)
8961 printf (" ENDFILTEE");
8962 val
^= DF_1_ENDFILTEE
;
8964 if (val
& DF_1_DISPRELDNE
)
8966 printf (" DISPRELDNE");
8967 val
^= DF_1_DISPRELDNE
;
8969 if (val
& DF_1_DISPRELPND
)
8971 printf (" DISPRELPND");
8972 val
^= DF_1_DISPRELPND
;
8974 if (val
& DF_1_NODIRECT
)
8976 printf (" NODIRECT");
8977 val
^= DF_1_NODIRECT
;
8979 if (val
& DF_1_IGNMULDEF
)
8981 printf (" IGNMULDEF");
8982 val
^= DF_1_IGNMULDEF
;
8984 if (val
& DF_1_NOKSYMS
)
8986 printf (" NOKSYMS");
8987 val
^= DF_1_NOKSYMS
;
8989 if (val
& DF_1_NOHDR
)
8994 if (val
& DF_1_EDITED
)
8999 if (val
& DF_1_NORELOC
)
9001 printf (" NORELOC");
9002 val
^= DF_1_NORELOC
;
9004 if (val
& DF_1_SYMINTPOSE
)
9006 printf (" SYMINTPOSE");
9007 val
^= DF_1_SYMINTPOSE
;
9009 if (val
& DF_1_GLOBAUDIT
)
9011 printf (" GLOBAUDIT");
9012 val
^= DF_1_GLOBAUDIT
;
9014 if (val
& DF_1_SINGLETON
)
9016 printf (" SINGLETON");
9017 val
^= DF_1_SINGLETON
;
9020 printf (" %lx", val
);
9027 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9029 puts (get_dynamic_type (entry
->d_un
.d_val
));
9049 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9055 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9056 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9062 switch (entry
->d_tag
)
9065 printf (_("Shared library: [%s]"), name
);
9067 if (streq (name
, program_interpreter
))
9068 printf (_(" program interpreter"));
9072 printf (_("Library soname: [%s]"), name
);
9076 printf (_("Library rpath: [%s]"), name
);
9080 printf (_("Library runpath: [%s]"), name
);
9084 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9089 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9102 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9106 case DT_INIT_ARRAYSZ
:
9107 case DT_FINI_ARRAYSZ
:
9108 case DT_GNU_CONFLICTSZ
:
9109 case DT_GNU_LIBLISTSZ
:
9112 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9113 printf (_(" (bytes)\n"));
9123 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9136 if (entry
->d_tag
== DT_USED
9137 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9139 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9143 printf (_("Not needed object: [%s]\n"), name
);
9148 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9154 /* The value of this entry is ignored. */
9159 case DT_GNU_PRELINKED
:
9163 time_t atime
= entry
->d_un
.d_val
;
9165 tmp
= gmtime (&atime
);
9166 /* PR 17533 file: 041-1244816-0.004. */
9168 printf (_("<corrupt time val: %lx"),
9169 (unsigned long) atime
);
9171 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9172 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9173 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9179 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9182 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9188 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9189 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9194 switch (elf_header
.e_machine
)
9197 case EM_MIPS_RS3_LE
:
9198 dynamic_section_mips_val (entry
);
9201 dynamic_section_parisc_val (entry
);
9204 dynamic_section_ia64_val (entry
);
9207 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9219 get_ver_flags (unsigned int flags
)
9221 static char buff
[32];
9228 if (flags
& VER_FLG_BASE
)
9229 strcat (buff
, "BASE ");
9231 if (flags
& VER_FLG_WEAK
)
9233 if (flags
& VER_FLG_BASE
)
9234 strcat (buff
, "| ");
9236 strcat (buff
, "WEAK ");
9239 if (flags
& VER_FLG_INFO
)
9241 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9242 strcat (buff
, "| ");
9244 strcat (buff
, "INFO ");
9247 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9248 strcat (buff
, _("| <unknown>"));
9253 /* Display the contents of the version sections. */
9256 process_version_sections (FILE * file
)
9258 Elf_Internal_Shdr
* section
;
9265 for (i
= 0, section
= section_headers
;
9266 i
< elf_header
.e_shnum
;
9269 switch (section
->sh_type
)
9271 case SHT_GNU_verdef
:
9273 Elf_External_Verdef
* edefs
;
9280 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9281 printable_section_name (section
),
9284 printf (_(" Addr: 0x"));
9285 printf_vma (section
->sh_addr
);
9286 printf (_(" Offset: %#08lx Link: %u (%s)"),
9287 (unsigned long) section
->sh_offset
, section
->sh_link
,
9288 printable_section_name_from_index (section
->sh_link
));
9290 edefs
= (Elf_External_Verdef
*)
9291 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9292 _("version definition section"));
9295 endbuf
= (char *) edefs
+ section
->sh_size
;
9297 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9300 Elf_External_Verdef
* edef
;
9301 Elf_Internal_Verdef ent
;
9302 Elf_External_Verdaux
* eaux
;
9303 Elf_Internal_Verdaux aux
;
9307 /* Check for very large indicies. */
9308 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9311 vstart
= ((char *) edefs
) + idx
;
9312 if (vstart
+ sizeof (*edef
) > endbuf
)
9315 edef
= (Elf_External_Verdef
*) vstart
;
9317 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9318 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9319 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9320 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9321 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9322 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9323 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9325 printf (_(" %#06x: Rev: %d Flags: %s"),
9326 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9328 printf (_(" Index: %d Cnt: %d "),
9329 ent
.vd_ndx
, ent
.vd_cnt
);
9331 /* Check for overflow. */
9332 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9335 vstart
+= ent
.vd_aux
;
9337 eaux
= (Elf_External_Verdaux
*) vstart
;
9339 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9340 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9342 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9343 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9345 printf (_("Name index: %ld\n"), aux
.vda_name
);
9347 isum
= idx
+ ent
.vd_aux
;
9349 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9351 /* Check for overflow. */
9352 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9355 isum
+= aux
.vda_next
;
9356 vstart
+= aux
.vda_next
;
9358 eaux
= (Elf_External_Verdaux
*) vstart
;
9359 if (vstart
+ sizeof (*eaux
) > endbuf
)
9362 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9363 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9365 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9366 printf (_(" %#06x: Parent %d: %s\n"),
9367 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9369 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9370 isum
, j
, aux
.vda_name
);
9374 printf (_(" Version def aux past end of section\n"));
9376 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9377 if (idx
+ ent
.vd_next
<= idx
)
9383 if (cnt
< section
->sh_info
)
9384 printf (_(" Version definition past end of section\n"));
9390 case SHT_GNU_verneed
:
9392 Elf_External_Verneed
* eneed
;
9399 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9400 printable_section_name (section
), section
->sh_info
);
9402 printf (_(" Addr: 0x"));
9403 printf_vma (section
->sh_addr
);
9404 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9405 (unsigned long) section
->sh_offset
, section
->sh_link
,
9406 printable_section_name_from_index (section
->sh_link
));
9408 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9409 section
->sh_offset
, 1,
9411 _("Version Needs section"));
9414 endbuf
= (char *) eneed
+ section
->sh_size
;
9416 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9418 Elf_External_Verneed
* entry
;
9419 Elf_Internal_Verneed ent
;
9424 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9427 vstart
= ((char *) eneed
) + idx
;
9428 if (vstart
+ sizeof (*entry
) > endbuf
)
9431 entry
= (Elf_External_Verneed
*) vstart
;
9433 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9434 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9435 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9436 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9437 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9439 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9441 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9442 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9444 printf (_(" File: %lx"), ent
.vn_file
);
9446 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9448 /* Check for overflow. */
9449 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9451 vstart
+= ent
.vn_aux
;
9453 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9455 Elf_External_Vernaux
* eaux
;
9456 Elf_Internal_Vernaux aux
;
9458 if (vstart
+ sizeof (*eaux
) > endbuf
)
9460 eaux
= (Elf_External_Vernaux
*) vstart
;
9462 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9463 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9464 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9465 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9466 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9468 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9469 printf (_(" %#06x: Name: %s"),
9470 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9472 printf (_(" %#06x: Name index: %lx"),
9473 isum
, aux
.vna_name
);
9475 printf (_(" Flags: %s Version: %d\n"),
9476 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9478 /* Check for overflow. */
9479 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9480 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9482 warn (_("Invalid vna_next field of %lx\n"),
9487 isum
+= aux
.vna_next
;
9488 vstart
+= aux
.vna_next
;
9492 warn (_("Missing Version Needs auxillary information\n"));
9494 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9496 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9497 cnt
= section
->sh_info
;
9503 if (cnt
< section
->sh_info
)
9504 warn (_("Missing Version Needs information\n"));
9510 case SHT_GNU_versym
:
9512 Elf_Internal_Shdr
* link_section
;
9515 unsigned char * edata
;
9516 unsigned short * data
;
9518 Elf_Internal_Sym
* symbols
;
9519 Elf_Internal_Shdr
* string_sec
;
9520 unsigned long num_syms
;
9523 if (section
->sh_link
>= elf_header
.e_shnum
)
9526 link_section
= section_headers
+ section
->sh_link
;
9527 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9529 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9534 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9535 if (symbols
== NULL
)
9538 string_sec
= section_headers
+ link_section
->sh_link
;
9540 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9541 string_sec
->sh_size
,
9542 _("version string table"));
9549 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9550 printable_section_name (section
), (unsigned long) total
);
9552 printf (_(" Addr: "));
9553 printf_vma (section
->sh_addr
);
9554 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9555 (unsigned long) section
->sh_offset
, section
->sh_link
,
9556 printable_section_name (link_section
));
9558 off
= offset_from_vma (file
,
9559 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9560 total
* sizeof (short));
9561 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9563 _("version symbol data"));
9571 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9573 for (cnt
= total
; cnt
--;)
9574 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9579 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9582 int check_def
, check_need
;
9585 printf (" %03x:", cnt
);
9587 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9588 switch (data
[cnt
+ j
])
9591 fputs (_(" 0 (*local*) "), stdout
);
9595 fputs (_(" 1 (*global*) "), stdout
);
9599 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9600 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9602 /* If this index value is greater than the size of the symbols
9603 array, break to avoid an out-of-bounds read. */
9604 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9606 warn (_("invalid index into symbol array\n"));
9612 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9613 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9616 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9623 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9625 Elf_Internal_Verneed ivn
;
9626 unsigned long offset
;
9628 offset
= offset_from_vma
9629 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9630 sizeof (Elf_External_Verneed
));
9634 Elf_Internal_Vernaux ivna
;
9635 Elf_External_Verneed evn
;
9636 Elf_External_Vernaux evna
;
9637 unsigned long a_off
;
9639 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9640 _("version need")) == NULL
)
9643 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9644 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9646 a_off
= offset
+ ivn
.vn_aux
;
9650 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9651 1, _("version need aux (2)")) == NULL
)
9658 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9659 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9662 a_off
+= ivna
.vna_next
;
9664 while (ivna
.vna_other
!= data
[cnt
+ j
]
9665 && ivna
.vna_next
!= 0);
9667 if (ivna
.vna_other
== data
[cnt
+ j
])
9669 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9671 if (ivna
.vna_name
>= string_sec
->sh_size
)
9672 name
= _("*invalid*");
9674 name
= strtab
+ ivna
.vna_name
;
9675 nn
+= printf ("(%s%-*s",
9677 12 - (int) strlen (name
),
9683 offset
+= ivn
.vn_next
;
9685 while (ivn
.vn_next
);
9688 if (check_def
&& data
[cnt
+ j
] != 0x8001
9689 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9691 Elf_Internal_Verdef ivd
;
9692 Elf_External_Verdef evd
;
9693 unsigned long offset
;
9695 offset
= offset_from_vma
9696 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9701 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9702 _("version def")) == NULL
)
9705 /* PR 17531: file: 046-1082287-0.004. */
9706 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9711 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9712 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9715 offset
+= ivd
.vd_next
;
9717 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9718 && ivd
.vd_next
!= 0);
9720 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9722 Elf_External_Verdaux evda
;
9723 Elf_Internal_Verdaux ivda
;
9725 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9727 if (get_data (&evda
, file
,
9728 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9730 _("version def aux")) == NULL
)
9733 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9735 if (ivda
.vda_name
>= string_sec
->sh_size
)
9736 name
= _("*invalid*");
9738 name
= strtab
+ ivda
.vda_name
;
9739 nn
+= printf ("(%s%-*s",
9741 12 - (int) strlen (name
),
9747 printf ("%*c", 18 - nn
, ' ');
9765 printf (_("\nNo version information found in this file.\n"));
9771 get_symbol_binding (unsigned int binding
)
9773 static char buff
[32];
9777 case STB_LOCAL
: return "LOCAL";
9778 case STB_GLOBAL
: return "GLOBAL";
9779 case STB_WEAK
: return "WEAK";
9781 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9782 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9784 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9786 if (binding
== STB_GNU_UNIQUE
9787 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9788 /* GNU is still using the default value 0. */
9789 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9791 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9794 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9800 get_symbol_type (unsigned int type
)
9802 static char buff
[32];
9806 case STT_NOTYPE
: return "NOTYPE";
9807 case STT_OBJECT
: return "OBJECT";
9808 case STT_FUNC
: return "FUNC";
9809 case STT_SECTION
: return "SECTION";
9810 case STT_FILE
: return "FILE";
9811 case STT_COMMON
: return "COMMON";
9812 case STT_TLS
: return "TLS";
9813 case STT_RELC
: return "RELC";
9814 case STT_SRELC
: return "SRELC";
9816 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9818 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9819 return "THUMB_FUNC";
9821 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9824 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9825 return "PARISC_MILLI";
9827 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9829 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9831 if (elf_header
.e_machine
== EM_PARISC
)
9833 if (type
== STT_HP_OPAQUE
)
9835 if (type
== STT_HP_STUB
)
9839 if (type
== STT_GNU_IFUNC
9840 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9841 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9842 /* GNU is still using the default value 0. */
9843 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9846 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9849 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9855 get_symbol_visibility (unsigned int visibility
)
9859 case STV_DEFAULT
: return "DEFAULT";
9860 case STV_INTERNAL
: return "INTERNAL";
9861 case STV_HIDDEN
: return "HIDDEN";
9862 case STV_PROTECTED
: return "PROTECTED";
9864 error (_("Unrecognized visibility value: %u"), visibility
);
9865 return _("<unknown>");
9870 get_mips_symbol_other (unsigned int other
)
9882 case STO_MICROMIPS
| STO_MIPS_PIC
:
9883 return "MICROMIPS, MIPS PIC";
9892 get_ia64_symbol_other (unsigned int other
)
9896 static char res
[32];
9900 /* Function types is for images and .STB files only. */
9901 switch (elf_header
.e_type
)
9905 switch (VMS_ST_FUNC_TYPE (other
))
9907 case VMS_SFT_CODE_ADDR
:
9908 strcat (res
, " CA");
9910 case VMS_SFT_SYMV_IDX
:
9911 strcat (res
, " VEC");
9914 strcat (res
, " FD");
9916 case VMS_SFT_RESERVE
:
9917 strcat (res
, " RSV");
9920 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9921 VMS_ST_FUNC_TYPE (other
));
9922 strcat (res
, " <unknown>");
9929 switch (VMS_ST_LINKAGE (other
))
9931 case VMS_STL_IGNORE
:
9932 strcat (res
, " IGN");
9934 case VMS_STL_RESERVE
:
9935 strcat (res
, " RSV");
9938 strcat (res
, " STD");
9941 strcat (res
, " LNK");
9944 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9945 VMS_ST_LINKAGE (other
));
9946 strcat (res
, " <unknown>");
9959 get_ppc64_symbol_other (unsigned int other
)
9961 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9963 static char buf
[32];
9964 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9965 PPC64_LOCAL_ENTRY_OFFSET (other
));
9972 get_symbol_other (unsigned int other
)
9974 const char * result
= NULL
;
9975 static char buff
[32];
9980 switch (elf_header
.e_machine
)
9983 result
= get_mips_symbol_other (other
);
9986 result
= get_ia64_symbol_other (other
);
9989 result
= get_ppc64_symbol_other (other
);
9998 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10002 static const char *
10003 get_symbol_index_type (unsigned int type
)
10005 static char buff
[32];
10009 case SHN_UNDEF
: return "UND";
10010 case SHN_ABS
: return "ABS";
10011 case SHN_COMMON
: return "COM";
10013 if (type
== SHN_IA_64_ANSI_COMMON
10014 && elf_header
.e_machine
== EM_IA_64
10015 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10017 else if ((elf_header
.e_machine
== EM_X86_64
10018 || elf_header
.e_machine
== EM_L1OM
10019 || elf_header
.e_machine
== EM_K1OM
)
10020 && type
== SHN_X86_64_LCOMMON
)
10021 return "LARGE_COM";
10022 else if ((type
== SHN_MIPS_SCOMMON
10023 && elf_header
.e_machine
== EM_MIPS
)
10024 || (type
== SHN_TIC6X_SCOMMON
10025 && elf_header
.e_machine
== EM_TI_C6000
))
10027 else if (type
== SHN_MIPS_SUNDEFINED
10028 && elf_header
.e_machine
== EM_MIPS
)
10030 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10031 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10032 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10033 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10034 else if (type
>= SHN_LORESERVE
)
10035 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10036 else if (type
>= elf_header
.e_shnum
)
10037 sprintf (buff
, _("bad section index[%3d]"), type
);
10039 sprintf (buff
, "%3d", type
);
10047 get_dynamic_data (FILE * file
, size_t number
, unsigned int ent_size
)
10049 unsigned char * e_data
;
10052 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10053 attempting to allocate memory when the read is bound to fail. */
10054 if (ent_size
* number
> current_file_size
)
10056 error (_("Invalid number of dynamic entries: %lu\n"),
10057 (unsigned long) number
);
10061 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
10062 if (e_data
== NULL
)
10064 error (_("Out of memory reading %lu dynamic entries\n"),
10065 (unsigned long) number
);
10069 if (fread (e_data
, ent_size
, number
, file
) != number
)
10071 error (_("Unable to read in %lu bytes of dynamic data\n"),
10072 (unsigned long) (number
* ent_size
));
10077 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
10078 if (i_data
== NULL
)
10080 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10081 (unsigned long) number
);
10087 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10095 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10097 Elf_Internal_Sym
* psym
;
10100 n
= print_vma (si
, DEC_5
);
10102 fputs (&" "[n
], stdout
);
10103 printf (" %3lu: ", hn
);
10105 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10107 printf (_("<No info available for dynamic symbol number %lu>\n"),
10108 (unsigned long) si
);
10112 psym
= dynamic_symbols
+ si
;
10113 print_vma (psym
->st_value
, LONG_HEX
);
10115 print_vma (psym
->st_size
, DEC_5
);
10117 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10118 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10119 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10120 /* Check to see if any other bits in the st_other field are set.
10121 Note - displaying this information disrupts the layout of the
10122 table being generated, but for the moment this case is very
10124 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10125 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10126 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10127 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10128 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10130 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10134 static const char *
10135 get_symbol_version_string (FILE *file
, int is_dynsym
,
10136 const char *strtab
,
10137 unsigned long int strtab_size
,
10138 unsigned int si
, Elf_Internal_Sym
*psym
,
10139 enum versioned_symbol_info
*sym_info
,
10140 unsigned short *vna_other
)
10142 const char *version_string
= NULL
;
10145 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10147 unsigned char data
[2];
10148 unsigned short vers_data
;
10149 unsigned long offset
;
10153 offset
= offset_from_vma
10154 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10155 sizeof data
+ si
* sizeof (vers_data
));
10157 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10158 sizeof (data
), 1, _("version data")) == NULL
)
10161 vers_data
= byte_get (data
, 2);
10163 is_nobits
= (section_headers
!= NULL
10164 && psym
->st_shndx
< elf_header
.e_shnum
10165 && section_headers
[psym
->st_shndx
].sh_type
10168 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10170 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10172 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10173 && (is_nobits
|| ! check_def
))
10175 Elf_External_Verneed evn
;
10176 Elf_Internal_Verneed ivn
;
10177 Elf_Internal_Vernaux ivna
;
10179 /* We must test both. */
10180 offset
= offset_from_vma
10181 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10186 unsigned long vna_off
;
10188 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10189 _("version need")) == NULL
)
10192 ivna
.vna_other
= 0;
10197 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10198 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10200 vna_off
= offset
+ ivn
.vn_aux
;
10204 Elf_External_Vernaux evna
;
10206 if (get_data (&evna
, file
, vna_off
,
10208 _("version need aux (3)")) == NULL
)
10211 ivna
.vna_other
= 0;
10216 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10217 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10218 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10221 vna_off
+= ivna
.vna_next
;
10223 while (ivna
.vna_other
!= vers_data
10224 && ivna
.vna_next
!= 0);
10226 if (ivna
.vna_other
== vers_data
)
10229 offset
+= ivn
.vn_next
;
10231 while (ivn
.vn_next
!= 0);
10233 if (ivna
.vna_other
== vers_data
)
10235 *sym_info
= symbol_undefined
;
10236 *vna_other
= ivna
.vna_other
;
10237 version_string
= (ivna
.vna_name
< strtab_size
10238 ? strtab
+ ivna
.vna_name
10242 else if (! is_nobits
)
10243 error (_("bad dynamic symbol\n"));
10250 if (vers_data
!= 0x8001
10251 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10253 Elf_Internal_Verdef ivd
;
10254 Elf_Internal_Verdaux ivda
;
10255 Elf_External_Verdaux evda
;
10258 off
= offset_from_vma
10260 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10261 sizeof (Elf_External_Verdef
));
10265 Elf_External_Verdef evd
;
10267 if (get_data (&evd
, file
, off
, sizeof (evd
),
10268 1, _("version def")) == NULL
)
10276 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10277 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10278 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10281 off
+= ivd
.vd_next
;
10283 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10284 && ivd
.vd_next
!= 0);
10286 off
-= ivd
.vd_next
;
10289 if (get_data (&evda
, file
, off
, sizeof (evda
),
10290 1, _("version def aux")) == NULL
)
10291 return version_string
;
10293 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10295 if (psym
->st_name
!= ivda
.vda_name
)
10297 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10298 ? symbol_hidden
: symbol_public
);
10299 version_string
= (ivda
.vda_name
< strtab_size
10300 ? strtab
+ ivda
.vda_name
10307 return version_string
;
10310 /* Dump the symbol table. */
10312 process_symbol_table (FILE * file
)
10314 Elf_Internal_Shdr
* section
;
10315 bfd_size_type nbuckets
= 0;
10316 bfd_size_type nchains
= 0;
10317 bfd_vma
* buckets
= NULL
;
10318 bfd_vma
* chains
= NULL
;
10319 bfd_vma ngnubuckets
= 0;
10320 bfd_vma
* gnubuckets
= NULL
;
10321 bfd_vma
* gnuchains
= NULL
;
10322 bfd_vma gnusymidx
= 0;
10323 bfd_size_type ngnuchains
= 0;
10325 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10328 if (dynamic_info
[DT_HASH
]
10330 || (do_using_dynamic
10332 && dynamic_strings
!= NULL
)))
10334 unsigned char nb
[8];
10335 unsigned char nc
[8];
10336 unsigned int hash_ent_size
= 4;
10338 if ((elf_header
.e_machine
== EM_ALPHA
10339 || elf_header
.e_machine
== EM_S390
10340 || elf_header
.e_machine
== EM_S390_OLD
)
10341 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10345 (archive_file_offset
10346 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10347 sizeof nb
+ sizeof nc
)),
10350 error (_("Unable to seek to start of dynamic information\n"));
10354 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10356 error (_("Failed to read in number of buckets\n"));
10360 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10362 error (_("Failed to read in number of chains\n"));
10366 nbuckets
= byte_get (nb
, hash_ent_size
);
10367 nchains
= byte_get (nc
, hash_ent_size
);
10369 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10370 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10373 if (buckets
== NULL
|| chains
== NULL
)
10375 if (do_using_dynamic
)
10386 if (dynamic_info_DT_GNU_HASH
10388 || (do_using_dynamic
10390 && dynamic_strings
!= NULL
)))
10392 unsigned char nb
[16];
10393 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10394 bfd_vma buckets_vma
;
10397 (archive_file_offset
10398 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10402 error (_("Unable to seek to start of dynamic information\n"));
10406 if (fread (nb
, 16, 1, file
) != 1)
10408 error (_("Failed to read in number of buckets\n"));
10412 ngnubuckets
= byte_get (nb
, 4);
10413 gnusymidx
= byte_get (nb
+ 4, 4);
10414 bitmaskwords
= byte_get (nb
+ 8, 4);
10415 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10417 buckets_vma
+= bitmaskwords
* 4;
10419 buckets_vma
+= bitmaskwords
* 8;
10422 (archive_file_offset
10423 + offset_from_vma (file
, buckets_vma
, 4)),
10426 error (_("Unable to seek to start of dynamic information\n"));
10430 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10432 if (gnubuckets
== NULL
)
10435 for (i
= 0; i
< ngnubuckets
; i
++)
10436 if (gnubuckets
[i
] != 0)
10438 if (gnubuckets
[i
] < gnusymidx
)
10441 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10442 maxchain
= gnubuckets
[i
];
10445 if (maxchain
== 0xffffffff)
10448 maxchain
-= gnusymidx
;
10451 (archive_file_offset
10452 + offset_from_vma (file
, buckets_vma
10453 + 4 * (ngnubuckets
+ maxchain
), 4)),
10456 error (_("Unable to seek to start of dynamic information\n"));
10462 if (fread (nb
, 4, 1, file
) != 1)
10464 error (_("Failed to determine last chain length\n"));
10468 if (maxchain
+ 1 == 0)
10473 while ((byte_get (nb
, 4) & 1) == 0);
10476 (archive_file_offset
10477 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10480 error (_("Unable to seek to start of dynamic information\n"));
10484 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10485 ngnuchains
= maxchain
;
10488 if (gnuchains
== NULL
)
10493 if (do_using_dynamic
)
10498 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10500 && do_using_dynamic
10501 && dynamic_strings
!= NULL
10502 && dynamic_symbols
!= NULL
)
10506 if (dynamic_info
[DT_HASH
])
10510 printf (_("\nSymbol table for image:\n"));
10512 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10514 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10516 for (hn
= 0; hn
< nbuckets
; hn
++)
10521 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10522 print_dynamic_symbol (si
, hn
);
10526 if (dynamic_info_DT_GNU_HASH
)
10528 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10530 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10532 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10534 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10535 if (gnubuckets
[hn
] != 0)
10537 bfd_vma si
= gnubuckets
[hn
];
10538 bfd_vma off
= si
- gnusymidx
;
10542 print_dynamic_symbol (si
, hn
);
10545 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10549 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10550 && section_headers
!= NULL
)
10554 for (i
= 0, section
= section_headers
;
10555 i
< elf_header
.e_shnum
;
10559 char * strtab
= NULL
;
10560 unsigned long int strtab_size
= 0;
10561 Elf_Internal_Sym
* symtab
;
10562 Elf_Internal_Sym
* psym
;
10563 unsigned long num_syms
;
10565 if ((section
->sh_type
!= SHT_SYMTAB
10566 && section
->sh_type
!= SHT_DYNSYM
)
10568 && section
->sh_type
== SHT_SYMTAB
))
10571 if (section
->sh_entsize
== 0)
10573 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10574 printable_section_name (section
));
10578 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10579 printable_section_name (section
),
10580 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10583 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10585 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10587 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10588 if (symtab
== NULL
)
10591 if (section
->sh_link
== elf_header
.e_shstrndx
)
10593 strtab
= string_table
;
10594 strtab_size
= string_table_length
;
10596 else if (section
->sh_link
< elf_header
.e_shnum
)
10598 Elf_Internal_Shdr
* string_sec
;
10600 string_sec
= section_headers
+ section
->sh_link
;
10602 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10603 1, string_sec
->sh_size
,
10604 _("string table"));
10605 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10608 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10610 const char *version_string
;
10611 enum versioned_symbol_info sym_info
;
10612 unsigned short vna_other
;
10614 printf ("%6d: ", si
);
10615 print_vma (psym
->st_value
, LONG_HEX
);
10617 print_vma (psym
->st_size
, DEC_5
);
10618 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10619 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10620 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10621 /* Check to see if any other bits in the st_other field are set.
10622 Note - displaying this information disrupts the layout of the
10623 table being generated, but for the moment this case is very rare. */
10624 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10625 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10626 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10627 print_symbol (25, psym
->st_name
< strtab_size
10628 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10631 = get_symbol_version_string (file
,
10632 section
->sh_type
== SHT_DYNSYM
,
10633 strtab
, strtab_size
, si
,
10634 psym
, &sym_info
, &vna_other
);
10635 if (version_string
)
10637 if (sym_info
== symbol_undefined
)
10638 printf ("@%s (%d)", version_string
, vna_other
);
10640 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10648 if (strtab
!= string_table
)
10654 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10656 if (do_histogram
&& buckets
!= NULL
)
10658 unsigned long * lengths
;
10659 unsigned long * counts
;
10662 unsigned long maxlength
= 0;
10663 unsigned long nzero_counts
= 0;
10664 unsigned long nsyms
= 0;
10666 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10667 (unsigned long) nbuckets
);
10669 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10670 if (lengths
== NULL
)
10672 error (_("Out of memory allocating space for histogram buckets\n"));
10676 printf (_(" Length Number %% of total Coverage\n"));
10677 for (hn
= 0; hn
< nbuckets
; ++hn
)
10679 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10682 if (maxlength
< ++lengths
[hn
])
10685 /* PR binutils/17531: A corrupt binary could contain broken
10686 histogram data. Do not go into an infinite loop trying
10688 if (chains
[si
] == si
)
10690 error (_("histogram chain links to itself\n"));
10696 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10697 if (counts
== NULL
)
10700 error (_("Out of memory allocating space for histogram counts\n"));
10704 for (hn
= 0; hn
< nbuckets
; ++hn
)
10705 ++counts
[lengths
[hn
]];
10710 printf (" 0 %-10lu (%5.1f%%)\n",
10711 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10712 for (i
= 1; i
<= maxlength
; ++i
)
10714 nzero_counts
+= counts
[i
] * i
;
10715 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10716 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10717 (nzero_counts
* 100.0) / nsyms
);
10725 if (buckets
!= NULL
)
10731 if (do_histogram
&& gnubuckets
!= NULL
)
10733 unsigned long * lengths
;
10734 unsigned long * counts
;
10736 unsigned long maxlength
= 0;
10737 unsigned long nzero_counts
= 0;
10738 unsigned long nsyms
= 0;
10740 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10741 (unsigned long) ngnubuckets
);
10743 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10744 if (lengths
== NULL
)
10746 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10750 printf (_(" Length Number %% of total Coverage\n"));
10752 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10753 if (gnubuckets
[hn
] != 0)
10755 bfd_vma off
, length
= 1;
10757 for (off
= gnubuckets
[hn
] - gnusymidx
;
10758 /* PR 17531 file: 010-77222-0.004. */
10759 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10762 lengths
[hn
] = length
;
10763 if (length
> maxlength
)
10764 maxlength
= length
;
10768 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10769 if (counts
== NULL
)
10772 error (_("Out of memory allocating space for gnu histogram counts\n"));
10776 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10777 ++counts
[lengths
[hn
]];
10779 if (ngnubuckets
> 0)
10782 printf (" 0 %-10lu (%5.1f%%)\n",
10783 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10784 for (j
= 1; j
<= maxlength
; ++j
)
10786 nzero_counts
+= counts
[j
] * j
;
10787 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10788 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10789 (nzero_counts
* 100.0) / nsyms
);
10803 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10807 if (dynamic_syminfo
== NULL
10809 /* No syminfo, this is ok. */
10812 /* There better should be a dynamic symbol section. */
10813 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10817 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10818 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10820 printf (_(" Num: Name BoundTo Flags\n"));
10821 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10823 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10825 printf ("%4d: ", i
);
10826 if (i
>= num_dynamic_syms
)
10827 printf (_("<corrupt index>"));
10828 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10829 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10831 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10834 switch (dynamic_syminfo
[i
].si_boundto
)
10836 case SYMINFO_BT_SELF
:
10837 fputs ("SELF ", stdout
);
10839 case SYMINFO_BT_PARENT
:
10840 fputs ("PARENT ", stdout
);
10843 if (dynamic_syminfo
[i
].si_boundto
> 0
10844 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10845 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10847 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10851 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10855 if (flags
& SYMINFO_FLG_DIRECT
)
10856 printf (" DIRECT");
10857 if (flags
& SYMINFO_FLG_PASSTHRU
)
10858 printf (" PASSTHRU");
10859 if (flags
& SYMINFO_FLG_COPY
)
10861 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10862 printf (" LAZYLOAD");
10870 /* Check to see if the given reloc needs to be handled in a target specific
10871 manner. If so then process the reloc and return TRUE otherwise return
10875 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10876 unsigned char * start
,
10877 Elf_Internal_Sym
* symtab
)
10879 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10881 switch (elf_header
.e_machine
)
10884 case EM_MSP430_OLD
:
10886 static Elf_Internal_Sym
* saved_sym
= NULL
;
10888 switch (reloc_type
)
10890 case 10: /* R_MSP430_SYM_DIFF */
10891 if (uses_msp430x_relocs ())
10893 case 21: /* R_MSP430X_SYM_DIFF */
10894 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10897 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10898 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10899 goto handle_sym_diff
;
10901 case 5: /* R_MSP430_16_BYTE */
10902 case 9: /* R_MSP430_8 */
10903 if (uses_msp430x_relocs ())
10905 goto handle_sym_diff
;
10907 case 2: /* R_MSP430_ABS16 */
10908 case 15: /* R_MSP430X_ABS16 */
10909 if (! uses_msp430x_relocs ())
10911 goto handle_sym_diff
;
10914 if (saved_sym
!= NULL
)
10918 value
= reloc
->r_addend
10919 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10920 - saved_sym
->st_value
);
10922 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10930 if (saved_sym
!= NULL
)
10931 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10938 case EM_CYGNUS_MN10300
:
10940 static Elf_Internal_Sym
* saved_sym
= NULL
;
10942 switch (reloc_type
)
10944 case 34: /* R_MN10300_ALIGN */
10946 case 33: /* R_MN10300_SYM_DIFF */
10947 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10949 case 1: /* R_MN10300_32 */
10950 case 2: /* R_MN10300_16 */
10951 if (saved_sym
!= NULL
)
10955 value
= reloc
->r_addend
10956 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10957 - saved_sym
->st_value
);
10959 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10966 if (saved_sym
!= NULL
)
10967 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10977 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10978 DWARF debug sections. This is a target specific test. Note - we do not
10979 go through the whole including-target-headers-multiple-times route, (as
10980 we have already done with <elf/h8.h>) because this would become very
10981 messy and even then this function would have to contain target specific
10982 information (the names of the relocs instead of their numeric values).
10983 FIXME: This is not the correct way to solve this problem. The proper way
10984 is to have target specific reloc sizing and typing functions created by
10985 the reloc-macros.h header, in the same way that it already creates the
10986 reloc naming functions. */
10989 is_32bit_abs_reloc (unsigned int reloc_type
)
10991 switch (elf_header
.e_machine
)
10995 return reloc_type
== 1; /* R_386_32. */
10997 return reloc_type
== 1; /* R_68K_32. */
10999 return reloc_type
== 1; /* R_860_32. */
11001 return reloc_type
== 2; /* R_960_32. */
11003 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11005 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11007 return reloc_type
== 1; /* R_ARC_32. */
11009 return reloc_type
== 2; /* R_ARM_ABS32 */
11012 return reloc_type
== 1;
11013 case EM_ADAPTEVA_EPIPHANY
:
11014 return reloc_type
== 3;
11016 return reloc_type
== 0x12; /* R_byte4_data. */
11018 return reloc_type
== 3; /* R_CRIS_32. */
11020 return reloc_type
== 3; /* R_CR16_NUM32. */
11022 return reloc_type
== 15; /* R_CRX_NUM32. */
11023 case EM_CYGNUS_FRV
:
11024 return reloc_type
== 1;
11025 case EM_CYGNUS_D10V
:
11027 return reloc_type
== 6; /* R_D10V_32. */
11028 case EM_CYGNUS_D30V
:
11030 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11032 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11033 case EM_CYGNUS_FR30
:
11035 return reloc_type
== 3; /* R_FR30_32. */
11039 return reloc_type
== 1; /* R_H8_DIR32. */
11041 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
11044 return reloc_type
== 2; /* R_IP2K_32. */
11046 return reloc_type
== 2; /* R_IQ2000_32. */
11047 case EM_LATTICEMICO32
:
11048 return reloc_type
== 3; /* R_LM32_32. */
11051 return reloc_type
== 3; /* R_M32C_32. */
11053 return reloc_type
== 34; /* R_M32R_32_RELA. */
11055 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11056 case EM_CYGNUS_MEP
:
11057 return reloc_type
== 4; /* R_MEP_32. */
11059 return reloc_type
== 2; /* R_METAG_ADDR32. */
11060 case EM_MICROBLAZE
:
11061 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11063 return reloc_type
== 2; /* R_MIPS_32. */
11065 return reloc_type
== 4; /* R_MMIX_32. */
11066 case EM_CYGNUS_MN10200
:
11068 return reloc_type
== 1; /* R_MN10200_32. */
11069 case EM_CYGNUS_MN10300
:
11071 return reloc_type
== 1; /* R_MN10300_32. */
11073 return reloc_type
== 1; /* R_MOXIE_32. */
11074 case EM_MSP430_OLD
:
11076 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11078 return reloc_type
== 2; /* R_MT_32. */
11080 return reloc_type
== 20; /* R_NDS32_RELA. */
11081 case EM_ALTERA_NIOS2
:
11082 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11084 return reloc_type
== 1; /* R_NIOS_32. */
11086 return reloc_type
== 1; /* R_OR1K_32. */
11088 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11089 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11092 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11094 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11096 return reloc_type
== 1; /* R_PPC_ADDR32. */
11098 return reloc_type
== 1; /* R_RL78_DIR32. */
11100 return reloc_type
== 1; /* R_RX_DIR32. */
11102 return reloc_type
== 1; /* R_I370_ADDR31. */
11105 return reloc_type
== 4; /* R_S390_32. */
11107 return reloc_type
== 8; /* R_SCORE_ABS32. */
11109 return reloc_type
== 1; /* R_SH_DIR32. */
11110 case EM_SPARC32PLUS
:
11113 return reloc_type
== 3 /* R_SPARC_32. */
11114 || reloc_type
== 23; /* R_SPARC_UA32. */
11116 return reloc_type
== 6; /* R_SPU_ADDR32 */
11118 return reloc_type
== 1; /* R_C6000_ABS32. */
11120 return reloc_type
== 2; /* R_TILEGX_32. */
11122 return reloc_type
== 1; /* R_TILEPRO_32. */
11123 case EM_CYGNUS_V850
:
11125 return reloc_type
== 6; /* R_V850_ABS32. */
11127 return reloc_type
== 0x33; /* R_V810_WORD. */
11129 return reloc_type
== 1; /* R_VAX_32. */
11131 return reloc_type
== 3; /* R_VISIUM_32. */
11135 return reloc_type
== 10; /* R_X86_64_32. */
11138 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11140 return reloc_type
== 4; /* R_XGATE_32. */
11142 return reloc_type
== 1; /* R_XSTROMY16_32. */
11143 case EM_XTENSA_OLD
:
11145 return reloc_type
== 1; /* R_XTENSA_32. */
11148 static unsigned int prev_warn
= 0;
11150 /* Avoid repeating the same warning multiple times. */
11151 if (prev_warn
!= elf_header
.e_machine
)
11152 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11153 elf_header
.e_machine
);
11154 prev_warn
= elf_header
.e_machine
;
11160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11161 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11164 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11166 switch (elf_header
.e_machine
)
11170 return reloc_type
== 2; /* R_386_PC32. */
11172 return reloc_type
== 4; /* R_68K_PC32. */
11174 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11175 case EM_ADAPTEVA_EPIPHANY
:
11176 return reloc_type
== 6;
11178 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11180 return reloc_type
== 3; /* R_ARM_REL32 */
11181 case EM_MICROBLAZE
:
11182 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11184 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11186 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11188 return reloc_type
== 26; /* R_PPC_REL32. */
11190 return reloc_type
== 26; /* R_PPC64_REL32. */
11193 return reloc_type
== 5; /* R_390_PC32. */
11195 return reloc_type
== 2; /* R_SH_REL32. */
11196 case EM_SPARC32PLUS
:
11199 return reloc_type
== 6; /* R_SPARC_DISP32. */
11201 return reloc_type
== 13; /* R_SPU_REL32. */
11203 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11205 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11207 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11211 return reloc_type
== 2; /* R_X86_64_PC32. */
11212 case EM_XTENSA_OLD
:
11214 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11216 /* Do not abort or issue an error message here. Not all targets use
11217 pc-relative 32-bit relocs in their DWARF debug information and we
11218 have already tested for target coverage in is_32bit_abs_reloc. A
11219 more helpful warning message will be generated by apply_relocations
11220 anyway, so just return. */
11225 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11226 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11229 is_64bit_abs_reloc (unsigned int reloc_type
)
11231 switch (elf_header
.e_machine
)
11234 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11236 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11238 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11240 return reloc_type
== 80; /* R_PARISC_DIR64. */
11242 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11243 case EM_SPARC32PLUS
:
11246 return reloc_type
== 54; /* R_SPARC_UA64. */
11250 return reloc_type
== 1; /* R_X86_64_64. */
11253 return reloc_type
== 22; /* R_S390_64. */
11255 return reloc_type
== 1; /* R_TILEGX_64. */
11257 return reloc_type
== 18; /* R_MIPS_64. */
11263 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11264 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11267 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11269 switch (elf_header
.e_machine
)
11272 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11274 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11276 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11278 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11280 return reloc_type
== 44; /* R_PPC64_REL64. */
11281 case EM_SPARC32PLUS
:
11284 return reloc_type
== 46; /* R_SPARC_DISP64. */
11288 return reloc_type
== 24; /* R_X86_64_PC64. */
11291 return reloc_type
== 23; /* R_S390_PC64. */
11293 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11299 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11300 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11303 is_24bit_abs_reloc (unsigned int reloc_type
)
11305 switch (elf_header
.e_machine
)
11307 case EM_CYGNUS_MN10200
:
11309 return reloc_type
== 4; /* R_MN10200_24. */
11315 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11316 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11319 is_16bit_abs_reloc (unsigned int reloc_type
)
11321 switch (elf_header
.e_machine
)
11325 return reloc_type
== 4; /* R_AVR_16. */
11326 case EM_ADAPTEVA_EPIPHANY
:
11327 return reloc_type
== 5;
11328 case EM_CYGNUS_D10V
:
11330 return reloc_type
== 3; /* R_D10V_16. */
11334 return reloc_type
== R_H8_DIR16
;
11337 return reloc_type
== 1; /* R_IP2K_16. */
11340 return reloc_type
== 1; /* R_M32C_16 */
11342 if (uses_msp430x_relocs ())
11343 return reloc_type
== 2; /* R_MSP430_ABS16. */
11344 case EM_MSP430_OLD
:
11345 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11347 return reloc_type
== 19; /* R_NDS32_RELA. */
11348 case EM_ALTERA_NIOS2
:
11349 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11351 return reloc_type
== 9; /* R_NIOS_16. */
11353 return reloc_type
== 2; /* R_OR1K_16. */
11355 return reloc_type
== 2; /* R_C6000_ABS16. */
11358 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11359 case EM_CYGNUS_MN10200
:
11361 return reloc_type
== 2; /* R_MN10200_16. */
11362 case EM_CYGNUS_MN10300
:
11364 return reloc_type
== 2; /* R_MN10300_16. */
11366 return reloc_type
== 2; /* R_VISIUM_16. */
11368 return reloc_type
== 3; /* R_XGATE_16. */
11374 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11375 relocation entries (possibly formerly used for SHT_GROUP sections). */
11378 is_none_reloc (unsigned int reloc_type
)
11380 switch (elf_header
.e_machine
)
11382 case EM_68K
: /* R_68K_NONE. */
11383 case EM_386
: /* R_386_NONE. */
11384 case EM_SPARC32PLUS
:
11386 case EM_SPARC
: /* R_SPARC_NONE. */
11387 case EM_MIPS
: /* R_MIPS_NONE. */
11388 case EM_PARISC
: /* R_PARISC_NONE. */
11389 case EM_ALPHA
: /* R_ALPHA_NONE. */
11390 case EM_ADAPTEVA_EPIPHANY
:
11391 case EM_PPC
: /* R_PPC_NONE. */
11392 case EM_PPC64
: /* R_PPC64_NONE. */
11393 case EM_ARM
: /* R_ARM_NONE. */
11394 case EM_IA_64
: /* R_IA64_NONE. */
11395 case EM_SH
: /* R_SH_NONE. */
11397 case EM_S390
: /* R_390_NONE. */
11398 case EM_CRIS
: /* R_CRIS_NONE. */
11399 case EM_X86_64
: /* R_X86_64_NONE. */
11400 case EM_L1OM
: /* R_X86_64_NONE. */
11401 case EM_K1OM
: /* R_X86_64_NONE. */
11402 case EM_MN10300
: /* R_MN10300_NONE. */
11403 case EM_MOXIE
: /* R_MOXIE_NONE. */
11404 case EM_M32R
: /* R_M32R_NONE. */
11405 case EM_TI_C6000
:/* R_C6000_NONE. */
11406 case EM_TILEGX
: /* R_TILEGX_NONE. */
11407 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11409 case EM_C166
: /* R_XC16X_NONE. */
11410 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11411 case EM_NIOS32
: /* R_NIOS_NONE. */
11412 case EM_OR1K
: /* R_OR1K_NONE. */
11413 return reloc_type
== 0;
11415 return reloc_type
== 0 || reloc_type
== 256;
11417 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11418 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11419 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11420 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11421 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11422 case EM_XTENSA_OLD
:
11424 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11425 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11426 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11427 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11429 return reloc_type
== 3; /* R_METAG_NONE. */
11434 /* Apply relocations to a section.
11435 Note: So far support has been added only for those relocations
11436 which can be found in debug sections.
11437 FIXME: Add support for more relocations ? */
11440 apply_relocations (void * file
,
11441 Elf_Internal_Shdr
* section
,
11442 unsigned char * start
)
11444 Elf_Internal_Shdr
* relsec
;
11445 unsigned char * end
= start
+ section
->sh_size
;
11447 if (elf_header
.e_type
!= ET_REL
)
11450 /* Find the reloc section associated with the section. */
11451 for (relsec
= section_headers
;
11452 relsec
< section_headers
+ elf_header
.e_shnum
;
11455 bfd_boolean is_rela
;
11456 unsigned long num_relocs
;
11457 Elf_Internal_Rela
* relocs
;
11458 Elf_Internal_Rela
* rp
;
11459 Elf_Internal_Shdr
* symsec
;
11460 Elf_Internal_Sym
* symtab
;
11461 unsigned long num_syms
;
11462 Elf_Internal_Sym
* sym
;
11464 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11465 || relsec
->sh_info
>= elf_header
.e_shnum
11466 || section_headers
+ relsec
->sh_info
!= section
11467 || relsec
->sh_size
== 0
11468 || relsec
->sh_link
>= elf_header
.e_shnum
)
11471 is_rela
= relsec
->sh_type
== SHT_RELA
;
11475 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11476 relsec
->sh_size
, & relocs
, & num_relocs
))
11481 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11482 relsec
->sh_size
, & relocs
, & num_relocs
))
11486 /* SH uses RELA but uses in place value instead of the addend field. */
11487 if (elf_header
.e_machine
== EM_SH
)
11490 symsec
= section_headers
+ relsec
->sh_link
;
11491 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11493 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11496 unsigned int reloc_type
;
11497 unsigned int reloc_size
;
11498 unsigned char * rloc
;
11499 unsigned long sym_index
;
11501 reloc_type
= get_reloc_type (rp
->r_info
);
11503 if (target_specific_reloc_handling (rp
, start
, symtab
))
11505 else if (is_none_reloc (reloc_type
))
11507 else if (is_32bit_abs_reloc (reloc_type
)
11508 || is_32bit_pcrel_reloc (reloc_type
))
11510 else if (is_64bit_abs_reloc (reloc_type
)
11511 || is_64bit_pcrel_reloc (reloc_type
))
11513 else if (is_24bit_abs_reloc (reloc_type
))
11515 else if (is_16bit_abs_reloc (reloc_type
))
11519 static unsigned int prev_reloc
= 0;
11520 if (reloc_type
!= prev_reloc
)
11521 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11522 reloc_type
, printable_section_name (section
));
11523 prev_reloc
= reloc_type
;
11527 rloc
= start
+ rp
->r_offset
;
11528 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11530 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11531 (unsigned long) rp
->r_offset
,
11532 printable_section_name (section
));
11536 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11537 if (sym_index
>= num_syms
)
11539 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11540 sym_index
, printable_section_name (section
));
11543 sym
= symtab
+ sym_index
;
11545 /* If the reloc has a symbol associated with it,
11546 make sure that it is of an appropriate type.
11548 Relocations against symbols without type can happen.
11549 Gcc -feliminate-dwarf2-dups may generate symbols
11550 without type for debug info.
11552 Icc generates relocations against function symbols
11553 instead of local labels.
11555 Relocations against object symbols can happen, eg when
11556 referencing a global array. For an example of this see
11557 the _clz.o binary in libgcc.a. */
11559 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11561 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11562 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11563 (long int)(rp
- relocs
),
11564 printable_section_name (relsec
));
11570 addend
+= rp
->r_addend
;
11571 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11572 partial_inplace. */
11574 || (elf_header
.e_machine
== EM_XTENSA
11575 && reloc_type
== 1)
11576 || ((elf_header
.e_machine
== EM_PJ
11577 || elf_header
.e_machine
== EM_PJ_OLD
)
11578 && reloc_type
== 1)
11579 || ((elf_header
.e_machine
== EM_D30V
11580 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11581 && reloc_type
== 12))
11582 addend
+= byte_get (rloc
, reloc_size
);
11584 if (is_32bit_pcrel_reloc (reloc_type
)
11585 || is_64bit_pcrel_reloc (reloc_type
))
11587 /* On HPPA, all pc-relative relocations are biased by 8. */
11588 if (elf_header
.e_machine
== EM_PARISC
)
11590 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11594 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11603 #ifdef SUPPORT_DISASSEMBLY
11605 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11607 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11609 /* FIXME: XXX -- to be done --- XXX */
11615 /* Reads in the contents of SECTION from FILE, returning a pointer
11616 to a malloc'ed buffer or NULL if something went wrong. */
11619 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11621 bfd_size_type num_bytes
;
11623 num_bytes
= section
->sh_size
;
11625 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11627 printf (_("\nSection '%s' has no data to dump.\n"),
11628 printable_section_name (section
));
11632 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11633 _("section contents"));
11638 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11640 Elf_Internal_Shdr
* relsec
;
11641 bfd_size_type num_bytes
;
11645 bfd_boolean some_strings_shown
;
11647 start
= get_section_contents (section
, file
);
11651 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11653 /* If the section being dumped has relocations against it the user might
11654 be expecting these relocations to have been applied. Check for this
11655 case and issue a warning message in order to avoid confusion.
11656 FIXME: Maybe we ought to have an option that dumps a section with
11657 relocs applied ? */
11658 for (relsec
= section_headers
;
11659 relsec
< section_headers
+ elf_header
.e_shnum
;
11662 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11663 || relsec
->sh_info
>= elf_header
.e_shnum
11664 || section_headers
+ relsec
->sh_info
!= section
11665 || relsec
->sh_size
== 0
11666 || relsec
->sh_link
>= elf_header
.e_shnum
)
11669 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11673 num_bytes
= section
->sh_size
;
11675 end
= start
+ num_bytes
;
11676 some_strings_shown
= FALSE
;
11680 while (!ISPRINT (* data
))
11681 if (++ data
>= end
)
11686 size_t maxlen
= end
- data
;
11689 /* PR 11128: Use two separate invocations in order to work
11690 around bugs in the Solaris 8 implementation of printf. */
11691 printf (" [%6tx] ", data
- start
);
11693 printf (" [%6Ix] ", (size_t) (data
- start
));
11697 print_symbol ((int) maxlen
, data
);
11699 data
+= strnlen (data
, maxlen
);
11703 printf (_("<corrupt>\n"));
11706 some_strings_shown
= TRUE
;
11710 if (! some_strings_shown
)
11711 printf (_(" No strings found in this section."));
11719 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11721 bfd_boolean relocate
)
11723 Elf_Internal_Shdr
* relsec
;
11724 bfd_size_type bytes
;
11726 unsigned char * data
;
11727 unsigned char * start
;
11729 start
= (unsigned char *) get_section_contents (section
, file
);
11733 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11737 apply_relocations (file
, section
, start
);
11741 /* If the section being dumped has relocations against it the user might
11742 be expecting these relocations to have been applied. Check for this
11743 case and issue a warning message in order to avoid confusion.
11744 FIXME: Maybe we ought to have an option that dumps a section with
11745 relocs applied ? */
11746 for (relsec
= section_headers
;
11747 relsec
< section_headers
+ elf_header
.e_shnum
;
11750 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11751 || relsec
->sh_info
>= elf_header
.e_shnum
11752 || section_headers
+ relsec
->sh_info
!= section
11753 || relsec
->sh_size
== 0
11754 || relsec
->sh_link
>= elf_header
.e_shnum
)
11757 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11762 addr
= section
->sh_addr
;
11763 bytes
= section
->sh_size
;
11772 lbytes
= (bytes
> 16 ? 16 : bytes
);
11774 printf (" 0x%8.8lx ", (unsigned long) addr
);
11776 for (j
= 0; j
< 16; j
++)
11779 printf ("%2.2x", data
[j
]);
11787 for (j
= 0; j
< lbytes
; j
++)
11790 if (k
>= ' ' && k
< 0x7f)
11808 /* Uncompresses a section that was compressed using zlib, in place. */
11811 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11812 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11814 #ifndef HAVE_ZLIB_H
11817 dwarf_size_type compressed_size
= *size
;
11818 unsigned char * compressed_buffer
= *buffer
;
11819 dwarf_size_type uncompressed_size
;
11820 unsigned char * uncompressed_buffer
;
11823 dwarf_size_type header_size
= 12;
11825 /* Read the zlib header. In this case, it should be "ZLIB" followed
11826 by the uncompressed section size, 8 bytes in big-endian order. */
11827 if (compressed_size
< header_size
11828 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11831 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11832 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11833 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11834 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11835 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11836 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11837 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11838 uncompressed_size
+= compressed_buffer
[11];
11840 /* It is possible the section consists of several compressed
11841 buffers concatenated together, so we uncompress in a loop. */
11842 strm
.zalloc
= NULL
;
11844 strm
.opaque
= NULL
;
11845 strm
.avail_in
= compressed_size
- header_size
;
11846 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11847 strm
.avail_out
= uncompressed_size
;
11848 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11850 rc
= inflateInit (& strm
);
11851 while (strm
.avail_in
> 0)
11855 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11856 + (uncompressed_size
- strm
.avail_out
));
11857 rc
= inflate (&strm
, Z_FINISH
);
11858 if (rc
!= Z_STREAM_END
)
11860 rc
= inflateReset (& strm
);
11862 rc
= inflateEnd (& strm
);
11864 || strm
.avail_out
!= 0)
11867 free (compressed_buffer
);
11868 *buffer
= uncompressed_buffer
;
11869 *size
= uncompressed_size
;
11873 free (uncompressed_buffer
);
11874 /* Indicate decompression failure. */
11877 #endif /* HAVE_ZLIB_H */
11881 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11882 Elf_Internal_Shdr
* sec
, void * file
)
11884 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11887 /* If it is already loaded, do nothing. */
11888 if (section
->start
!= NULL
)
11891 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11892 section
->address
= sec
->sh_addr
;
11893 section
->user_data
= NULL
;
11894 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11896 sec
->sh_size
, buf
);
11897 if (section
->start
== NULL
)
11901 section
->size
= sec
->sh_size
;
11902 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11903 sec
->sh_size
= section
->size
;
11906 if (section
->start
== NULL
)
11909 if (debug_displays
[debug
].relocate
)
11910 apply_relocations ((FILE *) file
, sec
, section
->start
);
11915 /* If this is not NULL, load_debug_section will only look for sections
11916 within the list of sections given here. */
11917 unsigned int *section_subset
= NULL
;
11920 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11922 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11923 Elf_Internal_Shdr
* sec
;
11925 /* Locate the debug section. */
11926 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11928 section
->name
= section
->uncompressed_name
;
11931 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11933 section
->name
= section
->compressed_name
;
11938 /* If we're loading from a subset of sections, and we've loaded
11939 a section matching this name before, it's likely that it's a
11941 if (section_subset
!= NULL
)
11942 free_debug_section (debug
);
11944 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11948 free_debug_section (enum dwarf_section_display_enum debug
)
11950 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11952 if (section
->start
== NULL
)
11955 free ((char *) section
->start
);
11956 section
->start
= NULL
;
11957 section
->address
= 0;
11962 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11964 char * name
= SECTION_NAME (section
);
11965 const char * print_name
= printable_section_name (section
);
11966 bfd_size_type length
;
11970 length
= section
->sh_size
;
11973 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
11976 if (section
->sh_type
== SHT_NOBITS
)
11978 /* There is no point in dumping the contents of a debugging section
11979 which has the NOBITS type - the bits in the file will be random.
11980 This can happen when a file containing a .eh_frame section is
11981 stripped with the --only-keep-debug command line option. */
11982 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11987 if (const_strneq (name
, ".gnu.linkonce.wi."))
11988 name
= ".debug_info";
11990 /* See if we know how to display the contents of this section. */
11991 for (i
= 0; i
< max
; i
++)
11992 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11993 || (i
== line
&& const_strneq (name
, ".debug_line."))
11994 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11996 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11997 int secondary
= (section
!= find_section (name
));
12000 free_debug_section ((enum dwarf_section_display_enum
) i
);
12002 if (i
== line
&& const_strneq (name
, ".debug_line."))
12004 else if (streq (sec
->uncompressed_name
, name
))
12005 sec
->name
= sec
->uncompressed_name
;
12007 sec
->name
= sec
->compressed_name
;
12008 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12011 /* If this debug section is part of a CU/TU set in a .dwp file,
12012 restrict load_debug_section to the sections in that set. */
12013 section_subset
= find_cu_tu_set (file
, shndx
);
12015 result
&= debug_displays
[i
].display (sec
, file
);
12017 section_subset
= NULL
;
12019 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12020 free_debug_section ((enum dwarf_section_display_enum
) i
);
12028 printf (_("Unrecognized debug section: %s\n"), print_name
);
12035 /* Set DUMP_SECTS for all sections where dumps were requested
12036 based on section name. */
12039 initialise_dumps_byname (void)
12041 struct dump_list_entry
* cur
;
12043 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12048 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12049 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12051 request_dump_bynumber (i
, cur
->type
);
12056 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12062 process_section_contents (FILE * file
)
12064 Elf_Internal_Shdr
* section
;
12070 initialise_dumps_byname ();
12072 for (i
= 0, section
= section_headers
;
12073 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12076 #ifdef SUPPORT_DISASSEMBLY
12077 if (dump_sects
[i
] & DISASS_DUMP
)
12078 disassemble_section (section
, file
);
12080 if (dump_sects
[i
] & HEX_DUMP
)
12081 dump_section_as_bytes (section
, file
, FALSE
);
12083 if (dump_sects
[i
] & RELOC_DUMP
)
12084 dump_section_as_bytes (section
, file
, TRUE
);
12086 if (dump_sects
[i
] & STRING_DUMP
)
12087 dump_section_as_strings (section
, file
);
12089 if (dump_sects
[i
] & DEBUG_DUMP
)
12090 display_debug_section (i
, section
, file
);
12093 /* Check to see if the user requested a
12094 dump of a section that does not exist. */
12095 while (i
++ < num_dump_sects
)
12097 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12101 process_mips_fpe_exception (int mask
)
12106 if (mask
& OEX_FPU_INEX
)
12107 fputs ("INEX", stdout
), first
= 0;
12108 if (mask
& OEX_FPU_UFLO
)
12109 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12110 if (mask
& OEX_FPU_OFLO
)
12111 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12112 if (mask
& OEX_FPU_DIV0
)
12113 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12114 if (mask
& OEX_FPU_INVAL
)
12115 printf ("%sINVAL", first
? "" : "|");
12118 fputs ("0", stdout
);
12121 /* Display's the value of TAG at location P. If TAG is
12122 greater than 0 it is assumed to be an unknown tag, and
12123 a message is printed to this effect. Otherwise it is
12124 assumed that a message has already been printed.
12126 If the bottom bit of TAG is set it assumed to have a
12127 string value, otherwise it is assumed to have an integer
12130 Returns an updated P pointing to the first unread byte
12131 beyond the end of TAG's value.
12133 Reads at or beyond END will not be made. */
12135 static unsigned char *
12136 display_tag_value (int tag
,
12138 const unsigned char * const end
)
12143 printf (" Tag_unknown_%d: ", tag
);
12147 warn (_("<corrupt tag>\n"));
12151 /* PR 17531 file: 027-19978-0.004. */
12152 size_t maxlen
= (end
- p
) - 1;
12157 print_symbol ((int) maxlen
, (const char *) p
);
12158 p
+= strnlen ((char *) p
, maxlen
) + 1;
12162 printf (_("<corrupt string tag>"));
12163 p
= (unsigned char *) end
;
12171 val
= read_uleb128 (p
, &len
, end
);
12173 printf ("%ld (0x%lx)\n", val
, val
);
12180 /* ARM EABI attributes section. */
12185 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12187 const char ** table
;
12188 } arm_attr_public_tag
;
12190 static const char * arm_attr_tag_CPU_arch
[] =
12191 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12192 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12193 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12194 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12195 {"No", "Thumb-1", "Thumb-2"};
12196 static const char * arm_attr_tag_FP_arch
[] =
12197 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12198 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12199 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12200 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12201 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12202 static const char * arm_attr_tag_PCS_config
[] =
12203 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12204 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12205 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12206 {"V6", "SB", "TLS", "Unused"};
12207 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12208 {"Absolute", "PC-relative", "SB-relative", "None"};
12209 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12210 {"Absolute", "PC-relative", "None"};
12211 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12212 {"None", "direct", "GOT-indirect"};
12213 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12214 {"None", "??? 1", "2", "??? 3", "4"};
12215 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12216 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12217 {"Unused", "Needed", "Sign only"};
12218 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12219 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12220 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12221 {"Unused", "Finite", "RTABI", "IEEE 754"};
12222 static const char * arm_attr_tag_ABI_enum_size
[] =
12223 {"Unused", "small", "int", "forced to int"};
12224 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12225 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12226 static const char * arm_attr_tag_ABI_VFP_args
[] =
12227 {"AAPCS", "VFP registers", "custom", "compatible"};
12228 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12229 {"AAPCS", "WMMX registers", "custom"};
12230 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12231 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12232 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12233 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12234 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12235 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12236 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12237 static const char * arm_attr_tag_FP_HP_extension
[] =
12238 {"Not Allowed", "Allowed"};
12239 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12240 {"None", "IEEE 754", "Alternative Format"};
12241 static const char * arm_attr_tag_MPextension_use
[] =
12242 {"Not Allowed", "Allowed"};
12243 static const char * arm_attr_tag_DIV_use
[] =
12244 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12245 "Allowed in v7-A with integer division extension"};
12246 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12247 static const char * arm_attr_tag_Virtualization_use
[] =
12248 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12249 "TrustZone and Virtualization Extensions"};
12250 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12251 {"Not Allowed", "Allowed"};
12253 #define LOOKUP(id, name) \
12254 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12255 static arm_attr_public_tag arm_attr_public_tags
[] =
12257 {4, "CPU_raw_name", 1, NULL
},
12258 {5, "CPU_name", 1, NULL
},
12259 LOOKUP(6, CPU_arch
),
12260 {7, "CPU_arch_profile", 0, NULL
},
12261 LOOKUP(8, ARM_ISA_use
),
12262 LOOKUP(9, THUMB_ISA_use
),
12263 LOOKUP(10, FP_arch
),
12264 LOOKUP(11, WMMX_arch
),
12265 LOOKUP(12, Advanced_SIMD_arch
),
12266 LOOKUP(13, PCS_config
),
12267 LOOKUP(14, ABI_PCS_R9_use
),
12268 LOOKUP(15, ABI_PCS_RW_data
),
12269 LOOKUP(16, ABI_PCS_RO_data
),
12270 LOOKUP(17, ABI_PCS_GOT_use
),
12271 LOOKUP(18, ABI_PCS_wchar_t
),
12272 LOOKUP(19, ABI_FP_rounding
),
12273 LOOKUP(20, ABI_FP_denormal
),
12274 LOOKUP(21, ABI_FP_exceptions
),
12275 LOOKUP(22, ABI_FP_user_exceptions
),
12276 LOOKUP(23, ABI_FP_number_model
),
12277 {24, "ABI_align_needed", 0, NULL
},
12278 {25, "ABI_align_preserved", 0, NULL
},
12279 LOOKUP(26, ABI_enum_size
),
12280 LOOKUP(27, ABI_HardFP_use
),
12281 LOOKUP(28, ABI_VFP_args
),
12282 LOOKUP(29, ABI_WMMX_args
),
12283 LOOKUP(30, ABI_optimization_goals
),
12284 LOOKUP(31, ABI_FP_optimization_goals
),
12285 {32, "compatibility", 0, NULL
},
12286 LOOKUP(34, CPU_unaligned_access
),
12287 LOOKUP(36, FP_HP_extension
),
12288 LOOKUP(38, ABI_FP_16bit_format
),
12289 LOOKUP(42, MPextension_use
),
12290 LOOKUP(44, DIV_use
),
12291 {64, "nodefaults", 0, NULL
},
12292 {65, "also_compatible_with", 0, NULL
},
12293 LOOKUP(66, T2EE_use
),
12294 {67, "conformance", 1, NULL
},
12295 LOOKUP(68, Virtualization_use
),
12296 LOOKUP(70, MPextension_use_legacy
)
12300 static unsigned char *
12301 display_arm_attribute (unsigned char * p
,
12302 const unsigned char * const end
)
12307 arm_attr_public_tag
* attr
;
12311 tag
= read_uleb128 (p
, &len
, end
);
12314 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12316 if (arm_attr_public_tags
[i
].tag
== tag
)
12318 attr
= &arm_attr_public_tags
[i
];
12325 printf (" Tag_%s: ", attr
->name
);
12326 switch (attr
->type
)
12331 case 7: /* Tag_CPU_arch_profile. */
12332 val
= read_uleb128 (p
, &len
, end
);
12336 case 0: printf (_("None\n")); break;
12337 case 'A': printf (_("Application\n")); break;
12338 case 'R': printf (_("Realtime\n")); break;
12339 case 'M': printf (_("Microcontroller\n")); break;
12340 case 'S': printf (_("Application or Realtime\n")); break;
12341 default: printf ("??? (%d)\n", val
); break;
12345 case 24: /* Tag_align_needed. */
12346 val
= read_uleb128 (p
, &len
, end
);
12350 case 0: printf (_("None\n")); break;
12351 case 1: printf (_("8-byte\n")); break;
12352 case 2: printf (_("4-byte\n")); break;
12353 case 3: printf ("??? 3\n"); break;
12356 printf (_("8-byte and up to %d-byte extended\n"),
12359 printf ("??? (%d)\n", val
);
12364 case 25: /* Tag_align_preserved. */
12365 val
= read_uleb128 (p
, &len
, end
);
12369 case 0: printf (_("None\n")); break;
12370 case 1: printf (_("8-byte, except leaf SP\n")); break;
12371 case 2: printf (_("8-byte\n")); break;
12372 case 3: printf ("??? 3\n"); break;
12375 printf (_("8-byte and up to %d-byte extended\n"),
12378 printf ("??? (%d)\n", val
);
12383 case 32: /* Tag_compatibility. */
12385 val
= read_uleb128 (p
, &len
, end
);
12387 printf (_("flag = %d, vendor = "), val
);
12390 size_t maxlen
= (end
- p
) - 1;
12392 print_symbol ((int) maxlen
, (const char *) p
);
12393 p
+= strnlen ((char *) p
, maxlen
) + 1;
12397 printf (_("<corrupt>"));
12398 p
= (unsigned char *) end
;
12404 case 64: /* Tag_nodefaults. */
12405 /* PR 17531: file: 001-505008-0.01. */
12408 printf (_("True\n"));
12411 case 65: /* Tag_also_compatible_with. */
12412 val
= read_uleb128 (p
, &len
, end
);
12414 if (val
== 6 /* Tag_CPU_arch. */)
12416 val
= read_uleb128 (p
, &len
, end
);
12418 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12419 printf ("??? (%d)\n", val
);
12421 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12425 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12430 printf (_("<unknown: %d>\n"), tag
);
12436 return display_tag_value (-1, p
, end
);
12438 return display_tag_value (0, p
, end
);
12441 assert (attr
->type
& 0x80);
12442 val
= read_uleb128 (p
, &len
, end
);
12444 type
= attr
->type
& 0x7f;
12446 printf ("??? (%d)\n", val
);
12448 printf ("%s\n", attr
->table
[val
]);
12453 return display_tag_value (tag
, p
, end
);
12456 static unsigned char *
12457 display_gnu_attribute (unsigned char * p
,
12458 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12459 const unsigned char * const end
)
12465 tag
= read_uleb128 (p
, &len
, end
);
12468 /* Tag_compatibility is the only generic GNU attribute defined at
12472 val
= read_uleb128 (p
, &len
, end
);
12475 printf (_("flag = %d, vendor = "), val
);
12478 printf (_("<corrupt>\n"));
12479 warn (_("corrupt vendor attribute\n"));
12485 size_t maxlen
= (end
- p
) - 1;
12487 print_symbol ((int) maxlen
, (const char *) p
);
12488 p
+= strnlen ((char *) p
, maxlen
) + 1;
12492 printf (_("<corrupt>"));
12493 p
= (unsigned char *) end
;
12500 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12501 return display_proc_gnu_attribute (p
, tag
, end
);
12503 return display_tag_value (tag
, p
, end
);
12506 static unsigned char *
12507 display_power_gnu_attribute (unsigned char * p
,
12509 const unsigned char * const end
)
12514 if (tag
== Tag_GNU_Power_ABI_FP
)
12516 val
= read_uleb128 (p
, &len
, end
);
12518 printf (" Tag_GNU_Power_ABI_FP: ");
12523 printf (_("Hard or soft float\n"));
12526 printf (_("Hard float\n"));
12529 printf (_("Soft float\n"));
12532 printf (_("Single-precision hard float\n"));
12535 printf ("??? (%d)\n", val
);
12541 if (tag
== Tag_GNU_Power_ABI_Vector
)
12543 val
= read_uleb128 (p
, &len
, end
);
12545 printf (" Tag_GNU_Power_ABI_Vector: ");
12549 printf (_("Any\n"));
12552 printf (_("Generic\n"));
12555 printf ("AltiVec\n");
12561 printf ("??? (%d)\n", val
);
12567 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12571 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12575 val
= read_uleb128 (p
, &len
, end
);
12577 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12581 printf (_("Any\n"));
12584 printf ("r3/r4\n");
12587 printf (_("Memory\n"));
12590 printf ("??? (%d)\n", val
);
12596 return display_tag_value (tag
& 1, p
, end
);
12600 display_sparc_hwcaps (int mask
)
12606 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12607 fputs ("mul32", stdout
), first
= 0;
12608 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12609 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12610 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12611 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12612 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12613 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12614 if (mask
& ELF_SPARC_HWCAP_POPC
)
12615 printf ("%spopc", first
? "" : "|"), first
= 0;
12616 if (mask
& ELF_SPARC_HWCAP_VIS
)
12617 printf ("%svis", first
? "" : "|"), first
= 0;
12618 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12619 printf ("%svis2", first
? "" : "|"), first
= 0;
12620 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12621 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12622 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12623 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12624 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12625 printf ("%svis3", first
? "" : "|"), first
= 0;
12626 if (mask
& ELF_SPARC_HWCAP_HPC
)
12627 printf ("%shpc", first
? "" : "|"), first
= 0;
12628 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12629 printf ("%srandom", first
? "" : "|"), first
= 0;
12630 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12631 printf ("%strans", first
? "" : "|"), first
= 0;
12632 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12633 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12634 if (mask
& ELF_SPARC_HWCAP_IMA
)
12635 printf ("%sima", first
? "" : "|"), first
= 0;
12636 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12637 printf ("%scspare", first
? "" : "|"), first
= 0;
12640 fputc ('0', stdout
);
12641 fputc ('\n', stdout
);
12645 display_sparc_hwcaps2 (int mask
)
12651 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12652 fputs ("fjathplus", stdout
), first
= 0;
12653 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12654 printf ("%svis3b", first
? "" : "|"), first
= 0;
12655 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12656 printf ("%sadp", first
? "" : "|"), first
= 0;
12657 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12658 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12659 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12660 printf ("%smwait", first
? "" : "|"), first
= 0;
12661 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12662 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12663 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12664 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12665 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12666 printf ("%snsec", first
? "" : "|"), first
= 0;
12667 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12668 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12669 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12670 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12671 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12672 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12675 fputc ('0', stdout
);
12676 fputc ('\n', stdout
);
12679 static unsigned char *
12680 display_sparc_gnu_attribute (unsigned char * p
,
12682 const unsigned char * const end
)
12687 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12689 val
= read_uleb128 (p
, &len
, end
);
12691 printf (" Tag_GNU_Sparc_HWCAPS: ");
12692 display_sparc_hwcaps (val
);
12695 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12697 val
= read_uleb128 (p
, &len
, end
);
12699 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12700 display_sparc_hwcaps2 (val
);
12704 return display_tag_value (tag
, p
, end
);
12708 print_mips_fp_abi_value (int val
)
12712 case Val_GNU_MIPS_ABI_FP_ANY
:
12713 printf (_("Hard or soft float\n"));
12715 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12716 printf (_("Hard float (double precision)\n"));
12718 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12719 printf (_("Hard float (single precision)\n"));
12721 case Val_GNU_MIPS_ABI_FP_SOFT
:
12722 printf (_("Soft float\n"));
12724 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12725 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12727 case Val_GNU_MIPS_ABI_FP_XX
:
12728 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12730 case Val_GNU_MIPS_ABI_FP_64
:
12731 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12733 case Val_GNU_MIPS_ABI_FP_64A
:
12734 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12737 printf ("??? (%d)\n", val
);
12742 static unsigned char *
12743 display_mips_gnu_attribute (unsigned char * p
,
12745 const unsigned char * const end
)
12747 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12752 val
= read_uleb128 (p
, &len
, end
);
12754 printf (" Tag_GNU_MIPS_ABI_FP: ");
12756 print_mips_fp_abi_value (val
);
12761 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12766 val
= read_uleb128 (p
, &len
, end
);
12768 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12772 case Val_GNU_MIPS_ABI_MSA_ANY
:
12773 printf (_("Any MSA or not\n"));
12775 case Val_GNU_MIPS_ABI_MSA_128
:
12776 printf (_("128-bit MSA\n"));
12779 printf ("??? (%d)\n", val
);
12785 return display_tag_value (tag
& 1, p
, end
);
12788 static unsigned char *
12789 display_tic6x_attribute (unsigned char * p
,
12790 const unsigned char * const end
)
12796 tag
= read_uleb128 (p
, &len
, end
);
12802 val
= read_uleb128 (p
, &len
, end
);
12804 printf (" Tag_ISA: ");
12808 case C6XABI_Tag_ISA_none
:
12809 printf (_("None\n"));
12811 case C6XABI_Tag_ISA_C62X
:
12814 case C6XABI_Tag_ISA_C67X
:
12817 case C6XABI_Tag_ISA_C67XP
:
12818 printf ("C67x+\n");
12820 case C6XABI_Tag_ISA_C64X
:
12823 case C6XABI_Tag_ISA_C64XP
:
12824 printf ("C64x+\n");
12826 case C6XABI_Tag_ISA_C674X
:
12827 printf ("C674x\n");
12830 printf ("??? (%d)\n", val
);
12835 case Tag_ABI_wchar_t
:
12836 val
= read_uleb128 (p
, &len
, end
);
12838 printf (" Tag_ABI_wchar_t: ");
12842 printf (_("Not used\n"));
12845 printf (_("2 bytes\n"));
12848 printf (_("4 bytes\n"));
12851 printf ("??? (%d)\n", val
);
12856 case Tag_ABI_stack_align_needed
:
12857 val
= read_uleb128 (p
, &len
, end
);
12859 printf (" Tag_ABI_stack_align_needed: ");
12863 printf (_("8-byte\n"));
12866 printf (_("16-byte\n"));
12869 printf ("??? (%d)\n", val
);
12874 case Tag_ABI_stack_align_preserved
:
12875 val
= read_uleb128 (p
, &len
, end
);
12877 printf (" Tag_ABI_stack_align_preserved: ");
12881 printf (_("8-byte\n"));
12884 printf (_("16-byte\n"));
12887 printf ("??? (%d)\n", val
);
12893 val
= read_uleb128 (p
, &len
, end
);
12895 printf (" Tag_ABI_DSBT: ");
12899 printf (_("DSBT addressing not used\n"));
12902 printf (_("DSBT addressing used\n"));
12905 printf ("??? (%d)\n", val
);
12911 val
= read_uleb128 (p
, &len
, end
);
12913 printf (" Tag_ABI_PID: ");
12917 printf (_("Data addressing position-dependent\n"));
12920 printf (_("Data addressing position-independent, GOT near DP\n"));
12923 printf (_("Data addressing position-independent, GOT far from DP\n"));
12926 printf ("??? (%d)\n", val
);
12932 val
= read_uleb128 (p
, &len
, end
);
12934 printf (" Tag_ABI_PIC: ");
12938 printf (_("Code addressing position-dependent\n"));
12941 printf (_("Code addressing position-independent\n"));
12944 printf ("??? (%d)\n", val
);
12949 case Tag_ABI_array_object_alignment
:
12950 val
= read_uleb128 (p
, &len
, end
);
12952 printf (" Tag_ABI_array_object_alignment: ");
12956 printf (_("8-byte\n"));
12959 printf (_("4-byte\n"));
12962 printf (_("16-byte\n"));
12965 printf ("??? (%d)\n", val
);
12970 case Tag_ABI_array_object_align_expected
:
12971 val
= read_uleb128 (p
, &len
, end
);
12973 printf (" Tag_ABI_array_object_align_expected: ");
12977 printf (_("8-byte\n"));
12980 printf (_("4-byte\n"));
12983 printf (_("16-byte\n"));
12986 printf ("??? (%d)\n", val
);
12991 case Tag_ABI_compatibility
:
12993 val
= read_uleb128 (p
, &len
, end
);
12995 printf (" Tag_ABI_compatibility: ");
12996 printf (_("flag = %d, vendor = "), val
);
12999 size_t maxlen
= (end
- p
) - 1;
13001 print_symbol ((int) maxlen
, (const char *) p
);
13002 p
+= strnlen ((char *) p
, maxlen
) + 1;
13006 printf (_("<corrupt>"));
13007 p
= (unsigned char *) end
;
13013 case Tag_ABI_conformance
:
13015 printf (" Tag_ABI_conformance: \"");
13018 size_t maxlen
= (end
- p
) - 1;
13020 print_symbol ((int) maxlen
, (const char *) p
);
13021 p
+= strnlen ((char *) p
, maxlen
) + 1;
13025 printf (_("<corrupt>"));
13026 p
= (unsigned char *) end
;
13033 return display_tag_value (tag
, p
, end
);
13037 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13039 unsigned long addr
= 0;
13040 size_t bytes
= end
- p
;
13047 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13049 printf (" 0x%8.8lx ", addr
);
13051 for (j
= 0; j
< 16; j
++)
13054 printf ("%2.2x", p
[j
]);
13062 for (j
= 0; j
< lbytes
; j
++)
13065 if (k
>= ' ' && k
< 0x7f)
13081 static unsigned char *
13082 display_msp430x_attribute (unsigned char * p
,
13083 const unsigned char * const end
)
13089 tag
= read_uleb128 (p
, & len
, end
);
13094 case OFBA_MSPABI_Tag_ISA
:
13095 val
= read_uleb128 (p
, &len
, end
);
13097 printf (" Tag_ISA: ");
13100 case 0: printf (_("None\n")); break;
13101 case 1: printf (_("MSP430\n")); break;
13102 case 2: printf (_("MSP430X\n")); break;
13103 default: printf ("??? (%d)\n", val
); break;
13107 case OFBA_MSPABI_Tag_Code_Model
:
13108 val
= read_uleb128 (p
, &len
, end
);
13110 printf (" Tag_Code_Model: ");
13113 case 0: printf (_("None\n")); break;
13114 case 1: printf (_("Small\n")); break;
13115 case 2: printf (_("Large\n")); break;
13116 default: printf ("??? (%d)\n", val
); break;
13120 case OFBA_MSPABI_Tag_Data_Model
:
13121 val
= read_uleb128 (p
, &len
, end
);
13123 printf (" Tag_Data_Model: ");
13126 case 0: printf (_("None\n")); break;
13127 case 1: printf (_("Small\n")); break;
13128 case 2: printf (_("Large\n")); break;
13129 case 3: printf (_("Restricted Large\n")); break;
13130 default: printf ("??? (%d)\n", val
); break;
13135 printf (_(" <unknown tag %d>: "), tag
);
13142 size_t maxlen
= (end
- p
) - 1;
13144 print_symbol ((int) maxlen
, (const char *) p
);
13145 p
+= strnlen ((char *) p
, maxlen
) + 1;
13149 printf (_("<corrupt>"));
13150 p
= (unsigned char *) end
;
13156 val
= read_uleb128 (p
, &len
, end
);
13158 printf ("%d (0x%x)\n", val
, val
);
13168 process_attributes (FILE * file
,
13169 const char * public_name
,
13170 unsigned int proc_type
,
13171 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13172 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13174 Elf_Internal_Shdr
* sect
;
13177 /* Find the section header so that we get the size. */
13178 for (i
= 0, sect
= section_headers
;
13179 i
< elf_header
.e_shnum
;
13182 unsigned char * contents
;
13185 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13188 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13189 sect
->sh_size
, _("attributes"));
13190 if (contents
== NULL
)
13196 bfd_vma section_len
;
13198 section_len
= sect
->sh_size
- 1;
13201 while (section_len
> 0)
13204 unsigned int namelen
;
13205 bfd_boolean public_section
;
13206 bfd_boolean gnu_section
;
13208 if (section_len
<= 4)
13210 error (_("Tag section ends prematurely\n"));
13213 attr_len
= byte_get (p
, 4);
13216 if (attr_len
> section_len
)
13218 error (_("Bad attribute length (%u > %u)\n"),
13219 (unsigned) attr_len
, (unsigned) section_len
);
13220 attr_len
= section_len
;
13222 /* PR 17531: file: 001-101425-0.004 */
13223 else if (attr_len
< 5)
13225 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13229 section_len
-= attr_len
;
13232 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13233 if (namelen
== 0 || namelen
>= attr_len
)
13235 error (_("Corrupt attribute section name\n"));
13239 printf (_("Attribute Section: "));
13240 print_symbol (INT_MAX
, (const char *) p
);
13243 if (public_name
&& streq ((char *) p
, public_name
))
13244 public_section
= TRUE
;
13246 public_section
= FALSE
;
13248 if (streq ((char *) p
, "gnu"))
13249 gnu_section
= TRUE
;
13251 gnu_section
= FALSE
;
13254 attr_len
-= namelen
;
13256 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13261 unsigned char * end
;
13263 /* PR binutils/17531: Safe handling of corrupt files. */
13266 error (_("Unused bytes at end of section\n"));
13272 size
= byte_get (p
, 4);
13273 if (size
> attr_len
)
13275 error (_("Bad subsection length (%u > %u)\n"),
13276 (unsigned) size
, (unsigned) attr_len
);
13279 /* PR binutils/17531: Safe handling of corrupt files. */
13282 error (_("Bad subsection length (%u < 6)\n"),
13289 end
= p
+ size
- 1;
13290 assert (end
<= contents
+ sect
->sh_size
);
13296 printf (_("File Attributes\n"));
13299 printf (_("Section Attributes:"));
13302 printf (_("Symbol Attributes:"));
13308 val
= read_uleb128 (p
, &j
, end
);
13312 printf (" %d", val
);
13317 printf (_("Unknown tag: %d\n"), tag
);
13318 public_section
= FALSE
;
13322 if (public_section
&& display_pub_attribute
!= NULL
)
13325 p
= display_pub_attribute (p
, end
);
13328 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13331 p
= display_gnu_attribute (p
,
13332 display_proc_gnu_attribute
,
13338 printf (_(" Unknown attribute:\n"));
13339 display_raw_attribute (p
, end
);
13348 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13356 process_arm_specific (FILE * file
)
13358 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13359 display_arm_attribute
, NULL
);
13363 process_power_specific (FILE * file
)
13365 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13366 display_power_gnu_attribute
);
13370 process_sparc_specific (FILE * file
)
13372 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13373 display_sparc_gnu_attribute
);
13377 process_tic6x_specific (FILE * file
)
13379 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13380 display_tic6x_attribute
, NULL
);
13384 process_msp430x_specific (FILE * file
)
13386 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13387 display_msp430x_attribute
, NULL
);
13390 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13391 Print the Address, Access and Initial fields of an entry at VMA ADDR
13392 and return the VMA of the next entry, or -1 if there was a problem.
13393 Does not read from DATA_END or beyond. */
13396 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13397 unsigned char * data_end
)
13400 print_vma (addr
, LONG_HEX
);
13402 if (addr
< pltgot
+ 0xfff0)
13403 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13405 printf ("%10s", "");
13408 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13412 unsigned char * from
= data
+ addr
- pltgot
;
13414 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13416 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13417 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13418 return (bfd_vma
) -1;
13422 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13423 print_vma (entry
, LONG_HEX
);
13426 return addr
+ (is_32bit_elf
? 4 : 8);
13429 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13430 PLTGOT. Print the Address and Initial fields of an entry at VMA
13431 ADDR and return the VMA of the next entry. */
13434 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13437 print_vma (addr
, LONG_HEX
);
13440 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13445 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13446 print_vma (entry
, LONG_HEX
);
13448 return addr
+ (is_32bit_elf
? 4 : 8);
13452 print_mips_ases (unsigned int mask
)
13454 if (mask
& AFL_ASE_DSP
)
13455 fputs ("\n\tDSP ASE", stdout
);
13456 if (mask
& AFL_ASE_DSPR2
)
13457 fputs ("\n\tDSP R2 ASE", stdout
);
13458 if (mask
& AFL_ASE_EVA
)
13459 fputs ("\n\tEnhanced VA Scheme", stdout
);
13460 if (mask
& AFL_ASE_MCU
)
13461 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13462 if (mask
& AFL_ASE_MDMX
)
13463 fputs ("\n\tMDMX ASE", stdout
);
13464 if (mask
& AFL_ASE_MIPS3D
)
13465 fputs ("\n\tMIPS-3D ASE", stdout
);
13466 if (mask
& AFL_ASE_MT
)
13467 fputs ("\n\tMT ASE", stdout
);
13468 if (mask
& AFL_ASE_SMARTMIPS
)
13469 fputs ("\n\tSmartMIPS ASE", stdout
);
13470 if (mask
& AFL_ASE_VIRT
)
13471 fputs ("\n\tVZ ASE", stdout
);
13472 if (mask
& AFL_ASE_MSA
)
13473 fputs ("\n\tMSA ASE", stdout
);
13474 if (mask
& AFL_ASE_MIPS16
)
13475 fputs ("\n\tMIPS16 ASE", stdout
);
13476 if (mask
& AFL_ASE_MICROMIPS
)
13477 fputs ("\n\tMICROMIPS ASE", stdout
);
13478 if (mask
& AFL_ASE_XPA
)
13479 fputs ("\n\tXPA ASE", stdout
);
13481 fprintf (stdout
, "\n\t%s", _("None"));
13482 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13483 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13487 print_mips_isa_ext (unsigned int isa_ext
)
13492 fputs (_("None"), stdout
);
13495 fputs ("RMI XLR", stdout
);
13497 case AFL_EXT_OCTEON3
:
13498 fputs ("Cavium Networks Octeon3", stdout
);
13500 case AFL_EXT_OCTEON2
:
13501 fputs ("Cavium Networks Octeon2", stdout
);
13503 case AFL_EXT_OCTEONP
:
13504 fputs ("Cavium Networks OcteonP", stdout
);
13506 case AFL_EXT_LOONGSON_3A
:
13507 fputs ("Loongson 3A", stdout
);
13509 case AFL_EXT_OCTEON
:
13510 fputs ("Cavium Networks Octeon", stdout
);
13513 fputs ("Toshiba R5900", stdout
);
13516 fputs ("MIPS R4650", stdout
);
13519 fputs ("LSI R4010", stdout
);
13522 fputs ("NEC VR4100", stdout
);
13525 fputs ("Toshiba R3900", stdout
);
13527 case AFL_EXT_10000
:
13528 fputs ("MIPS R10000", stdout
);
13531 fputs ("Broadcom SB-1", stdout
);
13534 fputs ("NEC VR4111/VR4181", stdout
);
13537 fputs ("NEC VR4120", stdout
);
13540 fputs ("NEC VR5400", stdout
);
13543 fputs ("NEC VR5500", stdout
);
13545 case AFL_EXT_LOONGSON_2E
:
13546 fputs ("ST Microelectronics Loongson 2E", stdout
);
13548 case AFL_EXT_LOONGSON_2F
:
13549 fputs ("ST Microelectronics Loongson 2F", stdout
);
13552 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13557 get_mips_reg_size (int reg_size
)
13559 return (reg_size
== AFL_REG_NONE
) ? 0
13560 : (reg_size
== AFL_REG_32
) ? 32
13561 : (reg_size
== AFL_REG_64
) ? 64
13562 : (reg_size
== AFL_REG_128
) ? 128
13567 process_mips_specific (FILE * file
)
13569 Elf_Internal_Dyn
* entry
;
13570 Elf_Internal_Shdr
*sect
= NULL
;
13571 size_t liblist_offset
= 0;
13572 size_t liblistno
= 0;
13573 size_t conflictsno
= 0;
13574 size_t options_offset
= 0;
13575 size_t conflicts_offset
= 0;
13576 size_t pltrelsz
= 0;
13578 bfd_vma pltgot
= 0;
13579 bfd_vma mips_pltgot
= 0;
13580 bfd_vma jmprel
= 0;
13581 bfd_vma local_gotno
= 0;
13582 bfd_vma gotsym
= 0;
13583 bfd_vma symtabno
= 0;
13585 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13586 display_mips_gnu_attribute
);
13588 sect
= find_section (".MIPS.abiflags");
13592 Elf_External_ABIFlags_v0
*abiflags_ext
;
13593 Elf_Internal_ABIFlags_v0 abiflags_in
;
13595 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13596 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13599 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13600 sect
->sh_size
, _("MIPS ABI Flags section"));
13603 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13604 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13605 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13606 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13607 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13608 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13609 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13610 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13611 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13612 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13613 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13615 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13616 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13617 if (abiflags_in
.isa_rev
> 1)
13618 printf ("r%d", abiflags_in
.isa_rev
);
13619 printf ("\nGPR size: %d",
13620 get_mips_reg_size (abiflags_in
.gpr_size
));
13621 printf ("\nCPR1 size: %d",
13622 get_mips_reg_size (abiflags_in
.cpr1_size
));
13623 printf ("\nCPR2 size: %d",
13624 get_mips_reg_size (abiflags_in
.cpr2_size
));
13625 fputs ("\nFP ABI: ", stdout
);
13626 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13627 fputs ("ISA Extension: ", stdout
);
13628 print_mips_isa_ext (abiflags_in
.isa_ext
);
13629 fputs ("\nASEs:", stdout
);
13630 print_mips_ases (abiflags_in
.ases
);
13631 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13632 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13633 fputc ('\n', stdout
);
13634 free (abiflags_ext
);
13639 /* We have a lot of special sections. Thanks SGI! */
13640 if (dynamic_section
== NULL
)
13641 /* No information available. */
13644 for (entry
= dynamic_section
;
13645 /* PR 17531 file: 012-50589-0.004. */
13646 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13648 switch (entry
->d_tag
)
13650 case DT_MIPS_LIBLIST
:
13652 = offset_from_vma (file
, entry
->d_un
.d_val
,
13653 liblistno
* sizeof (Elf32_External_Lib
));
13655 case DT_MIPS_LIBLISTNO
:
13656 liblistno
= entry
->d_un
.d_val
;
13658 case DT_MIPS_OPTIONS
:
13659 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13661 case DT_MIPS_CONFLICT
:
13663 = offset_from_vma (file
, entry
->d_un
.d_val
,
13664 conflictsno
* sizeof (Elf32_External_Conflict
));
13666 case DT_MIPS_CONFLICTNO
:
13667 conflictsno
= entry
->d_un
.d_val
;
13670 pltgot
= entry
->d_un
.d_ptr
;
13672 case DT_MIPS_LOCAL_GOTNO
:
13673 local_gotno
= entry
->d_un
.d_val
;
13675 case DT_MIPS_GOTSYM
:
13676 gotsym
= entry
->d_un
.d_val
;
13678 case DT_MIPS_SYMTABNO
:
13679 symtabno
= entry
->d_un
.d_val
;
13681 case DT_MIPS_PLTGOT
:
13682 mips_pltgot
= entry
->d_un
.d_ptr
;
13685 pltrel
= entry
->d_un
.d_val
;
13688 pltrelsz
= entry
->d_un
.d_val
;
13691 jmprel
= entry
->d_un
.d_ptr
;
13697 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13699 Elf32_External_Lib
* elib
;
13702 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13704 sizeof (Elf32_External_Lib
),
13705 _("liblist section data"));
13708 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13709 (unsigned long) liblistno
);
13710 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13713 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13720 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13721 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13722 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13723 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13724 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13726 tmp
= gmtime (&atime
);
13727 snprintf (timebuf
, sizeof (timebuf
),
13728 "%04u-%02u-%02uT%02u:%02u:%02u",
13729 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13730 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13732 printf ("%3lu: ", (unsigned long) cnt
);
13733 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13734 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13736 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13737 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13738 liblist
.l_version
);
13740 if (liblist
.l_flags
== 0)
13744 static const struct
13751 { " EXACT_MATCH", LL_EXACT_MATCH
},
13752 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13753 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13754 { " EXPORTS", LL_EXPORTS
},
13755 { " DELAY_LOAD", LL_DELAY_LOAD
},
13756 { " DELTA", LL_DELTA
}
13758 int flags
= liblist
.l_flags
;
13761 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13762 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13764 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13765 flags
^= l_flags_vals
[fcnt
].bit
;
13768 printf (" %#x", (unsigned int) flags
);
13778 if (options_offset
!= 0)
13780 Elf_External_Options
* eopt
;
13781 Elf_Internal_Options
* iopt
;
13782 Elf_Internal_Options
* option
;
13785 sect
= section_headers
;
13787 /* Find the section header so that we get the size. */
13788 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13789 /* PR 17533 file: 012-277276-0.004. */
13792 error (_("No MIPS_OPTIONS header found\n"));
13796 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13797 sect
->sh_size
, _("options"));
13800 iopt
= (Elf_Internal_Options
*)
13801 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13804 error (_("Out of memory allocatinf space for MIPS options\n"));
13811 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
13813 Elf_External_Options
* eoption
;
13815 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13817 option
->kind
= BYTE_GET (eoption
->kind
);
13818 option
->size
= BYTE_GET (eoption
->size
);
13819 option
->section
= BYTE_GET (eoption
->section
);
13820 option
->info
= BYTE_GET (eoption
->info
);
13822 /* PR 17531: file: ffa0fa3b. */
13823 if (option
->size
< sizeof (* eopt
)
13824 || offset
+ option
->size
> sect
->sh_size
)
13826 warn (_("Invalid size (%u) for MIPS option\n"), option
->size
);
13827 option
->size
= sizeof (* eopt
);
13830 offset
+= option
->size
;
13836 printf (_("\nSection '%s' contains %d entries:\n"),
13837 printable_section_name (sect
), cnt
);
13846 switch (option
->kind
)
13849 /* This shouldn't happen. */
13850 printf (" NULL %d %lx", option
->section
, option
->info
);
13853 printf (" REGINFO ");
13854 if (elf_header
.e_machine
== EM_MIPS
)
13857 Elf32_External_RegInfo
* ereg
;
13858 Elf32_RegInfo reginfo
;
13860 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13861 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13862 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13863 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13864 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13865 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13866 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13868 printf ("GPR %08lx GP 0x%lx\n",
13869 reginfo
.ri_gprmask
,
13870 (unsigned long) reginfo
.ri_gp_value
);
13871 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13872 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13873 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13878 Elf64_External_RegInfo
* ereg
;
13879 Elf64_Internal_RegInfo reginfo
;
13881 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13882 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13883 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13884 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13885 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13886 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13887 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13889 printf ("GPR %08lx GP 0x",
13890 reginfo
.ri_gprmask
);
13891 printf_vma (reginfo
.ri_gp_value
);
13894 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13895 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13896 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13900 case ODK_EXCEPTIONS
:
13901 fputs (" EXCEPTIONS fpe_min(", stdout
);
13902 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13903 fputs (") fpe_max(", stdout
);
13904 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13905 fputs (")", stdout
);
13907 if (option
->info
& OEX_PAGE0
)
13908 fputs (" PAGE0", stdout
);
13909 if (option
->info
& OEX_SMM
)
13910 fputs (" SMM", stdout
);
13911 if (option
->info
& OEX_FPDBUG
)
13912 fputs (" FPDBUG", stdout
);
13913 if (option
->info
& OEX_DISMISS
)
13914 fputs (" DISMISS", stdout
);
13917 fputs (" PAD ", stdout
);
13918 if (option
->info
& OPAD_PREFIX
)
13919 fputs (" PREFIX", stdout
);
13920 if (option
->info
& OPAD_POSTFIX
)
13921 fputs (" POSTFIX", stdout
);
13922 if (option
->info
& OPAD_SYMBOL
)
13923 fputs (" SYMBOL", stdout
);
13926 fputs (" HWPATCH ", stdout
);
13927 if (option
->info
& OHW_R4KEOP
)
13928 fputs (" R4KEOP", stdout
);
13929 if (option
->info
& OHW_R8KPFETCH
)
13930 fputs (" R8KPFETCH", stdout
);
13931 if (option
->info
& OHW_R5KEOP
)
13932 fputs (" R5KEOP", stdout
);
13933 if (option
->info
& OHW_R5KCVTL
)
13934 fputs (" R5KCVTL", stdout
);
13937 fputs (" FILL ", stdout
);
13938 /* XXX Print content of info word? */
13941 fputs (" TAGS ", stdout
);
13942 /* XXX Print content of info word? */
13945 fputs (" HWAND ", stdout
);
13946 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13947 fputs (" R4KEOP_CHECKED", stdout
);
13948 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13949 fputs (" R4KEOP_CLEAN", stdout
);
13952 fputs (" HWOR ", stdout
);
13953 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13954 fputs (" R4KEOP_CHECKED", stdout
);
13955 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13956 fputs (" R4KEOP_CLEAN", stdout
);
13959 printf (" GP_GROUP %#06lx self-contained %#06lx",
13960 option
->info
& OGP_GROUP
,
13961 (option
->info
& OGP_SELF
) >> 16);
13964 printf (" IDENT %#06lx self-contained %#06lx",
13965 option
->info
& OGP_GROUP
,
13966 (option
->info
& OGP_SELF
) >> 16);
13969 /* This shouldn't happen. */
13970 printf (" %3d ??? %d %lx",
13971 option
->kind
, option
->section
, option
->info
);
13975 len
= sizeof (* eopt
);
13976 while (len
< option
->size
)
13978 char datum
= * ((char *) eopt
+ offset
+ len
);
13980 if (ISPRINT (datum
))
13981 printf ("%c", datum
);
13983 printf ("\\%03o", datum
);
13986 fputs ("\n", stdout
);
13988 offset
+= option
->size
;
13996 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13998 Elf32_Conflict
* iconf
;
14001 if (dynamic_symbols
== NULL
)
14003 error (_("conflict list found without a dynamic symbol table\n"));
14007 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14010 error (_("Out of memory allocating space for dynamic conflicts\n"));
14016 Elf32_External_Conflict
* econf32
;
14018 econf32
= (Elf32_External_Conflict
*)
14019 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14020 sizeof (* econf32
), _("conflict"));
14024 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14025 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14031 Elf64_External_Conflict
* econf64
;
14033 econf64
= (Elf64_External_Conflict
*)
14034 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14035 sizeof (* econf64
), _("conflict"));
14039 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14040 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14045 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14046 (unsigned long) conflictsno
);
14047 puts (_(" Num: Index Value Name"));
14049 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14051 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14053 if (iconf
[cnt
] >= num_dynamic_syms
)
14054 printf (_("<corrupt symbol index>"));
14057 Elf_Internal_Sym
* psym
;
14059 psym
= & dynamic_symbols
[iconf
[cnt
]];
14060 print_vma (psym
->st_value
, FULL_HEX
);
14062 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14063 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14065 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14073 if (pltgot
!= 0 && local_gotno
!= 0)
14075 bfd_vma ent
, local_end
, global_end
;
14077 unsigned char * data
;
14078 unsigned char * data_end
;
14082 addr_size
= (is_32bit_elf
? 4 : 8);
14083 local_end
= pltgot
+ local_gotno
* addr_size
;
14085 /* PR binutils/17533 file: 012-111227-0.004 */
14086 if (symtabno
< gotsym
)
14088 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14089 (unsigned long) gotsym
, (unsigned long) symtabno
);
14093 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14094 /* PR 17531: file: 54c91a34. */
14095 if (global_end
< local_end
)
14097 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14101 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14102 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14103 global_end
- pltgot
, 1,
14104 _("Global Offset Table data"));
14107 data_end
= data
+ (global_end
- pltgot
);
14109 printf (_("\nPrimary GOT:\n"));
14110 printf (_(" Canonical gp value: "));
14111 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14114 printf (_(" Reserved entries:\n"));
14115 printf (_(" %*s %10s %*s Purpose\n"),
14116 addr_size
* 2, _("Address"), _("Access"),
14117 addr_size
* 2, _("Initial"));
14118 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14119 printf (_(" Lazy resolver\n"));
14120 if (ent
== (bfd_vma
) -1)
14121 goto got_print_fail
;
14123 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14124 >> (addr_size
* 8 - 1)) != 0)
14126 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14127 printf (_(" Module pointer (GNU extension)\n"));
14128 if (ent
== (bfd_vma
) -1)
14129 goto got_print_fail
;
14133 if (ent
< local_end
)
14135 printf (_(" Local entries:\n"));
14136 printf (" %*s %10s %*s\n",
14137 addr_size
* 2, _("Address"), _("Access"),
14138 addr_size
* 2, _("Initial"));
14139 while (ent
< local_end
)
14141 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14143 if (ent
== (bfd_vma
) -1)
14144 goto got_print_fail
;
14149 if (gotsym
< symtabno
)
14153 printf (_(" Global entries:\n"));
14154 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14155 addr_size
* 2, _("Address"),
14157 addr_size
* 2, _("Initial"),
14158 addr_size
* 2, _("Sym.Val."),
14160 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14161 _("Ndx"), _("Name"));
14163 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14165 for (i
= gotsym
; i
< symtabno
; i
++)
14167 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14170 if (dynamic_symbols
== NULL
)
14171 printf (_("<no dynamic symbols>"));
14172 else if (i
< num_dynamic_syms
)
14174 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14176 print_vma (psym
->st_value
, LONG_HEX
);
14177 printf (" %-7s %3s ",
14178 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14179 get_symbol_index_type (psym
->st_shndx
));
14181 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14182 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14184 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14187 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14188 (unsigned long) i
);
14191 if (ent
== (bfd_vma
) -1)
14202 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14205 size_t offset
, rel_offset
;
14206 unsigned long count
, i
;
14207 unsigned char * data
;
14208 int addr_size
, sym_width
;
14209 Elf_Internal_Rela
* rels
;
14211 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14212 if (pltrel
== DT_RELA
)
14214 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14219 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14224 addr_size
= (is_32bit_elf
? 4 : 8);
14225 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14227 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14228 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14229 1, _("Procedure Linkage Table data"));
14233 printf ("\nPLT GOT:\n\n");
14234 printf (_(" Reserved entries:\n"));
14235 printf (_(" %*s %*s Purpose\n"),
14236 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14237 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14238 printf (_(" PLT lazy resolver\n"));
14239 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14240 printf (_(" Module pointer\n"));
14243 printf (_(" Entries:\n"));
14244 printf (" %*s %*s %*s %-7s %3s %s\n",
14245 addr_size
* 2, _("Address"),
14246 addr_size
* 2, _("Initial"),
14247 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14248 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14249 for (i
= 0; i
< count
; i
++)
14251 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14253 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14256 if (idx
>= num_dynamic_syms
)
14257 printf (_("<corrupt symbol index: %lu>"), idx
);
14260 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14262 print_vma (psym
->st_value
, LONG_HEX
);
14263 printf (" %-7s %3s ",
14264 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14265 get_symbol_index_type (psym
->st_shndx
));
14266 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14267 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14269 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14284 process_nds32_specific (FILE * file
)
14286 Elf_Internal_Shdr
*sect
= NULL
;
14288 sect
= find_section (".nds32_e_flags");
14291 unsigned int *flag
;
14293 printf ("\nNDS32 elf flags section:\n");
14294 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14295 sect
->sh_size
, _("NDS32 elf flags section"));
14297 switch ((*flag
) & 0x3)
14300 printf ("(VEC_SIZE):\tNo entry.\n");
14303 printf ("(VEC_SIZE):\t4 bytes\n");
14306 printf ("(VEC_SIZE):\t16 bytes\n");
14309 printf ("(VEC_SIZE):\treserved\n");
14318 process_gnu_liblist (FILE * file
)
14320 Elf_Internal_Shdr
* section
;
14321 Elf_Internal_Shdr
* string_sec
;
14322 Elf32_External_Lib
* elib
;
14324 size_t strtab_size
;
14331 for (i
= 0, section
= section_headers
;
14332 i
< elf_header
.e_shnum
;
14335 switch (section
->sh_type
)
14337 case SHT_GNU_LIBLIST
:
14338 if (section
->sh_link
>= elf_header
.e_shnum
)
14341 elib
= (Elf32_External_Lib
*)
14342 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14343 _("liblist section data"));
14347 string_sec
= section_headers
+ section
->sh_link
;
14349 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14350 string_sec
->sh_size
,
14351 _("liblist string table"));
14353 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14359 strtab_size
= string_sec
->sh_size
;
14361 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14362 printable_section_name (section
),
14363 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14365 puts (_(" Library Time Stamp Checksum Version Flags"));
14367 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14375 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14376 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14377 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14378 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14379 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14381 tmp
= gmtime (&atime
);
14382 snprintf (timebuf
, sizeof (timebuf
),
14383 "%04u-%02u-%02uT%02u:%02u:%02u",
14384 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14385 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14387 printf ("%3lu: ", (unsigned long) cnt
);
14389 printf ("%-20s", liblist
.l_name
< strtab_size
14390 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14392 printf ("%-20.20s", liblist
.l_name
< strtab_size
14393 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14394 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14395 liblist
.l_version
, liblist
.l_flags
);
14406 static const char *
14407 get_note_type (unsigned e_type
)
14409 static char buff
[64];
14411 if (elf_header
.e_type
== ET_CORE
)
14415 return _("NT_AUXV (auxiliary vector)");
14417 return _("NT_PRSTATUS (prstatus structure)");
14419 return _("NT_FPREGSET (floating point registers)");
14421 return _("NT_PRPSINFO (prpsinfo structure)");
14422 case NT_TASKSTRUCT
:
14423 return _("NT_TASKSTRUCT (task structure)");
14425 return _("NT_PRXFPREG (user_xfpregs structure)");
14427 return _("NT_PPC_VMX (ppc Altivec registers)");
14429 return _("NT_PPC_VSX (ppc VSX registers)");
14431 return _("NT_386_TLS (x86 TLS information)");
14432 case NT_386_IOPERM
:
14433 return _("NT_386_IOPERM (x86 I/O permissions)");
14434 case NT_X86_XSTATE
:
14435 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14436 case NT_S390_HIGH_GPRS
:
14437 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14438 case NT_S390_TIMER
:
14439 return _("NT_S390_TIMER (s390 timer register)");
14440 case NT_S390_TODCMP
:
14441 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14442 case NT_S390_TODPREG
:
14443 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14445 return _("NT_S390_CTRS (s390 control registers)");
14446 case NT_S390_PREFIX
:
14447 return _("NT_S390_PREFIX (s390 prefix register)");
14448 case NT_S390_LAST_BREAK
:
14449 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14450 case NT_S390_SYSTEM_CALL
:
14451 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14453 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14455 return _("NT_ARM_VFP (arm VFP registers)");
14457 return _("NT_ARM_TLS (AArch TLS registers)");
14458 case NT_ARM_HW_BREAK
:
14459 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14460 case NT_ARM_HW_WATCH
:
14461 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14463 return _("NT_PSTATUS (pstatus structure)");
14465 return _("NT_FPREGS (floating point registers)");
14467 return _("NT_PSINFO (psinfo structure)");
14469 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14471 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14472 case NT_WIN32PSTATUS
:
14473 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14475 return _("NT_SIGINFO (siginfo_t data)");
14477 return _("NT_FILE (mapped files)");
14485 return _("NT_VERSION (version)");
14487 return _("NT_ARCH (architecture)");
14492 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14497 print_core_note (Elf_Internal_Note
*pnote
)
14499 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14500 bfd_vma count
, page_size
;
14501 unsigned char *descdata
, *filenames
, *descend
;
14503 if (pnote
->type
!= NT_FILE
)
14509 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14510 /* Still "successful". */
14515 if (pnote
->descsz
< 2 * addr_size
)
14517 printf (_(" Malformed note - too short for header\n"));
14521 descdata
= (unsigned char *) pnote
->descdata
;
14522 descend
= descdata
+ pnote
->descsz
;
14524 if (descdata
[pnote
->descsz
- 1] != '\0')
14526 printf (_(" Malformed note - does not end with \\0\n"));
14530 count
= byte_get (descdata
, addr_size
);
14531 descdata
+= addr_size
;
14533 page_size
= byte_get (descdata
, addr_size
);
14534 descdata
+= addr_size
;
14536 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14538 printf (_(" Malformed note - too short for supplied file count\n"));
14542 printf (_(" Page size: "));
14543 print_vma (page_size
, DEC
);
14546 printf (_(" %*s%*s%*s\n"),
14547 (int) (2 + 2 * addr_size
), _("Start"),
14548 (int) (4 + 2 * addr_size
), _("End"),
14549 (int) (4 + 2 * addr_size
), _("Page Offset"));
14550 filenames
= descdata
+ count
* 3 * addr_size
;
14551 while (--count
> 0)
14553 bfd_vma start
, end
, file_ofs
;
14555 if (filenames
== descend
)
14557 printf (_(" Malformed note - filenames end too early\n"));
14561 start
= byte_get (descdata
, addr_size
);
14562 descdata
+= addr_size
;
14563 end
= byte_get (descdata
, addr_size
);
14564 descdata
+= addr_size
;
14565 file_ofs
= byte_get (descdata
, addr_size
);
14566 descdata
+= addr_size
;
14569 print_vma (start
, FULL_HEX
);
14571 print_vma (end
, FULL_HEX
);
14573 print_vma (file_ofs
, FULL_HEX
);
14574 printf ("\n %s\n", filenames
);
14576 filenames
+= 1 + strlen ((char *) filenames
);
14582 static const char *
14583 get_gnu_elf_note_type (unsigned e_type
)
14585 static char buff
[64];
14589 case NT_GNU_ABI_TAG
:
14590 return _("NT_GNU_ABI_TAG (ABI version tag)");
14592 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14593 case NT_GNU_BUILD_ID
:
14594 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14595 case NT_GNU_GOLD_VERSION
:
14596 return _("NT_GNU_GOLD_VERSION (gold version)");
14601 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14606 print_gnu_note (Elf_Internal_Note
*pnote
)
14608 switch (pnote
->type
)
14610 case NT_GNU_BUILD_ID
:
14614 printf (_(" Build ID: "));
14615 for (i
= 0; i
< pnote
->descsz
; ++i
)
14616 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14621 case NT_GNU_ABI_TAG
:
14623 unsigned long os
, major
, minor
, subminor
;
14624 const char *osname
;
14626 /* PR 17531: file: 030-599401-0.004. */
14627 if (pnote
->descsz
< 16)
14629 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14633 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14634 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14635 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14636 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14640 case GNU_ABI_TAG_LINUX
:
14643 case GNU_ABI_TAG_HURD
:
14646 case GNU_ABI_TAG_SOLARIS
:
14647 osname
= "Solaris";
14649 case GNU_ABI_TAG_FREEBSD
:
14650 osname
= "FreeBSD";
14652 case GNU_ABI_TAG_NETBSD
:
14656 osname
= "Unknown";
14660 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14661 major
, minor
, subminor
);
14665 case NT_GNU_GOLD_VERSION
:
14669 printf (_(" Version: "));
14670 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14671 printf ("%c", pnote
->descdata
[i
]);
14680 static const char *
14681 get_netbsd_elfcore_note_type (unsigned e_type
)
14683 static char buff
[64];
14685 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14687 /* NetBSD core "procinfo" structure. */
14688 return _("NetBSD procinfo structure");
14691 /* As of Jan 2002 there are no other machine-independent notes
14692 defined for NetBSD core files. If the note type is less
14693 than the start of the machine-dependent note types, we don't
14696 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14698 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14702 switch (elf_header
.e_machine
)
14704 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14705 and PT_GETFPREGS == mach+2. */
14710 case EM_SPARC32PLUS
:
14714 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14715 return _("PT_GETREGS (reg structure)");
14716 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14717 return _("PT_GETFPREGS (fpreg structure)");
14723 /* On all other arch's, PT_GETREGS == mach+1 and
14724 PT_GETFPREGS == mach+3. */
14728 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14729 return _("PT_GETREGS (reg structure)");
14730 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14731 return _("PT_GETFPREGS (fpreg structure)");
14737 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14738 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14742 static const char *
14743 get_stapsdt_note_type (unsigned e_type
)
14745 static char buff
[64];
14750 return _("NT_STAPSDT (SystemTap probe descriptors)");
14756 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14761 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14763 int addr_size
= is_32bit_elf
? 4 : 8;
14764 char *data
= pnote
->descdata
;
14765 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14766 bfd_vma pc
, base_addr
, semaphore
;
14767 char *provider
, *probe
, *arg_fmt
;
14769 pc
= byte_get ((unsigned char *) data
, addr_size
);
14771 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14773 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14777 data
+= strlen (data
) + 1;
14779 data
+= strlen (data
) + 1;
14781 data
+= strlen (data
) + 1;
14783 printf (_(" Provider: %s\n"), provider
);
14784 printf (_(" Name: %s\n"), probe
);
14785 printf (_(" Location: "));
14786 print_vma (pc
, FULL_HEX
);
14787 printf (_(", Base: "));
14788 print_vma (base_addr
, FULL_HEX
);
14789 printf (_(", Semaphore: "));
14790 print_vma (semaphore
, FULL_HEX
);
14792 printf (_(" Arguments: %s\n"), arg_fmt
);
14794 return data
== data_end
;
14797 static const char *
14798 get_ia64_vms_note_type (unsigned e_type
)
14800 static char buff
[64];
14805 return _("NT_VMS_MHD (module header)");
14807 return _("NT_VMS_LNM (language name)");
14809 return _("NT_VMS_SRC (source files)");
14811 return "NT_VMS_TITLE";
14813 return _("NT_VMS_EIDC (consistency check)");
14814 case NT_VMS_FPMODE
:
14815 return _("NT_VMS_FPMODE (FP mode)");
14816 case NT_VMS_LINKTIME
:
14817 return "NT_VMS_LINKTIME";
14818 case NT_VMS_IMGNAM
:
14819 return _("NT_VMS_IMGNAM (image name)");
14821 return _("NT_VMS_IMGID (image id)");
14822 case NT_VMS_LINKID
:
14823 return _("NT_VMS_LINKID (link id)");
14824 case NT_VMS_IMGBID
:
14825 return _("NT_VMS_IMGBID (build id)");
14826 case NT_VMS_GSTNAM
:
14827 return _("NT_VMS_GSTNAM (sym table name)");
14828 case NT_VMS_ORIG_DYN
:
14829 return "NT_VMS_ORIG_DYN";
14830 case NT_VMS_PATCHTIME
:
14831 return "NT_VMS_PATCHTIME";
14833 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14839 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14841 switch (pnote
->type
)
14844 if (pnote
->descsz
> 36)
14846 size_t l
= strlen (pnote
->descdata
+ 34);
14847 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14848 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14849 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14850 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14853 printf (_(" Invalid size\n"));
14856 printf (_(" Language: %s\n"), pnote
->descdata
);
14859 case NT_VMS_FPMODE
:
14860 printf (_(" Floating Point mode: "));
14861 printf ("0x%016" BFD_VMA_FMT
"x\n",
14862 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14864 case NT_VMS_LINKTIME
:
14865 printf (_(" Link time: "));
14867 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14870 case NT_VMS_PATCHTIME
:
14871 printf (_(" Patch time: "));
14873 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14876 case NT_VMS_ORIG_DYN
:
14877 printf (_(" Major id: %u, minor id: %u\n"),
14878 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14879 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14880 printf (_(" Last modified : "));
14882 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14883 printf (_("\n Link flags : "));
14884 printf ("0x%016" BFD_VMA_FMT
"x\n",
14885 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14886 printf (_(" Header flags: 0x%08x\n"),
14887 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14888 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14891 case NT_VMS_IMGNAM
:
14892 printf (_(" Image name: %s\n"), pnote
->descdata
);
14894 case NT_VMS_GSTNAM
:
14895 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14898 printf (_(" Image id: %s\n"), pnote
->descdata
);
14900 case NT_VMS_LINKID
:
14901 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14909 /* Note that by the ELF standard, the name field is already null byte
14910 terminated, and namesz includes the terminating null byte.
14911 I.E. the value of namesz for the name "FSF" is 4.
14913 If the value of namesz is zero, there is no name present. */
14915 process_note (Elf_Internal_Note
* pnote
)
14917 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14920 if (pnote
->namesz
== 0)
14921 /* If there is no note name, then use the default set of
14922 note type strings. */
14923 nt
= get_note_type (pnote
->type
);
14925 else if (const_strneq (pnote
->namedata
, "GNU"))
14926 /* GNU-specific object file notes. */
14927 nt
= get_gnu_elf_note_type (pnote
->type
);
14929 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14930 /* NetBSD-specific core file notes. */
14931 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14933 else if (strneq (pnote
->namedata
, "SPU/", 4))
14935 /* SPU-specific core file notes. */
14936 nt
= pnote
->namedata
+ 4;
14940 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14941 /* VMS/ia64-specific file notes. */
14942 nt
= get_ia64_vms_note_type (pnote
->type
);
14944 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14945 nt
= get_stapsdt_note_type (pnote
->type
);
14948 /* Don't recognize this note name; just use the default set of
14949 note type strings. */
14950 nt
= get_note_type (pnote
->type
);
14952 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14954 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14955 return print_ia64_vms_note (pnote
);
14956 else if (const_strneq (pnote
->namedata
, "GNU"))
14957 return print_gnu_note (pnote
);
14958 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14959 return print_stapsdt_note (pnote
);
14960 else if (const_strneq (pnote
->namedata
, "CORE"))
14961 return print_core_note (pnote
);
14968 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14970 Elf_External_Note
* pnotes
;
14971 Elf_External_Note
* external
;
14977 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14979 if (pnotes
== NULL
)
14984 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14985 (unsigned long) offset
, (unsigned long) length
);
14986 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14988 while ((char *) external
< (char *) pnotes
+ length
)
14990 Elf_Internal_Note inote
;
14993 char * temp
= NULL
;
14994 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14996 if (!is_ia64_vms ())
14998 /* PR binutils/15191
14999 Make sure that there is enough data to read. */
15000 min_notesz
= offsetof (Elf_External_Note
, name
);
15001 if (data_remaining
< min_notesz
)
15003 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15004 (int) data_remaining
);
15007 inote
.type
= BYTE_GET (external
->type
);
15008 inote
.namesz
= BYTE_GET (external
->namesz
);
15009 inote
.namedata
= external
->name
;
15010 inote
.descsz
= BYTE_GET (external
->descsz
);
15011 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15012 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15013 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15017 Elf64_External_VMS_Note
*vms_external
;
15019 /* PR binutils/15191
15020 Make sure that there is enough data to read. */
15021 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15022 if (data_remaining
< min_notesz
)
15024 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15025 (int) data_remaining
);
15029 vms_external
= (Elf64_External_VMS_Note
*) external
;
15030 inote
.type
= BYTE_GET (vms_external
->type
);
15031 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15032 inote
.namedata
= vms_external
->name
;
15033 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15034 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15035 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15036 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15039 if (inote
.descdata
< (char *) external
+ min_notesz
15040 || next
< (char *) external
+ min_notesz
15041 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15042 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15043 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15044 || data_remaining
< (size_t)(next
- (char *) external
))
15046 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15047 (unsigned long) ((char *) external
- (char *) pnotes
));
15048 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15049 inote
.type
, inote
.namesz
, inote
.descsz
);
15053 external
= (Elf_External_Note
*) next
;
15055 /* Verify that name is null terminated. It appears that at least
15056 one version of Linux (RedHat 6.0) generates corefiles that don't
15057 comply with the ELF spec by failing to include the null byte in
15059 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15061 temp
= (char *) malloc (inote
.namesz
+ 1);
15064 error (_("Out of memory allocating space for inote name\n"));
15069 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15070 temp
[inote
.namesz
] = 0;
15072 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15073 inote
.namedata
= temp
;
15076 res
&= process_note (& inote
);
15091 process_corefile_note_segments (FILE * file
)
15093 Elf_Internal_Phdr
* segment
;
15097 if (! get_program_headers (file
))
15100 for (i
= 0, segment
= program_headers
;
15101 i
< elf_header
.e_phnum
;
15104 if (segment
->p_type
== PT_NOTE
)
15105 res
&= process_corefile_note_segment (file
,
15106 (bfd_vma
) segment
->p_offset
,
15107 (bfd_vma
) segment
->p_filesz
);
15114 process_note_sections (FILE * file
)
15116 Elf_Internal_Shdr
* section
;
15121 for (i
= 0, section
= section_headers
;
15122 i
< elf_header
.e_shnum
&& section
!= NULL
;
15124 if (section
->sh_type
== SHT_NOTE
)
15126 res
&= process_corefile_note_segment (file
,
15127 (bfd_vma
) section
->sh_offset
,
15128 (bfd_vma
) section
->sh_size
);
15133 /* Try processing NOTE segments instead. */
15134 return process_corefile_note_segments (file
);
15140 process_notes (FILE * file
)
15142 /* If we have not been asked to display the notes then do nothing. */
15146 if (elf_header
.e_type
!= ET_CORE
)
15147 return process_note_sections (file
);
15149 /* No program headers means no NOTE segment. */
15150 if (elf_header
.e_phnum
> 0)
15151 return process_corefile_note_segments (file
);
15153 printf (_("No note segments present in the core file.\n"));
15158 process_arch_specific (FILE * file
)
15163 switch (elf_header
.e_machine
)
15166 return process_arm_specific (file
);
15168 case EM_MIPS_RS3_LE
:
15169 return process_mips_specific (file
);
15172 return process_nds32_specific (file
);
15175 return process_power_specific (file
);
15178 case EM_SPARC32PLUS
:
15180 return process_sparc_specific (file
);
15183 return process_tic6x_specific (file
);
15186 return process_msp430x_specific (file
);
15194 get_file_header (FILE * file
)
15196 /* Read in the identity array. */
15197 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15200 /* Determine how to read the rest of the header. */
15201 switch (elf_header
.e_ident
[EI_DATA
])
15203 default: /* fall through */
15204 case ELFDATANONE
: /* fall through */
15206 byte_get
= byte_get_little_endian
;
15207 byte_put
= byte_put_little_endian
;
15210 byte_get
= byte_get_big_endian
;
15211 byte_put
= byte_put_big_endian
;
15215 /* For now we only support 32 bit and 64 bit ELF files. */
15216 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15218 /* Read in the rest of the header. */
15221 Elf32_External_Ehdr ehdr32
;
15223 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15226 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15227 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15228 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15229 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15230 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15231 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15232 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15233 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15234 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15235 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15236 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15237 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15238 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15242 Elf64_External_Ehdr ehdr64
;
15244 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15245 we will not be able to cope with the 64bit data found in
15246 64 ELF files. Detect this now and abort before we start
15247 overwriting things. */
15248 if (sizeof (bfd_vma
) < 8)
15250 error (_("This instance of readelf has been built without support for a\n\
15251 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15255 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15258 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15259 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15260 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15261 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15262 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15263 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15264 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15265 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15266 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15267 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15268 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15269 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15270 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15273 if (elf_header
.e_shoff
)
15275 /* There may be some extensions in the first section header. Don't
15276 bomb if we can't read it. */
15278 get_32bit_section_headers (file
, TRUE
);
15280 get_64bit_section_headers (file
, TRUE
);
15286 /* Process one ELF object file according to the command line options.
15287 This file may actually be stored in an archive. The file is
15288 positioned at the start of the ELF object. */
15291 process_object (char * file_name
, FILE * file
)
15295 if (! get_file_header (file
))
15297 error (_("%s: Failed to read file header\n"), file_name
);
15301 /* Initialise per file variables. */
15302 for (i
= ARRAY_SIZE (version_info
); i
--;)
15303 version_info
[i
] = 0;
15305 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15306 dynamic_info
[i
] = 0;
15307 dynamic_info_DT_GNU_HASH
= 0;
15309 /* Process the file. */
15311 printf (_("\nFile: %s\n"), file_name
);
15313 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15314 Note we do this even if cmdline_dump_sects is empty because we
15315 must make sure that the dump_sets array is zeroed out before each
15316 object file is processed. */
15317 if (num_dump_sects
> num_cmdline_dump_sects
)
15318 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15320 if (num_cmdline_dump_sects
> 0)
15322 if (num_dump_sects
== 0)
15323 /* A sneaky way of allocating the dump_sects array. */
15324 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15326 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15327 memcpy (dump_sects
, cmdline_dump_sects
,
15328 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15331 if (! process_file_header ())
15334 if (! process_section_headers (file
))
15336 /* Without loaded section headers we cannot process lots of
15338 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15340 if (! do_using_dynamic
)
15341 do_syms
= do_dyn_syms
= do_reloc
= 0;
15344 if (! process_section_groups (file
))
15346 /* Without loaded section groups we cannot process unwind. */
15350 if (process_program_headers (file
))
15351 process_dynamic_section (file
);
15353 process_relocs (file
);
15355 process_unwind (file
);
15357 process_symbol_table (file
);
15359 process_syminfo (file
);
15361 process_version_sections (file
);
15363 process_section_contents (file
);
15365 process_notes (file
);
15367 process_gnu_liblist (file
);
15369 process_arch_specific (file
);
15371 if (program_headers
)
15373 free (program_headers
);
15374 program_headers
= NULL
;
15377 if (section_headers
)
15379 free (section_headers
);
15380 section_headers
= NULL
;
15385 free (string_table
);
15386 string_table
= NULL
;
15387 string_table_length
= 0;
15390 if (dynamic_strings
)
15392 free (dynamic_strings
);
15393 dynamic_strings
= NULL
;
15394 dynamic_strings_length
= 0;
15397 if (dynamic_symbols
)
15399 free (dynamic_symbols
);
15400 dynamic_symbols
= NULL
;
15401 num_dynamic_syms
= 0;
15404 if (dynamic_syminfo
)
15406 free (dynamic_syminfo
);
15407 dynamic_syminfo
= NULL
;
15410 if (dynamic_section
)
15412 free (dynamic_section
);
15413 dynamic_section
= NULL
;
15416 if (section_headers_groups
)
15418 free (section_headers_groups
);
15419 section_headers_groups
= NULL
;
15422 if (section_groups
)
15424 struct group_list
* g
;
15425 struct group_list
* next
;
15427 for (i
= 0; i
< group_count
; i
++)
15429 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15436 free (section_groups
);
15437 section_groups
= NULL
;
15440 free_debug_memory ();
15445 /* Process an ELF archive.
15446 On entry the file is positioned just after the ARMAG string. */
15449 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15451 struct archive_info arch
;
15452 struct archive_info nested_arch
;
15458 /* The ARCH structure is used to hold information about this archive. */
15459 arch
.file_name
= NULL
;
15461 arch
.index_array
= NULL
;
15462 arch
.sym_table
= NULL
;
15463 arch
.longnames
= NULL
;
15465 /* The NESTED_ARCH structure is used as a single-item cache of information
15466 about a nested archive (when members of a thin archive reside within
15467 another regular archive file). */
15468 nested_arch
.file_name
= NULL
;
15469 nested_arch
.file
= NULL
;
15470 nested_arch
.index_array
= NULL
;
15471 nested_arch
.sym_table
= NULL
;
15472 nested_arch
.longnames
= NULL
;
15474 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15480 if (do_archive_index
)
15482 if (arch
.sym_table
== NULL
)
15483 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15486 unsigned long i
, l
;
15487 unsigned long current_pos
;
15489 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15490 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15491 current_pos
= ftell (file
);
15493 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15495 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15497 char * member_name
;
15499 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15501 if (member_name
!= NULL
)
15503 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15505 if (qualified_name
!= NULL
)
15507 printf (_("Contents of binary %s at offset "), qualified_name
);
15508 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15510 free (qualified_name
);
15515 if (l
>= arch
.sym_size
)
15517 error (_("%s: end of the symbol table reached before the end of the index\n"),
15521 /* PR 17531: file: 0b6630b2. */
15522 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15523 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15526 if (arch
.uses_64bit_indicies
)
15531 if (l
< arch
.sym_size
)
15532 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15533 file_name
, arch
.sym_size
- l
);
15535 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15537 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15543 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15544 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15545 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15546 && !do_section_groups
&& !do_dyn_syms
)
15548 ret
= 0; /* Archive index only. */
15559 char * qualified_name
;
15561 /* Read the next archive header. */
15562 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15564 error (_("%s: failed to seek to next archive header\n"), file_name
);
15567 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15568 if (got
!= sizeof arch
.arhdr
)
15572 error (_("%s: failed to read archive header\n"), file_name
);
15576 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15578 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15583 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15585 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15586 if (archive_file_size
& 01)
15587 ++archive_file_size
;
15589 name
= get_archive_member_name (&arch
, &nested_arch
);
15592 error (_("%s: bad archive file name\n"), file_name
);
15596 namelen
= strlen (name
);
15598 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15599 if (qualified_name
== NULL
)
15601 error (_("%s: bad archive file name\n"), file_name
);
15606 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15608 /* This is a proxy for an external member of a thin archive. */
15609 FILE * member_file
;
15610 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15611 if (member_file_name
== NULL
)
15617 member_file
= fopen (member_file_name
, "rb");
15618 if (member_file
== NULL
)
15620 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15621 free (member_file_name
);
15626 archive_file_offset
= arch
.nested_member_origin
;
15628 ret
|= process_object (qualified_name
, member_file
);
15630 fclose (member_file
);
15631 free (member_file_name
);
15633 else if (is_thin_archive
)
15635 /* PR 15140: Allow for corrupt thin archives. */
15636 if (nested_arch
.file
== NULL
)
15638 error (_("%s: contains corrupt thin archive: %s\n"),
15644 /* This is a proxy for a member of a nested archive. */
15645 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15647 /* The nested archive file will have been opened and setup by
15648 get_archive_member_name. */
15649 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15651 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15656 ret
|= process_object (qualified_name
, nested_arch
.file
);
15660 archive_file_offset
= arch
.next_arhdr_offset
;
15661 arch
.next_arhdr_offset
+= archive_file_size
;
15663 ret
|= process_object (qualified_name
, file
);
15666 if (dump_sects
!= NULL
)
15670 num_dump_sects
= 0;
15673 free (qualified_name
);
15677 if (nested_arch
.file
!= NULL
)
15678 fclose (nested_arch
.file
);
15679 release_archive (&nested_arch
);
15680 release_archive (&arch
);
15686 process_file (char * file_name
)
15689 struct stat statbuf
;
15690 char armag
[SARMAG
];
15693 if (stat (file_name
, &statbuf
) < 0)
15695 if (errno
== ENOENT
)
15696 error (_("'%s': No such file\n"), file_name
);
15698 error (_("Could not locate '%s'. System error message: %s\n"),
15699 file_name
, strerror (errno
));
15703 if (! S_ISREG (statbuf
.st_mode
))
15705 error (_("'%s' is not an ordinary file\n"), file_name
);
15709 file
= fopen (file_name
, "rb");
15712 error (_("Input file '%s' is not readable.\n"), file_name
);
15716 if (fread (armag
, SARMAG
, 1, file
) != 1)
15718 error (_("%s: Failed to read file's magic number\n"), file_name
);
15723 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15725 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15726 ret
= process_archive (file_name
, file
, FALSE
);
15727 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15728 ret
= process_archive (file_name
, file
, TRUE
);
15731 if (do_archive_index
)
15732 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15736 archive_file_size
= archive_file_offset
= 0;
15737 ret
= process_object (file_name
, file
);
15742 current_file_size
= 0;
15746 #ifdef SUPPORT_DISASSEMBLY
15747 /* Needed by the i386 disassembler. For extra credit, someone could
15748 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15752 print_address (unsigned int addr
, FILE * outfile
)
15754 fprintf (outfile
,"0x%8.8x", addr
);
15757 /* Needed by the i386 disassembler. */
15759 db_task_printsym (unsigned int addr
)
15761 print_address (addr
, stderr
);
15766 main (int argc
, char ** argv
)
15770 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15771 setlocale (LC_MESSAGES
, "");
15773 #if defined (HAVE_SETLOCALE)
15774 setlocale (LC_CTYPE
, "");
15776 bindtextdomain (PACKAGE
, LOCALEDIR
);
15777 textdomain (PACKAGE
);
15779 expandargv (&argc
, &argv
);
15781 parse_args (argc
, argv
);
15783 if (num_dump_sects
> 0)
15785 /* Make a copy of the dump_sects array. */
15786 cmdline_dump_sects
= (dump_type
*)
15787 malloc (num_dump_sects
* sizeof (* dump_sects
));
15788 if (cmdline_dump_sects
== NULL
)
15789 error (_("Out of memory allocating dump request table.\n"));
15792 memcpy (cmdline_dump_sects
, dump_sects
,
15793 num_dump_sects
* sizeof (* dump_sects
));
15794 num_cmdline_dump_sects
= num_dump_sects
;
15798 if (optind
< (argc
- 1))
15802 while (optind
< argc
)
15803 err
|= process_file (argv
[optind
++]);
15805 if (dump_sects
!= NULL
)
15807 if (cmdline_dump_sects
!= NULL
)
15808 free (cmdline_dump_sects
);