1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/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 char * procname
;
6495 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6496 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6498 fputs ("\n<", stdout
);
6502 fputs (procname
, stdout
);
6505 printf ("+%lx", (unsigned long) offset
);
6508 fputs (">: [", stdout
);
6509 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6510 fputc ('-', stdout
);
6511 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6512 printf ("], info at +0x%lx\n",
6513 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6515 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6516 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6518 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6519 (unsigned) UNW_VER (stamp
),
6520 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6521 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6522 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6523 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6525 if (UNW_VER (stamp
) != 1)
6527 printf (_("\tUnknown version.\n"));
6532 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6533 dp
= unw_decode (dp
, in_body
, & in_body
);
6538 slurp_ia64_unwind_table (FILE * file
,
6539 struct ia64_unw_aux_info
* aux
,
6540 Elf_Internal_Shdr
* sec
)
6542 unsigned long size
, nrelas
, i
;
6543 Elf_Internal_Phdr
* seg
;
6544 struct ia64_unw_table_entry
* tep
;
6545 Elf_Internal_Shdr
* relsec
;
6546 Elf_Internal_Rela
* rela
;
6547 Elf_Internal_Rela
* rp
;
6548 unsigned char * table
;
6550 Elf_Internal_Sym
* sym
;
6551 const char * relname
;
6553 /* First, find the starting address of the segment that includes
6556 if (elf_header
.e_phnum
)
6558 if (! get_program_headers (file
))
6561 for (seg
= program_headers
;
6562 seg
< program_headers
+ elf_header
.e_phnum
;
6565 if (seg
->p_type
!= PT_LOAD
)
6568 if (sec
->sh_addr
>= seg
->p_vaddr
6569 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6571 aux
->seg_base
= seg
->p_vaddr
;
6577 /* Second, build the unwind table from the contents of the unwind section: */
6578 size
= sec
->sh_size
;
6579 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6584 aux
->table
= (struct ia64_unw_table_entry
*)
6585 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6587 for (tp
= table
; tp
< table
+ size
; ++tep
)
6589 tep
->start
.section
= SHN_UNDEF
;
6590 tep
->end
.section
= SHN_UNDEF
;
6591 tep
->info
.section
= SHN_UNDEF
;
6592 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6593 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6594 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6595 tep
->start
.offset
+= aux
->seg_base
;
6596 tep
->end
.offset
+= aux
->seg_base
;
6597 tep
->info
.offset
+= aux
->seg_base
;
6601 /* Third, apply any relocations to the unwind table: */
6602 for (relsec
= section_headers
;
6603 relsec
< section_headers
+ elf_header
.e_shnum
;
6606 if (relsec
->sh_type
!= SHT_RELA
6607 || relsec
->sh_info
>= elf_header
.e_shnum
6608 || section_headers
+ relsec
->sh_info
!= sec
)
6611 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6615 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6617 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6618 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6620 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6622 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6626 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6628 switch (rp
->r_offset
/eh_addr_size
% 3)
6631 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6632 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6635 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6636 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6639 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6640 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6650 aux
->table_len
= size
/ (3 * eh_addr_size
);
6655 ia64_process_unwind (FILE * file
)
6657 Elf_Internal_Shdr
* sec
;
6658 Elf_Internal_Shdr
* unwsec
= NULL
;
6659 Elf_Internal_Shdr
* strsec
;
6660 unsigned long i
, unwcount
= 0, unwstart
= 0;
6661 struct ia64_unw_aux_info aux
;
6663 memset (& aux
, 0, sizeof (aux
));
6665 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6667 if (sec
->sh_type
== SHT_SYMTAB
6668 && sec
->sh_link
< elf_header
.e_shnum
)
6670 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6672 strsec
= section_headers
+ sec
->sh_link
;
6673 if (aux
.strtab
!= NULL
)
6675 error (_("Multiple auxillary string tables encountered\n"));
6678 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6681 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6683 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6688 printf (_("\nThere are no unwind sections in this file.\n"));
6690 while (unwcount
-- > 0)
6695 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6696 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6697 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6702 /* We have already counted the number of SHT_IA64_UNWIND
6703 sections so the loop above should never fail. */
6704 assert (unwsec
!= NULL
);
6707 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6709 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6711 /* We need to find which section group it is in. */
6712 struct group_list
* g
;
6714 if (section_headers_groups
== NULL
6715 || section_headers_groups
[i
] == NULL
)
6716 i
= elf_header
.e_shnum
;
6719 g
= section_headers_groups
[i
]->root
;
6721 for (; g
!= NULL
; g
= g
->next
)
6723 sec
= section_headers
+ g
->section_index
;
6725 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6730 i
= elf_header
.e_shnum
;
6733 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6735 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6736 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6737 suffix
= SECTION_NAME (unwsec
) + len
;
6738 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6740 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6741 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6746 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6747 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6748 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6749 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6751 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6752 suffix
= SECTION_NAME (unwsec
) + len
;
6753 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6755 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6756 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6760 if (i
== elf_header
.e_shnum
)
6762 printf (_("\nCould not find unwind info section for "));
6764 if (string_table
== NULL
)
6765 printf ("%d", unwsec
->sh_name
);
6767 printf ("'%s'", printable_section_name (unwsec
));
6771 aux
.info_addr
= sec
->sh_addr
;
6772 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6775 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6777 printf (_("\nUnwind section "));
6779 if (string_table
== NULL
)
6780 printf ("%d", unwsec
->sh_name
);
6782 printf ("'%s'", printable_section_name (unwsec
));
6784 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6785 (unsigned long) unwsec
->sh_offset
,
6786 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6788 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6790 if (aux
.table_len
> 0)
6791 dump_ia64_unwind (& aux
);
6794 free ((char *) aux
.table
);
6796 free ((char *) aux
.info
);
6805 free ((char *) aux
.strtab
);
6808 struct hppa_unw_table_entry
6810 struct absaddr start
;
6812 unsigned int Cannot_unwind
:1; /* 0 */
6813 unsigned int Millicode
:1; /* 1 */
6814 unsigned int Millicode_save_sr0
:1; /* 2 */
6815 unsigned int Region_description
:2; /* 3..4 */
6816 unsigned int reserved1
:1; /* 5 */
6817 unsigned int Entry_SR
:1; /* 6 */
6818 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6819 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6820 unsigned int Args_stored
:1; /* 16 */
6821 unsigned int Variable_Frame
:1; /* 17 */
6822 unsigned int Separate_Package_Body
:1; /* 18 */
6823 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6824 unsigned int Stack_Overflow_Check
:1; /* 20 */
6825 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6826 unsigned int Ada_Region
:1; /* 22 */
6827 unsigned int cxx_info
:1; /* 23 */
6828 unsigned int cxx_try_catch
:1; /* 24 */
6829 unsigned int sched_entry_seq
:1; /* 25 */
6830 unsigned int reserved2
:1; /* 26 */
6831 unsigned int Save_SP
:1; /* 27 */
6832 unsigned int Save_RP
:1; /* 28 */
6833 unsigned int Save_MRP_in_frame
:1; /* 29 */
6834 unsigned int extn_ptr_defined
:1; /* 30 */
6835 unsigned int Cleanup_defined
:1; /* 31 */
6837 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6838 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6839 unsigned int Large_frame
:1; /* 2 */
6840 unsigned int Pseudo_SP_Set
:1; /* 3 */
6841 unsigned int reserved4
:1; /* 4 */
6842 unsigned int Total_frame_size
:27; /* 5..31 */
6845 struct hppa_unw_aux_info
6847 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6848 unsigned long table_len
; /* Length of unwind table. */
6849 bfd_vma seg_base
; /* Starting address of segment. */
6850 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6851 unsigned long nsyms
; /* Number of symbols. */
6852 char * strtab
; /* The string table. */
6853 unsigned long strtab_size
; /* Size of string table. */
6857 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6859 struct hppa_unw_table_entry
* tp
;
6861 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6864 const char * procname
;
6866 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6867 aux
->strtab_size
, tp
->start
, &procname
,
6870 fputs ("\n<", stdout
);
6874 fputs (procname
, stdout
);
6877 printf ("+%lx", (unsigned long) offset
);
6880 fputs (">: [", stdout
);
6881 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6882 fputc ('-', stdout
);
6883 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6886 #define PF(_m) if (tp->_m) printf (#_m " ");
6887 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6890 PF(Millicode_save_sr0
);
6891 /* PV(Region_description); */
6897 PF(Separate_Package_Body
);
6898 PF(Frame_Extension_Millicode
);
6899 PF(Stack_Overflow_Check
);
6900 PF(Two_Instruction_SP_Increment
);
6904 PF(sched_entry_seq
);
6907 PF(Save_MRP_in_frame
);
6908 PF(extn_ptr_defined
);
6909 PF(Cleanup_defined
);
6910 PF(MPE_XL_interrupt_marker
);
6911 PF(HP_UX_interrupt_marker
);
6914 PV(Total_frame_size
);
6923 slurp_hppa_unwind_table (FILE * file
,
6924 struct hppa_unw_aux_info
* aux
,
6925 Elf_Internal_Shdr
* sec
)
6927 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6928 Elf_Internal_Phdr
* seg
;
6929 struct hppa_unw_table_entry
* tep
;
6930 Elf_Internal_Shdr
* relsec
;
6931 Elf_Internal_Rela
* rela
;
6932 Elf_Internal_Rela
* rp
;
6933 unsigned char * table
;
6935 Elf_Internal_Sym
* sym
;
6936 const char * relname
;
6938 /* First, find the starting address of the segment that includes
6941 if (elf_header
.e_phnum
)
6943 if (! get_program_headers (file
))
6946 for (seg
= program_headers
;
6947 seg
< program_headers
+ elf_header
.e_phnum
;
6950 if (seg
->p_type
!= PT_LOAD
)
6953 if (sec
->sh_addr
>= seg
->p_vaddr
6954 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6956 aux
->seg_base
= seg
->p_vaddr
;
6962 /* Second, build the unwind table from the contents of the unwind
6964 size
= sec
->sh_size
;
6965 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6971 nentries
= size
/ unw_ent_size
;
6972 size
= unw_ent_size
* nentries
;
6974 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6975 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6977 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6979 unsigned int tmp1
, tmp2
;
6981 tep
->start
.section
= SHN_UNDEF
;
6982 tep
->end
.section
= SHN_UNDEF
;
6984 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6985 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6986 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6987 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6989 tep
->start
.offset
+= aux
->seg_base
;
6990 tep
->end
.offset
+= aux
->seg_base
;
6992 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6993 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6994 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6995 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6996 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6997 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6998 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6999 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7000 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7001 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7002 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7003 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7004 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7005 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7006 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7007 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7008 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7009 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7010 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7011 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7012 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7013 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7014 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7015 tep
->Cleanup_defined
= tmp1
& 0x1;
7017 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7018 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7019 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7020 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7021 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7022 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7026 /* Third, apply any relocations to the unwind table. */
7027 for (relsec
= section_headers
;
7028 relsec
< section_headers
+ elf_header
.e_shnum
;
7031 if (relsec
->sh_type
!= SHT_RELA
7032 || relsec
->sh_info
>= elf_header
.e_shnum
7033 || section_headers
+ relsec
->sh_info
!= sec
)
7036 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7040 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7042 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7043 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7045 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7046 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7048 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7052 i
= rp
->r_offset
/ unw_ent_size
;
7054 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7057 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7058 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7061 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7062 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7072 aux
->table_len
= nentries
;
7078 hppa_process_unwind (FILE * file
)
7080 struct hppa_unw_aux_info aux
;
7081 Elf_Internal_Shdr
* unwsec
= NULL
;
7082 Elf_Internal_Shdr
* strsec
;
7083 Elf_Internal_Shdr
* sec
;
7086 if (string_table
== NULL
)
7089 memset (& aux
, 0, sizeof (aux
));
7091 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7093 if (sec
->sh_type
== SHT_SYMTAB
7094 && sec
->sh_link
< elf_header
.e_shnum
)
7096 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7098 strsec
= section_headers
+ sec
->sh_link
;
7099 if (aux
.strtab
!= NULL
)
7101 error (_("Multiple auxillary string tables encountered\n"));
7104 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7107 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7109 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7114 printf (_("\nThere are no unwind sections in this file.\n"));
7116 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7118 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7120 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7121 printable_section_name (sec
),
7122 (unsigned long) sec
->sh_offset
,
7123 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7125 slurp_hppa_unwind_table (file
, &aux
, sec
);
7126 if (aux
.table_len
> 0)
7127 dump_hppa_unwind (&aux
);
7130 free ((char *) aux
.table
);
7138 free ((char *) aux
.strtab
);
7143 unsigned char * data
; /* The unwind data. */
7144 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7145 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7146 unsigned long nrelas
; /* The number of relocations. */
7147 unsigned int rel_type
; /* REL or RELA ? */
7148 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7151 struct arm_unw_aux_info
7153 FILE * file
; /* The file containing the unwind sections. */
7154 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7155 unsigned long nsyms
; /* Number of symbols. */
7156 char * strtab
; /* The file's string table. */
7157 unsigned long strtab_size
; /* Size of string table. */
7161 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7162 bfd_vma fn
, struct absaddr addr
)
7164 const char *procname
;
7167 if (addr
.section
== SHN_UNDEF
)
7170 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
7171 aux
->strtab_size
, addr
, &procname
,
7174 print_vma (fn
, PREFIX_HEX
);
7178 fputs (" <", stdout
);
7179 fputs (procname
, stdout
);
7182 printf ("+0x%lx", (unsigned long) sym_offset
);
7183 fputc ('>', stdout
);
7190 arm_free_section (struct arm_section
*arm_sec
)
7192 if (arm_sec
->data
!= NULL
)
7193 free (arm_sec
->data
);
7195 if (arm_sec
->rela
!= NULL
)
7196 free (arm_sec
->rela
);
7199 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7200 cached section and install SEC instead.
7201 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7202 and return its valued in * WORDP, relocating if necessary.
7203 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7204 relocation's offset in ADDR.
7205 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7206 into the string table of the symbol associated with the reloc. If no
7207 reloc was applied store -1 there.
7208 5) Return TRUE upon success, FALSE otherwise. */
7211 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7212 struct arm_section
* arm_sec
,
7213 Elf_Internal_Shdr
* sec
,
7214 bfd_vma word_offset
,
7215 unsigned int * wordp
,
7216 struct absaddr
* addr
,
7219 Elf_Internal_Rela
*rp
;
7220 Elf_Internal_Sym
*sym
;
7221 const char * relname
;
7223 bfd_boolean wrapped
;
7225 if (sec
== NULL
|| arm_sec
== NULL
)
7228 addr
->section
= SHN_UNDEF
;
7231 if (sym_name
!= NULL
)
7232 *sym_name
= (bfd_vma
) -1;
7234 /* If necessary, update the section cache. */
7235 if (sec
!= arm_sec
->sec
)
7237 Elf_Internal_Shdr
*relsec
;
7239 arm_free_section (arm_sec
);
7242 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7243 sec
->sh_size
, _("unwind data"));
7244 arm_sec
->rela
= NULL
;
7245 arm_sec
->nrelas
= 0;
7247 for (relsec
= section_headers
;
7248 relsec
< section_headers
+ elf_header
.e_shnum
;
7251 if (relsec
->sh_info
>= elf_header
.e_shnum
7252 || section_headers
+ relsec
->sh_info
!= sec
7253 /* PR 15745: Check the section type as well. */
7254 || (relsec
->sh_type
!= SHT_REL
7255 && relsec
->sh_type
!= SHT_RELA
))
7258 arm_sec
->rel_type
= relsec
->sh_type
;
7259 if (relsec
->sh_type
== SHT_REL
)
7261 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7263 & arm_sec
->rela
, & arm_sec
->nrelas
))
7266 else /* relsec->sh_type == SHT_RELA */
7268 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7270 & arm_sec
->rela
, & arm_sec
->nrelas
))
7276 arm_sec
->next_rela
= arm_sec
->rela
;
7279 /* If there is no unwind data we can do nothing. */
7280 if (arm_sec
->data
== NULL
)
7283 /* If the offset is invalid then fail. */
7284 if (word_offset
> sec
->sh_size
- 4)
7287 /* Get the word at the required offset. */
7288 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7290 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7291 if (arm_sec
->rela
== NULL
)
7297 /* Look through the relocs to find the one that applies to the provided offset. */
7299 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7301 bfd_vma prelval
, offset
;
7303 if (rp
->r_offset
> word_offset
&& !wrapped
)
7308 if (rp
->r_offset
> word_offset
)
7311 if (rp
->r_offset
& 3)
7313 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7314 (unsigned long) rp
->r_offset
);
7318 if (rp
->r_offset
< word_offset
)
7321 /* PR 17531: file: 027-161405-0.004 */
7322 if (aux
->symtab
== NULL
)
7325 if (arm_sec
->rel_type
== SHT_REL
)
7327 offset
= word
& 0x7fffffff;
7328 if (offset
& 0x40000000)
7329 offset
|= ~ (bfd_vma
) 0x7fffffff;
7331 else if (arm_sec
->rel_type
== SHT_RELA
)
7332 offset
= rp
->r_addend
;
7335 error (_("Unknown section relocation type %d encountered\n"),
7340 /* PR 17531 file: 027-1241568-0.004. */
7341 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7343 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7344 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7348 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7349 offset
+= sym
->st_value
;
7350 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7352 /* Check that we are processing the expected reloc type. */
7353 if (elf_header
.e_machine
== EM_ARM
)
7355 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7356 if (relname
== NULL
)
7358 warn (_("Skipping unknown ARM relocation type: %d\n"),
7359 (int) ELF32_R_TYPE (rp
->r_info
));
7363 if (streq (relname
, "R_ARM_NONE"))
7366 if (! streq (relname
, "R_ARM_PREL31"))
7368 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7372 else if (elf_header
.e_machine
== EM_TI_C6000
)
7374 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7375 if (relname
== NULL
)
7377 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7378 (int) ELF32_R_TYPE (rp
->r_info
));
7382 if (streq (relname
, "R_C6000_NONE"))
7385 if (! streq (relname
, "R_C6000_PREL31"))
7387 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7395 /* This function currently only supports ARM and TI unwinders. */
7396 warn (_("Only TI and ARM unwinders are currently supported\n"));
7400 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7401 addr
->section
= sym
->st_shndx
;
7402 addr
->offset
= offset
;
7405 * sym_name
= sym
->st_name
;
7410 arm_sec
->next_rela
= rp
;
7415 static const char *tic6x_unwind_regnames
[16] =
7417 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7418 "A14", "A13", "A12", "A11", "A10",
7419 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7423 decode_tic6x_unwind_regmask (unsigned int mask
)
7427 for (i
= 12; mask
; mask
>>= 1, i
--)
7431 fputs (tic6x_unwind_regnames
[i
], stdout
);
7433 fputs (", ", stdout
);
7439 if (remaining == 0 && more_words) \
7442 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7443 data_offset, & word, & addr, NULL)) \
7449 #define GET_OP(OP) \
7454 (OP) = word >> 24; \
7459 printf (_("[Truncated opcode]\n")); \
7462 printf ("0x%02x ", OP)
7465 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7466 unsigned int word
, unsigned int remaining
,
7467 unsigned int more_words
,
7468 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7469 struct arm_section
*data_arm_sec
)
7471 struct absaddr addr
;
7473 /* Decode the unwinding instructions. */
7476 unsigned int op
, op2
;
7485 printf (" 0x%02x ", op
);
7487 if ((op
& 0xc0) == 0x00)
7489 int offset
= ((op
& 0x3f) << 2) + 4;
7491 printf (" vsp = vsp + %d", offset
);
7493 else if ((op
& 0xc0) == 0x40)
7495 int offset
= ((op
& 0x3f) << 2) + 4;
7497 printf (" vsp = vsp - %d", offset
);
7499 else if ((op
& 0xf0) == 0x80)
7502 if (op
== 0x80 && op2
== 0)
7503 printf (_("Refuse to unwind"));
7506 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7511 for (i
= 0; i
< 12; i
++)
7512 if (mask
& (1 << i
))
7518 printf ("r%d", 4 + i
);
7523 else if ((op
& 0xf0) == 0x90)
7525 if (op
== 0x9d || op
== 0x9f)
7526 printf (_(" [Reserved]"));
7528 printf (" vsp = r%d", op
& 0x0f);
7530 else if ((op
& 0xf0) == 0xa0)
7532 int end
= 4 + (op
& 0x07);
7537 for (i
= 4; i
<= end
; i
++)
7553 else if (op
== 0xb0)
7554 printf (_(" finish"));
7555 else if (op
== 0xb1)
7558 if (op2
== 0 || (op2
& 0xf0) != 0)
7559 printf (_("[Spare]"));
7562 unsigned int mask
= op2
& 0x0f;
7567 for (i
= 0; i
< 12; i
++)
7568 if (mask
& (1 << i
))
7579 else if (op
== 0xb2)
7581 unsigned char buf
[9];
7582 unsigned int i
, len
;
7583 unsigned long offset
;
7585 for (i
= 0; i
< sizeof (buf
); i
++)
7588 if ((buf
[i
] & 0x80) == 0)
7591 if (i
== sizeof (buf
))
7592 printf (_("corrupt change to vsp"));
7595 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7596 assert (len
== i
+ 1);
7597 offset
= offset
* 4 + 0x204;
7598 printf ("vsp = vsp + %ld", offset
);
7601 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7603 unsigned int first
, last
;
7610 printf ("pop {D%d", first
);
7612 printf ("-D%d", first
+ last
);
7615 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7617 unsigned int count
= op
& 0x07;
7621 printf ("-D%d", 8 + count
);
7624 else if (op
>= 0xc0 && op
<= 0xc5)
7626 unsigned int count
= op
& 0x07;
7628 printf (" pop {wR10");
7630 printf ("-wR%d", 10 + count
);
7633 else if (op
== 0xc6)
7635 unsigned int first
, last
;
7640 printf ("pop {wR%d", first
);
7642 printf ("-wR%d", first
+ last
);
7645 else if (op
== 0xc7)
7648 if (op2
== 0 || (op2
& 0xf0) != 0)
7649 printf (_("[Spare]"));
7652 unsigned int mask
= op2
& 0x0f;
7657 for (i
= 0; i
< 4; i
++)
7658 if (mask
& (1 << i
))
7664 printf ("wCGR%d", i
);
7670 printf (_(" [unsupported opcode]"));
7676 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7677 unsigned int word
, unsigned int remaining
,
7678 unsigned int more_words
,
7679 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7680 struct arm_section
*data_arm_sec
)
7682 struct absaddr addr
;
7684 /* Decode the unwinding instructions. */
7687 unsigned int op
, op2
;
7696 printf (" 0x%02x ", op
);
7698 if ((op
& 0xc0) == 0x00)
7700 int offset
= ((op
& 0x3f) << 3) + 8;
7701 printf (" sp = sp + %d", offset
);
7703 else if ((op
& 0xc0) == 0x80)
7706 if (op
== 0x80 && op2
== 0)
7707 printf (_("Refuse to unwind"));
7710 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7712 printf ("pop compact {");
7716 decode_tic6x_unwind_regmask (mask
);
7720 else if ((op
& 0xf0) == 0xc0)
7728 unsigned int offset
;
7732 /* Scan entire instruction first so that GET_OP output is not
7733 interleaved with disassembly. */
7735 for (i
= 0; nregs
< (op
& 0xf); i
++)
7741 regpos
[nregs
].offset
= i
* 2;
7742 regpos
[nregs
].reg
= reg
;
7749 regpos
[nregs
].offset
= i
* 2 + 1;
7750 regpos
[nregs
].reg
= reg
;
7755 printf (_("pop frame {"));
7757 for (i
= i
* 2; i
> 0; i
--)
7759 if (regpos
[reg
].offset
== i
- 1)
7761 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7768 fputs (name
, stdout
);
7775 else if (op
== 0xd0)
7776 printf (" MOV FP, SP");
7777 else if (op
== 0xd1)
7778 printf (" __c6xabi_pop_rts");
7779 else if (op
== 0xd2)
7781 unsigned char buf
[9];
7782 unsigned int i
, len
;
7783 unsigned long offset
;
7785 for (i
= 0; i
< sizeof (buf
); i
++)
7788 if ((buf
[i
] & 0x80) == 0)
7791 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7792 if (i
== sizeof (buf
))
7794 printf ("<corrupt sp adjust>\n");
7795 warn (_("Corrupt stack pointer adjustment detected\n"));
7799 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7800 assert (len
== i
+ 1);
7801 offset
= offset
* 8 + 0x408;
7802 printf (_("sp = sp + %ld"), offset
);
7804 else if ((op
& 0xf0) == 0xe0)
7806 if ((op
& 0x0f) == 7)
7809 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7813 printf (_(" [unsupported opcode]"));
7820 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7824 offset
= word
& 0x7fffffff;
7825 if (offset
& 0x40000000)
7826 offset
|= ~ (bfd_vma
) 0x7fffffff;
7828 if (elf_header
.e_machine
== EM_TI_C6000
)
7831 return offset
+ where
;
7835 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7837 unsigned int remaining
,
7838 bfd_vma data_offset
,
7839 Elf_Internal_Shdr
* data_sec
,
7840 struct arm_section
* data_arm_sec
)
7843 unsigned int more_words
= 0;
7844 struct absaddr addr
;
7845 bfd_vma sym_name
= (bfd_vma
) -1;
7849 /* Fetch the first word.
7850 Note - when decoding an object file the address extracted
7851 here will always be 0. So we also pass in the sym_name
7852 parameter so that we can find the symbol associated with
7853 the personality routine. */
7854 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7855 & word
, & addr
, & sym_name
))
7861 if ((word
& 0x80000000) == 0)
7863 /* Expand prel31 for personality routine. */
7865 const char *procname
;
7867 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7868 printf (_(" Personality routine: "));
7870 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7871 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7873 procname
= aux
->strtab
+ sym_name
;
7874 print_vma (fn
, PREFIX_HEX
);
7877 fputs (" <", stdout
);
7878 fputs (procname
, stdout
);
7879 fputc ('>', stdout
);
7883 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7884 fputc ('\n', stdout
);
7886 /* The GCC personality routines use the standard compact
7887 encoding, starting with one byte giving the number of
7889 if (procname
!= NULL
7890 && (const_strneq (procname
, "__gcc_personality_v0")
7891 || const_strneq (procname
, "__gxx_personality_v0")
7892 || const_strneq (procname
, "__gcj_personality_v0")
7893 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7900 printf (_(" [Truncated data]\n"));
7903 more_words
= word
>> 24;
7913 /* ARM EHABI Section 6.3:
7915 An exception-handling table entry for the compact model looks like:
7919 1 0 index Data for personalityRoutine[index] */
7921 if (elf_header
.e_machine
== EM_ARM
7922 && (word
& 0x70000000))
7923 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7925 per_index
= (word
>> 24) & 0x7f;
7926 printf (_(" Compact model index: %d\n"), per_index
);
7933 else if (per_index
< 3)
7935 more_words
= (word
>> 16) & 0xff;
7941 switch (elf_header
.e_machine
)
7946 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7947 data_offset
, data_sec
, data_arm_sec
);
7951 warn (_("Unknown ARM compact model index encountered\n"));
7952 printf (_(" [reserved]\n"));
7959 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7960 data_offset
, data_sec
, data_arm_sec
);
7962 else if (per_index
< 5)
7964 if (((word
>> 17) & 0x7f) == 0x7f)
7965 printf (_(" Restore stack from frame pointer\n"));
7967 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7968 printf (_(" Registers restored: "));
7970 printf (" (compact) ");
7971 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7973 printf (_(" Return register: %s\n"),
7974 tic6x_unwind_regnames
[word
& 0xf]);
7977 printf (_(" [reserved (%d)]\n"), per_index
);
7981 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7982 elf_header
.e_machine
);
7985 /* Decode the descriptors. Not implemented. */
7989 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7991 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7992 unsigned int i
, exidx_len
;
7994 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7995 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7996 exidx_len
= exidx_sec
->sh_size
/ 8;
7998 for (i
= 0; i
< exidx_len
; i
++)
8000 unsigned int exidx_fn
, exidx_entry
;
8001 struct absaddr fn_addr
, entry_addr
;
8004 fputc ('\n', stdout
);
8006 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8007 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8008 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8009 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8011 arm_free_section (& exidx_arm_sec
);
8012 arm_free_section (& extab_arm_sec
);
8016 /* ARM EHABI, Section 5:
8017 An index table entry consists of 2 words.
8018 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8019 if (exidx_fn
& 0x80000000)
8020 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8022 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8024 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8025 fputs (": ", stdout
);
8027 if (exidx_entry
== 1)
8029 print_vma (exidx_entry
, PREFIX_HEX
);
8030 fputs (" [cantunwind]\n", stdout
);
8032 else if (exidx_entry
& 0x80000000)
8034 print_vma (exidx_entry
, PREFIX_HEX
);
8035 fputc ('\n', stdout
);
8036 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8040 bfd_vma table
, table_offset
= 0;
8041 Elf_Internal_Shdr
*table_sec
;
8043 fputs ("@", stdout
);
8044 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8045 print_vma (table
, PREFIX_HEX
);
8048 /* Locate the matching .ARM.extab. */
8049 if (entry_addr
.section
!= SHN_UNDEF
8050 && entry_addr
.section
< elf_header
.e_shnum
)
8052 table_sec
= section_headers
+ entry_addr
.section
;
8053 table_offset
= entry_addr
.offset
;
8057 table_sec
= find_section_by_address (table
);
8058 if (table_sec
!= NULL
)
8059 table_offset
= table
- table_sec
->sh_addr
;
8061 if (table_sec
== NULL
)
8063 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8064 (unsigned long) table
);
8067 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8074 arm_free_section (&exidx_arm_sec
);
8075 arm_free_section (&extab_arm_sec
);
8078 /* Used for both ARM and C6X unwinding tables. */
8081 arm_process_unwind (FILE *file
)
8083 struct arm_unw_aux_info aux
;
8084 Elf_Internal_Shdr
*unwsec
= NULL
;
8085 Elf_Internal_Shdr
*strsec
;
8086 Elf_Internal_Shdr
*sec
;
8088 unsigned int sec_type
;
8090 switch (elf_header
.e_machine
)
8093 sec_type
= SHT_ARM_EXIDX
;
8097 sec_type
= SHT_C6000_UNWIND
;
8101 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8102 elf_header
.e_machine
);
8106 if (string_table
== NULL
)
8109 memset (& aux
, 0, sizeof (aux
));
8112 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8114 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8116 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8118 strsec
= section_headers
+ sec
->sh_link
;
8120 /* PR binutils/17531 file: 011-12666-0.004. */
8121 if (aux
.strtab
!= NULL
)
8123 error (_("Multiple string tables found in file.\n"));
8126 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8127 1, strsec
->sh_size
, _("string table"));
8128 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8130 else if (sec
->sh_type
== sec_type
)
8135 printf (_("\nThere are no unwind sections in this file.\n"));
8137 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8139 if (sec
->sh_type
== sec_type
)
8141 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8142 printable_section_name (sec
),
8143 (unsigned long) sec
->sh_offset
,
8144 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8146 dump_arm_unwind (&aux
, sec
);
8153 free ((char *) aux
.strtab
);
8157 process_unwind (FILE * file
)
8159 struct unwind_handler
8162 void (* handler
)(FILE *);
8165 { EM_ARM
, arm_process_unwind
},
8166 { EM_IA_64
, ia64_process_unwind
},
8167 { EM_PARISC
, hppa_process_unwind
},
8168 { EM_TI_C6000
, arm_process_unwind
},
8176 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8177 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8179 handlers
[i
].handler (file
);
8183 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8184 get_machine_name (elf_header
.e_machine
));
8188 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8190 switch (entry
->d_tag
)
8193 if (entry
->d_un
.d_val
== 0)
8197 static const char * opts
[] =
8199 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8200 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8201 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8202 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8208 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8209 if (entry
->d_un
.d_val
& (1 << cnt
))
8211 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8217 case DT_MIPS_IVERSION
:
8218 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8219 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8223 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8224 /* Note: coded this way so that there is a single string for translation. */
8225 printf (_("<corrupt: %s>"), buf
);
8229 case DT_MIPS_TIME_STAMP
:
8234 time_t atime
= entry
->d_un
.d_val
;
8235 tmp
= gmtime (&atime
);
8236 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8237 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8238 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8239 printf (_("Time Stamp: %s"), timebuf
);
8243 case DT_MIPS_RLD_VERSION
:
8244 case DT_MIPS_LOCAL_GOTNO
:
8245 case DT_MIPS_CONFLICTNO
:
8246 case DT_MIPS_LIBLISTNO
:
8247 case DT_MIPS_SYMTABNO
:
8248 case DT_MIPS_UNREFEXTNO
:
8249 case DT_MIPS_HIPAGENO
:
8250 case DT_MIPS_DELTA_CLASS_NO
:
8251 case DT_MIPS_DELTA_INSTANCE_NO
:
8252 case DT_MIPS_DELTA_RELOC_NO
:
8253 case DT_MIPS_DELTA_SYM_NO
:
8254 case DT_MIPS_DELTA_CLASSSYM_NO
:
8255 case DT_MIPS_COMPACT_SIZE
:
8256 print_vma (entry
->d_un
.d_ptr
, DEC
);
8260 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8266 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8268 switch (entry
->d_tag
)
8270 case DT_HP_DLD_FLAGS
:
8279 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8280 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8281 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8282 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8283 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8284 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8285 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8286 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8287 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8288 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8289 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8290 { DT_HP_GST
, "HP_GST" },
8291 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8292 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8293 { DT_HP_NODELETE
, "HP_NODELETE" },
8294 { DT_HP_GROUP
, "HP_GROUP" },
8295 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8299 bfd_vma val
= entry
->d_un
.d_val
;
8301 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8302 if (val
& flags
[cnt
].bit
)
8306 fputs (flags
[cnt
].str
, stdout
);
8308 val
^= flags
[cnt
].bit
;
8311 if (val
!= 0 || first
)
8315 print_vma (val
, HEX
);
8321 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8329 /* VMS vs Unix time offset and factor. */
8331 #define VMS_EPOCH_OFFSET 35067168000000000LL
8332 #define VMS_GRANULARITY_FACTOR 10000000
8334 /* Display a VMS time in a human readable format. */
8337 print_vms_time (bfd_int64_t vmstime
)
8342 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8343 tm
= gmtime (&unxtime
);
8344 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8345 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8346 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8351 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8353 switch (entry
->d_tag
)
8355 case DT_IA_64_PLT_RESERVE
:
8356 /* First 3 slots reserved. */
8357 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8359 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8362 case DT_IA_64_VMS_LINKTIME
:
8364 print_vms_time (entry
->d_un
.d_val
);
8368 case DT_IA_64_VMS_LNKFLAGS
:
8369 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8370 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8371 printf (" CALL_DEBUG");
8372 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8373 printf (" NOP0BUFS");
8374 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8375 printf (" P0IMAGE");
8376 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8377 printf (" MKTHREADS");
8378 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8379 printf (" UPCALLS");
8380 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8382 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8383 printf (" INITIALIZE");
8384 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8386 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8387 printf (" EXE_INIT");
8388 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8389 printf (" TBK_IN_IMG");
8390 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8391 printf (" DBG_IN_IMG");
8392 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8393 printf (" TBK_IN_DSF");
8394 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8395 printf (" DBG_IN_DSF");
8396 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8397 printf (" SIGNATURES");
8398 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8399 printf (" REL_SEG_OFF");
8403 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8410 get_32bit_dynamic_section (FILE * file
)
8412 Elf32_External_Dyn
* edyn
;
8413 Elf32_External_Dyn
* ext
;
8414 Elf_Internal_Dyn
* entry
;
8416 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8417 dynamic_size
, _("dynamic section"));
8421 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8422 might not have the luxury of section headers. Look for the DT_NULL
8423 terminator to determine the number of entries. */
8424 for (ext
= edyn
, dynamic_nent
= 0;
8425 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8429 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8433 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8435 if (dynamic_section
== NULL
)
8437 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8438 (unsigned long) dynamic_nent
);
8443 for (ext
= edyn
, entry
= dynamic_section
;
8444 entry
< dynamic_section
+ dynamic_nent
;
8447 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8448 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8457 get_64bit_dynamic_section (FILE * file
)
8459 Elf64_External_Dyn
* edyn
;
8460 Elf64_External_Dyn
* ext
;
8461 Elf_Internal_Dyn
* entry
;
8463 /* Read in the data. */
8464 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8465 dynamic_size
, _("dynamic section"));
8469 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8470 might not have the luxury of section headers. Look for the DT_NULL
8471 terminator to determine the number of entries. */
8472 for (ext
= edyn
, dynamic_nent
= 0;
8473 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8474 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8478 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8482 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8484 if (dynamic_section
== NULL
)
8486 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8487 (unsigned long) dynamic_nent
);
8492 /* Convert from external to internal formats. */
8493 for (ext
= edyn
, entry
= dynamic_section
;
8494 entry
< dynamic_section
+ dynamic_nent
;
8497 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8498 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8507 print_dynamic_flags (bfd_vma flags
)
8515 flag
= flags
& - flags
;
8525 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8526 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8527 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8528 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8529 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8530 default: fputs (_("unknown"), stdout
); break;
8536 /* Parse and display the contents of the dynamic section. */
8539 process_dynamic_section (FILE * file
)
8541 Elf_Internal_Dyn
* entry
;
8543 if (dynamic_size
== 0)
8546 printf (_("\nThere is no dynamic section in this file.\n"));
8553 if (! get_32bit_dynamic_section (file
))
8556 else if (! get_64bit_dynamic_section (file
))
8559 /* Find the appropriate symbol table. */
8560 if (dynamic_symbols
== NULL
)
8562 for (entry
= dynamic_section
;
8563 entry
< dynamic_section
+ dynamic_nent
;
8566 Elf_Internal_Shdr section
;
8568 if (entry
->d_tag
!= DT_SYMTAB
)
8571 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8573 /* Since we do not know how big the symbol table is,
8574 we default to reading in the entire file (!) and
8575 processing that. This is overkill, I know, but it
8577 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8579 if (archive_file_offset
!= 0)
8580 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8583 if (fseek (file
, 0, SEEK_END
))
8584 error (_("Unable to seek to end of file!\n"));
8586 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8590 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8592 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8593 section
.sh_name
= string_table_length
;
8595 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8596 if (num_dynamic_syms
< 1)
8598 error (_("Unable to determine the number of symbols to load\n"));
8604 /* Similarly find a string table. */
8605 if (dynamic_strings
== NULL
)
8607 for (entry
= dynamic_section
;
8608 entry
< dynamic_section
+ dynamic_nent
;
8611 unsigned long offset
;
8614 if (entry
->d_tag
!= DT_STRTAB
)
8617 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8619 /* Since we do not know how big the string table is,
8620 we default to reading in the entire file (!) and
8621 processing that. This is overkill, I know, but it
8624 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8626 if (archive_file_offset
!= 0)
8627 str_tab_len
= archive_file_size
- offset
;
8630 if (fseek (file
, 0, SEEK_END
))
8631 error (_("Unable to seek to end of file\n"));
8632 str_tab_len
= ftell (file
) - offset
;
8635 if (str_tab_len
< 1)
8638 (_("Unable to determine the length of the dynamic string table\n"));
8642 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8644 _("dynamic string table"));
8645 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8650 /* And find the syminfo section if available. */
8651 if (dynamic_syminfo
== NULL
)
8653 unsigned long syminsz
= 0;
8655 for (entry
= dynamic_section
;
8656 entry
< dynamic_section
+ dynamic_nent
;
8659 if (entry
->d_tag
== DT_SYMINENT
)
8661 /* Note: these braces are necessary to avoid a syntax
8662 error from the SunOS4 C compiler. */
8663 /* PR binutils/17531: A corrupt file can trigger this test.
8664 So do not use an assert, instead generate an error message. */
8665 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8666 error (_("Bad value (%d) for SYMINENT entry\n"),
8667 (int) entry
->d_un
.d_val
);
8669 else if (entry
->d_tag
== DT_SYMINSZ
)
8670 syminsz
= entry
->d_un
.d_val
;
8671 else if (entry
->d_tag
== DT_SYMINFO
)
8672 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8676 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8678 Elf_External_Syminfo
* extsyminfo
;
8679 Elf_External_Syminfo
* extsym
;
8680 Elf_Internal_Syminfo
* syminfo
;
8682 /* There is a syminfo section. Read the data. */
8683 extsyminfo
= (Elf_External_Syminfo
*)
8684 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8685 _("symbol information"));
8689 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8690 if (dynamic_syminfo
== NULL
)
8692 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8693 (unsigned long) syminsz
);
8697 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8698 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8699 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8700 ++syminfo
, ++extsym
)
8702 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8703 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8710 if (do_dynamic
&& dynamic_addr
)
8711 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8712 dynamic_addr
, (unsigned long) dynamic_nent
);
8714 printf (_(" Tag Type Name/Value\n"));
8716 for (entry
= dynamic_section
;
8717 entry
< dynamic_section
+ dynamic_nent
;
8725 print_vma (entry
->d_tag
, FULL_HEX
);
8726 dtype
= get_dynamic_type (entry
->d_tag
);
8727 printf (" (%s)%*s", dtype
,
8728 ((is_32bit_elf
? 27 : 19)
8729 - (int) strlen (dtype
)),
8733 switch (entry
->d_tag
)
8737 print_dynamic_flags (entry
->d_un
.d_val
);
8747 switch (entry
->d_tag
)
8750 printf (_("Auxiliary library"));
8754 printf (_("Filter library"));
8758 printf (_("Configuration file"));
8762 printf (_("Dependency audit library"));
8766 printf (_("Audit library"));
8770 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8771 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8775 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8784 printf (_("Flags:"));
8786 if (entry
->d_un
.d_val
== 0)
8787 printf (_(" None\n"));
8790 unsigned long int val
= entry
->d_un
.d_val
;
8792 if (val
& DTF_1_PARINIT
)
8794 printf (" PARINIT");
8795 val
^= DTF_1_PARINIT
;
8797 if (val
& DTF_1_CONFEXP
)
8799 printf (" CONFEXP");
8800 val
^= DTF_1_CONFEXP
;
8803 printf (" %lx", val
);
8812 printf (_("Flags:"));
8814 if (entry
->d_un
.d_val
== 0)
8815 printf (_(" None\n"));
8818 unsigned long int val
= entry
->d_un
.d_val
;
8820 if (val
& DF_P1_LAZYLOAD
)
8822 printf (" LAZYLOAD");
8823 val
^= DF_P1_LAZYLOAD
;
8825 if (val
& DF_P1_GROUPPERM
)
8827 printf (" GROUPPERM");
8828 val
^= DF_P1_GROUPPERM
;
8831 printf (" %lx", val
);
8840 printf (_("Flags:"));
8841 if (entry
->d_un
.d_val
== 0)
8842 printf (_(" None\n"));
8845 unsigned long int val
= entry
->d_un
.d_val
;
8852 if (val
& DF_1_GLOBAL
)
8857 if (val
& DF_1_GROUP
)
8862 if (val
& DF_1_NODELETE
)
8864 printf (" NODELETE");
8865 val
^= DF_1_NODELETE
;
8867 if (val
& DF_1_LOADFLTR
)
8869 printf (" LOADFLTR");
8870 val
^= DF_1_LOADFLTR
;
8872 if (val
& DF_1_INITFIRST
)
8874 printf (" INITFIRST");
8875 val
^= DF_1_INITFIRST
;
8877 if (val
& DF_1_NOOPEN
)
8882 if (val
& DF_1_ORIGIN
)
8887 if (val
& DF_1_DIRECT
)
8892 if (val
& DF_1_TRANS
)
8897 if (val
& DF_1_INTERPOSE
)
8899 printf (" INTERPOSE");
8900 val
^= DF_1_INTERPOSE
;
8902 if (val
& DF_1_NODEFLIB
)
8904 printf (" NODEFLIB");
8905 val
^= DF_1_NODEFLIB
;
8907 if (val
& DF_1_NODUMP
)
8912 if (val
& DF_1_CONFALT
)
8914 printf (" CONFALT");
8915 val
^= DF_1_CONFALT
;
8917 if (val
& DF_1_ENDFILTEE
)
8919 printf (" ENDFILTEE");
8920 val
^= DF_1_ENDFILTEE
;
8922 if (val
& DF_1_DISPRELDNE
)
8924 printf (" DISPRELDNE");
8925 val
^= DF_1_DISPRELDNE
;
8927 if (val
& DF_1_DISPRELPND
)
8929 printf (" DISPRELPND");
8930 val
^= DF_1_DISPRELPND
;
8932 if (val
& DF_1_NODIRECT
)
8934 printf (" NODIRECT");
8935 val
^= DF_1_NODIRECT
;
8937 if (val
& DF_1_IGNMULDEF
)
8939 printf (" IGNMULDEF");
8940 val
^= DF_1_IGNMULDEF
;
8942 if (val
& DF_1_NOKSYMS
)
8944 printf (" NOKSYMS");
8945 val
^= DF_1_NOKSYMS
;
8947 if (val
& DF_1_NOHDR
)
8952 if (val
& DF_1_EDITED
)
8957 if (val
& DF_1_NORELOC
)
8959 printf (" NORELOC");
8960 val
^= DF_1_NORELOC
;
8962 if (val
& DF_1_SYMINTPOSE
)
8964 printf (" SYMINTPOSE");
8965 val
^= DF_1_SYMINTPOSE
;
8967 if (val
& DF_1_GLOBAUDIT
)
8969 printf (" GLOBAUDIT");
8970 val
^= DF_1_GLOBAUDIT
;
8972 if (val
& DF_1_SINGLETON
)
8974 printf (" SINGLETON");
8975 val
^= DF_1_SINGLETON
;
8978 printf (" %lx", val
);
8985 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8987 puts (get_dynamic_type (entry
->d_un
.d_val
));
9007 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9013 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9014 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9020 switch (entry
->d_tag
)
9023 printf (_("Shared library: [%s]"), name
);
9025 if (streq (name
, program_interpreter
))
9026 printf (_(" program interpreter"));
9030 printf (_("Library soname: [%s]"), name
);
9034 printf (_("Library rpath: [%s]"), name
);
9038 printf (_("Library runpath: [%s]"), name
);
9042 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9047 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9060 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9064 case DT_INIT_ARRAYSZ
:
9065 case DT_FINI_ARRAYSZ
:
9066 case DT_GNU_CONFLICTSZ
:
9067 case DT_GNU_LIBLISTSZ
:
9070 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9071 printf (_(" (bytes)\n"));
9081 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9094 if (entry
->d_tag
== DT_USED
9095 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9097 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9101 printf (_("Not needed object: [%s]\n"), name
);
9106 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9112 /* The value of this entry is ignored. */
9117 case DT_GNU_PRELINKED
:
9121 time_t atime
= entry
->d_un
.d_val
;
9123 tmp
= gmtime (&atime
);
9124 /* PR 17533 file: 041-1244816-0.004. */
9126 printf (_("<corrupt time val: %lx"),
9127 (unsigned long) atime
);
9129 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9130 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9131 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9137 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9140 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9146 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9147 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9152 switch (elf_header
.e_machine
)
9155 case EM_MIPS_RS3_LE
:
9156 dynamic_section_mips_val (entry
);
9159 dynamic_section_parisc_val (entry
);
9162 dynamic_section_ia64_val (entry
);
9165 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9177 get_ver_flags (unsigned int flags
)
9179 static char buff
[32];
9186 if (flags
& VER_FLG_BASE
)
9187 strcat (buff
, "BASE ");
9189 if (flags
& VER_FLG_WEAK
)
9191 if (flags
& VER_FLG_BASE
)
9192 strcat (buff
, "| ");
9194 strcat (buff
, "WEAK ");
9197 if (flags
& VER_FLG_INFO
)
9199 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9200 strcat (buff
, "| ");
9202 strcat (buff
, "INFO ");
9205 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9206 strcat (buff
, _("| <unknown>"));
9211 /* Display the contents of the version sections. */
9214 process_version_sections (FILE * file
)
9216 Elf_Internal_Shdr
* section
;
9223 for (i
= 0, section
= section_headers
;
9224 i
< elf_header
.e_shnum
;
9227 switch (section
->sh_type
)
9229 case SHT_GNU_verdef
:
9231 Elf_External_Verdef
* edefs
;
9238 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9239 printable_section_name (section
),
9242 printf (_(" Addr: 0x"));
9243 printf_vma (section
->sh_addr
);
9244 printf (_(" Offset: %#08lx Link: %u (%s)"),
9245 (unsigned long) section
->sh_offset
, section
->sh_link
,
9246 printable_section_name_from_index (section
->sh_link
));
9248 edefs
= (Elf_External_Verdef
*)
9249 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9250 _("version definition section"));
9253 endbuf
= (char *) edefs
+ section
->sh_size
;
9255 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9258 Elf_External_Verdef
* edef
;
9259 Elf_Internal_Verdef ent
;
9260 Elf_External_Verdaux
* eaux
;
9261 Elf_Internal_Verdaux aux
;
9265 /* Check for very large indicies. */
9266 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9269 vstart
= ((char *) edefs
) + idx
;
9270 if (vstart
+ sizeof (*edef
) > endbuf
)
9273 edef
= (Elf_External_Verdef
*) vstart
;
9275 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9276 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9277 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9278 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9279 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9280 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9281 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9283 printf (_(" %#06x: Rev: %d Flags: %s"),
9284 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9286 printf (_(" Index: %d Cnt: %d "),
9287 ent
.vd_ndx
, ent
.vd_cnt
);
9289 /* Check for overflow. */
9290 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9293 vstart
+= ent
.vd_aux
;
9295 eaux
= (Elf_External_Verdaux
*) vstart
;
9297 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9298 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9300 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9301 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9303 printf (_("Name index: %ld\n"), aux
.vda_name
);
9305 isum
= idx
+ ent
.vd_aux
;
9307 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9309 /* Check for overflow. */
9310 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9313 isum
+= aux
.vda_next
;
9314 vstart
+= aux
.vda_next
;
9316 eaux
= (Elf_External_Verdaux
*) vstart
;
9317 if (vstart
+ sizeof (*eaux
) > endbuf
)
9320 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9321 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9323 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9324 printf (_(" %#06x: Parent %d: %s\n"),
9325 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9327 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9328 isum
, j
, aux
.vda_name
);
9332 printf (_(" Version def aux past end of section\n"));
9334 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9335 if (idx
+ ent
.vd_next
<= idx
)
9341 if (cnt
< section
->sh_info
)
9342 printf (_(" Version definition past end of section\n"));
9348 case SHT_GNU_verneed
:
9350 Elf_External_Verneed
* eneed
;
9357 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9358 printable_section_name (section
), section
->sh_info
);
9360 printf (_(" Addr: 0x"));
9361 printf_vma (section
->sh_addr
);
9362 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9363 (unsigned long) section
->sh_offset
, section
->sh_link
,
9364 printable_section_name_from_index (section
->sh_link
));
9366 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9367 section
->sh_offset
, 1,
9369 _("Version Needs section"));
9372 endbuf
= (char *) eneed
+ section
->sh_size
;
9374 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9376 Elf_External_Verneed
* entry
;
9377 Elf_Internal_Verneed ent
;
9382 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9385 vstart
= ((char *) eneed
) + idx
;
9386 if (vstart
+ sizeof (*entry
) > endbuf
)
9389 entry
= (Elf_External_Verneed
*) vstart
;
9391 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9392 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9393 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9394 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9395 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9397 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9399 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9400 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9402 printf (_(" File: %lx"), ent
.vn_file
);
9404 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9406 /* Check for overflow. */
9407 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9410 vstart
+= ent
.vn_aux
;
9412 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9414 Elf_External_Vernaux
* eaux
;
9415 Elf_Internal_Vernaux aux
;
9417 if (vstart
+ sizeof (*eaux
) > endbuf
)
9419 eaux
= (Elf_External_Vernaux
*) vstart
;
9421 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9422 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9423 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9424 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9425 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9427 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9428 printf (_(" %#06x: Name: %s"),
9429 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9431 printf (_(" %#06x: Name index: %lx"),
9432 isum
, aux
.vna_name
);
9434 printf (_(" Flags: %s Version: %d\n"),
9435 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9437 /* Check for overflow. */
9438 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9441 isum
+= aux
.vna_next
;
9442 vstart
+= aux
.vna_next
;
9446 warn (_("Missing Version Needs auxillary information\n"));
9448 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9450 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9451 cnt
= section
->sh_info
;
9457 if (cnt
< section
->sh_info
)
9458 warn (_("Missing Version Needs information\n"));
9464 case SHT_GNU_versym
:
9466 Elf_Internal_Shdr
* link_section
;
9469 unsigned char * edata
;
9470 unsigned short * data
;
9472 Elf_Internal_Sym
* symbols
;
9473 Elf_Internal_Shdr
* string_sec
;
9474 unsigned long num_syms
;
9477 if (section
->sh_link
>= elf_header
.e_shnum
)
9480 link_section
= section_headers
+ section
->sh_link
;
9481 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9483 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9488 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9489 if (symbols
== NULL
)
9492 string_sec
= section_headers
+ link_section
->sh_link
;
9494 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9495 string_sec
->sh_size
,
9496 _("version string table"));
9503 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9504 printable_section_name (section
), (unsigned long) total
);
9506 printf (_(" Addr: "));
9507 printf_vma (section
->sh_addr
);
9508 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9509 (unsigned long) section
->sh_offset
, section
->sh_link
,
9510 printable_section_name (link_section
));
9512 off
= offset_from_vma (file
,
9513 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9514 total
* sizeof (short));
9515 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9517 _("version symbol data"));
9525 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9527 for (cnt
= total
; cnt
--;)
9528 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9533 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9536 int check_def
, check_need
;
9539 printf (" %03x:", cnt
);
9541 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9542 switch (data
[cnt
+ j
])
9545 fputs (_(" 0 (*local*) "), stdout
);
9549 fputs (_(" 1 (*global*) "), stdout
);
9553 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9554 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9556 /* If this index value is greater than the size of the symbols
9557 array, break to avoid an out-of-bounds read. */
9558 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9560 warn (_("invalid index into symbol array\n"));
9566 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9567 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9570 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9577 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9579 Elf_Internal_Verneed ivn
;
9580 unsigned long offset
;
9582 offset
= offset_from_vma
9583 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9584 sizeof (Elf_External_Verneed
));
9588 Elf_Internal_Vernaux ivna
;
9589 Elf_External_Verneed evn
;
9590 Elf_External_Vernaux evna
;
9591 unsigned long a_off
;
9593 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9594 _("version need")) == NULL
)
9597 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9598 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9600 a_off
= offset
+ ivn
.vn_aux
;
9604 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9605 1, _("version need aux (2)")) == NULL
)
9612 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9613 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9616 a_off
+= ivna
.vna_next
;
9618 while (ivna
.vna_other
!= data
[cnt
+ j
]
9619 && ivna
.vna_next
!= 0);
9621 if (ivna
.vna_other
== data
[cnt
+ j
])
9623 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9625 if (ivna
.vna_name
>= string_sec
->sh_size
)
9626 name
= _("*invalid*");
9628 name
= strtab
+ ivna
.vna_name
;
9629 nn
+= printf ("(%s%-*s",
9631 12 - (int) strlen (name
),
9637 offset
+= ivn
.vn_next
;
9639 while (ivn
.vn_next
);
9642 if (check_def
&& data
[cnt
+ j
] != 0x8001
9643 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9645 Elf_Internal_Verdef ivd
;
9646 Elf_External_Verdef evd
;
9647 unsigned long offset
;
9649 offset
= offset_from_vma
9650 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9655 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9656 _("version def")) == NULL
)
9659 /* PR 17531: file: 046-1082287-0.004. */
9660 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9665 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9666 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9669 offset
+= ivd
.vd_next
;
9671 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9672 && ivd
.vd_next
!= 0);
9674 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9676 Elf_External_Verdaux evda
;
9677 Elf_Internal_Verdaux ivda
;
9679 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9681 if (get_data (&evda
, file
,
9682 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9684 _("version def aux")) == NULL
)
9687 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9689 if (ivda
.vda_name
>= string_sec
->sh_size
)
9690 name
= _("*invalid*");
9692 name
= strtab
+ ivda
.vda_name
;
9693 nn
+= printf ("(%s%-*s",
9695 12 - (int) strlen (name
),
9701 printf ("%*c", 18 - nn
, ' ');
9719 printf (_("\nNo version information found in this file.\n"));
9725 get_symbol_binding (unsigned int binding
)
9727 static char buff
[32];
9731 case STB_LOCAL
: return "LOCAL";
9732 case STB_GLOBAL
: return "GLOBAL";
9733 case STB_WEAK
: return "WEAK";
9735 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9736 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9738 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9740 if (binding
== STB_GNU_UNIQUE
9741 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9742 /* GNU is still using the default value 0. */
9743 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9745 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9748 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9754 get_symbol_type (unsigned int type
)
9756 static char buff
[32];
9760 case STT_NOTYPE
: return "NOTYPE";
9761 case STT_OBJECT
: return "OBJECT";
9762 case STT_FUNC
: return "FUNC";
9763 case STT_SECTION
: return "SECTION";
9764 case STT_FILE
: return "FILE";
9765 case STT_COMMON
: return "COMMON";
9766 case STT_TLS
: return "TLS";
9767 case STT_RELC
: return "RELC";
9768 case STT_SRELC
: return "SRELC";
9770 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9772 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9773 return "THUMB_FUNC";
9775 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9778 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9779 return "PARISC_MILLI";
9781 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9783 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9785 if (elf_header
.e_machine
== EM_PARISC
)
9787 if (type
== STT_HP_OPAQUE
)
9789 if (type
== STT_HP_STUB
)
9793 if (type
== STT_GNU_IFUNC
9794 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9795 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9796 /* GNU is still using the default value 0. */
9797 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9800 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9803 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9809 get_symbol_visibility (unsigned int visibility
)
9813 case STV_DEFAULT
: return "DEFAULT";
9814 case STV_INTERNAL
: return "INTERNAL";
9815 case STV_HIDDEN
: return "HIDDEN";
9816 case STV_PROTECTED
: return "PROTECTED";
9818 error (_("Unrecognized visibility value: %u"), visibility
);
9819 return _("<unknown>");
9824 get_mips_symbol_other (unsigned int other
)
9836 case STO_MICROMIPS
| STO_MIPS_PIC
:
9837 return "MICROMIPS, MIPS PIC";
9846 get_ia64_symbol_other (unsigned int other
)
9850 static char res
[32];
9854 /* Function types is for images and .STB files only. */
9855 switch (elf_header
.e_type
)
9859 switch (VMS_ST_FUNC_TYPE (other
))
9861 case VMS_SFT_CODE_ADDR
:
9862 strcat (res
, " CA");
9864 case VMS_SFT_SYMV_IDX
:
9865 strcat (res
, " VEC");
9868 strcat (res
, " FD");
9870 case VMS_SFT_RESERVE
:
9871 strcat (res
, " RSV");
9874 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9875 VMS_ST_FUNC_TYPE (other
));
9876 strcat (res
, " <unknown>");
9883 switch (VMS_ST_LINKAGE (other
))
9885 case VMS_STL_IGNORE
:
9886 strcat (res
, " IGN");
9888 case VMS_STL_RESERVE
:
9889 strcat (res
, " RSV");
9892 strcat (res
, " STD");
9895 strcat (res
, " LNK");
9898 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9899 VMS_ST_LINKAGE (other
));
9900 strcat (res
, " <unknown>");
9913 get_ppc64_symbol_other (unsigned int other
)
9915 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9917 static char buf
[32];
9918 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9919 PPC64_LOCAL_ENTRY_OFFSET (other
));
9926 get_symbol_other (unsigned int other
)
9928 const char * result
= NULL
;
9929 static char buff
[32];
9934 switch (elf_header
.e_machine
)
9937 result
= get_mips_symbol_other (other
);
9940 result
= get_ia64_symbol_other (other
);
9943 result
= get_ppc64_symbol_other (other
);
9952 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9957 get_symbol_index_type (unsigned int type
)
9959 static char buff
[32];
9963 case SHN_UNDEF
: return "UND";
9964 case SHN_ABS
: return "ABS";
9965 case SHN_COMMON
: return "COM";
9967 if (type
== SHN_IA_64_ANSI_COMMON
9968 && elf_header
.e_machine
== EM_IA_64
9969 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9971 else if ((elf_header
.e_machine
== EM_X86_64
9972 || elf_header
.e_machine
== EM_L1OM
9973 || elf_header
.e_machine
== EM_K1OM
)
9974 && type
== SHN_X86_64_LCOMMON
)
9976 else if ((type
== SHN_MIPS_SCOMMON
9977 && elf_header
.e_machine
== EM_MIPS
)
9978 || (type
== SHN_TIC6X_SCOMMON
9979 && elf_header
.e_machine
== EM_TI_C6000
))
9981 else if (type
== SHN_MIPS_SUNDEFINED
9982 && elf_header
.e_machine
== EM_MIPS
)
9984 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9985 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9986 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9987 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9988 else if (type
>= SHN_LORESERVE
)
9989 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9990 else if (type
>= elf_header
.e_shnum
)
9991 sprintf (buff
, _("bad section index[%3d]"), type
);
9993 sprintf (buff
, "%3d", type
);
10001 get_dynamic_data (FILE * file
, size_t number
, unsigned int ent_size
)
10003 unsigned char * e_data
;
10006 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10007 attempting to allocate memory when the read is bound to fail. */
10008 if (ent_size
* number
> current_file_size
)
10010 error (_("Invalid number of dynamic entries: %lu\n"),
10011 (unsigned long) number
);
10015 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
10016 if (e_data
== NULL
)
10018 error (_("Out of memory reading %lu dynamic entries\n"),
10019 (unsigned long) number
);
10023 if (fread (e_data
, ent_size
, number
, file
) != number
)
10025 error (_("Unable to read in %lu bytes of dynamic data\n"),
10026 (unsigned long) (number
* ent_size
));
10031 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
10032 if (i_data
== NULL
)
10034 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10035 (unsigned long) number
);
10041 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10049 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10051 Elf_Internal_Sym
* psym
;
10054 n
= print_vma (si
, DEC_5
);
10056 fputs (&" "[n
], stdout
);
10057 printf (" %3lu: ", hn
);
10059 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10061 printf (_("<No info available for dynamic symbol number %lu>\n"),
10062 (unsigned long) si
);
10066 psym
= dynamic_symbols
+ si
;
10067 print_vma (psym
->st_value
, LONG_HEX
);
10069 print_vma (psym
->st_size
, DEC_5
);
10071 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10072 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10073 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10074 /* Check to see if any other bits in the st_other field are set.
10075 Note - displaying this information disrupts the layout of the
10076 table being generated, but for the moment this case is very
10078 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10079 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10080 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10081 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10082 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10084 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10088 static const char *
10089 get_symbol_version_string (FILE *file
, int is_dynsym
,
10090 const char *strtab
,
10091 unsigned long int strtab_size
,
10092 unsigned int si
, Elf_Internal_Sym
*psym
,
10093 enum versioned_symbol_info
*sym_info
,
10094 unsigned short *vna_other
)
10096 const char *version_string
= NULL
;
10099 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10101 unsigned char data
[2];
10102 unsigned short vers_data
;
10103 unsigned long offset
;
10107 offset
= offset_from_vma
10108 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10109 sizeof data
+ si
* sizeof (vers_data
));
10111 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10112 sizeof (data
), 1, _("version data")) == NULL
)
10115 vers_data
= byte_get (data
, 2);
10117 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
10118 && section_headers
[psym
->st_shndx
].sh_type
10121 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10123 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10125 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10126 && (is_nobits
|| ! check_def
))
10128 Elf_External_Verneed evn
;
10129 Elf_Internal_Verneed ivn
;
10130 Elf_Internal_Vernaux ivna
;
10132 /* We must test both. */
10133 offset
= offset_from_vma
10134 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10139 unsigned long vna_off
;
10141 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10142 _("version need")) == NULL
)
10145 ivna
.vna_other
= 0;
10150 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10151 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10153 vna_off
= offset
+ ivn
.vn_aux
;
10157 Elf_External_Vernaux evna
;
10159 if (get_data (&evna
, file
, vna_off
,
10161 _("version need aux (3)")) == NULL
)
10164 ivna
.vna_other
= 0;
10169 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10170 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10171 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10174 vna_off
+= ivna
.vna_next
;
10176 while (ivna
.vna_other
!= vers_data
10177 && ivna
.vna_next
!= 0);
10179 if (ivna
.vna_other
== vers_data
)
10182 offset
+= ivn
.vn_next
;
10184 while (ivn
.vn_next
!= 0);
10186 if (ivna
.vna_other
== vers_data
)
10188 *sym_info
= symbol_undefined
;
10189 *vna_other
= ivna
.vna_other
;
10190 version_string
= (ivna
.vna_name
< strtab_size
10191 ? strtab
+ ivna
.vna_name
10195 else if (! is_nobits
)
10196 error (_("bad dynamic symbol\n"));
10203 if (vers_data
!= 0x8001
10204 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10206 Elf_Internal_Verdef ivd
;
10207 Elf_Internal_Verdaux ivda
;
10208 Elf_External_Verdaux evda
;
10211 off
= offset_from_vma
10213 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10214 sizeof (Elf_External_Verdef
));
10218 Elf_External_Verdef evd
;
10220 if (get_data (&evd
, file
, off
, sizeof (evd
),
10221 1, _("version def")) == NULL
)
10229 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10230 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10231 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10234 off
+= ivd
.vd_next
;
10236 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10237 && ivd
.vd_next
!= 0);
10239 off
-= ivd
.vd_next
;
10242 if (get_data (&evda
, file
, off
, sizeof (evda
),
10243 1, _("version def aux")) == NULL
)
10244 return version_string
;
10246 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10248 if (psym
->st_name
!= ivda
.vda_name
)
10250 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10251 ? symbol_hidden
: symbol_public
);
10252 version_string
= (ivda
.vda_name
< strtab_size
10253 ? strtab
+ ivda
.vda_name
10260 return version_string
;
10263 /* Dump the symbol table. */
10265 process_symbol_table (FILE * file
)
10267 Elf_Internal_Shdr
* section
;
10268 bfd_size_type nbuckets
= 0;
10269 bfd_size_type nchains
= 0;
10270 bfd_vma
* buckets
= NULL
;
10271 bfd_vma
* chains
= NULL
;
10272 bfd_vma ngnubuckets
= 0;
10273 bfd_vma
* gnubuckets
= NULL
;
10274 bfd_vma
* gnuchains
= NULL
;
10275 bfd_vma gnusymidx
= 0;
10276 bfd_size_type ngnuchains
= 0;
10278 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10281 if (dynamic_info
[DT_HASH
]
10283 || (do_using_dynamic
10285 && dynamic_strings
!= NULL
)))
10287 unsigned char nb
[8];
10288 unsigned char nc
[8];
10289 unsigned int hash_ent_size
= 4;
10291 if ((elf_header
.e_machine
== EM_ALPHA
10292 || elf_header
.e_machine
== EM_S390
10293 || elf_header
.e_machine
== EM_S390_OLD
)
10294 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10298 (archive_file_offset
10299 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10300 sizeof nb
+ sizeof nc
)),
10303 error (_("Unable to seek to start of dynamic information\n"));
10307 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10309 error (_("Failed to read in number of buckets\n"));
10313 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10315 error (_("Failed to read in number of chains\n"));
10319 nbuckets
= byte_get (nb
, hash_ent_size
);
10320 nchains
= byte_get (nc
, hash_ent_size
);
10322 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10323 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10326 if (buckets
== NULL
|| chains
== NULL
)
10328 if (do_using_dynamic
)
10339 if (dynamic_info_DT_GNU_HASH
10341 || (do_using_dynamic
10343 && dynamic_strings
!= NULL
)))
10345 unsigned char nb
[16];
10346 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10347 bfd_vma buckets_vma
;
10350 (archive_file_offset
10351 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10355 error (_("Unable to seek to start of dynamic information\n"));
10359 if (fread (nb
, 16, 1, file
) != 1)
10361 error (_("Failed to read in number of buckets\n"));
10365 ngnubuckets
= byte_get (nb
, 4);
10366 gnusymidx
= byte_get (nb
+ 4, 4);
10367 bitmaskwords
= byte_get (nb
+ 8, 4);
10368 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10370 buckets_vma
+= bitmaskwords
* 4;
10372 buckets_vma
+= bitmaskwords
* 8;
10375 (archive_file_offset
10376 + offset_from_vma (file
, buckets_vma
, 4)),
10379 error (_("Unable to seek to start of dynamic information\n"));
10383 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10385 if (gnubuckets
== NULL
)
10388 for (i
= 0; i
< ngnubuckets
; i
++)
10389 if (gnubuckets
[i
] != 0)
10391 if (gnubuckets
[i
] < gnusymidx
)
10394 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10395 maxchain
= gnubuckets
[i
];
10398 if (maxchain
== 0xffffffff)
10401 maxchain
-= gnusymidx
;
10404 (archive_file_offset
10405 + offset_from_vma (file
, buckets_vma
10406 + 4 * (ngnubuckets
+ maxchain
), 4)),
10409 error (_("Unable to seek to start of dynamic information\n"));
10415 if (fread (nb
, 4, 1, file
) != 1)
10417 error (_("Failed to determine last chain length\n"));
10421 if (maxchain
+ 1 == 0)
10426 while ((byte_get (nb
, 4) & 1) == 0);
10429 (archive_file_offset
10430 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10433 error (_("Unable to seek to start of dynamic information\n"));
10437 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10438 ngnuchains
= maxchain
;
10441 if (gnuchains
== NULL
)
10446 if (do_using_dynamic
)
10451 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10453 && do_using_dynamic
10454 && dynamic_strings
!= NULL
10455 && dynamic_symbols
!= NULL
)
10459 if (dynamic_info
[DT_HASH
])
10463 printf (_("\nSymbol table for image:\n"));
10465 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10467 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10469 for (hn
= 0; hn
< nbuckets
; hn
++)
10474 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10475 print_dynamic_symbol (si
, hn
);
10479 if (dynamic_info_DT_GNU_HASH
)
10481 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10483 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10485 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10487 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10488 if (gnubuckets
[hn
] != 0)
10490 bfd_vma si
= gnubuckets
[hn
];
10491 bfd_vma off
= si
- gnusymidx
;
10495 print_dynamic_symbol (si
, hn
);
10498 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10502 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10503 && section_headers
!= NULL
)
10507 for (i
= 0, section
= section_headers
;
10508 i
< elf_header
.e_shnum
;
10512 char * strtab
= NULL
;
10513 unsigned long int strtab_size
= 0;
10514 Elf_Internal_Sym
* symtab
;
10515 Elf_Internal_Sym
* psym
;
10516 unsigned long num_syms
;
10518 if ((section
->sh_type
!= SHT_SYMTAB
10519 && section
->sh_type
!= SHT_DYNSYM
)
10521 && section
->sh_type
== SHT_SYMTAB
))
10524 if (section
->sh_entsize
== 0)
10526 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10527 printable_section_name (section
));
10531 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10532 printable_section_name (section
),
10533 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10536 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10538 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10540 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10541 if (symtab
== NULL
)
10544 if (section
->sh_link
== elf_header
.e_shstrndx
)
10546 strtab
= string_table
;
10547 strtab_size
= string_table_length
;
10549 else if (section
->sh_link
< elf_header
.e_shnum
)
10551 Elf_Internal_Shdr
* string_sec
;
10553 string_sec
= section_headers
+ section
->sh_link
;
10555 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10556 1, string_sec
->sh_size
,
10557 _("string table"));
10558 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10561 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10563 const char *version_string
;
10564 enum versioned_symbol_info sym_info
;
10565 unsigned short vna_other
;
10567 printf ("%6d: ", si
);
10568 print_vma (psym
->st_value
, LONG_HEX
);
10570 print_vma (psym
->st_size
, DEC_5
);
10571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10573 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10574 /* Check to see if any other bits in the st_other field are set.
10575 Note - displaying this information disrupts the layout of the
10576 table being generated, but for the moment this case is very rare. */
10577 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10578 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10579 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10580 print_symbol (25, psym
->st_name
< strtab_size
10581 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10584 = get_symbol_version_string (file
,
10585 section
->sh_type
== SHT_DYNSYM
,
10586 strtab
, strtab_size
, si
,
10587 psym
, &sym_info
, &vna_other
);
10588 if (version_string
)
10590 if (sym_info
== symbol_undefined
)
10591 printf ("@%s (%d)", version_string
, vna_other
);
10593 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10601 if (strtab
!= string_table
)
10607 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10609 if (do_histogram
&& buckets
!= NULL
)
10611 unsigned long * lengths
;
10612 unsigned long * counts
;
10615 unsigned long maxlength
= 0;
10616 unsigned long nzero_counts
= 0;
10617 unsigned long nsyms
= 0;
10619 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10620 (unsigned long) nbuckets
);
10622 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10623 if (lengths
== NULL
)
10625 error (_("Out of memory allocating space for histogram buckets\n"));
10629 printf (_(" Length Number %% of total Coverage\n"));
10630 for (hn
= 0; hn
< nbuckets
; ++hn
)
10632 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10635 if (maxlength
< ++lengths
[hn
])
10638 /* PR binutils/17531: A corrupt binary could contain broken
10639 histogram data. Do not go into an infinite loop trying
10641 if (chains
[si
] == si
)
10643 error (_("histogram chain links to itself\n"));
10649 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10650 if (counts
== NULL
)
10653 error (_("Out of memory allocating space for histogram counts\n"));
10657 for (hn
= 0; hn
< nbuckets
; ++hn
)
10658 ++counts
[lengths
[hn
]];
10663 printf (" 0 %-10lu (%5.1f%%)\n",
10664 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10665 for (i
= 1; i
<= maxlength
; ++i
)
10667 nzero_counts
+= counts
[i
] * i
;
10668 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10669 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10670 (nzero_counts
* 100.0) / nsyms
);
10678 if (buckets
!= NULL
)
10684 if (do_histogram
&& gnubuckets
!= NULL
)
10686 unsigned long * lengths
;
10687 unsigned long * counts
;
10689 unsigned long maxlength
= 0;
10690 unsigned long nzero_counts
= 0;
10691 unsigned long nsyms
= 0;
10693 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10694 (unsigned long) ngnubuckets
);
10696 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10697 if (lengths
== NULL
)
10699 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10703 printf (_(" Length Number %% of total Coverage\n"));
10705 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10706 if (gnubuckets
[hn
] != 0)
10708 bfd_vma off
, length
= 1;
10710 for (off
= gnubuckets
[hn
] - gnusymidx
;
10711 /* PR 17531 file: 010-77222-0.004. */
10712 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10715 lengths
[hn
] = length
;
10716 if (length
> maxlength
)
10717 maxlength
= length
;
10721 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10722 if (counts
== NULL
)
10725 error (_("Out of memory allocating space for gnu histogram counts\n"));
10729 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10730 ++counts
[lengths
[hn
]];
10732 if (ngnubuckets
> 0)
10735 printf (" 0 %-10lu (%5.1f%%)\n",
10736 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10737 for (j
= 1; j
<= maxlength
; ++j
)
10739 nzero_counts
+= counts
[j
] * j
;
10740 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10741 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10742 (nzero_counts
* 100.0) / nsyms
);
10756 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10760 if (dynamic_syminfo
== NULL
10762 /* No syminfo, this is ok. */
10765 /* There better should be a dynamic symbol section. */
10766 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10770 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10771 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10773 printf (_(" Num: Name BoundTo Flags\n"));
10774 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10776 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10778 printf ("%4d: ", i
);
10779 if (i
>= num_dynamic_syms
)
10780 printf (_("<corrupt index>"));
10781 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10782 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10784 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10787 switch (dynamic_syminfo
[i
].si_boundto
)
10789 case SYMINFO_BT_SELF
:
10790 fputs ("SELF ", stdout
);
10792 case SYMINFO_BT_PARENT
:
10793 fputs ("PARENT ", stdout
);
10796 if (dynamic_syminfo
[i
].si_boundto
> 0
10797 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10798 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10800 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10804 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10808 if (flags
& SYMINFO_FLG_DIRECT
)
10809 printf (" DIRECT");
10810 if (flags
& SYMINFO_FLG_PASSTHRU
)
10811 printf (" PASSTHRU");
10812 if (flags
& SYMINFO_FLG_COPY
)
10814 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10815 printf (" LAZYLOAD");
10823 /* Check to see if the given reloc needs to be handled in a target specific
10824 manner. If so then process the reloc and return TRUE otherwise return
10828 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10829 unsigned char * start
,
10830 Elf_Internal_Sym
* symtab
)
10832 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10834 switch (elf_header
.e_machine
)
10837 case EM_MSP430_OLD
:
10839 static Elf_Internal_Sym
* saved_sym
= NULL
;
10841 switch (reloc_type
)
10843 case 10: /* R_MSP430_SYM_DIFF */
10844 if (uses_msp430x_relocs ())
10846 case 21: /* R_MSP430X_SYM_DIFF */
10847 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10850 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10851 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10852 goto handle_sym_diff
;
10854 case 5: /* R_MSP430_16_BYTE */
10855 case 9: /* R_MSP430_8 */
10856 if (uses_msp430x_relocs ())
10858 goto handle_sym_diff
;
10860 case 2: /* R_MSP430_ABS16 */
10861 case 15: /* R_MSP430X_ABS16 */
10862 if (! uses_msp430x_relocs ())
10864 goto handle_sym_diff
;
10867 if (saved_sym
!= NULL
)
10871 value
= reloc
->r_addend
10872 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10873 - saved_sym
->st_value
);
10875 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10883 if (saved_sym
!= NULL
)
10884 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10891 case EM_CYGNUS_MN10300
:
10893 static Elf_Internal_Sym
* saved_sym
= NULL
;
10895 switch (reloc_type
)
10897 case 34: /* R_MN10300_ALIGN */
10899 case 33: /* R_MN10300_SYM_DIFF */
10900 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10902 case 1: /* R_MN10300_32 */
10903 case 2: /* R_MN10300_16 */
10904 if (saved_sym
!= NULL
)
10908 value
= reloc
->r_addend
10909 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10910 - saved_sym
->st_value
);
10912 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10919 if (saved_sym
!= NULL
)
10920 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10930 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10931 DWARF debug sections. This is a target specific test. Note - we do not
10932 go through the whole including-target-headers-multiple-times route, (as
10933 we have already done with <elf/h8.h>) because this would become very
10934 messy and even then this function would have to contain target specific
10935 information (the names of the relocs instead of their numeric values).
10936 FIXME: This is not the correct way to solve this problem. The proper way
10937 is to have target specific reloc sizing and typing functions created by
10938 the reloc-macros.h header, in the same way that it already creates the
10939 reloc naming functions. */
10942 is_32bit_abs_reloc (unsigned int reloc_type
)
10944 switch (elf_header
.e_machine
)
10948 return reloc_type
== 1; /* R_386_32. */
10950 return reloc_type
== 1; /* R_68K_32. */
10952 return reloc_type
== 1; /* R_860_32. */
10954 return reloc_type
== 2; /* R_960_32. */
10956 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10958 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10960 return reloc_type
== 1; /* R_ARC_32. */
10962 return reloc_type
== 2; /* R_ARM_ABS32 */
10965 return reloc_type
== 1;
10966 case EM_ADAPTEVA_EPIPHANY
:
10967 return reloc_type
== 3;
10969 return reloc_type
== 0x12; /* R_byte4_data. */
10971 return reloc_type
== 3; /* R_CRIS_32. */
10973 return reloc_type
== 3; /* R_CR16_NUM32. */
10975 return reloc_type
== 15; /* R_CRX_NUM32. */
10976 case EM_CYGNUS_FRV
:
10977 return reloc_type
== 1;
10978 case EM_CYGNUS_D10V
:
10980 return reloc_type
== 6; /* R_D10V_32. */
10981 case EM_CYGNUS_D30V
:
10983 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10985 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10986 case EM_CYGNUS_FR30
:
10988 return reloc_type
== 3; /* R_FR30_32. */
10992 return reloc_type
== 1; /* R_H8_DIR32. */
10994 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10997 return reloc_type
== 2; /* R_IP2K_32. */
10999 return reloc_type
== 2; /* R_IQ2000_32. */
11000 case EM_LATTICEMICO32
:
11001 return reloc_type
== 3; /* R_LM32_32. */
11004 return reloc_type
== 3; /* R_M32C_32. */
11006 return reloc_type
== 34; /* R_M32R_32_RELA. */
11008 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11009 case EM_CYGNUS_MEP
:
11010 return reloc_type
== 4; /* R_MEP_32. */
11012 return reloc_type
== 2; /* R_METAG_ADDR32. */
11013 case EM_MICROBLAZE
:
11014 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11016 return reloc_type
== 2; /* R_MIPS_32. */
11018 return reloc_type
== 4; /* R_MMIX_32. */
11019 case EM_CYGNUS_MN10200
:
11021 return reloc_type
== 1; /* R_MN10200_32. */
11022 case EM_CYGNUS_MN10300
:
11024 return reloc_type
== 1; /* R_MN10300_32. */
11026 return reloc_type
== 1; /* R_MOXIE_32. */
11027 case EM_MSP430_OLD
:
11029 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11031 return reloc_type
== 2; /* R_MT_32. */
11033 return reloc_type
== 20; /* R_NDS32_RELA. */
11034 case EM_ALTERA_NIOS2
:
11035 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11037 return reloc_type
== 1; /* R_NIOS_32. */
11039 return reloc_type
== 1; /* R_OR1K_32. */
11041 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11042 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11045 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11047 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11049 return reloc_type
== 1; /* R_PPC_ADDR32. */
11051 return reloc_type
== 1; /* R_RL78_DIR32. */
11053 return reloc_type
== 1; /* R_RX_DIR32. */
11055 return reloc_type
== 1; /* R_I370_ADDR31. */
11058 return reloc_type
== 4; /* R_S390_32. */
11060 return reloc_type
== 8; /* R_SCORE_ABS32. */
11062 return reloc_type
== 1; /* R_SH_DIR32. */
11063 case EM_SPARC32PLUS
:
11066 return reloc_type
== 3 /* R_SPARC_32. */
11067 || reloc_type
== 23; /* R_SPARC_UA32. */
11069 return reloc_type
== 6; /* R_SPU_ADDR32 */
11071 return reloc_type
== 1; /* R_C6000_ABS32. */
11073 return reloc_type
== 2; /* R_TILEGX_32. */
11075 return reloc_type
== 1; /* R_TILEPRO_32. */
11076 case EM_CYGNUS_V850
:
11078 return reloc_type
== 6; /* R_V850_ABS32. */
11080 return reloc_type
== 0x33; /* R_V810_WORD. */
11082 return reloc_type
== 1; /* R_VAX_32. */
11084 return reloc_type
== 3; /* R_VISIUM_32. */
11088 return reloc_type
== 10; /* R_X86_64_32. */
11091 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11093 return reloc_type
== 4; /* R_XGATE_32. */
11095 return reloc_type
== 1; /* R_XSTROMY16_32. */
11096 case EM_XTENSA_OLD
:
11098 return reloc_type
== 1; /* R_XTENSA_32. */
11101 static unsigned int prev_warn
= 0;
11103 /* Avoid repeating the same warning multiple times. */
11104 if (prev_warn
!= elf_header
.e_machine
)
11105 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11106 elf_header
.e_machine
);
11107 prev_warn
= elf_header
.e_machine
;
11113 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11114 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11117 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11119 switch (elf_header
.e_machine
)
11123 return reloc_type
== 2; /* R_386_PC32. */
11125 return reloc_type
== 4; /* R_68K_PC32. */
11127 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11128 case EM_ADAPTEVA_EPIPHANY
:
11129 return reloc_type
== 6;
11131 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11133 return reloc_type
== 3; /* R_ARM_REL32 */
11134 case EM_MICROBLAZE
:
11135 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11137 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11139 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11141 return reloc_type
== 26; /* R_PPC_REL32. */
11143 return reloc_type
== 26; /* R_PPC64_REL32. */
11146 return reloc_type
== 5; /* R_390_PC32. */
11148 return reloc_type
== 2; /* R_SH_REL32. */
11149 case EM_SPARC32PLUS
:
11152 return reloc_type
== 6; /* R_SPARC_DISP32. */
11154 return reloc_type
== 13; /* R_SPU_REL32. */
11156 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11158 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11160 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11164 return reloc_type
== 2; /* R_X86_64_PC32. */
11165 case EM_XTENSA_OLD
:
11167 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11169 /* Do not abort or issue an error message here. Not all targets use
11170 pc-relative 32-bit relocs in their DWARF debug information and we
11171 have already tested for target coverage in is_32bit_abs_reloc. A
11172 more helpful warning message will be generated by apply_relocations
11173 anyway, so just return. */
11178 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11179 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11182 is_64bit_abs_reloc (unsigned int reloc_type
)
11184 switch (elf_header
.e_machine
)
11187 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11189 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11191 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11193 return reloc_type
== 80; /* R_PARISC_DIR64. */
11195 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11196 case EM_SPARC32PLUS
:
11199 return reloc_type
== 54; /* R_SPARC_UA64. */
11203 return reloc_type
== 1; /* R_X86_64_64. */
11206 return reloc_type
== 22; /* R_S390_64. */
11208 return reloc_type
== 1; /* R_TILEGX_64. */
11210 return reloc_type
== 18; /* R_MIPS_64. */
11216 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11217 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11220 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11222 switch (elf_header
.e_machine
)
11225 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11227 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11229 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11231 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11233 return reloc_type
== 44; /* R_PPC64_REL64. */
11234 case EM_SPARC32PLUS
:
11237 return reloc_type
== 46; /* R_SPARC_DISP64. */
11241 return reloc_type
== 24; /* R_X86_64_PC64. */
11244 return reloc_type
== 23; /* R_S390_PC64. */
11246 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11253 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11256 is_24bit_abs_reloc (unsigned int reloc_type
)
11258 switch (elf_header
.e_machine
)
11260 case EM_CYGNUS_MN10200
:
11262 return reloc_type
== 4; /* R_MN10200_24. */
11268 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11269 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11272 is_16bit_abs_reloc (unsigned int reloc_type
)
11274 switch (elf_header
.e_machine
)
11278 return reloc_type
== 4; /* R_AVR_16. */
11279 case EM_ADAPTEVA_EPIPHANY
:
11280 return reloc_type
== 5;
11281 case EM_CYGNUS_D10V
:
11283 return reloc_type
== 3; /* R_D10V_16. */
11287 return reloc_type
== R_H8_DIR16
;
11290 return reloc_type
== 1; /* R_IP2K_16. */
11293 return reloc_type
== 1; /* R_M32C_16 */
11295 if (uses_msp430x_relocs ())
11296 return reloc_type
== 2; /* R_MSP430_ABS16. */
11297 case EM_MSP430_OLD
:
11298 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11300 return reloc_type
== 19; /* R_NDS32_RELA. */
11301 case EM_ALTERA_NIOS2
:
11302 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11304 return reloc_type
== 9; /* R_NIOS_16. */
11306 return reloc_type
== 2; /* R_OR1K_16. */
11308 return reloc_type
== 2; /* R_C6000_ABS16. */
11311 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11312 case EM_CYGNUS_MN10200
:
11314 return reloc_type
== 2; /* R_MN10200_16. */
11315 case EM_CYGNUS_MN10300
:
11317 return reloc_type
== 2; /* R_MN10300_16. */
11319 return reloc_type
== 2; /* R_VISIUM_16. */
11321 return reloc_type
== 3; /* R_XGATE_16. */
11327 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11328 relocation entries (possibly formerly used for SHT_GROUP sections). */
11331 is_none_reloc (unsigned int reloc_type
)
11333 switch (elf_header
.e_machine
)
11335 case EM_68K
: /* R_68K_NONE. */
11336 case EM_386
: /* R_386_NONE. */
11337 case EM_SPARC32PLUS
:
11339 case EM_SPARC
: /* R_SPARC_NONE. */
11340 case EM_MIPS
: /* R_MIPS_NONE. */
11341 case EM_PARISC
: /* R_PARISC_NONE. */
11342 case EM_ALPHA
: /* R_ALPHA_NONE. */
11343 case EM_ADAPTEVA_EPIPHANY
:
11344 case EM_PPC
: /* R_PPC_NONE. */
11345 case EM_PPC64
: /* R_PPC64_NONE. */
11346 case EM_ARM
: /* R_ARM_NONE. */
11347 case EM_IA_64
: /* R_IA64_NONE. */
11348 case EM_SH
: /* R_SH_NONE. */
11350 case EM_S390
: /* R_390_NONE. */
11351 case EM_CRIS
: /* R_CRIS_NONE. */
11352 case EM_X86_64
: /* R_X86_64_NONE. */
11353 case EM_L1OM
: /* R_X86_64_NONE. */
11354 case EM_K1OM
: /* R_X86_64_NONE. */
11355 case EM_MN10300
: /* R_MN10300_NONE. */
11356 case EM_MOXIE
: /* R_MOXIE_NONE. */
11357 case EM_M32R
: /* R_M32R_NONE. */
11358 case EM_TI_C6000
:/* R_C6000_NONE. */
11359 case EM_TILEGX
: /* R_TILEGX_NONE. */
11360 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11362 case EM_C166
: /* R_XC16X_NONE. */
11363 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11364 case EM_NIOS32
: /* R_NIOS_NONE. */
11365 case EM_OR1K
: /* R_OR1K_NONE. */
11366 return reloc_type
== 0;
11368 return reloc_type
== 0 || reloc_type
== 256;
11370 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11371 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11372 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11373 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11374 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11375 case EM_XTENSA_OLD
:
11377 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11378 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11379 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11380 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11382 return reloc_type
== 3; /* R_METAG_NONE. */
11387 /* Apply relocations to a section.
11388 Note: So far support has been added only for those relocations
11389 which can be found in debug sections.
11390 FIXME: Add support for more relocations ? */
11393 apply_relocations (void * file
,
11394 Elf_Internal_Shdr
* section
,
11395 unsigned char * start
)
11397 Elf_Internal_Shdr
* relsec
;
11398 unsigned char * end
= start
+ section
->sh_size
;
11400 if (elf_header
.e_type
!= ET_REL
)
11403 /* Find the reloc section associated with the section. */
11404 for (relsec
= section_headers
;
11405 relsec
< section_headers
+ elf_header
.e_shnum
;
11408 bfd_boolean is_rela
;
11409 unsigned long num_relocs
;
11410 Elf_Internal_Rela
* relocs
;
11411 Elf_Internal_Rela
* rp
;
11412 Elf_Internal_Shdr
* symsec
;
11413 Elf_Internal_Sym
* symtab
;
11414 unsigned long num_syms
;
11415 Elf_Internal_Sym
* sym
;
11417 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11418 || relsec
->sh_info
>= elf_header
.e_shnum
11419 || section_headers
+ relsec
->sh_info
!= section
11420 || relsec
->sh_size
== 0
11421 || relsec
->sh_link
>= elf_header
.e_shnum
)
11424 is_rela
= relsec
->sh_type
== SHT_RELA
;
11428 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11429 relsec
->sh_size
, & relocs
, & num_relocs
))
11434 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11435 relsec
->sh_size
, & relocs
, & num_relocs
))
11439 /* SH uses RELA but uses in place value instead of the addend field. */
11440 if (elf_header
.e_machine
== EM_SH
)
11443 symsec
= section_headers
+ relsec
->sh_link
;
11444 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11446 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11449 unsigned int reloc_type
;
11450 unsigned int reloc_size
;
11451 unsigned char * rloc
;
11452 unsigned long sym_index
;
11454 reloc_type
= get_reloc_type (rp
->r_info
);
11456 if (target_specific_reloc_handling (rp
, start
, symtab
))
11458 else if (is_none_reloc (reloc_type
))
11460 else if (is_32bit_abs_reloc (reloc_type
)
11461 || is_32bit_pcrel_reloc (reloc_type
))
11463 else if (is_64bit_abs_reloc (reloc_type
)
11464 || is_64bit_pcrel_reloc (reloc_type
))
11466 else if (is_24bit_abs_reloc (reloc_type
))
11468 else if (is_16bit_abs_reloc (reloc_type
))
11472 static unsigned int prev_reloc
= 0;
11473 if (reloc_type
!= prev_reloc
)
11474 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11475 reloc_type
, printable_section_name (section
));
11476 prev_reloc
= reloc_type
;
11480 rloc
= start
+ rp
->r_offset
;
11481 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11483 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11484 (unsigned long) rp
->r_offset
,
11485 printable_section_name (section
));
11489 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11490 if (sym_index
>= num_syms
)
11492 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11493 sym_index
, printable_section_name (section
));
11496 sym
= symtab
+ sym_index
;
11498 /* If the reloc has a symbol associated with it,
11499 make sure that it is of an appropriate type.
11501 Relocations against symbols without type can happen.
11502 Gcc -feliminate-dwarf2-dups may generate symbols
11503 without type for debug info.
11505 Icc generates relocations against function symbols
11506 instead of local labels.
11508 Relocations against object symbols can happen, eg when
11509 referencing a global array. For an example of this see
11510 the _clz.o binary in libgcc.a. */
11512 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11514 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11515 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11516 (long int)(rp
- relocs
),
11517 printable_section_name (relsec
));
11523 addend
+= rp
->r_addend
;
11524 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11525 partial_inplace. */
11527 || (elf_header
.e_machine
== EM_XTENSA
11528 && reloc_type
== 1)
11529 || ((elf_header
.e_machine
== EM_PJ
11530 || elf_header
.e_machine
== EM_PJ_OLD
)
11531 && reloc_type
== 1)
11532 || ((elf_header
.e_machine
== EM_D30V
11533 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11534 && reloc_type
== 12))
11535 addend
+= byte_get (rloc
, reloc_size
);
11537 if (is_32bit_pcrel_reloc (reloc_type
)
11538 || is_64bit_pcrel_reloc (reloc_type
))
11540 /* On HPPA, all pc-relative relocations are biased by 8. */
11541 if (elf_header
.e_machine
== EM_PARISC
)
11543 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11547 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11556 #ifdef SUPPORT_DISASSEMBLY
11558 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11560 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11562 /* FIXME: XXX -- to be done --- XXX */
11568 /* Reads in the contents of SECTION from FILE, returning a pointer
11569 to a malloc'ed buffer or NULL if something went wrong. */
11572 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11574 bfd_size_type num_bytes
;
11576 num_bytes
= section
->sh_size
;
11578 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11580 printf (_("\nSection '%s' has no data to dump.\n"),
11581 printable_section_name (section
));
11585 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11586 _("section contents"));
11591 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11593 Elf_Internal_Shdr
* relsec
;
11594 bfd_size_type num_bytes
;
11598 bfd_boolean some_strings_shown
;
11600 start
= get_section_contents (section
, file
);
11604 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11606 /* If the section being dumped has relocations against it the user might
11607 be expecting these relocations to have been applied. Check for this
11608 case and issue a warning message in order to avoid confusion.
11609 FIXME: Maybe we ought to have an option that dumps a section with
11610 relocs applied ? */
11611 for (relsec
= section_headers
;
11612 relsec
< section_headers
+ elf_header
.e_shnum
;
11615 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11616 || relsec
->sh_info
>= elf_header
.e_shnum
11617 || section_headers
+ relsec
->sh_info
!= section
11618 || relsec
->sh_size
== 0
11619 || relsec
->sh_link
>= elf_header
.e_shnum
)
11622 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11626 num_bytes
= section
->sh_size
;
11628 end
= start
+ num_bytes
;
11629 some_strings_shown
= FALSE
;
11633 while (!ISPRINT (* data
))
11634 if (++ data
>= end
)
11639 size_t maxlen
= end
- data
;
11642 /* PR 11128: Use two separate invocations in order to work
11643 around bugs in the Solaris 8 implementation of printf. */
11644 printf (" [%6tx] ", data
- start
);
11646 printf (" [%6Ix] ", (size_t) (data
- start
));
11650 print_symbol ((int) maxlen
, data
);
11652 data
+= strnlen (data
, maxlen
);
11656 printf (_("<corrupt>\n"));
11659 some_strings_shown
= TRUE
;
11663 if (! some_strings_shown
)
11664 printf (_(" No strings found in this section."));
11672 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11674 bfd_boolean relocate
)
11676 Elf_Internal_Shdr
* relsec
;
11677 bfd_size_type bytes
;
11679 unsigned char * data
;
11680 unsigned char * start
;
11682 start
= (unsigned char *) get_section_contents (section
, file
);
11686 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11690 apply_relocations (file
, section
, start
);
11694 /* If the section being dumped has relocations against it the user might
11695 be expecting these relocations to have been applied. Check for this
11696 case and issue a warning message in order to avoid confusion.
11697 FIXME: Maybe we ought to have an option that dumps a section with
11698 relocs applied ? */
11699 for (relsec
= section_headers
;
11700 relsec
< section_headers
+ elf_header
.e_shnum
;
11703 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11704 || relsec
->sh_info
>= elf_header
.e_shnum
11705 || section_headers
+ relsec
->sh_info
!= section
11706 || relsec
->sh_size
== 0
11707 || relsec
->sh_link
>= elf_header
.e_shnum
)
11710 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11715 addr
= section
->sh_addr
;
11716 bytes
= section
->sh_size
;
11725 lbytes
= (bytes
> 16 ? 16 : bytes
);
11727 printf (" 0x%8.8lx ", (unsigned long) addr
);
11729 for (j
= 0; j
< 16; j
++)
11732 printf ("%2.2x", data
[j
]);
11740 for (j
= 0; j
< lbytes
; j
++)
11743 if (k
>= ' ' && k
< 0x7f)
11761 /* Uncompresses a section that was compressed using zlib, in place. */
11764 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11765 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11767 #ifndef HAVE_ZLIB_H
11770 dwarf_size_type compressed_size
= *size
;
11771 unsigned char * compressed_buffer
= *buffer
;
11772 dwarf_size_type uncompressed_size
;
11773 unsigned char * uncompressed_buffer
;
11776 dwarf_size_type header_size
= 12;
11778 /* Read the zlib header. In this case, it should be "ZLIB" followed
11779 by the uncompressed section size, 8 bytes in big-endian order. */
11780 if (compressed_size
< header_size
11781 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11784 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11785 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11786 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11787 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11788 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11789 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11790 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11791 uncompressed_size
+= compressed_buffer
[11];
11793 /* It is possible the section consists of several compressed
11794 buffers concatenated together, so we uncompress in a loop. */
11795 strm
.zalloc
= NULL
;
11797 strm
.opaque
= NULL
;
11798 strm
.avail_in
= compressed_size
- header_size
;
11799 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11800 strm
.avail_out
= uncompressed_size
;
11801 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11803 rc
= inflateInit (& strm
);
11804 while (strm
.avail_in
> 0)
11808 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11809 + (uncompressed_size
- strm
.avail_out
));
11810 rc
= inflate (&strm
, Z_FINISH
);
11811 if (rc
!= Z_STREAM_END
)
11813 rc
= inflateReset (& strm
);
11815 rc
= inflateEnd (& strm
);
11817 || strm
.avail_out
!= 0)
11820 free (compressed_buffer
);
11821 *buffer
= uncompressed_buffer
;
11822 *size
= uncompressed_size
;
11826 free (uncompressed_buffer
);
11827 /* Indicate decompression failure. */
11830 #endif /* HAVE_ZLIB_H */
11834 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11835 Elf_Internal_Shdr
* sec
, void * file
)
11837 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11840 /* If it is already loaded, do nothing. */
11841 if (section
->start
!= NULL
)
11844 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11845 section
->address
= sec
->sh_addr
;
11846 section
->user_data
= NULL
;
11847 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11849 sec
->sh_size
, buf
);
11850 if (section
->start
== NULL
)
11854 section
->size
= sec
->sh_size
;
11855 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11856 sec
->sh_size
= section
->size
;
11859 if (section
->start
== NULL
)
11862 if (debug_displays
[debug
].relocate
)
11863 apply_relocations ((FILE *) file
, sec
, section
->start
);
11868 /* If this is not NULL, load_debug_section will only look for sections
11869 within the list of sections given here. */
11870 unsigned int *section_subset
= NULL
;
11873 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11875 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11876 Elf_Internal_Shdr
* sec
;
11878 /* Locate the debug section. */
11879 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11881 section
->name
= section
->uncompressed_name
;
11884 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11886 section
->name
= section
->compressed_name
;
11891 /* If we're loading from a subset of sections, and we've loaded
11892 a section matching this name before, it's likely that it's a
11894 if (section_subset
!= NULL
)
11895 free_debug_section (debug
);
11897 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11901 free_debug_section (enum dwarf_section_display_enum debug
)
11903 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11905 if (section
->start
== NULL
)
11908 free ((char *) section
->start
);
11909 section
->start
= NULL
;
11910 section
->address
= 0;
11915 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11917 char * name
= SECTION_NAME (section
);
11918 const char * print_name
= printable_section_name (section
);
11919 bfd_size_type length
;
11923 length
= section
->sh_size
;
11926 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
11929 if (section
->sh_type
== SHT_NOBITS
)
11931 /* There is no point in dumping the contents of a debugging section
11932 which has the NOBITS type - the bits in the file will be random.
11933 This can happen when a file containing a .eh_frame section is
11934 stripped with the --only-keep-debug command line option. */
11935 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11940 if (const_strneq (name
, ".gnu.linkonce.wi."))
11941 name
= ".debug_info";
11943 /* See if we know how to display the contents of this section. */
11944 for (i
= 0; i
< max
; i
++)
11945 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11946 || (i
== line
&& const_strneq (name
, ".debug_line."))
11947 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11949 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11950 int secondary
= (section
!= find_section (name
));
11953 free_debug_section ((enum dwarf_section_display_enum
) i
);
11955 if (i
== line
&& const_strneq (name
, ".debug_line."))
11957 else if (streq (sec
->uncompressed_name
, name
))
11958 sec
->name
= sec
->uncompressed_name
;
11960 sec
->name
= sec
->compressed_name
;
11961 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11964 /* If this debug section is part of a CU/TU set in a .dwp file,
11965 restrict load_debug_section to the sections in that set. */
11966 section_subset
= find_cu_tu_set (file
, shndx
);
11968 result
&= debug_displays
[i
].display (sec
, file
);
11970 section_subset
= NULL
;
11972 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11973 free_debug_section ((enum dwarf_section_display_enum
) i
);
11981 printf (_("Unrecognized debug section: %s\n"), print_name
);
11988 /* Set DUMP_SECTS for all sections where dumps were requested
11989 based on section name. */
11992 initialise_dumps_byname (void)
11994 struct dump_list_entry
* cur
;
11996 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12001 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12002 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12004 request_dump_bynumber (i
, cur
->type
);
12009 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12015 process_section_contents (FILE * file
)
12017 Elf_Internal_Shdr
* section
;
12023 initialise_dumps_byname ();
12025 for (i
= 0, section
= section_headers
;
12026 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12029 #ifdef SUPPORT_DISASSEMBLY
12030 if (dump_sects
[i
] & DISASS_DUMP
)
12031 disassemble_section (section
, file
);
12033 if (dump_sects
[i
] & HEX_DUMP
)
12034 dump_section_as_bytes (section
, file
, FALSE
);
12036 if (dump_sects
[i
] & RELOC_DUMP
)
12037 dump_section_as_bytes (section
, file
, TRUE
);
12039 if (dump_sects
[i
] & STRING_DUMP
)
12040 dump_section_as_strings (section
, file
);
12042 if (dump_sects
[i
] & DEBUG_DUMP
)
12043 display_debug_section (i
, section
, file
);
12046 /* Check to see if the user requested a
12047 dump of a section that does not exist. */
12048 while (i
++ < num_dump_sects
)
12050 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12054 process_mips_fpe_exception (int mask
)
12059 if (mask
& OEX_FPU_INEX
)
12060 fputs ("INEX", stdout
), first
= 0;
12061 if (mask
& OEX_FPU_UFLO
)
12062 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12063 if (mask
& OEX_FPU_OFLO
)
12064 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12065 if (mask
& OEX_FPU_DIV0
)
12066 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12067 if (mask
& OEX_FPU_INVAL
)
12068 printf ("%sINVAL", first
? "" : "|");
12071 fputs ("0", stdout
);
12074 /* Display's the value of TAG at location P. If TAG is
12075 greater than 0 it is assumed to be an unknown tag, and
12076 a message is printed to this effect. Otherwise it is
12077 assumed that a message has already been printed.
12079 If the bottom bit of TAG is set it assumed to have a
12080 string value, otherwise it is assumed to have an integer
12083 Returns an updated P pointing to the first unread byte
12084 beyond the end of TAG's value.
12086 Reads at or beyond END will not be made. */
12088 static unsigned char *
12089 display_tag_value (int tag
,
12091 const unsigned char * const end
)
12096 printf (" Tag_unknown_%d: ", tag
);
12100 warn (_("<corrupt tag>\n"));
12104 /* PR 17531 file: 027-19978-0.004. */
12105 size_t maxlen
= (end
- p
) - 1;
12110 print_symbol ((int) maxlen
, (const char *) p
);
12111 p
+= strnlen ((char *) p
, maxlen
) + 1;
12115 printf (_("<corrupt string tag>"));
12116 p
= (unsigned char *) end
;
12124 val
= read_uleb128 (p
, &len
, end
);
12126 printf ("%ld (0x%lx)\n", val
, val
);
12133 /* ARM EABI attributes section. */
12138 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12140 const char ** table
;
12141 } arm_attr_public_tag
;
12143 static const char * arm_attr_tag_CPU_arch
[] =
12144 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12145 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12146 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12147 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12148 {"No", "Thumb-1", "Thumb-2"};
12149 static const char * arm_attr_tag_FP_arch
[] =
12150 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12151 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12152 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12153 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12154 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12155 static const char * arm_attr_tag_PCS_config
[] =
12156 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12157 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12158 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12159 {"V6", "SB", "TLS", "Unused"};
12160 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12161 {"Absolute", "PC-relative", "SB-relative", "None"};
12162 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12163 {"Absolute", "PC-relative", "None"};
12164 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12165 {"None", "direct", "GOT-indirect"};
12166 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12167 {"None", "??? 1", "2", "??? 3", "4"};
12168 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12169 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12170 {"Unused", "Needed", "Sign only"};
12171 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12172 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12173 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12174 {"Unused", "Finite", "RTABI", "IEEE 754"};
12175 static const char * arm_attr_tag_ABI_enum_size
[] =
12176 {"Unused", "small", "int", "forced to int"};
12177 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12178 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12179 static const char * arm_attr_tag_ABI_VFP_args
[] =
12180 {"AAPCS", "VFP registers", "custom"};
12181 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12182 {"AAPCS", "WMMX registers", "custom"};
12183 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12184 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12185 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12186 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12187 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12188 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12189 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12190 static const char * arm_attr_tag_FP_HP_extension
[] =
12191 {"Not Allowed", "Allowed"};
12192 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12193 {"None", "IEEE 754", "Alternative Format"};
12194 static const char * arm_attr_tag_MPextension_use
[] =
12195 {"Not Allowed", "Allowed"};
12196 static const char * arm_attr_tag_DIV_use
[] =
12197 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12198 "Allowed in v7-A with integer division extension"};
12199 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12200 static const char * arm_attr_tag_Virtualization_use
[] =
12201 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12202 "TrustZone and Virtualization Extensions"};
12203 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12204 {"Not Allowed", "Allowed"};
12206 #define LOOKUP(id, name) \
12207 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12208 static arm_attr_public_tag arm_attr_public_tags
[] =
12210 {4, "CPU_raw_name", 1, NULL
},
12211 {5, "CPU_name", 1, NULL
},
12212 LOOKUP(6, CPU_arch
),
12213 {7, "CPU_arch_profile", 0, NULL
},
12214 LOOKUP(8, ARM_ISA_use
),
12215 LOOKUP(9, THUMB_ISA_use
),
12216 LOOKUP(10, FP_arch
),
12217 LOOKUP(11, WMMX_arch
),
12218 LOOKUP(12, Advanced_SIMD_arch
),
12219 LOOKUP(13, PCS_config
),
12220 LOOKUP(14, ABI_PCS_R9_use
),
12221 LOOKUP(15, ABI_PCS_RW_data
),
12222 LOOKUP(16, ABI_PCS_RO_data
),
12223 LOOKUP(17, ABI_PCS_GOT_use
),
12224 LOOKUP(18, ABI_PCS_wchar_t
),
12225 LOOKUP(19, ABI_FP_rounding
),
12226 LOOKUP(20, ABI_FP_denormal
),
12227 LOOKUP(21, ABI_FP_exceptions
),
12228 LOOKUP(22, ABI_FP_user_exceptions
),
12229 LOOKUP(23, ABI_FP_number_model
),
12230 {24, "ABI_align_needed", 0, NULL
},
12231 {25, "ABI_align_preserved", 0, NULL
},
12232 LOOKUP(26, ABI_enum_size
),
12233 LOOKUP(27, ABI_HardFP_use
),
12234 LOOKUP(28, ABI_VFP_args
),
12235 LOOKUP(29, ABI_WMMX_args
),
12236 LOOKUP(30, ABI_optimization_goals
),
12237 LOOKUP(31, ABI_FP_optimization_goals
),
12238 {32, "compatibility", 0, NULL
},
12239 LOOKUP(34, CPU_unaligned_access
),
12240 LOOKUP(36, FP_HP_extension
),
12241 LOOKUP(38, ABI_FP_16bit_format
),
12242 LOOKUP(42, MPextension_use
),
12243 LOOKUP(44, DIV_use
),
12244 {64, "nodefaults", 0, NULL
},
12245 {65, "also_compatible_with", 0, NULL
},
12246 LOOKUP(66, T2EE_use
),
12247 {67, "conformance", 1, NULL
},
12248 LOOKUP(68, Virtualization_use
),
12249 LOOKUP(70, MPextension_use_legacy
)
12253 static unsigned char *
12254 display_arm_attribute (unsigned char * p
,
12255 const unsigned char * const end
)
12260 arm_attr_public_tag
* attr
;
12264 tag
= read_uleb128 (p
, &len
, end
);
12267 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12269 if (arm_attr_public_tags
[i
].tag
== tag
)
12271 attr
= &arm_attr_public_tags
[i
];
12278 printf (" Tag_%s: ", attr
->name
);
12279 switch (attr
->type
)
12284 case 7: /* Tag_CPU_arch_profile. */
12285 val
= read_uleb128 (p
, &len
, end
);
12289 case 0: printf (_("None\n")); break;
12290 case 'A': printf (_("Application\n")); break;
12291 case 'R': printf (_("Realtime\n")); break;
12292 case 'M': printf (_("Microcontroller\n")); break;
12293 case 'S': printf (_("Application or Realtime\n")); break;
12294 default: printf ("??? (%d)\n", val
); break;
12298 case 24: /* Tag_align_needed. */
12299 val
= read_uleb128 (p
, &len
, end
);
12303 case 0: printf (_("None\n")); break;
12304 case 1: printf (_("8-byte\n")); break;
12305 case 2: printf (_("4-byte\n")); break;
12306 case 3: printf ("??? 3\n"); break;
12309 printf (_("8-byte and up to %d-byte extended\n"),
12312 printf ("??? (%d)\n", val
);
12317 case 25: /* Tag_align_preserved. */
12318 val
= read_uleb128 (p
, &len
, end
);
12322 case 0: printf (_("None\n")); break;
12323 case 1: printf (_("8-byte, except leaf SP\n")); break;
12324 case 2: printf (_("8-byte\n")); break;
12325 case 3: printf ("??? 3\n"); break;
12328 printf (_("8-byte and up to %d-byte extended\n"),
12331 printf ("??? (%d)\n", val
);
12336 case 32: /* Tag_compatibility. */
12338 val
= read_uleb128 (p
, &len
, end
);
12340 printf (_("flag = %d, vendor = "), val
);
12343 size_t maxlen
= (end
- p
) - 1;
12345 print_symbol ((int) maxlen
, (const char *) p
);
12346 p
+= strnlen ((char *) p
, maxlen
) + 1;
12350 printf (_("<corrupt>"));
12351 p
= (unsigned char *) end
;
12357 case 64: /* Tag_nodefaults. */
12358 /* PR 17531: file: 001-505008-0.01. */
12361 printf (_("True\n"));
12364 case 65: /* Tag_also_compatible_with. */
12365 val
= read_uleb128 (p
, &len
, end
);
12367 if (val
== 6 /* Tag_CPU_arch. */)
12369 val
= read_uleb128 (p
, &len
, end
);
12371 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12372 printf ("??? (%d)\n", val
);
12374 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12378 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12383 printf (_("<unknown: %d>\n"), tag
);
12389 return display_tag_value (-1, p
, end
);
12391 return display_tag_value (0, p
, end
);
12394 assert (attr
->type
& 0x80);
12395 val
= read_uleb128 (p
, &len
, end
);
12397 type
= attr
->type
& 0x7f;
12399 printf ("??? (%d)\n", val
);
12401 printf ("%s\n", attr
->table
[val
]);
12406 return display_tag_value (tag
, p
, end
);
12409 static unsigned char *
12410 display_gnu_attribute (unsigned char * p
,
12411 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12412 const unsigned char * const end
)
12418 tag
= read_uleb128 (p
, &len
, end
);
12421 /* Tag_compatibility is the only generic GNU attribute defined at
12425 val
= read_uleb128 (p
, &len
, end
);
12428 printf (_("flag = %d, vendor = "), val
);
12431 printf (_("<corrupt>\n"));
12432 warn (_("corrupt vendor attribute\n"));
12438 size_t maxlen
= (end
- p
) - 1;
12440 print_symbol ((int) maxlen
, (const char *) p
);
12441 p
+= strnlen ((char *) p
, maxlen
) + 1;
12445 printf (_("<corrupt>"));
12446 p
= (unsigned char *) end
;
12453 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12454 return display_proc_gnu_attribute (p
, tag
, end
);
12456 return display_tag_value (tag
, p
, end
);
12459 static unsigned char *
12460 display_power_gnu_attribute (unsigned char * p
,
12462 const unsigned char * const end
)
12467 if (tag
== Tag_GNU_Power_ABI_FP
)
12469 val
= read_uleb128 (p
, &len
, end
);
12471 printf (" Tag_GNU_Power_ABI_FP: ");
12476 printf (_("Hard or soft float\n"));
12479 printf (_("Hard float\n"));
12482 printf (_("Soft float\n"));
12485 printf (_("Single-precision hard float\n"));
12488 printf ("??? (%d)\n", val
);
12494 if (tag
== Tag_GNU_Power_ABI_Vector
)
12496 val
= read_uleb128 (p
, &len
, end
);
12498 printf (" Tag_GNU_Power_ABI_Vector: ");
12502 printf (_("Any\n"));
12505 printf (_("Generic\n"));
12508 printf ("AltiVec\n");
12514 printf ("??? (%d)\n", val
);
12520 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12524 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12528 val
= read_uleb128 (p
, &len
, end
);
12530 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12534 printf (_("Any\n"));
12537 printf ("r3/r4\n");
12540 printf (_("Memory\n"));
12543 printf ("??? (%d)\n", val
);
12549 return display_tag_value (tag
& 1, p
, end
);
12553 display_sparc_hwcaps (int mask
)
12559 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12560 fputs ("mul32", stdout
), first
= 0;
12561 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12562 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12563 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12564 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12565 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12566 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12567 if (mask
& ELF_SPARC_HWCAP_POPC
)
12568 printf ("%spopc", first
? "" : "|"), first
= 0;
12569 if (mask
& ELF_SPARC_HWCAP_VIS
)
12570 printf ("%svis", first
? "" : "|"), first
= 0;
12571 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12572 printf ("%svis2", first
? "" : "|"), first
= 0;
12573 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12574 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12575 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12576 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12577 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12578 printf ("%svis3", first
? "" : "|"), first
= 0;
12579 if (mask
& ELF_SPARC_HWCAP_HPC
)
12580 printf ("%shpc", first
? "" : "|"), first
= 0;
12581 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12582 printf ("%srandom", first
? "" : "|"), first
= 0;
12583 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12584 printf ("%strans", first
? "" : "|"), first
= 0;
12585 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12586 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12587 if (mask
& ELF_SPARC_HWCAP_IMA
)
12588 printf ("%sima", first
? "" : "|"), first
= 0;
12589 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12590 printf ("%scspare", first
? "" : "|"), first
= 0;
12593 fputc ('0', stdout
);
12594 fputc ('\n', stdout
);
12598 display_sparc_hwcaps2 (int mask
)
12604 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12605 fputs ("fjathplus", stdout
), first
= 0;
12606 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12607 printf ("%svis3b", first
? "" : "|"), first
= 0;
12608 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12609 printf ("%sadp", first
? "" : "|"), first
= 0;
12610 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12611 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12612 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12613 printf ("%smwait", first
? "" : "|"), first
= 0;
12614 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12615 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12616 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12617 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12618 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12619 printf ("%snsec", first
? "" : "|"), first
= 0;
12620 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12621 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12622 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12623 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12624 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12625 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12628 fputc ('0', stdout
);
12629 fputc ('\n', stdout
);
12632 static unsigned char *
12633 display_sparc_gnu_attribute (unsigned char * p
,
12635 const unsigned char * const end
)
12640 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12642 val
= read_uleb128 (p
, &len
, end
);
12644 printf (" Tag_GNU_Sparc_HWCAPS: ");
12645 display_sparc_hwcaps (val
);
12648 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12650 val
= read_uleb128 (p
, &len
, end
);
12652 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12653 display_sparc_hwcaps2 (val
);
12657 return display_tag_value (tag
, p
, end
);
12661 print_mips_fp_abi_value (int val
)
12665 case Val_GNU_MIPS_ABI_FP_ANY
:
12666 printf (_("Hard or soft float\n"));
12668 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12669 printf (_("Hard float (double precision)\n"));
12671 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12672 printf (_("Hard float (single precision)\n"));
12674 case Val_GNU_MIPS_ABI_FP_SOFT
:
12675 printf (_("Soft float\n"));
12677 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12678 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12680 case Val_GNU_MIPS_ABI_FP_XX
:
12681 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12683 case Val_GNU_MIPS_ABI_FP_64
:
12684 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12686 case Val_GNU_MIPS_ABI_FP_64A
:
12687 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12690 printf ("??? (%d)\n", val
);
12695 static unsigned char *
12696 display_mips_gnu_attribute (unsigned char * p
,
12698 const unsigned char * const end
)
12700 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12705 val
= read_uleb128 (p
, &len
, end
);
12707 printf (" Tag_GNU_MIPS_ABI_FP: ");
12709 print_mips_fp_abi_value (val
);
12714 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12719 val
= read_uleb128 (p
, &len
, end
);
12721 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12725 case Val_GNU_MIPS_ABI_MSA_ANY
:
12726 printf (_("Any MSA or not\n"));
12728 case Val_GNU_MIPS_ABI_MSA_128
:
12729 printf (_("128-bit MSA\n"));
12732 printf ("??? (%d)\n", val
);
12738 return display_tag_value (tag
& 1, p
, end
);
12741 static unsigned char *
12742 display_tic6x_attribute (unsigned char * p
,
12743 const unsigned char * const end
)
12749 tag
= read_uleb128 (p
, &len
, end
);
12755 val
= read_uleb128 (p
, &len
, end
);
12757 printf (" Tag_ISA: ");
12761 case C6XABI_Tag_ISA_none
:
12762 printf (_("None\n"));
12764 case C6XABI_Tag_ISA_C62X
:
12767 case C6XABI_Tag_ISA_C67X
:
12770 case C6XABI_Tag_ISA_C67XP
:
12771 printf ("C67x+\n");
12773 case C6XABI_Tag_ISA_C64X
:
12776 case C6XABI_Tag_ISA_C64XP
:
12777 printf ("C64x+\n");
12779 case C6XABI_Tag_ISA_C674X
:
12780 printf ("C674x\n");
12783 printf ("??? (%d)\n", val
);
12788 case Tag_ABI_wchar_t
:
12789 val
= read_uleb128 (p
, &len
, end
);
12791 printf (" Tag_ABI_wchar_t: ");
12795 printf (_("Not used\n"));
12798 printf (_("2 bytes\n"));
12801 printf (_("4 bytes\n"));
12804 printf ("??? (%d)\n", val
);
12809 case Tag_ABI_stack_align_needed
:
12810 val
= read_uleb128 (p
, &len
, end
);
12812 printf (" Tag_ABI_stack_align_needed: ");
12816 printf (_("8-byte\n"));
12819 printf (_("16-byte\n"));
12822 printf ("??? (%d)\n", val
);
12827 case Tag_ABI_stack_align_preserved
:
12828 val
= read_uleb128 (p
, &len
, end
);
12830 printf (" Tag_ABI_stack_align_preserved: ");
12834 printf (_("8-byte\n"));
12837 printf (_("16-byte\n"));
12840 printf ("??? (%d)\n", val
);
12846 val
= read_uleb128 (p
, &len
, end
);
12848 printf (" Tag_ABI_DSBT: ");
12852 printf (_("DSBT addressing not used\n"));
12855 printf (_("DSBT addressing used\n"));
12858 printf ("??? (%d)\n", val
);
12864 val
= read_uleb128 (p
, &len
, end
);
12866 printf (" Tag_ABI_PID: ");
12870 printf (_("Data addressing position-dependent\n"));
12873 printf (_("Data addressing position-independent, GOT near DP\n"));
12876 printf (_("Data addressing position-independent, GOT far from DP\n"));
12879 printf ("??? (%d)\n", val
);
12885 val
= read_uleb128 (p
, &len
, end
);
12887 printf (" Tag_ABI_PIC: ");
12891 printf (_("Code addressing position-dependent\n"));
12894 printf (_("Code addressing position-independent\n"));
12897 printf ("??? (%d)\n", val
);
12902 case Tag_ABI_array_object_alignment
:
12903 val
= read_uleb128 (p
, &len
, end
);
12905 printf (" Tag_ABI_array_object_alignment: ");
12909 printf (_("8-byte\n"));
12912 printf (_("4-byte\n"));
12915 printf (_("16-byte\n"));
12918 printf ("??? (%d)\n", val
);
12923 case Tag_ABI_array_object_align_expected
:
12924 val
= read_uleb128 (p
, &len
, end
);
12926 printf (" Tag_ABI_array_object_align_expected: ");
12930 printf (_("8-byte\n"));
12933 printf (_("4-byte\n"));
12936 printf (_("16-byte\n"));
12939 printf ("??? (%d)\n", val
);
12944 case Tag_ABI_compatibility
:
12946 val
= read_uleb128 (p
, &len
, end
);
12948 printf (" Tag_ABI_compatibility: ");
12949 printf (_("flag = %d, vendor = "), val
);
12952 size_t maxlen
= (end
- p
) - 1;
12954 print_symbol ((int) maxlen
, (const char *) p
);
12955 p
+= strnlen ((char *) p
, maxlen
) + 1;
12959 printf (_("<corrupt>"));
12960 p
= (unsigned char *) end
;
12966 case Tag_ABI_conformance
:
12968 printf (" Tag_ABI_conformance: \"");
12971 size_t maxlen
= (end
- p
) - 1;
12973 print_symbol ((int) maxlen
, (const char *) p
);
12974 p
+= strnlen ((char *) p
, maxlen
) + 1;
12978 printf (_("<corrupt>"));
12979 p
= (unsigned char *) end
;
12986 return display_tag_value (tag
, p
, end
);
12990 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12992 unsigned long addr
= 0;
12993 size_t bytes
= end
- p
;
13000 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13002 printf (" 0x%8.8lx ", addr
);
13004 for (j
= 0; j
< 16; j
++)
13007 printf ("%2.2x", p
[j
]);
13015 for (j
= 0; j
< lbytes
; j
++)
13018 if (k
>= ' ' && k
< 0x7f)
13034 static unsigned char *
13035 display_msp430x_attribute (unsigned char * p
,
13036 const unsigned char * const end
)
13042 tag
= read_uleb128 (p
, & len
, end
);
13047 case OFBA_MSPABI_Tag_ISA
:
13048 val
= read_uleb128 (p
, &len
, end
);
13050 printf (" Tag_ISA: ");
13053 case 0: printf (_("None\n")); break;
13054 case 1: printf (_("MSP430\n")); break;
13055 case 2: printf (_("MSP430X\n")); break;
13056 default: printf ("??? (%d)\n", val
); break;
13060 case OFBA_MSPABI_Tag_Code_Model
:
13061 val
= read_uleb128 (p
, &len
, end
);
13063 printf (" Tag_Code_Model: ");
13066 case 0: printf (_("None\n")); break;
13067 case 1: printf (_("Small\n")); break;
13068 case 2: printf (_("Large\n")); break;
13069 default: printf ("??? (%d)\n", val
); break;
13073 case OFBA_MSPABI_Tag_Data_Model
:
13074 val
= read_uleb128 (p
, &len
, end
);
13076 printf (" Tag_Data_Model: ");
13079 case 0: printf (_("None\n")); break;
13080 case 1: printf (_("Small\n")); break;
13081 case 2: printf (_("Large\n")); break;
13082 case 3: printf (_("Restricted Large\n")); break;
13083 default: printf ("??? (%d)\n", val
); break;
13088 printf (_(" <unknown tag %d>: "), tag
);
13095 size_t maxlen
= (end
- p
) - 1;
13097 print_symbol ((int) maxlen
, (const char *) p
);
13098 p
+= strnlen ((char *) p
, maxlen
) + 1;
13102 printf (_("<corrupt>"));
13103 p
= (unsigned char *) end
;
13109 val
= read_uleb128 (p
, &len
, end
);
13111 printf ("%d (0x%x)\n", val
, val
);
13121 process_attributes (FILE * file
,
13122 const char * public_name
,
13123 unsigned int proc_type
,
13124 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13125 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13127 Elf_Internal_Shdr
* sect
;
13130 /* Find the section header so that we get the size. */
13131 for (i
= 0, sect
= section_headers
;
13132 i
< elf_header
.e_shnum
;
13135 unsigned char * contents
;
13138 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13141 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13142 sect
->sh_size
, _("attributes"));
13143 if (contents
== NULL
)
13149 bfd_vma section_len
;
13151 section_len
= sect
->sh_size
- 1;
13154 while (section_len
> 0)
13157 unsigned int namelen
;
13158 bfd_boolean public_section
;
13159 bfd_boolean gnu_section
;
13161 if (section_len
<= 4)
13163 error (_("Tag section ends prematurely\n"));
13166 attr_len
= byte_get (p
, 4);
13169 if (attr_len
> section_len
)
13171 error (_("Bad attribute length (%u > %u)\n"),
13172 (unsigned) attr_len
, (unsigned) section_len
);
13173 attr_len
= section_len
;
13175 /* PR 17531: file: 001-101425-0.004 */
13176 else if (attr_len
< 5)
13178 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13182 section_len
-= attr_len
;
13185 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13186 if (namelen
== 0 || namelen
>= attr_len
)
13188 error (_("Corrupt attribute section name\n"));
13192 printf (_("Attribute Section: "));
13193 print_symbol (INT_MAX
, (const char *) p
);
13196 if (public_name
&& streq ((char *) p
, public_name
))
13197 public_section
= TRUE
;
13199 public_section
= FALSE
;
13201 if (streq ((char *) p
, "gnu"))
13202 gnu_section
= TRUE
;
13204 gnu_section
= FALSE
;
13207 attr_len
-= namelen
;
13209 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13214 unsigned char * end
;
13216 /* PR binutils/17531: Safe handling of corrupt files. */
13219 error (_("Unused bytes at end of section\n"));
13225 size
= byte_get (p
, 4);
13226 if (size
> attr_len
)
13228 error (_("Bad subsection length (%u > %u)\n"),
13229 (unsigned) size
, (unsigned) attr_len
);
13232 /* PR binutils/17531: Safe handling of corrupt files. */
13235 error (_("Bad subsection length (%u < 6)\n"),
13242 end
= p
+ size
- 1;
13243 assert (end
<= contents
+ sect
->sh_size
);
13249 printf (_("File Attributes\n"));
13252 printf (_("Section Attributes:"));
13255 printf (_("Symbol Attributes:"));
13261 val
= read_uleb128 (p
, &j
, end
);
13265 printf (" %d", val
);
13270 printf (_("Unknown tag: %d\n"), tag
);
13271 public_section
= FALSE
;
13275 if (public_section
&& display_pub_attribute
!= NULL
)
13278 p
= display_pub_attribute (p
, end
);
13281 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13284 p
= display_gnu_attribute (p
,
13285 display_proc_gnu_attribute
,
13291 printf (_(" Unknown attribute:\n"));
13292 display_raw_attribute (p
, end
);
13301 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13309 process_arm_specific (FILE * file
)
13311 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13312 display_arm_attribute
, NULL
);
13316 process_power_specific (FILE * file
)
13318 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13319 display_power_gnu_attribute
);
13323 process_sparc_specific (FILE * file
)
13325 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13326 display_sparc_gnu_attribute
);
13330 process_tic6x_specific (FILE * file
)
13332 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13333 display_tic6x_attribute
, NULL
);
13337 process_msp430x_specific (FILE * file
)
13339 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13340 display_msp430x_attribute
, NULL
);
13343 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13344 Print the Address, Access and Initial fields of an entry at VMA ADDR
13345 and return the VMA of the next entry. */
13348 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13351 print_vma (addr
, LONG_HEX
);
13353 if (addr
< pltgot
+ 0xfff0)
13354 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13356 printf ("%10s", "");
13359 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13364 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13365 print_vma (entry
, LONG_HEX
);
13367 return addr
+ (is_32bit_elf
? 4 : 8);
13370 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13371 PLTGOT. Print the Address and Initial fields of an entry at VMA
13372 ADDR and return the VMA of the next entry. */
13375 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13378 print_vma (addr
, LONG_HEX
);
13381 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13386 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13387 print_vma (entry
, LONG_HEX
);
13389 return addr
+ (is_32bit_elf
? 4 : 8);
13393 print_mips_ases (unsigned int mask
)
13395 if (mask
& AFL_ASE_DSP
)
13396 fputs ("\n\tDSP ASE", stdout
);
13397 if (mask
& AFL_ASE_DSPR2
)
13398 fputs ("\n\tDSP R2 ASE", stdout
);
13399 if (mask
& AFL_ASE_EVA
)
13400 fputs ("\n\tEnhanced VA Scheme", stdout
);
13401 if (mask
& AFL_ASE_MCU
)
13402 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13403 if (mask
& AFL_ASE_MDMX
)
13404 fputs ("\n\tMDMX ASE", stdout
);
13405 if (mask
& AFL_ASE_MIPS3D
)
13406 fputs ("\n\tMIPS-3D ASE", stdout
);
13407 if (mask
& AFL_ASE_MT
)
13408 fputs ("\n\tMT ASE", stdout
);
13409 if (mask
& AFL_ASE_SMARTMIPS
)
13410 fputs ("\n\tSmartMIPS ASE", stdout
);
13411 if (mask
& AFL_ASE_VIRT
)
13412 fputs ("\n\tVZ ASE", stdout
);
13413 if (mask
& AFL_ASE_MSA
)
13414 fputs ("\n\tMSA ASE", stdout
);
13415 if (mask
& AFL_ASE_MIPS16
)
13416 fputs ("\n\tMIPS16 ASE", stdout
);
13417 if (mask
& AFL_ASE_MICROMIPS
)
13418 fputs ("\n\tMICROMIPS ASE", stdout
);
13419 if (mask
& AFL_ASE_XPA
)
13420 fputs ("\n\tXPA ASE", stdout
);
13422 fprintf (stdout
, "\n\t%s", _("None"));
13423 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13424 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13428 print_mips_isa_ext (unsigned int isa_ext
)
13433 fputs (_("None"), stdout
);
13436 fputs ("RMI XLR", stdout
);
13438 case AFL_EXT_OCTEON3
:
13439 fputs ("Cavium Networks Octeon3", stdout
);
13441 case AFL_EXT_OCTEON2
:
13442 fputs ("Cavium Networks Octeon2", stdout
);
13444 case AFL_EXT_OCTEONP
:
13445 fputs ("Cavium Networks OcteonP", stdout
);
13447 case AFL_EXT_LOONGSON_3A
:
13448 fputs ("Loongson 3A", stdout
);
13450 case AFL_EXT_OCTEON
:
13451 fputs ("Cavium Networks Octeon", stdout
);
13454 fputs ("Toshiba R5900", stdout
);
13457 fputs ("MIPS R4650", stdout
);
13460 fputs ("LSI R4010", stdout
);
13463 fputs ("NEC VR4100", stdout
);
13466 fputs ("Toshiba R3900", stdout
);
13468 case AFL_EXT_10000
:
13469 fputs ("MIPS R10000", stdout
);
13472 fputs ("Broadcom SB-1", stdout
);
13475 fputs ("NEC VR4111/VR4181", stdout
);
13478 fputs ("NEC VR4120", stdout
);
13481 fputs ("NEC VR5400", stdout
);
13484 fputs ("NEC VR5500", stdout
);
13486 case AFL_EXT_LOONGSON_2E
:
13487 fputs ("ST Microelectronics Loongson 2E", stdout
);
13489 case AFL_EXT_LOONGSON_2F
:
13490 fputs ("ST Microelectronics Loongson 2F", stdout
);
13493 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13498 get_mips_reg_size (int reg_size
)
13500 return (reg_size
== AFL_REG_NONE
) ? 0
13501 : (reg_size
== AFL_REG_32
) ? 32
13502 : (reg_size
== AFL_REG_64
) ? 64
13503 : (reg_size
== AFL_REG_128
) ? 128
13508 process_mips_specific (FILE * file
)
13510 Elf_Internal_Dyn
* entry
;
13511 Elf_Internal_Shdr
*sect
= NULL
;
13512 size_t liblist_offset
= 0;
13513 size_t liblistno
= 0;
13514 size_t conflictsno
= 0;
13515 size_t options_offset
= 0;
13516 size_t conflicts_offset
= 0;
13517 size_t pltrelsz
= 0;
13519 bfd_vma pltgot
= 0;
13520 bfd_vma mips_pltgot
= 0;
13521 bfd_vma jmprel
= 0;
13522 bfd_vma local_gotno
= 0;
13523 bfd_vma gotsym
= 0;
13524 bfd_vma symtabno
= 0;
13526 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13527 display_mips_gnu_attribute
);
13529 sect
= find_section (".MIPS.abiflags");
13533 Elf_External_ABIFlags_v0
*abiflags_ext
;
13534 Elf_Internal_ABIFlags_v0 abiflags_in
;
13536 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13537 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13540 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13541 sect
->sh_size
, _("MIPS ABI Flags section"));
13544 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13545 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13546 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13547 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13548 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13549 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13550 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13551 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13552 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13553 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13554 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13556 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13557 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13558 if (abiflags_in
.isa_rev
> 1)
13559 printf ("r%d", abiflags_in
.isa_rev
);
13560 printf ("\nGPR size: %d",
13561 get_mips_reg_size (abiflags_in
.gpr_size
));
13562 printf ("\nCPR1 size: %d",
13563 get_mips_reg_size (abiflags_in
.cpr1_size
));
13564 printf ("\nCPR2 size: %d",
13565 get_mips_reg_size (abiflags_in
.cpr2_size
));
13566 fputs ("\nFP ABI: ", stdout
);
13567 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13568 fputs ("ISA Extension: ", stdout
);
13569 print_mips_isa_ext (abiflags_in
.isa_ext
);
13570 fputs ("\nASEs:", stdout
);
13571 print_mips_ases (abiflags_in
.ases
);
13572 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13573 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13574 fputc ('\n', stdout
);
13575 free (abiflags_ext
);
13580 /* We have a lot of special sections. Thanks SGI! */
13581 if (dynamic_section
== NULL
)
13582 /* No information available. */
13585 for (entry
= dynamic_section
;
13586 /* PR 17531 file: 012-50589-0.004. */
13587 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13589 switch (entry
->d_tag
)
13591 case DT_MIPS_LIBLIST
:
13593 = offset_from_vma (file
, entry
->d_un
.d_val
,
13594 liblistno
* sizeof (Elf32_External_Lib
));
13596 case DT_MIPS_LIBLISTNO
:
13597 liblistno
= entry
->d_un
.d_val
;
13599 case DT_MIPS_OPTIONS
:
13600 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13602 case DT_MIPS_CONFLICT
:
13604 = offset_from_vma (file
, entry
->d_un
.d_val
,
13605 conflictsno
* sizeof (Elf32_External_Conflict
));
13607 case DT_MIPS_CONFLICTNO
:
13608 conflictsno
= entry
->d_un
.d_val
;
13611 pltgot
= entry
->d_un
.d_ptr
;
13613 case DT_MIPS_LOCAL_GOTNO
:
13614 local_gotno
= entry
->d_un
.d_val
;
13616 case DT_MIPS_GOTSYM
:
13617 gotsym
= entry
->d_un
.d_val
;
13619 case DT_MIPS_SYMTABNO
:
13620 symtabno
= entry
->d_un
.d_val
;
13622 case DT_MIPS_PLTGOT
:
13623 mips_pltgot
= entry
->d_un
.d_ptr
;
13626 pltrel
= entry
->d_un
.d_val
;
13629 pltrelsz
= entry
->d_un
.d_val
;
13632 jmprel
= entry
->d_un
.d_ptr
;
13638 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13640 Elf32_External_Lib
* elib
;
13643 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13645 sizeof (Elf32_External_Lib
),
13646 _("liblist section data"));
13649 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13650 (unsigned long) liblistno
);
13651 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13654 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13661 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13662 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13663 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13664 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13665 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13667 tmp
= gmtime (&atime
);
13668 snprintf (timebuf
, sizeof (timebuf
),
13669 "%04u-%02u-%02uT%02u:%02u:%02u",
13670 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13671 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13673 printf ("%3lu: ", (unsigned long) cnt
);
13674 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13675 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13677 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13678 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13679 liblist
.l_version
);
13681 if (liblist
.l_flags
== 0)
13685 static const struct
13692 { " EXACT_MATCH", LL_EXACT_MATCH
},
13693 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13694 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13695 { " EXPORTS", LL_EXPORTS
},
13696 { " DELAY_LOAD", LL_DELAY_LOAD
},
13697 { " DELTA", LL_DELTA
}
13699 int flags
= liblist
.l_flags
;
13702 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13703 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13705 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13706 flags
^= l_flags_vals
[fcnt
].bit
;
13709 printf (" %#x", (unsigned int) flags
);
13719 if (options_offset
!= 0)
13721 Elf_External_Options
* eopt
;
13722 Elf_Internal_Options
* iopt
;
13723 Elf_Internal_Options
* option
;
13726 sect
= section_headers
;
13728 /* Find the section header so that we get the size. */
13729 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13730 /* PR 17533 file: 012-277276-0.004. */
13733 error (_("No MIPS_OPTIONS header found\n"));
13737 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13738 sect
->sh_size
, _("options"));
13741 iopt
= (Elf_Internal_Options
*)
13742 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13745 error (_("Out of memory allocatinf space for MIPS options\n"));
13752 while (offset
< sect
->sh_size
)
13754 Elf_External_Options
* eoption
;
13756 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13758 option
->kind
= BYTE_GET (eoption
->kind
);
13759 option
->size
= BYTE_GET (eoption
->size
);
13760 option
->section
= BYTE_GET (eoption
->section
);
13761 option
->info
= BYTE_GET (eoption
->info
);
13763 offset
+= option
->size
;
13769 printf (_("\nSection '%s' contains %d entries:\n"),
13770 printable_section_name (sect
), cnt
);
13778 switch (option
->kind
)
13781 /* This shouldn't happen. */
13782 printf (" NULL %d %lx", option
->section
, option
->info
);
13785 printf (" REGINFO ");
13786 if (elf_header
.e_machine
== EM_MIPS
)
13789 Elf32_External_RegInfo
* ereg
;
13790 Elf32_RegInfo reginfo
;
13792 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13793 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13794 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13795 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13796 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13797 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13798 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13800 printf ("GPR %08lx GP 0x%lx\n",
13801 reginfo
.ri_gprmask
,
13802 (unsigned long) reginfo
.ri_gp_value
);
13803 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13804 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13805 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13810 Elf64_External_RegInfo
* ereg
;
13811 Elf64_Internal_RegInfo reginfo
;
13813 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13814 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13815 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13816 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13817 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13818 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13819 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13821 printf ("GPR %08lx GP 0x",
13822 reginfo
.ri_gprmask
);
13823 printf_vma (reginfo
.ri_gp_value
);
13826 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13827 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13828 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13832 case ODK_EXCEPTIONS
:
13833 fputs (" EXCEPTIONS fpe_min(", stdout
);
13834 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13835 fputs (") fpe_max(", stdout
);
13836 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13837 fputs (")", stdout
);
13839 if (option
->info
& OEX_PAGE0
)
13840 fputs (" PAGE0", stdout
);
13841 if (option
->info
& OEX_SMM
)
13842 fputs (" SMM", stdout
);
13843 if (option
->info
& OEX_FPDBUG
)
13844 fputs (" FPDBUG", stdout
);
13845 if (option
->info
& OEX_DISMISS
)
13846 fputs (" DISMISS", stdout
);
13849 fputs (" PAD ", stdout
);
13850 if (option
->info
& OPAD_PREFIX
)
13851 fputs (" PREFIX", stdout
);
13852 if (option
->info
& OPAD_POSTFIX
)
13853 fputs (" POSTFIX", stdout
);
13854 if (option
->info
& OPAD_SYMBOL
)
13855 fputs (" SYMBOL", stdout
);
13858 fputs (" HWPATCH ", stdout
);
13859 if (option
->info
& OHW_R4KEOP
)
13860 fputs (" R4KEOP", stdout
);
13861 if (option
->info
& OHW_R8KPFETCH
)
13862 fputs (" R8KPFETCH", stdout
);
13863 if (option
->info
& OHW_R5KEOP
)
13864 fputs (" R5KEOP", stdout
);
13865 if (option
->info
& OHW_R5KCVTL
)
13866 fputs (" R5KCVTL", stdout
);
13869 fputs (" FILL ", stdout
);
13870 /* XXX Print content of info word? */
13873 fputs (" TAGS ", stdout
);
13874 /* XXX Print content of info word? */
13877 fputs (" HWAND ", stdout
);
13878 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13879 fputs (" R4KEOP_CHECKED", stdout
);
13880 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13881 fputs (" R4KEOP_CLEAN", stdout
);
13884 fputs (" HWOR ", stdout
);
13885 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13886 fputs (" R4KEOP_CHECKED", stdout
);
13887 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13888 fputs (" R4KEOP_CLEAN", stdout
);
13891 printf (" GP_GROUP %#06lx self-contained %#06lx",
13892 option
->info
& OGP_GROUP
,
13893 (option
->info
& OGP_SELF
) >> 16);
13896 printf (" IDENT %#06lx self-contained %#06lx",
13897 option
->info
& OGP_GROUP
,
13898 (option
->info
& OGP_SELF
) >> 16);
13901 /* This shouldn't happen. */
13902 printf (" %3d ??? %d %lx",
13903 option
->kind
, option
->section
, option
->info
);
13907 len
= sizeof (* eopt
);
13908 while (len
< option
->size
)
13909 if (((char *) option
)[len
] >= ' '
13910 && ((char *) option
)[len
] < 0x7f)
13911 printf ("%c", ((char *) option
)[len
++]);
13913 printf ("\\%03o", ((char *) option
)[len
++]);
13915 fputs ("\n", stdout
);
13923 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13925 Elf32_Conflict
* iconf
;
13928 if (dynamic_symbols
== NULL
)
13930 error (_("conflict list found without a dynamic symbol table\n"));
13934 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13937 error (_("Out of memory allocating space for dynamic conflicts\n"));
13943 Elf32_External_Conflict
* econf32
;
13945 econf32
= (Elf32_External_Conflict
*)
13946 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13947 sizeof (* econf32
), _("conflict"));
13951 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13952 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13958 Elf64_External_Conflict
* econf64
;
13960 econf64
= (Elf64_External_Conflict
*)
13961 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13962 sizeof (* econf64
), _("conflict"));
13966 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13967 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13972 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13973 (unsigned long) conflictsno
);
13974 puts (_(" Num: Index Value Name"));
13976 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13978 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13980 if (iconf
[cnt
] >= num_dynamic_syms
)
13981 printf (_("<corrupt symbol index>"));
13984 Elf_Internal_Sym
* psym
;
13986 psym
= & dynamic_symbols
[iconf
[cnt
]];
13987 print_vma (psym
->st_value
, FULL_HEX
);
13989 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13990 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13992 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14000 if (pltgot
!= 0 && local_gotno
!= 0)
14002 bfd_vma ent
, local_end
, global_end
;
14004 unsigned char * data
;
14008 addr_size
= (is_32bit_elf
? 4 : 8);
14009 local_end
= pltgot
+ local_gotno
* addr_size
;
14011 /* PR binutils/17533 file: 012-111227-0.004 */
14012 if (symtabno
< gotsym
)
14014 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14015 (long) gotsym
, (long) symtabno
);
14019 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14020 assert (global_end
>= local_end
);
14021 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14022 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14023 global_end
- pltgot
, 1,
14024 _("Global Offset Table data"));
14028 printf (_("\nPrimary GOT:\n"));
14029 printf (_(" Canonical gp value: "));
14030 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14033 printf (_(" Reserved entries:\n"));
14034 printf (_(" %*s %10s %*s Purpose\n"),
14035 addr_size
* 2, _("Address"), _("Access"),
14036 addr_size
* 2, _("Initial"));
14037 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14038 printf (_(" Lazy resolver\n"));
14040 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14041 >> (addr_size
* 8 - 1)) != 0)
14043 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14044 printf (_(" Module pointer (GNU extension)\n"));
14048 if (ent
< local_end
)
14050 printf (_(" Local entries:\n"));
14051 printf (" %*s %10s %*s\n",
14052 addr_size
* 2, _("Address"), _("Access"),
14053 addr_size
* 2, _("Initial"));
14054 while (ent
< local_end
)
14056 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14062 if (gotsym
< symtabno
)
14066 printf (_(" Global entries:\n"));
14067 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14068 addr_size
* 2, _("Address"),
14070 addr_size
* 2, _("Initial"),
14071 addr_size
* 2, _("Sym.Val."),
14073 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14074 _("Ndx"), _("Name"));
14076 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14078 for (i
= gotsym
; i
< symtabno
; i
++)
14080 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14083 if (dynamic_symbols
== NULL
)
14084 printf (_("<no dynamic symbols>"));
14085 else if (i
< num_dynamic_syms
)
14087 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14089 print_vma (psym
->st_value
, LONG_HEX
);
14090 printf (" %-7s %3s ",
14091 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14092 get_symbol_index_type (psym
->st_shndx
));
14094 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14095 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14097 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14100 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14101 (unsigned long) i
);
14112 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14115 size_t offset
, rel_offset
;
14116 unsigned long count
, i
;
14117 unsigned char * data
;
14118 int addr_size
, sym_width
;
14119 Elf_Internal_Rela
* rels
;
14121 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14122 if (pltrel
== DT_RELA
)
14124 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14129 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14134 addr_size
= (is_32bit_elf
? 4 : 8);
14135 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14137 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14138 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14139 1, _("Procedure Linkage Table data"));
14143 printf ("\nPLT GOT:\n\n");
14144 printf (_(" Reserved entries:\n"));
14145 printf (_(" %*s %*s Purpose\n"),
14146 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14147 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14148 printf (_(" PLT lazy resolver\n"));
14149 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14150 printf (_(" Module pointer\n"));
14153 printf (_(" Entries:\n"));
14154 printf (" %*s %*s %*s %-7s %3s %s\n",
14155 addr_size
* 2, _("Address"),
14156 addr_size
* 2, _("Initial"),
14157 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14158 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14159 for (i
= 0; i
< count
; i
++)
14161 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14163 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14166 if (idx
>= num_dynamic_syms
)
14167 printf (_("<corrupt symbol index: %lu>"), idx
);
14170 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14172 print_vma (psym
->st_value
, LONG_HEX
);
14173 printf (" %-7s %3s ",
14174 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14175 get_symbol_index_type (psym
->st_shndx
));
14176 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14177 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14179 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14194 process_nds32_specific (FILE * file
)
14196 Elf_Internal_Shdr
*sect
= NULL
;
14198 sect
= find_section (".nds32_e_flags");
14201 unsigned int *flag
;
14203 printf ("\nNDS32 elf flags section:\n");
14204 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14205 sect
->sh_size
, _("NDS32 elf flags section"));
14207 switch ((*flag
) & 0x3)
14210 printf ("(VEC_SIZE):\tNo entry.\n");
14213 printf ("(VEC_SIZE):\t4 bytes\n");
14216 printf ("(VEC_SIZE):\t16 bytes\n");
14219 printf ("(VEC_SIZE):\treserved\n");
14228 process_gnu_liblist (FILE * file
)
14230 Elf_Internal_Shdr
* section
;
14231 Elf_Internal_Shdr
* string_sec
;
14232 Elf32_External_Lib
* elib
;
14234 size_t strtab_size
;
14241 for (i
= 0, section
= section_headers
;
14242 i
< elf_header
.e_shnum
;
14245 switch (section
->sh_type
)
14247 case SHT_GNU_LIBLIST
:
14248 if (section
->sh_link
>= elf_header
.e_shnum
)
14251 elib
= (Elf32_External_Lib
*)
14252 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14253 _("liblist section data"));
14257 string_sec
= section_headers
+ section
->sh_link
;
14259 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14260 string_sec
->sh_size
,
14261 _("liblist string table"));
14263 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14269 strtab_size
= string_sec
->sh_size
;
14271 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14272 printable_section_name (section
),
14273 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14275 puts (_(" Library Time Stamp Checksum Version Flags"));
14277 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14285 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14286 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14287 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14288 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14289 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14291 tmp
= gmtime (&atime
);
14292 snprintf (timebuf
, sizeof (timebuf
),
14293 "%04u-%02u-%02uT%02u:%02u:%02u",
14294 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14295 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14297 printf ("%3lu: ", (unsigned long) cnt
);
14299 printf ("%-20s", liblist
.l_name
< strtab_size
14300 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14302 printf ("%-20.20s", liblist
.l_name
< strtab_size
14303 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14304 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14305 liblist
.l_version
, liblist
.l_flags
);
14316 static const char *
14317 get_note_type (unsigned e_type
)
14319 static char buff
[64];
14321 if (elf_header
.e_type
== ET_CORE
)
14325 return _("NT_AUXV (auxiliary vector)");
14327 return _("NT_PRSTATUS (prstatus structure)");
14329 return _("NT_FPREGSET (floating point registers)");
14331 return _("NT_PRPSINFO (prpsinfo structure)");
14332 case NT_TASKSTRUCT
:
14333 return _("NT_TASKSTRUCT (task structure)");
14335 return _("NT_PRXFPREG (user_xfpregs structure)");
14337 return _("NT_PPC_VMX (ppc Altivec registers)");
14339 return _("NT_PPC_VSX (ppc VSX registers)");
14341 return _("NT_386_TLS (x86 TLS information)");
14342 case NT_386_IOPERM
:
14343 return _("NT_386_IOPERM (x86 I/O permissions)");
14344 case NT_X86_XSTATE
:
14345 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14346 case NT_S390_HIGH_GPRS
:
14347 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14348 case NT_S390_TIMER
:
14349 return _("NT_S390_TIMER (s390 timer register)");
14350 case NT_S390_TODCMP
:
14351 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14352 case NT_S390_TODPREG
:
14353 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14355 return _("NT_S390_CTRS (s390 control registers)");
14356 case NT_S390_PREFIX
:
14357 return _("NT_S390_PREFIX (s390 prefix register)");
14358 case NT_S390_LAST_BREAK
:
14359 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14360 case NT_S390_SYSTEM_CALL
:
14361 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14363 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14365 return _("NT_ARM_VFP (arm VFP registers)");
14367 return _("NT_ARM_TLS (AArch TLS registers)");
14368 case NT_ARM_HW_BREAK
:
14369 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14370 case NT_ARM_HW_WATCH
:
14371 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14373 return _("NT_PSTATUS (pstatus structure)");
14375 return _("NT_FPREGS (floating point registers)");
14377 return _("NT_PSINFO (psinfo structure)");
14379 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14381 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14382 case NT_WIN32PSTATUS
:
14383 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14385 return _("NT_SIGINFO (siginfo_t data)");
14387 return _("NT_FILE (mapped files)");
14395 return _("NT_VERSION (version)");
14397 return _("NT_ARCH (architecture)");
14402 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14407 print_core_note (Elf_Internal_Note
*pnote
)
14409 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14410 bfd_vma count
, page_size
;
14411 unsigned char *descdata
, *filenames
, *descend
;
14413 if (pnote
->type
!= NT_FILE
)
14419 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14420 /* Still "successful". */
14425 if (pnote
->descsz
< 2 * addr_size
)
14427 printf (_(" Malformed note - too short for header\n"));
14431 descdata
= (unsigned char *) pnote
->descdata
;
14432 descend
= descdata
+ pnote
->descsz
;
14434 if (descdata
[pnote
->descsz
- 1] != '\0')
14436 printf (_(" Malformed note - does not end with \\0\n"));
14440 count
= byte_get (descdata
, addr_size
);
14441 descdata
+= addr_size
;
14443 page_size
= byte_get (descdata
, addr_size
);
14444 descdata
+= addr_size
;
14446 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14448 printf (_(" Malformed note - too short for supplied file count\n"));
14452 printf (_(" Page size: "));
14453 print_vma (page_size
, DEC
);
14456 printf (_(" %*s%*s%*s\n"),
14457 (int) (2 + 2 * addr_size
), _("Start"),
14458 (int) (4 + 2 * addr_size
), _("End"),
14459 (int) (4 + 2 * addr_size
), _("Page Offset"));
14460 filenames
= descdata
+ count
* 3 * addr_size
;
14461 while (--count
> 0)
14463 bfd_vma start
, end
, file_ofs
;
14465 if (filenames
== descend
)
14467 printf (_(" Malformed note - filenames end too early\n"));
14471 start
= byte_get (descdata
, addr_size
);
14472 descdata
+= addr_size
;
14473 end
= byte_get (descdata
, addr_size
);
14474 descdata
+= addr_size
;
14475 file_ofs
= byte_get (descdata
, addr_size
);
14476 descdata
+= addr_size
;
14479 print_vma (start
, FULL_HEX
);
14481 print_vma (end
, FULL_HEX
);
14483 print_vma (file_ofs
, FULL_HEX
);
14484 printf ("\n %s\n", filenames
);
14486 filenames
+= 1 + strlen ((char *) filenames
);
14492 static const char *
14493 get_gnu_elf_note_type (unsigned e_type
)
14495 static char buff
[64];
14499 case NT_GNU_ABI_TAG
:
14500 return _("NT_GNU_ABI_TAG (ABI version tag)");
14502 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14503 case NT_GNU_BUILD_ID
:
14504 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14505 case NT_GNU_GOLD_VERSION
:
14506 return _("NT_GNU_GOLD_VERSION (gold version)");
14511 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14516 print_gnu_note (Elf_Internal_Note
*pnote
)
14518 switch (pnote
->type
)
14520 case NT_GNU_BUILD_ID
:
14524 printf (_(" Build ID: "));
14525 for (i
= 0; i
< pnote
->descsz
; ++i
)
14526 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14531 case NT_GNU_ABI_TAG
:
14533 unsigned long os
, major
, minor
, subminor
;
14534 const char *osname
;
14536 /* PR 17531: file: 030-599401-0.004. */
14537 if (pnote
->descsz
< 16)
14539 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14543 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14544 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14545 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14546 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14550 case GNU_ABI_TAG_LINUX
:
14553 case GNU_ABI_TAG_HURD
:
14556 case GNU_ABI_TAG_SOLARIS
:
14557 osname
= "Solaris";
14559 case GNU_ABI_TAG_FREEBSD
:
14560 osname
= "FreeBSD";
14562 case GNU_ABI_TAG_NETBSD
:
14566 osname
= "Unknown";
14570 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14571 major
, minor
, subminor
);
14575 case NT_GNU_GOLD_VERSION
:
14579 printf (_(" Version: "));
14580 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14581 printf ("%c", pnote
->descdata
[i
]);
14590 static const char *
14591 get_netbsd_elfcore_note_type (unsigned e_type
)
14593 static char buff
[64];
14595 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14597 /* NetBSD core "procinfo" structure. */
14598 return _("NetBSD procinfo structure");
14601 /* As of Jan 2002 there are no other machine-independent notes
14602 defined for NetBSD core files. If the note type is less
14603 than the start of the machine-dependent note types, we don't
14606 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14608 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14612 switch (elf_header
.e_machine
)
14614 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14615 and PT_GETFPREGS == mach+2. */
14620 case EM_SPARC32PLUS
:
14624 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14625 return _("PT_GETREGS (reg structure)");
14626 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14627 return _("PT_GETFPREGS (fpreg structure)");
14633 /* On all other arch's, PT_GETREGS == mach+1 and
14634 PT_GETFPREGS == mach+3. */
14638 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14639 return _("PT_GETREGS (reg structure)");
14640 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14641 return _("PT_GETFPREGS (fpreg structure)");
14647 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14648 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14652 static const char *
14653 get_stapsdt_note_type (unsigned e_type
)
14655 static char buff
[64];
14660 return _("NT_STAPSDT (SystemTap probe descriptors)");
14666 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14671 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14673 int addr_size
= is_32bit_elf
? 4 : 8;
14674 char *data
= pnote
->descdata
;
14675 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14676 bfd_vma pc
, base_addr
, semaphore
;
14677 char *provider
, *probe
, *arg_fmt
;
14679 pc
= byte_get ((unsigned char *) data
, addr_size
);
14681 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14683 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14687 data
+= strlen (data
) + 1;
14689 data
+= strlen (data
) + 1;
14691 data
+= strlen (data
) + 1;
14693 printf (_(" Provider: %s\n"), provider
);
14694 printf (_(" Name: %s\n"), probe
);
14695 printf (_(" Location: "));
14696 print_vma (pc
, FULL_HEX
);
14697 printf (_(", Base: "));
14698 print_vma (base_addr
, FULL_HEX
);
14699 printf (_(", Semaphore: "));
14700 print_vma (semaphore
, FULL_HEX
);
14702 printf (_(" Arguments: %s\n"), arg_fmt
);
14704 return data
== data_end
;
14707 static const char *
14708 get_ia64_vms_note_type (unsigned e_type
)
14710 static char buff
[64];
14715 return _("NT_VMS_MHD (module header)");
14717 return _("NT_VMS_LNM (language name)");
14719 return _("NT_VMS_SRC (source files)");
14721 return "NT_VMS_TITLE";
14723 return _("NT_VMS_EIDC (consistency check)");
14724 case NT_VMS_FPMODE
:
14725 return _("NT_VMS_FPMODE (FP mode)");
14726 case NT_VMS_LINKTIME
:
14727 return "NT_VMS_LINKTIME";
14728 case NT_VMS_IMGNAM
:
14729 return _("NT_VMS_IMGNAM (image name)");
14731 return _("NT_VMS_IMGID (image id)");
14732 case NT_VMS_LINKID
:
14733 return _("NT_VMS_LINKID (link id)");
14734 case NT_VMS_IMGBID
:
14735 return _("NT_VMS_IMGBID (build id)");
14736 case NT_VMS_GSTNAM
:
14737 return _("NT_VMS_GSTNAM (sym table name)");
14738 case NT_VMS_ORIG_DYN
:
14739 return "NT_VMS_ORIG_DYN";
14740 case NT_VMS_PATCHTIME
:
14741 return "NT_VMS_PATCHTIME";
14743 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14749 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14751 switch (pnote
->type
)
14754 if (pnote
->descsz
> 36)
14756 size_t l
= strlen (pnote
->descdata
+ 34);
14757 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14758 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14759 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14760 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14763 printf (_(" Invalid size\n"));
14766 printf (_(" Language: %s\n"), pnote
->descdata
);
14769 case NT_VMS_FPMODE
:
14770 printf (_(" Floating Point mode: "));
14771 printf ("0x%016" BFD_VMA_FMT
"x\n",
14772 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14774 case NT_VMS_LINKTIME
:
14775 printf (_(" Link time: "));
14777 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14780 case NT_VMS_PATCHTIME
:
14781 printf (_(" Patch time: "));
14783 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14786 case NT_VMS_ORIG_DYN
:
14787 printf (_(" Major id: %u, minor id: %u\n"),
14788 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14789 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14790 printf (_(" Last modified : "));
14792 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14793 printf (_("\n Link flags : "));
14794 printf ("0x%016" BFD_VMA_FMT
"x\n",
14795 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14796 printf (_(" Header flags: 0x%08x\n"),
14797 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14798 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14801 case NT_VMS_IMGNAM
:
14802 printf (_(" Image name: %s\n"), pnote
->descdata
);
14804 case NT_VMS_GSTNAM
:
14805 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14808 printf (_(" Image id: %s\n"), pnote
->descdata
);
14810 case NT_VMS_LINKID
:
14811 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14819 /* Note that by the ELF standard, the name field is already null byte
14820 terminated, and namesz includes the terminating null byte.
14821 I.E. the value of namesz for the name "FSF" is 4.
14823 If the value of namesz is zero, there is no name present. */
14825 process_note (Elf_Internal_Note
* pnote
)
14827 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14830 if (pnote
->namesz
== 0)
14831 /* If there is no note name, then use the default set of
14832 note type strings. */
14833 nt
= get_note_type (pnote
->type
);
14835 else if (const_strneq (pnote
->namedata
, "GNU"))
14836 /* GNU-specific object file notes. */
14837 nt
= get_gnu_elf_note_type (pnote
->type
);
14839 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14840 /* NetBSD-specific core file notes. */
14841 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14843 else if (strneq (pnote
->namedata
, "SPU/", 4))
14845 /* SPU-specific core file notes. */
14846 nt
= pnote
->namedata
+ 4;
14850 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14851 /* VMS/ia64-specific file notes. */
14852 nt
= get_ia64_vms_note_type (pnote
->type
);
14854 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14855 nt
= get_stapsdt_note_type (pnote
->type
);
14858 /* Don't recognize this note name; just use the default set of
14859 note type strings. */
14860 nt
= get_note_type (pnote
->type
);
14862 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14864 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14865 return print_ia64_vms_note (pnote
);
14866 else if (const_strneq (pnote
->namedata
, "GNU"))
14867 return print_gnu_note (pnote
);
14868 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14869 return print_stapsdt_note (pnote
);
14870 else if (const_strneq (pnote
->namedata
, "CORE"))
14871 return print_core_note (pnote
);
14878 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14880 Elf_External_Note
* pnotes
;
14881 Elf_External_Note
* external
;
14887 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14889 if (pnotes
== NULL
)
14894 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14895 (unsigned long) offset
, (unsigned long) length
);
14896 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14898 while ((char *) external
< (char *) pnotes
+ length
)
14900 Elf_Internal_Note inote
;
14903 char * temp
= NULL
;
14904 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14906 if (!is_ia64_vms ())
14908 /* PR binutils/15191
14909 Make sure that there is enough data to read. */
14910 min_notesz
= offsetof (Elf_External_Note
, name
);
14911 if (data_remaining
< min_notesz
)
14913 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14914 (int) data_remaining
);
14917 inote
.type
= BYTE_GET (external
->type
);
14918 inote
.namesz
= BYTE_GET (external
->namesz
);
14919 inote
.namedata
= external
->name
;
14920 inote
.descsz
= BYTE_GET (external
->descsz
);
14921 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14922 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14923 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14927 Elf64_External_VMS_Note
*vms_external
;
14929 /* PR binutils/15191
14930 Make sure that there is enough data to read. */
14931 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14932 if (data_remaining
< min_notesz
)
14934 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14935 (int) data_remaining
);
14939 vms_external
= (Elf64_External_VMS_Note
*) external
;
14940 inote
.type
= BYTE_GET (vms_external
->type
);
14941 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14942 inote
.namedata
= vms_external
->name
;
14943 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14944 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14945 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14946 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14949 if (inote
.descdata
< (char *) external
+ min_notesz
14950 || next
< (char *) external
+ min_notesz
14951 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14952 || inote
.namedata
+ inote
.namesz
< inote
.namedata
14953 || inote
.descdata
+ inote
.descsz
< inote
.descdata
14954 || data_remaining
< (size_t)(next
- (char *) external
))
14956 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14957 (unsigned long) ((char *) external
- (char *) pnotes
));
14958 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14959 inote
.type
, inote
.namesz
, inote
.descsz
);
14963 external
= (Elf_External_Note
*) next
;
14965 /* Verify that name is null terminated. It appears that at least
14966 one version of Linux (RedHat 6.0) generates corefiles that don't
14967 comply with the ELF spec by failing to include the null byte in
14969 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14971 temp
= (char *) malloc (inote
.namesz
+ 1);
14974 error (_("Out of memory allocating space for inote name\n"));
14979 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14980 temp
[inote
.namesz
] = 0;
14982 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14983 inote
.namedata
= temp
;
14986 res
&= process_note (& inote
);
15001 process_corefile_note_segments (FILE * file
)
15003 Elf_Internal_Phdr
* segment
;
15007 if (! get_program_headers (file
))
15010 for (i
= 0, segment
= program_headers
;
15011 i
< elf_header
.e_phnum
;
15014 if (segment
->p_type
== PT_NOTE
)
15015 res
&= process_corefile_note_segment (file
,
15016 (bfd_vma
) segment
->p_offset
,
15017 (bfd_vma
) segment
->p_filesz
);
15024 process_note_sections (FILE * file
)
15026 Elf_Internal_Shdr
* section
;
15031 for (i
= 0, section
= section_headers
;
15032 i
< elf_header
.e_shnum
&& section
!= NULL
;
15034 if (section
->sh_type
== SHT_NOTE
)
15036 res
&= process_corefile_note_segment (file
,
15037 (bfd_vma
) section
->sh_offset
,
15038 (bfd_vma
) section
->sh_size
);
15043 /* Try processing NOTE segments instead. */
15044 return process_corefile_note_segments (file
);
15050 process_notes (FILE * file
)
15052 /* If we have not been asked to display the notes then do nothing. */
15056 if (elf_header
.e_type
!= ET_CORE
)
15057 return process_note_sections (file
);
15059 /* No program headers means no NOTE segment. */
15060 if (elf_header
.e_phnum
> 0)
15061 return process_corefile_note_segments (file
);
15063 printf (_("No note segments present in the core file.\n"));
15068 process_arch_specific (FILE * file
)
15073 switch (elf_header
.e_machine
)
15076 return process_arm_specific (file
);
15078 case EM_MIPS_RS3_LE
:
15079 return process_mips_specific (file
);
15082 return process_nds32_specific (file
);
15085 return process_power_specific (file
);
15088 case EM_SPARC32PLUS
:
15090 return process_sparc_specific (file
);
15093 return process_tic6x_specific (file
);
15096 return process_msp430x_specific (file
);
15104 get_file_header (FILE * file
)
15106 /* Read in the identity array. */
15107 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15110 /* Determine how to read the rest of the header. */
15111 switch (elf_header
.e_ident
[EI_DATA
])
15113 default: /* fall through */
15114 case ELFDATANONE
: /* fall through */
15116 byte_get
= byte_get_little_endian
;
15117 byte_put
= byte_put_little_endian
;
15120 byte_get
= byte_get_big_endian
;
15121 byte_put
= byte_put_big_endian
;
15125 /* For now we only support 32 bit and 64 bit ELF files. */
15126 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15128 /* Read in the rest of the header. */
15131 Elf32_External_Ehdr ehdr32
;
15133 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15136 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15137 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15138 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15139 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15140 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15141 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15142 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15143 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15144 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15145 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15146 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15147 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15148 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15152 Elf64_External_Ehdr ehdr64
;
15154 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15155 we will not be able to cope with the 64bit data found in
15156 64 ELF files. Detect this now and abort before we start
15157 overwriting things. */
15158 if (sizeof (bfd_vma
) < 8)
15160 error (_("This instance of readelf has been built without support for a\n\
15161 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15165 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15168 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15169 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15170 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15171 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15172 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15173 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15174 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15175 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15176 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15177 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15178 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15179 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15180 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15183 if (elf_header
.e_shoff
)
15185 /* There may be some extensions in the first section header. Don't
15186 bomb if we can't read it. */
15188 get_32bit_section_headers (file
, TRUE
);
15190 get_64bit_section_headers (file
, TRUE
);
15196 /* Process one ELF object file according to the command line options.
15197 This file may actually be stored in an archive. The file is
15198 positioned at the start of the ELF object. */
15201 process_object (char * file_name
, FILE * file
)
15205 if (! get_file_header (file
))
15207 error (_("%s: Failed to read file header\n"), file_name
);
15211 /* Initialise per file variables. */
15212 for (i
= ARRAY_SIZE (version_info
); i
--;)
15213 version_info
[i
] = 0;
15215 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15216 dynamic_info
[i
] = 0;
15217 dynamic_info_DT_GNU_HASH
= 0;
15219 /* Process the file. */
15221 printf (_("\nFile: %s\n"), file_name
);
15223 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15224 Note we do this even if cmdline_dump_sects is empty because we
15225 must make sure that the dump_sets array is zeroed out before each
15226 object file is processed. */
15227 if (num_dump_sects
> num_cmdline_dump_sects
)
15228 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15230 if (num_cmdline_dump_sects
> 0)
15232 if (num_dump_sects
== 0)
15233 /* A sneaky way of allocating the dump_sects array. */
15234 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15236 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15237 memcpy (dump_sects
, cmdline_dump_sects
,
15238 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15241 if (! process_file_header ())
15244 if (! process_section_headers (file
))
15246 /* Without loaded section headers we cannot process lots of
15248 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15250 if (! do_using_dynamic
)
15251 do_syms
= do_dyn_syms
= do_reloc
= 0;
15254 if (! process_section_groups (file
))
15256 /* Without loaded section groups we cannot process unwind. */
15260 if (process_program_headers (file
))
15261 process_dynamic_section (file
);
15263 process_relocs (file
);
15265 process_unwind (file
);
15267 process_symbol_table (file
);
15269 process_syminfo (file
);
15271 process_version_sections (file
);
15273 process_section_contents (file
);
15275 process_notes (file
);
15277 process_gnu_liblist (file
);
15279 process_arch_specific (file
);
15281 if (program_headers
)
15283 free (program_headers
);
15284 program_headers
= NULL
;
15287 if (section_headers
)
15289 free (section_headers
);
15290 section_headers
= NULL
;
15295 free (string_table
);
15296 string_table
= NULL
;
15297 string_table_length
= 0;
15300 if (dynamic_strings
)
15302 free (dynamic_strings
);
15303 dynamic_strings
= NULL
;
15304 dynamic_strings_length
= 0;
15307 if (dynamic_symbols
)
15309 free (dynamic_symbols
);
15310 dynamic_symbols
= NULL
;
15311 num_dynamic_syms
= 0;
15314 if (dynamic_syminfo
)
15316 free (dynamic_syminfo
);
15317 dynamic_syminfo
= NULL
;
15320 if (dynamic_section
)
15322 free (dynamic_section
);
15323 dynamic_section
= NULL
;
15326 if (section_headers_groups
)
15328 free (section_headers_groups
);
15329 section_headers_groups
= NULL
;
15332 if (section_groups
)
15334 struct group_list
* g
;
15335 struct group_list
* next
;
15337 for (i
= 0; i
< group_count
; i
++)
15339 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15346 free (section_groups
);
15347 section_groups
= NULL
;
15350 free_debug_memory ();
15355 /* Process an ELF archive.
15356 On entry the file is positioned just after the ARMAG string. */
15359 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15361 struct archive_info arch
;
15362 struct archive_info nested_arch
;
15368 /* The ARCH structure is used to hold information about this archive. */
15369 arch
.file_name
= NULL
;
15371 arch
.index_array
= NULL
;
15372 arch
.sym_table
= NULL
;
15373 arch
.longnames
= NULL
;
15375 /* The NESTED_ARCH structure is used as a single-item cache of information
15376 about a nested archive (when members of a thin archive reside within
15377 another regular archive file). */
15378 nested_arch
.file_name
= NULL
;
15379 nested_arch
.file
= NULL
;
15380 nested_arch
.index_array
= NULL
;
15381 nested_arch
.sym_table
= NULL
;
15382 nested_arch
.longnames
= NULL
;
15384 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15390 if (do_archive_index
)
15392 if (arch
.sym_table
== NULL
)
15393 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15396 unsigned long i
, l
;
15397 unsigned long current_pos
;
15399 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15400 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15401 current_pos
= ftell (file
);
15403 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15405 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15407 char * member_name
;
15409 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15411 if (member_name
!= NULL
)
15413 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15415 if (qualified_name
!= NULL
)
15417 printf (_("Contents of binary %s at offset "), qualified_name
);
15418 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15420 free (qualified_name
);
15425 if (l
>= arch
.sym_size
)
15427 error (_("%s: end of the symbol table reached before the end of the index\n"),
15431 /* PR 17531: file: 0b6630b2. */
15432 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15433 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15436 if (arch
.uses_64bit_indicies
)
15441 if (l
< arch
.sym_size
)
15442 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15443 file_name
, arch
.sym_size
- l
);
15445 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15447 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15453 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15454 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15455 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15456 && !do_section_groups
&& !do_dyn_syms
)
15458 ret
= 0; /* Archive index only. */
15469 char * qualified_name
;
15471 /* Read the next archive header. */
15472 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15474 error (_("%s: failed to seek to next archive header\n"), file_name
);
15477 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15478 if (got
!= sizeof arch
.arhdr
)
15482 error (_("%s: failed to read archive header\n"), file_name
);
15486 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15488 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15493 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15495 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15496 if (archive_file_size
& 01)
15497 ++archive_file_size
;
15499 name
= get_archive_member_name (&arch
, &nested_arch
);
15502 error (_("%s: bad archive file name\n"), file_name
);
15506 namelen
= strlen (name
);
15508 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15509 if (qualified_name
== NULL
)
15511 error (_("%s: bad archive file name\n"), file_name
);
15516 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15518 /* This is a proxy for an external member of a thin archive. */
15519 FILE * member_file
;
15520 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15521 if (member_file_name
== NULL
)
15527 member_file
= fopen (member_file_name
, "rb");
15528 if (member_file
== NULL
)
15530 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15531 free (member_file_name
);
15536 archive_file_offset
= arch
.nested_member_origin
;
15538 ret
|= process_object (qualified_name
, member_file
);
15540 fclose (member_file
);
15541 free (member_file_name
);
15543 else if (is_thin_archive
)
15545 /* PR 15140: Allow for corrupt thin archives. */
15546 if (nested_arch
.file
== NULL
)
15548 error (_("%s: contains corrupt thin archive: %s\n"),
15554 /* This is a proxy for a member of a nested archive. */
15555 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15557 /* The nested archive file will have been opened and setup by
15558 get_archive_member_name. */
15559 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15561 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15566 ret
|= process_object (qualified_name
, nested_arch
.file
);
15570 archive_file_offset
= arch
.next_arhdr_offset
;
15571 arch
.next_arhdr_offset
+= archive_file_size
;
15573 ret
|= process_object (qualified_name
, file
);
15576 if (dump_sects
!= NULL
)
15580 num_dump_sects
= 0;
15583 free (qualified_name
);
15587 if (nested_arch
.file
!= NULL
)
15588 fclose (nested_arch
.file
);
15589 release_archive (&nested_arch
);
15590 release_archive (&arch
);
15596 process_file (char * file_name
)
15599 struct stat statbuf
;
15600 char armag
[SARMAG
];
15603 if (stat (file_name
, &statbuf
) < 0)
15605 if (errno
== ENOENT
)
15606 error (_("'%s': No such file\n"), file_name
);
15608 error (_("Could not locate '%s'. System error message: %s\n"),
15609 file_name
, strerror (errno
));
15613 if (! S_ISREG (statbuf
.st_mode
))
15615 error (_("'%s' is not an ordinary file\n"), file_name
);
15619 file
= fopen (file_name
, "rb");
15622 error (_("Input file '%s' is not readable.\n"), file_name
);
15626 if (fread (armag
, SARMAG
, 1, file
) != 1)
15628 error (_("%s: Failed to read file's magic number\n"), file_name
);
15633 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15635 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15636 ret
= process_archive (file_name
, file
, FALSE
);
15637 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15638 ret
= process_archive (file_name
, file
, TRUE
);
15641 if (do_archive_index
)
15642 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15646 archive_file_size
= archive_file_offset
= 0;
15647 ret
= process_object (file_name
, file
);
15652 current_file_size
= 0;
15656 #ifdef SUPPORT_DISASSEMBLY
15657 /* Needed by the i386 disassembler. For extra credit, someone could
15658 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15662 print_address (unsigned int addr
, FILE * outfile
)
15664 fprintf (outfile
,"0x%8.8x", addr
);
15667 /* Needed by the i386 disassembler. */
15669 db_task_printsym (unsigned int addr
)
15671 print_address (addr
, stderr
);
15676 main (int argc
, char ** argv
)
15680 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15681 setlocale (LC_MESSAGES
, "");
15683 #if defined (HAVE_SETLOCALE)
15684 setlocale (LC_CTYPE
, "");
15686 bindtextdomain (PACKAGE
, LOCALEDIR
);
15687 textdomain (PACKAGE
);
15689 expandargv (&argc
, &argv
);
15691 parse_args (argc
, argv
);
15693 if (num_dump_sects
> 0)
15695 /* Make a copy of the dump_sects array. */
15696 cmdline_dump_sects
= (dump_type
*)
15697 malloc (num_dump_sects
* sizeof (* dump_sects
));
15698 if (cmdline_dump_sects
== NULL
)
15699 error (_("Out of memory allocating dump request table.\n"));
15702 memcpy (cmdline_dump_sects
, dump_sects
,
15703 num_dump_sects
* sizeof (* dump_sects
));
15704 num_cmdline_dump_sects
= num_dump_sects
;
15708 if (optind
< (argc
- 1))
15712 while (optind
< argc
)
15713 err
|= process_file (argv
[optind
++]);
15715 if (dump_sects
!= NULL
)
15717 if (cmdline_dump_sects
!= NULL
)
15718 free (cmdline_dump_sects
);