1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 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. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 typedef struct elf_section_list
169 Elf_Internal_Shdr
* hdr
;
170 struct elf_section_list
* next
;
173 char * program_name
= "readelf";
174 static unsigned long archive_file_offset
;
175 static unsigned long archive_file_size
;
176 static bfd_size_type current_file_size
;
177 static unsigned long dynamic_addr
;
178 static bfd_size_type dynamic_size
;
179 static size_t dynamic_nent
;
180 static char * dynamic_strings
;
181 static unsigned long dynamic_strings_length
;
182 static char * string_table
;
183 static unsigned long string_table_length
;
184 static unsigned long num_dynamic_syms
;
185 static Elf_Internal_Sym
* dynamic_symbols
;
186 static Elf_Internal_Syminfo
* dynamic_syminfo
;
187 static unsigned long dynamic_syminfo_offset
;
188 static unsigned int dynamic_syminfo_nent
;
189 static char program_interpreter
[PATH_MAX
];
190 static bfd_vma dynamic_info
[DT_ENCODING
];
191 static bfd_vma dynamic_info_DT_GNU_HASH
;
192 static bfd_vma version_info
[16];
193 static Elf_Internal_Ehdr elf_header
;
194 static Elf_Internal_Shdr
* section_headers
;
195 static Elf_Internal_Phdr
* program_headers
;
196 static Elf_Internal_Dyn
* dynamic_section
;
197 static elf_section_list
* symtab_shndx_list
;
198 static int show_name
;
199 static int do_dynamic
;
201 static int do_dyn_syms
;
203 static int do_sections
;
204 static int do_section_groups
;
205 static int do_section_details
;
206 static int do_segments
;
207 static int do_unwind
;
208 static int do_using_dynamic
;
209 static int do_header
;
211 static int do_version
;
212 static int do_histogram
;
213 static int do_debugging
;
216 static int do_archive_index
;
217 static int is_32bit_elf
;
218 static int decompress_dumps
;
222 struct group_list
* next
;
223 unsigned int section_index
;
228 struct group_list
* root
;
229 unsigned int group_index
;
232 static size_t group_count
;
233 static struct group
* section_groups
;
234 static struct group
** section_headers_groups
;
237 /* Flag bits indicating particular types of dump. */
238 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
239 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
242 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
244 typedef unsigned char dump_type
;
246 /* A linked list of the section names for which dumps were requested. */
247 struct dump_list_entry
251 struct dump_list_entry
* next
;
253 static struct dump_list_entry
* dump_sects_byname
;
255 /* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257 static dump_type
* cmdline_dump_sects
= NULL
;
258 static unsigned int num_cmdline_dump_sects
= 0;
260 /* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
265 static dump_type
* dump_sects
= NULL
;
266 static unsigned int num_dump_sects
= 0;
269 /* How to print a vma value. */
270 typedef enum print_mode
282 /* Versioned symbol info. */
283 enum versioned_symbol_info
290 static const char *get_symbol_version_string
291 (FILE *file
, int is_dynsym
, const char *strtab
,
292 unsigned long int strtab_size
, unsigned int si
,
293 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
294 unsigned short *vna_other
);
298 #define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
304 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306 #define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
310 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
315 #define REMOVE_ARCH_BITS(ADDR) \
318 if (elf_header.e_machine == EM_ARM) \
323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
328 and REASON is not NULL then emit an error message using REASON as part of the
332 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
333 bfd_size_type nmemb
, const char * reason
)
336 bfd_size_type amt
= size
* nmemb
;
338 if (size
== 0 || nmemb
== 0)
341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type
)
345 && ( (bfd_size_type
) ((size_t) size
) != size
346 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
349 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
350 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
351 nmemb
, size
, reason
);
355 /* Check for size overflow. */
359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
360 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
361 nmemb
, size
, reason
);
365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt
> current_file_size
368 || offset
+ archive_file_offset
+ amt
> current_file_size
)
371 error (_("Reading 0x%" BFD_VMA_FMT
"x"
372 " bytes extends past end of file for %s\n"),
377 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
380 error (_("Unable to seek to 0x%lx for %s\n"),
381 archive_file_offset
+ offset
, reason
);
388 /* Check for overflow. */
389 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
390 /* + 1 so that we can '\0' terminate invalid string table sections. */
391 mvar
= malloc ((size_t) amt
+ 1);
396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
402 ((char *) mvar
)[amt
] = '\0';
405 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
408 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
418 /* Print a VMA value. */
421 print_vma (bfd_vma vma
, print_mode mode
)
434 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
441 return printf ("%5" BFD_VMA_FMT
"d", vma
);
449 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
452 return printf ("%" BFD_VMA_FMT
"d", vma
);
455 return printf ("%" BFD_VMA_FMT
"u", vma
);
460 /* Display a symbol on stdout. Handles the display of control characters and
461 multibye characters (assuming the host environment supports them).
463 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
465 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
466 padding as necessary.
468 Returns the number of emitted characters. */
471 print_symbol (int width
, const char *symbol
)
473 bfd_boolean extra_padding
= FALSE
;
475 #ifdef HAVE_MBSTATE_T
482 /* Keep the width positive. This also helps. */
484 extra_padding
= TRUE
;
489 /* Set the remaining width to a very large value.
490 This simplifies the code below. */
491 width_remaining
= INT_MAX
;
493 width_remaining
= width
;
495 #ifdef HAVE_MBSTATE_T
496 /* Initialise the multibyte conversion state. */
497 memset (& state
, 0, sizeof (state
));
500 while (width_remaining
)
503 const char c
= *symbol
++;
508 /* Do not print control characters directly as they can affect terminal
509 settings. Such characters usually appear in the names generated
510 by the assembler for local labels. */
513 if (width_remaining
< 2)
516 printf ("^%c", c
+ 0x40);
517 width_remaining
-= 2;
520 else if (ISPRINT (c
))
528 #ifdef HAVE_MBSTATE_T
531 /* Let printf do the hard work of displaying multibyte characters. */
532 printf ("%.1s", symbol
- 1);
536 #ifdef HAVE_MBSTATE_T
537 /* Try to find out how many bytes made up the character that was
538 just printed. Advance the symbol pointer past the bytes that
540 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
544 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
549 if (extra_padding
&& num_printed
< width
)
551 /* Fill in the remaining spaces. */
552 printf ("%-*s", width
- num_printed
, " ");
559 /* Returns a pointer to a static buffer containing a printable version of
560 the given section's name. Like print_symbol, except that it does not try
561 to print multibyte characters, it just interprets them as hex values. */
564 printable_section_name (const Elf_Internal_Shdr
* sec
)
566 #define MAX_PRINT_SEC_NAME_LEN 128
567 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
568 const char * name
= SECTION_NAME (sec
);
569 char * buf
= sec_name_buf
;
571 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
573 while ((c
= * name
++) != 0)
584 else if (ISPRINT (c
))
591 static char hex
[17] = "0123456789ABCDEF";
596 * buf
++ = hex
[(c
& 0xf0) >> 4];
597 * buf
++ = hex
[c
& 0x0f];
611 printable_section_name_from_index (unsigned long ndx
)
613 if (ndx
>= elf_header
.e_shnum
)
614 return _("<corrupt>");
616 return printable_section_name (section_headers
+ ndx
);
619 /* Return a pointer to section NAME, or NULL if no such section exists. */
621 static Elf_Internal_Shdr
*
622 find_section (const char * name
)
626 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
627 if (streq (SECTION_NAME (section_headers
+ i
), name
))
628 return section_headers
+ i
;
633 /* Return a pointer to a section containing ADDR, or NULL if no such
636 static Elf_Internal_Shdr
*
637 find_section_by_address (bfd_vma addr
)
641 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
643 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
644 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
651 static Elf_Internal_Shdr
*
652 find_section_by_type (unsigned int type
)
656 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
658 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
659 if (sec
->sh_type
== type
)
666 /* Return a pointer to section NAME, or NULL if no such section exists,
667 restricted to the list of sections given in SET. */
669 static Elf_Internal_Shdr
*
670 find_section_in_set (const char * name
, unsigned int * set
)
676 while ((i
= *set
++) > 0)
677 if (streq (SECTION_NAME (section_headers
+ i
), name
))
678 return section_headers
+ i
;
681 return find_section (name
);
684 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
687 static inline unsigned long
688 read_uleb128 (unsigned char *data
,
689 unsigned int *length_return
,
690 const unsigned char * const end
)
692 return read_leb128 (data
, length_return
, FALSE
, end
);
695 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
696 This OS has so many departures from the ELF standard that we test it at
702 return elf_header
.e_machine
== EM_IA_64
703 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
706 /* Guess the relocation size commonly used by the specific machines. */
709 guess_is_rela (unsigned int e_machine
)
713 /* Targets that use REL relocations. */
728 /* Targets that use RELA relocations. */
732 case EM_ADAPTEVA_EPIPHANY
:
734 case EM_ALTERA_NIOS2
:
737 case EM_ARC_COMPACT2
:
757 case EM_LATTICEMICO32
:
766 case EM_CYGNUS_MN10200
:
768 case EM_CYGNUS_MN10300
:
802 case EM_MICROBLAZE_OLD
:
823 warn (_("Don't know about relocations on this machine architecture\n"));
829 slurp_rela_relocs (FILE * file
,
830 unsigned long rel_offset
,
831 unsigned long rel_size
,
832 Elf_Internal_Rela
** relasp
,
833 unsigned long * nrelasp
)
835 Elf_Internal_Rela
* relas
;
841 Elf32_External_Rela
* erelas
;
843 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
844 rel_size
, _("32-bit relocation data"));
848 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
850 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
851 sizeof (Elf_Internal_Rela
));
856 error (_("out of memory parsing relocs\n"));
860 for (i
= 0; i
< nrelas
; i
++)
862 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
863 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
864 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
871 Elf64_External_Rela
* erelas
;
873 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
874 rel_size
, _("64-bit relocation data"));
878 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
880 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
881 sizeof (Elf_Internal_Rela
));
886 error (_("out of memory parsing relocs\n"));
890 for (i
= 0; i
< nrelas
; i
++)
892 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
893 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
894 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
896 /* The #ifdef BFD64 below is to prevent a compile time
897 warning. We know that if we do not have a 64 bit data
898 type that we will never execute this code anyway. */
900 if (elf_header
.e_machine
== EM_MIPS
901 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
903 /* In little-endian objects, r_info isn't really a
904 64-bit little-endian value: it has a 32-bit
905 little-endian symbol index followed by four
906 individual byte fields. Reorder INFO
908 bfd_vma inf
= relas
[i
].r_info
;
909 inf
= (((inf
& 0xffffffff) << 32)
910 | ((inf
>> 56) & 0xff)
911 | ((inf
>> 40) & 0xff00)
912 | ((inf
>> 24) & 0xff0000)
913 | ((inf
>> 8) & 0xff000000));
914 relas
[i
].r_info
= inf
;
927 slurp_rel_relocs (FILE * file
,
928 unsigned long rel_offset
,
929 unsigned long rel_size
,
930 Elf_Internal_Rela
** relsp
,
931 unsigned long * nrelsp
)
933 Elf_Internal_Rela
* rels
;
939 Elf32_External_Rel
* erels
;
941 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
942 rel_size
, _("32-bit relocation data"));
946 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
948 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
953 error (_("out of memory parsing relocs\n"));
957 for (i
= 0; i
< nrels
; i
++)
959 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
960 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
961 rels
[i
].r_addend
= 0;
968 Elf64_External_Rel
* erels
;
970 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
971 rel_size
, _("64-bit relocation data"));
975 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
977 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
982 error (_("out of memory parsing relocs\n"));
986 for (i
= 0; i
< nrels
; i
++)
988 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
989 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
990 rels
[i
].r_addend
= 0;
992 /* The #ifdef BFD64 below is to prevent a compile time
993 warning. We know that if we do not have a 64 bit data
994 type that we will never execute this code anyway. */
996 if (elf_header
.e_machine
== EM_MIPS
997 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
999 /* In little-endian objects, r_info isn't really a
1000 64-bit little-endian value: it has a 32-bit
1001 little-endian symbol index followed by four
1002 individual byte fields. Reorder INFO
1004 bfd_vma inf
= rels
[i
].r_info
;
1005 inf
= (((inf
& 0xffffffff) << 32)
1006 | ((inf
>> 56) & 0xff)
1007 | ((inf
>> 40) & 0xff00)
1008 | ((inf
>> 24) & 0xff0000)
1009 | ((inf
>> 8) & 0xff000000));
1010 rels
[i
].r_info
= inf
;
1022 /* Returns the reloc type extracted from the reloc info field. */
1025 get_reloc_type (bfd_vma reloc_info
)
1028 return ELF32_R_TYPE (reloc_info
);
1030 switch (elf_header
.e_machine
)
1033 /* Note: We assume that reloc_info has already been adjusted for us. */
1034 return ELF64_MIPS_R_TYPE (reloc_info
);
1037 return ELF64_R_TYPE_ID (reloc_info
);
1040 return ELF64_R_TYPE (reloc_info
);
1044 /* Return the symbol index extracted from the reloc info field. */
1047 get_reloc_symindex (bfd_vma reloc_info
)
1049 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1052 static inline bfd_boolean
1053 uses_msp430x_relocs (void)
1056 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1057 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1058 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1059 /* TI compiler uses ELFOSABI_NONE. */
1060 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1063 /* Display the contents of the relocation data found at the specified
1067 dump_relocations (FILE * file
,
1068 unsigned long rel_offset
,
1069 unsigned long rel_size
,
1070 Elf_Internal_Sym
* symtab
,
1071 unsigned long nsyms
,
1073 unsigned long strtablen
,
1078 Elf_Internal_Rela
* rels
;
1080 if (is_rela
== UNKNOWN
)
1081 is_rela
= guess_is_rela (elf_header
.e_machine
);
1085 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1090 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1101 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1108 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1118 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1123 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1125 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1129 for (i
= 0; i
< rel_size
; i
++)
1134 bfd_vma symtab_index
;
1137 offset
= rels
[i
].r_offset
;
1138 inf
= rels
[i
].r_info
;
1140 type
= get_reloc_type (inf
);
1141 symtab_index
= get_reloc_symindex (inf
);
1145 printf ("%8.8lx %8.8lx ",
1146 (unsigned long) offset
& 0xffffffff,
1147 (unsigned long) inf
& 0xffffffff);
1151 #if BFD_HOST_64BIT_LONG
1153 ? "%16.16lx %16.16lx "
1154 : "%12.12lx %12.12lx ",
1156 #elif BFD_HOST_64BIT_LONG_LONG
1159 ? "%16.16llx %16.16llx "
1160 : "%12.12llx %12.12llx ",
1164 ? "%16.16I64x %16.16I64x "
1165 : "%12.12I64x %12.12I64x ",
1170 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1171 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1172 _bfd_int64_high (offset
),
1173 _bfd_int64_low (offset
),
1174 _bfd_int64_high (inf
),
1175 _bfd_int64_low (inf
));
1179 switch (elf_header
.e_machine
)
1186 rtype
= elf_aarch64_reloc_type (type
);
1190 case EM_CYGNUS_M32R
:
1191 rtype
= elf_m32r_reloc_type (type
);
1196 rtype
= elf_i386_reloc_type (type
);
1201 rtype
= elf_m68hc11_reloc_type (type
);
1205 rtype
= elf_m68k_reloc_type (type
);
1209 rtype
= elf_i960_reloc_type (type
);
1214 rtype
= elf_avr_reloc_type (type
);
1217 case EM_OLD_SPARCV9
:
1218 case EM_SPARC32PLUS
:
1221 rtype
= elf_sparc_reloc_type (type
);
1225 rtype
= elf_spu_reloc_type (type
);
1229 rtype
= v800_reloc_type (type
);
1232 case EM_CYGNUS_V850
:
1233 rtype
= v850_reloc_type (type
);
1237 case EM_CYGNUS_D10V
:
1238 rtype
= elf_d10v_reloc_type (type
);
1242 case EM_CYGNUS_D30V
:
1243 rtype
= elf_d30v_reloc_type (type
);
1247 rtype
= elf_dlx_reloc_type (type
);
1251 rtype
= elf_sh_reloc_type (type
);
1255 case EM_CYGNUS_MN10300
:
1256 rtype
= elf_mn10300_reloc_type (type
);
1260 case EM_CYGNUS_MN10200
:
1261 rtype
= elf_mn10200_reloc_type (type
);
1265 case EM_CYGNUS_FR30
:
1266 rtype
= elf_fr30_reloc_type (type
);
1270 rtype
= elf_frv_reloc_type (type
);
1274 rtype
= elf_ft32_reloc_type (type
);
1278 rtype
= elf_mcore_reloc_type (type
);
1282 rtype
= elf_mmix_reloc_type (type
);
1286 rtype
= elf_moxie_reloc_type (type
);
1290 if (uses_msp430x_relocs ())
1292 rtype
= elf_msp430x_reloc_type (type
);
1296 rtype
= elf_msp430_reloc_type (type
);
1300 rtype
= elf_nds32_reloc_type (type
);
1304 rtype
= elf_ppc_reloc_type (type
);
1308 rtype
= elf_ppc64_reloc_type (type
);
1312 case EM_MIPS_RS3_LE
:
1313 rtype
= elf_mips_reloc_type (type
);
1317 rtype
= elf_alpha_reloc_type (type
);
1321 rtype
= elf_arm_reloc_type (type
);
1325 case EM_ARC_COMPACT
:
1326 case EM_ARC_COMPACT2
:
1327 rtype
= elf_arc_reloc_type (type
);
1331 rtype
= elf_hppa_reloc_type (type
);
1337 rtype
= elf_h8_reloc_type (type
);
1341 rtype
= elf_or1k_reloc_type (type
);
1346 rtype
= elf_pj_reloc_type (type
);
1349 rtype
= elf_ia64_reloc_type (type
);
1353 rtype
= elf_cris_reloc_type (type
);
1357 rtype
= elf_i860_reloc_type (type
);
1363 rtype
= elf_x86_64_reloc_type (type
);
1367 rtype
= i370_reloc_type (type
);
1372 rtype
= elf_s390_reloc_type (type
);
1376 rtype
= elf_score_reloc_type (type
);
1380 rtype
= elf_xstormy16_reloc_type (type
);
1384 rtype
= elf_crx_reloc_type (type
);
1388 rtype
= elf_vax_reloc_type (type
);
1392 rtype
= elf_visium_reloc_type (type
);
1395 case EM_ADAPTEVA_EPIPHANY
:
1396 rtype
= elf_epiphany_reloc_type (type
);
1401 rtype
= elf_ip2k_reloc_type (type
);
1405 rtype
= elf_iq2000_reloc_type (type
);
1410 rtype
= elf_xtensa_reloc_type (type
);
1413 case EM_LATTICEMICO32
:
1414 rtype
= elf_lm32_reloc_type (type
);
1419 rtype
= elf_m32c_reloc_type (type
);
1423 rtype
= elf_mt_reloc_type (type
);
1427 rtype
= elf_bfin_reloc_type (type
);
1431 rtype
= elf_mep_reloc_type (type
);
1435 rtype
= elf_cr16_reloc_type (type
);
1439 case EM_MICROBLAZE_OLD
:
1440 rtype
= elf_microblaze_reloc_type (type
);
1444 rtype
= elf_rl78_reloc_type (type
);
1448 rtype
= elf_rx_reloc_type (type
);
1452 rtype
= elf_metag_reloc_type (type
);
1457 rtype
= elf_xc16x_reloc_type (type
);
1461 rtype
= elf_tic6x_reloc_type (type
);
1465 rtype
= elf_tilegx_reloc_type (type
);
1469 rtype
= elf_tilepro_reloc_type (type
);
1473 rtype
= elf_xgate_reloc_type (type
);
1476 case EM_ALTERA_NIOS2
:
1477 rtype
= elf_nios2_reloc_type (type
);
1482 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1484 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1486 if (elf_header
.e_machine
== EM_ALPHA
1488 && streq (rtype
, "R_ALPHA_LITUSE")
1491 switch (rels
[i
].r_addend
)
1493 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1494 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1495 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1496 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1497 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1498 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1499 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1500 default: rtype
= NULL
;
1503 printf (" (%s)", rtype
);
1507 printf (_("<unknown addend: %lx>"),
1508 (unsigned long) rels
[i
].r_addend
);
1511 else if (symtab_index
)
1513 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1514 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1517 Elf_Internal_Sym
* psym
;
1518 const char * version_string
;
1519 enum versioned_symbol_info sym_info
;
1520 unsigned short vna_other
;
1522 psym
= symtab
+ symtab_index
;
1525 = get_symbol_version_string (file
, is_dynsym
,
1534 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1538 unsigned int width
= is_32bit_elf
? 8 : 14;
1540 /* Relocations against GNU_IFUNC symbols do not use the value
1541 of the symbol as the address to relocate against. Instead
1542 they invoke the function named by the symbol and use its
1543 result as the address for relocation.
1545 To indicate this to the user, do not display the value of
1546 the symbol in the "Symbols's Value" field. Instead show
1547 its name followed by () as a hint that the symbol is
1551 || psym
->st_name
== 0
1552 || psym
->st_name
>= strtablen
)
1555 name
= strtab
+ psym
->st_name
;
1557 len
= print_symbol (width
, name
);
1559 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1561 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1565 print_vma (psym
->st_value
, LONG_HEX
);
1567 printf (is_32bit_elf
? " " : " ");
1570 if (psym
->st_name
== 0)
1572 const char * sec_name
= "<null>";
1575 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1577 if (psym
->st_shndx
< elf_header
.e_shnum
)
1578 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1579 else if (psym
->st_shndx
== SHN_ABS
)
1581 else if (psym
->st_shndx
== SHN_COMMON
)
1582 sec_name
= "COMMON";
1583 else if ((elf_header
.e_machine
== EM_MIPS
1584 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1585 || (elf_header
.e_machine
== EM_TI_C6000
1586 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1587 sec_name
= "SCOMMON";
1588 else if (elf_header
.e_machine
== EM_MIPS
1589 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1590 sec_name
= "SUNDEF";
1591 else if ((elf_header
.e_machine
== EM_X86_64
1592 || elf_header
.e_machine
== EM_L1OM
1593 || elf_header
.e_machine
== EM_K1OM
)
1594 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1595 sec_name
= "LARGE_COMMON";
1596 else if (elf_header
.e_machine
== EM_IA_64
1597 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1598 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1599 sec_name
= "ANSI_COM";
1600 else if (is_ia64_vms ()
1601 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1602 sec_name
= "VMS_SYMVEC";
1605 sprintf (name_buf
, "<section 0x%x>",
1606 (unsigned int) psym
->st_shndx
);
1607 sec_name
= name_buf
;
1610 print_symbol (22, sec_name
);
1612 else if (strtab
== NULL
)
1613 printf (_("<string table index: %3ld>"), psym
->st_name
);
1614 else if (psym
->st_name
>= strtablen
)
1615 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1618 print_symbol (22, strtab
+ psym
->st_name
);
1620 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1626 bfd_vma off
= rels
[i
].r_addend
;
1628 if ((bfd_signed_vma
) off
< 0)
1629 printf (" - %" BFD_VMA_FMT
"x", - off
);
1631 printf (" + %" BFD_VMA_FMT
"x", off
);
1637 bfd_vma off
= rels
[i
].r_addend
;
1639 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1640 if ((bfd_signed_vma
) off
< 0)
1641 printf ("-%" BFD_VMA_FMT
"x", - off
);
1643 printf ("%" BFD_VMA_FMT
"x", off
);
1646 if (elf_header
.e_machine
== EM_SPARCV9
1648 && streq (rtype
, "R_SPARC_OLO10"))
1649 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1654 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1656 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1657 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1658 const char * rtype2
= elf_mips_reloc_type (type2
);
1659 const char * rtype3
= elf_mips_reloc_type (type3
);
1661 printf (" Type2: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type2
& 0xffffffff);
1667 printf ("%-17.17s", rtype2
);
1669 printf ("\n Type3: ");
1672 printf (_("unrecognized: %-7lx"),
1673 (unsigned long) type3
& 0xffffffff);
1675 printf ("%-17.17s", rtype3
);
1686 get_mips_dynamic_type (unsigned long type
)
1690 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1691 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1692 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1693 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1694 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1695 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1696 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1697 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1698 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1699 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1700 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1701 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1702 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1703 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1704 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1705 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1706 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1707 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1708 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1709 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1710 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1711 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1712 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1713 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1714 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1715 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1716 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1717 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1718 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1719 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1720 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1721 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1722 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1723 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1724 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1725 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1726 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1727 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1728 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1729 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1730 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1731 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1732 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1733 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1734 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1735 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1742 get_sparc64_dynamic_type (unsigned long type
)
1746 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1753 get_ppc_dynamic_type (unsigned long type
)
1757 case DT_PPC_GOT
: return "PPC_GOT";
1758 case DT_PPC_OPT
: return "PPC_OPT";
1765 get_ppc64_dynamic_type (unsigned long type
)
1769 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1770 case DT_PPC64_OPD
: return "PPC64_OPD";
1771 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1772 case DT_PPC64_OPT
: return "PPC64_OPT";
1779 get_parisc_dynamic_type (unsigned long type
)
1783 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1784 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1785 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1786 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1787 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1788 case DT_HP_PREINIT
: return "HP_PREINIT";
1789 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1790 case DT_HP_NEEDED
: return "HP_NEEDED";
1791 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1792 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1793 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1794 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1795 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1796 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1797 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1798 case DT_HP_FILTERED
: return "HP_FILTERED";
1799 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1800 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1801 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1802 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1803 case DT_PLT
: return "PLT";
1804 case DT_PLT_SIZE
: return "PLT_SIZE";
1805 case DT_DLT
: return "DLT";
1806 case DT_DLT_SIZE
: return "DLT_SIZE";
1813 get_ia64_dynamic_type (unsigned long type
)
1817 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1818 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1819 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1820 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1821 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1822 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1823 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1824 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1825 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1826 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1828 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1829 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1830 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1831 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1832 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1833 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1834 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1835 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1836 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1837 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1838 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1839 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1840 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1841 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1842 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1843 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1844 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1845 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1846 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1847 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1854 get_alpha_dynamic_type (unsigned long type
)
1858 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1865 get_score_dynamic_type (unsigned long type
)
1869 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1870 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1871 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1872 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1873 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1874 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1881 get_tic6x_dynamic_type (unsigned long type
)
1885 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1886 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1887 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1888 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1889 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1890 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1897 get_nios2_dynamic_type (unsigned long type
)
1901 case DT_NIOS2_GP
: return "NIOS2_GP";
1908 get_dynamic_type (unsigned long type
)
1910 static char buff
[64];
1914 case DT_NULL
: return "NULL";
1915 case DT_NEEDED
: return "NEEDED";
1916 case DT_PLTRELSZ
: return "PLTRELSZ";
1917 case DT_PLTGOT
: return "PLTGOT";
1918 case DT_HASH
: return "HASH";
1919 case DT_STRTAB
: return "STRTAB";
1920 case DT_SYMTAB
: return "SYMTAB";
1921 case DT_RELA
: return "RELA";
1922 case DT_RELASZ
: return "RELASZ";
1923 case DT_RELAENT
: return "RELAENT";
1924 case DT_STRSZ
: return "STRSZ";
1925 case DT_SYMENT
: return "SYMENT";
1926 case DT_INIT
: return "INIT";
1927 case DT_FINI
: return "FINI";
1928 case DT_SONAME
: return "SONAME";
1929 case DT_RPATH
: return "RPATH";
1930 case DT_SYMBOLIC
: return "SYMBOLIC";
1931 case DT_REL
: return "REL";
1932 case DT_RELSZ
: return "RELSZ";
1933 case DT_RELENT
: return "RELENT";
1934 case DT_PLTREL
: return "PLTREL";
1935 case DT_DEBUG
: return "DEBUG";
1936 case DT_TEXTREL
: return "TEXTREL";
1937 case DT_JMPREL
: return "JMPREL";
1938 case DT_BIND_NOW
: return "BIND_NOW";
1939 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1940 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1941 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1942 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1943 case DT_RUNPATH
: return "RUNPATH";
1944 case DT_FLAGS
: return "FLAGS";
1946 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1947 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1949 case DT_CHECKSUM
: return "CHECKSUM";
1950 case DT_PLTPADSZ
: return "PLTPADSZ";
1951 case DT_MOVEENT
: return "MOVEENT";
1952 case DT_MOVESZ
: return "MOVESZ";
1953 case DT_FEATURE
: return "FEATURE";
1954 case DT_POSFLAG_1
: return "POSFLAG_1";
1955 case DT_SYMINSZ
: return "SYMINSZ";
1956 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1958 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1959 case DT_CONFIG
: return "CONFIG";
1960 case DT_DEPAUDIT
: return "DEPAUDIT";
1961 case DT_AUDIT
: return "AUDIT";
1962 case DT_PLTPAD
: return "PLTPAD";
1963 case DT_MOVETAB
: return "MOVETAB";
1964 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1966 case DT_VERSYM
: return "VERSYM";
1968 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1969 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1970 case DT_RELACOUNT
: return "RELACOUNT";
1971 case DT_RELCOUNT
: return "RELCOUNT";
1972 case DT_FLAGS_1
: return "FLAGS_1";
1973 case DT_VERDEF
: return "VERDEF";
1974 case DT_VERDEFNUM
: return "VERDEFNUM";
1975 case DT_VERNEED
: return "VERNEED";
1976 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1978 case DT_AUXILIARY
: return "AUXILIARY";
1979 case DT_USED
: return "USED";
1980 case DT_FILTER
: return "FILTER";
1982 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1983 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1984 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1985 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1986 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1987 case DT_GNU_HASH
: return "GNU_HASH";
1990 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1992 const char * result
;
1994 switch (elf_header
.e_machine
)
1997 case EM_MIPS_RS3_LE
:
1998 result
= get_mips_dynamic_type (type
);
2001 result
= get_sparc64_dynamic_type (type
);
2004 result
= get_ppc_dynamic_type (type
);
2007 result
= get_ppc64_dynamic_type (type
);
2010 result
= get_ia64_dynamic_type (type
);
2013 result
= get_alpha_dynamic_type (type
);
2016 result
= get_score_dynamic_type (type
);
2019 result
= get_tic6x_dynamic_type (type
);
2021 case EM_ALTERA_NIOS2
:
2022 result
= get_nios2_dynamic_type (type
);
2032 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2034 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2035 || (elf_header
.e_machine
== EM_PARISC
2036 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2038 const char * result
;
2040 switch (elf_header
.e_machine
)
2043 result
= get_parisc_dynamic_type (type
);
2046 result
= get_ia64_dynamic_type (type
);
2056 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2060 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2067 get_file_type (unsigned e_type
)
2069 static char buff
[32];
2073 case ET_NONE
: return _("NONE (None)");
2074 case ET_REL
: return _("REL (Relocatable file)");
2075 case ET_EXEC
: return _("EXEC (Executable file)");
2076 case ET_DYN
: return _("DYN (Shared object file)");
2077 case ET_CORE
: return _("CORE (Core file)");
2080 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2081 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2082 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2083 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2085 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2091 get_machine_name (unsigned e_machine
)
2093 static char buff
[64]; /* XXX */
2097 case EM_NONE
: return _("None");
2098 case EM_AARCH64
: return "AArch64";
2099 case EM_M32
: return "WE32100";
2100 case EM_SPARC
: return "Sparc";
2101 case EM_SPU
: return "SPU";
2102 case EM_386
: return "Intel 80386";
2103 case EM_68K
: return "MC68000";
2104 case EM_88K
: return "MC88000";
2105 case EM_IAMCU
: return "Intel MCU";
2106 case EM_860
: return "Intel 80860";
2107 case EM_MIPS
: return "MIPS R3000";
2108 case EM_S370
: return "IBM System/370";
2109 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2110 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2111 case EM_PARISC
: return "HPPA";
2112 case EM_PPC_OLD
: return "Power PC (old)";
2113 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2114 case EM_960
: return "Intel 90860";
2115 case EM_PPC
: return "PowerPC";
2116 case EM_PPC64
: return "PowerPC64";
2117 case EM_FR20
: return "Fujitsu FR20";
2118 case EM_FT32
: return "FTDI FT32";
2119 case EM_RH32
: return "TRW RH32";
2120 case EM_MCORE
: return "MCORE";
2121 case EM_ARM
: return "ARM";
2122 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2123 case EM_SH
: return "Renesas / SuperH SH";
2124 case EM_SPARCV9
: return "Sparc v9";
2125 case EM_TRICORE
: return "Siemens Tricore";
2126 case EM_ARC
: return "ARC";
2127 case EM_ARC_COMPACT
: return "ARCompact";
2128 case EM_ARC_COMPACT2
: return "ARCv2";
2129 case EM_H8_300
: return "Renesas H8/300";
2130 case EM_H8_300H
: return "Renesas H8/300H";
2131 case EM_H8S
: return "Renesas H8S";
2132 case EM_H8_500
: return "Renesas H8/500";
2133 case EM_IA_64
: return "Intel IA-64";
2134 case EM_MIPS_X
: return "Stanford MIPS-X";
2135 case EM_COLDFIRE
: return "Motorola Coldfire";
2136 case EM_ALPHA
: return "Alpha";
2137 case EM_CYGNUS_D10V
:
2138 case EM_D10V
: return "d10v";
2139 case EM_CYGNUS_D30V
:
2140 case EM_D30V
: return "d30v";
2141 case EM_CYGNUS_M32R
:
2142 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2143 case EM_CYGNUS_V850
:
2144 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2145 case EM_V850
: return "Renesas V850";
2146 case EM_CYGNUS_MN10300
:
2147 case EM_MN10300
: return "mn10300";
2148 case EM_CYGNUS_MN10200
:
2149 case EM_MN10200
: return "mn10200";
2150 case EM_MOXIE
: return "Moxie";
2151 case EM_CYGNUS_FR30
:
2152 case EM_FR30
: return "Fujitsu FR30";
2153 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2155 case EM_PJ
: return "picoJava";
2156 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2157 case EM_PCP
: return "Siemens PCP";
2158 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2159 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2160 case EM_STARCORE
: return "Motorola Star*Core processor";
2161 case EM_ME16
: return "Toyota ME16 processor";
2162 case EM_ST100
: return "STMicroelectronics ST100 processor";
2163 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2164 case EM_PDSP
: return "Sony DSP processor";
2165 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2166 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2167 case EM_FX66
: return "Siemens FX66 microcontroller";
2168 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2169 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2170 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2171 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2172 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2173 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2174 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2175 case EM_SVX
: return "Silicon Graphics SVx";
2176 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2177 case EM_VAX
: return "Digital VAX";
2178 case EM_VISIUM
: return "CDS VISIUMcore processor";
2180 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2181 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2182 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2183 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2184 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2185 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2186 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2187 case EM_PRISM
: return "Vitesse Prism";
2188 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2189 case EM_L1OM
: return "Intel L1OM";
2190 case EM_K1OM
: return "Intel K1OM";
2192 case EM_S390
: return "IBM S/390";
2193 case EM_SCORE
: return "SUNPLUS S+Core";
2194 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2195 case EM_OR1K
: return "OpenRISC 1000";
2196 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2197 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2198 case EM_DLX
: return "OpenDLX";
2200 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2201 case EM_IQ2000
: return "Vitesse IQ2000";
2203 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2204 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2205 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2206 case EM_NS32K
: return "National Semiconductor 32000 series";
2207 case EM_TPC
: return "Tenor Network TPC processor";
2208 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2209 case EM_MAX
: return "MAX Processor";
2210 case EM_CR
: return "National Semiconductor CompactRISC";
2211 case EM_F2MC16
: return "Fujitsu F2MC16";
2212 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2213 case EM_LATTICEMICO32
: return "Lattice Mico32";
2215 case EM_M32C
: return "Renesas M32c";
2216 case EM_MT
: return "Morpho Techologies MT processor";
2217 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2218 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2219 case EM_SEP
: return "Sharp embedded microprocessor";
2220 case EM_ARCA
: return "Arca RISC microprocessor";
2221 case EM_UNICORE
: return "Unicore";
2222 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2223 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2224 case EM_NIOS32
: return "Altera Nios";
2225 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2227 case EM_XC16X
: return "Infineon Technologies xc16x";
2228 case EM_M16C
: return "Renesas M16C series microprocessors";
2229 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2230 case EM_CE
: return "Freescale Communication Engine RISC core";
2231 case EM_TSK3000
: return "Altium TSK3000 core";
2232 case EM_RS08
: return "Freescale RS08 embedded processor";
2233 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2234 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2235 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2236 case EM_SE_C17
: return "Seiko Epson C17 family";
2237 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2238 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2239 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2240 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2241 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2242 case EM_R32C
: return "Renesas R32C series microprocessors";
2243 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2244 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2245 case EM_8051
: return "Intel 8051 and variants";
2246 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2247 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2248 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2249 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2250 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2251 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2252 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2253 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2256 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2257 case EM_RL78
: return "Renesas RL78";
2258 case EM_RX
: return "Renesas RX";
2259 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2260 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2261 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2262 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2263 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2264 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2265 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2266 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2267 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2268 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2269 case EM_CUDA
: return "NVIDIA CUDA architecture";
2270 case EM_XGATE
: return "Motorola XGATE embedded processor";
2272 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2278 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2280 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2281 other compilers don't a specific architecture type in the e_flags, and
2282 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2283 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2286 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2287 but also sets a specific architecture type in the e_flags field.
2289 However, when decoding the flags we don't worry if we see an
2290 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2291 ARCEM architecture type. */
2293 switch (e_flags
& EF_ARC_MACH_MSK
)
2295 /* We only expect these to occur for EM_ARC_COMPACT2. */
2296 case EF_ARC_CPU_ARCV2EM
:
2297 strcat (buf
, ", ARC EM");
2299 case EF_ARC_CPU_ARCV2HS
:
2300 strcat (buf
, ", ARC HS");
2303 /* We only expect these to occur for EM_ARC_COMPACT. */
2304 case E_ARC_MACH_ARC600
:
2305 strcat (buf
, ", ARC600");
2307 case E_ARC_MACH_ARC601
:
2308 strcat (buf
, ", ARC601");
2310 case E_ARC_MACH_ARC700
:
2311 strcat (buf
, ", ARC700");
2313 case E_ARC_MACH_NPS400
:
2314 strcat (buf
, ", NPS400");
2317 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2318 new ELF with new architecture being read by an old version of
2319 readelf, or (c) An ELF built with non-GNU compiler that does not
2320 set the architecture in the e_flags. */
2322 if (e_machine
== EM_ARC_COMPACT
)
2323 strcat (buf
, ", Unknown ARCompact");
2325 strcat (buf
, ", Unknown ARC");
2329 switch (e_flags
& EF_ARC_OSABI_MSK
)
2331 case E_ARC_OSABI_ORIG
:
2332 strcat (buf
, ", (ABI:legacy)");
2334 case E_ARC_OSABI_V2
:
2335 strcat (buf
, ", (ABI:v2)");
2337 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2338 case E_ARC_OSABI_V3
:
2339 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2342 strcat (buf
, ", unrecognised ARC OSABI flag");
2348 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2353 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2354 e_flags
&= ~ EF_ARM_EABIMASK
;
2356 /* Handle "generic" ARM flags. */
2357 if (e_flags
& EF_ARM_RELEXEC
)
2359 strcat (buf
, ", relocatable executable");
2360 e_flags
&= ~ EF_ARM_RELEXEC
;
2363 /* Now handle EABI specific flags. */
2367 strcat (buf
, ", <unrecognized EABI>");
2372 case EF_ARM_EABI_VER1
:
2373 strcat (buf
, ", Version1 EABI");
2378 /* Process flags one bit at a time. */
2379 flag
= e_flags
& - e_flags
;
2384 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2385 strcat (buf
, ", sorted symbol tables");
2395 case EF_ARM_EABI_VER2
:
2396 strcat (buf
, ", Version2 EABI");
2401 /* Process flags one bit at a time. */
2402 flag
= e_flags
& - e_flags
;
2407 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2408 strcat (buf
, ", sorted symbol tables");
2411 case EF_ARM_DYNSYMSUSESEGIDX
:
2412 strcat (buf
, ", dynamic symbols use segment index");
2415 case EF_ARM_MAPSYMSFIRST
:
2416 strcat (buf
, ", mapping symbols precede others");
2426 case EF_ARM_EABI_VER3
:
2427 strcat (buf
, ", Version3 EABI");
2430 case EF_ARM_EABI_VER4
:
2431 strcat (buf
, ", Version4 EABI");
2436 /* Process flags one bit at a time. */
2437 flag
= e_flags
& - e_flags
;
2443 strcat (buf
, ", BE8");
2447 strcat (buf
, ", LE8");
2458 case EF_ARM_EABI_VER5
:
2459 strcat (buf
, ", Version5 EABI");
2464 /* Process flags one bit at a time. */
2465 flag
= e_flags
& - e_flags
;
2471 strcat (buf
, ", BE8");
2475 strcat (buf
, ", LE8");
2478 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2479 strcat (buf
, ", soft-float ABI");
2482 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2483 strcat (buf
, ", hard-float ABI");
2493 case EF_ARM_EABI_UNKNOWN
:
2494 strcat (buf
, ", GNU EABI");
2499 /* Process flags one bit at a time. */
2500 flag
= e_flags
& - e_flags
;
2505 case EF_ARM_INTERWORK
:
2506 strcat (buf
, ", interworking enabled");
2509 case EF_ARM_APCS_26
:
2510 strcat (buf
, ", uses APCS/26");
2513 case EF_ARM_APCS_FLOAT
:
2514 strcat (buf
, ", uses APCS/float");
2518 strcat (buf
, ", position independent");
2522 strcat (buf
, ", 8 bit structure alignment");
2525 case EF_ARM_NEW_ABI
:
2526 strcat (buf
, ", uses new ABI");
2529 case EF_ARM_OLD_ABI
:
2530 strcat (buf
, ", uses old ABI");
2533 case EF_ARM_SOFT_FLOAT
:
2534 strcat (buf
, ", software FP");
2537 case EF_ARM_VFP_FLOAT
:
2538 strcat (buf
, ", VFP");
2541 case EF_ARM_MAVERICK_FLOAT
:
2542 strcat (buf
, ", Maverick FP");
2553 strcat (buf
,_(", <unknown>"));
2557 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2559 --size
; /* Leave space for null terminator. */
2561 switch (e_flags
& EF_AVR_MACH
)
2563 case E_AVR_MACH_AVR1
:
2564 strncat (buf
, ", avr:1", size
);
2566 case E_AVR_MACH_AVR2
:
2567 strncat (buf
, ", avr:2", size
);
2569 case E_AVR_MACH_AVR25
:
2570 strncat (buf
, ", avr:25", size
);
2572 case E_AVR_MACH_AVR3
:
2573 strncat (buf
, ", avr:3", size
);
2575 case E_AVR_MACH_AVR31
:
2576 strncat (buf
, ", avr:31", size
);
2578 case E_AVR_MACH_AVR35
:
2579 strncat (buf
, ", avr:35", size
);
2581 case E_AVR_MACH_AVR4
:
2582 strncat (buf
, ", avr:4", size
);
2584 case E_AVR_MACH_AVR5
:
2585 strncat (buf
, ", avr:5", size
);
2587 case E_AVR_MACH_AVR51
:
2588 strncat (buf
, ", avr:51", size
);
2590 case E_AVR_MACH_AVR6
:
2591 strncat (buf
, ", avr:6", size
);
2593 case E_AVR_MACH_AVRTINY
:
2594 strncat (buf
, ", avr:100", size
);
2596 case E_AVR_MACH_XMEGA1
:
2597 strncat (buf
, ", avr:101", size
);
2599 case E_AVR_MACH_XMEGA2
:
2600 strncat (buf
, ", avr:102", size
);
2602 case E_AVR_MACH_XMEGA3
:
2603 strncat (buf
, ", avr:103", size
);
2605 case E_AVR_MACH_XMEGA4
:
2606 strncat (buf
, ", avr:104", size
);
2608 case E_AVR_MACH_XMEGA5
:
2609 strncat (buf
, ", avr:105", size
);
2611 case E_AVR_MACH_XMEGA6
:
2612 strncat (buf
, ", avr:106", size
);
2614 case E_AVR_MACH_XMEGA7
:
2615 strncat (buf
, ", avr:107", size
);
2618 strncat (buf
, ", avr:<unknown>", size
);
2622 size
-= strlen (buf
);
2623 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2624 strncat (buf
, ", link-relax", size
);
2628 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2637 static const char *ABI_STRINGS
[] =
2639 "ABI v0", /* use r5 as return register; only used in N1213HC */
2640 "ABI v1", /* use r0 as return register */
2641 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2642 "ABI v2fp", /* for FPU */
2646 static const char *VER_STRINGS
[] =
2648 "Andes ELF V1.3 or older",
2652 static const char *ARCH_STRINGS
[] =
2661 abi
= EF_NDS_ABI
& e_flags
;
2662 arch
= EF_NDS_ARCH
& e_flags
;
2663 config
= EF_NDS_INST
& e_flags
;
2664 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2666 memset (buf
, 0, size
);
2673 case E_NDS_ABI_V2FP
:
2674 case E_NDS_ABI_AABI
:
2675 case E_NDS_ABI_V2FP_PLUS
:
2676 /* In case there are holes in the array. */
2677 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2681 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2687 case E_NDS32_ELF_VER_1_2
:
2688 case E_NDS32_ELF_VER_1_3
:
2689 case E_NDS32_ELF_VER_1_4
:
2690 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2694 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2698 if (E_NDS_ABI_V0
== abi
)
2700 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2701 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2702 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2703 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2709 case E_NDS_ARCH_STAR_V1_0
:
2710 case E_NDS_ARCH_STAR_V2_0
:
2711 case E_NDS_ARCH_STAR_V3_0
:
2712 case E_NDS_ARCH_STAR_V3_M
:
2713 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2717 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2718 /* ARCH version determines how the e_flags are interpreted.
2719 If it is unknown, we cannot proceed. */
2723 /* Newer ABI; Now handle architecture specific flags. */
2724 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2726 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2727 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2729 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2730 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2732 if (config
& E_NDS32_HAS_DIV_INST
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2735 if (config
& E_NDS32_HAS_16BIT_INST
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2740 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2742 if (version
<= E_NDS32_ELF_VER_1_3
)
2743 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2745 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2748 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2749 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2751 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2752 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2754 if (config
& E_NDS32_HAS_16BIT_INST
)
2756 if (version
<= E_NDS32_ELF_VER_1_3
)
2757 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2759 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2763 if (config
& E_NDS32_HAS_EXT_INST
)
2764 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2766 if (config
& E_NDS32_HAS_EXT2_INST
)
2767 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2769 if (config
& E_NDS32_HAS_FPU_INST
)
2772 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2775 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2778 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2781 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2784 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2789 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2791 case E_NDS32_FPU_REG_8SP_4DP
:
2792 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2794 case E_NDS32_FPU_REG_16SP_8DP
:
2795 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2797 case E_NDS32_FPU_REG_32SP_16DP
:
2798 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2800 case E_NDS32_FPU_REG_32SP_32DP
:
2801 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2806 if (config
& E_NDS32_HAS_AUDIO_INST
)
2807 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2809 if (config
& E_NDS32_HAS_STRING_INST
)
2810 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2812 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2813 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2815 if (config
& E_NDS32_HAS_VIDEO_INST
)
2817 if (version
<= E_NDS32_ELF_VER_1_3
)
2818 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2820 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2823 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2824 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2826 if (config
& E_NDS32_HAS_L2C_INST
)
2827 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2831 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2833 static char buf
[1024];
2844 case EM_ARC_COMPACT2
:
2845 case EM_ARC_COMPACT
:
2846 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2850 decode_ARM_machine_flags (e_flags
, buf
);
2854 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2858 if (e_flags
& EF_BFIN_PIC
)
2859 strcat (buf
, ", PIC");
2861 if (e_flags
& EF_BFIN_FDPIC
)
2862 strcat (buf
, ", FDPIC");
2864 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2865 strcat (buf
, ", code in L1");
2867 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2868 strcat (buf
, ", data in L1");
2873 switch (e_flags
& EF_FRV_CPU_MASK
)
2875 case EF_FRV_CPU_GENERIC
:
2879 strcat (buf
, ", fr???");
2882 case EF_FRV_CPU_FR300
:
2883 strcat (buf
, ", fr300");
2886 case EF_FRV_CPU_FR400
:
2887 strcat (buf
, ", fr400");
2889 case EF_FRV_CPU_FR405
:
2890 strcat (buf
, ", fr405");
2893 case EF_FRV_CPU_FR450
:
2894 strcat (buf
, ", fr450");
2897 case EF_FRV_CPU_FR500
:
2898 strcat (buf
, ", fr500");
2900 case EF_FRV_CPU_FR550
:
2901 strcat (buf
, ", fr550");
2904 case EF_FRV_CPU_SIMPLE
:
2905 strcat (buf
, ", simple");
2907 case EF_FRV_CPU_TOMCAT
:
2908 strcat (buf
, ", tomcat");
2914 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2915 strcat (buf
, ", m68000");
2916 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2917 strcat (buf
, ", cpu32");
2918 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2919 strcat (buf
, ", fido_a");
2922 char const * isa
= _("unknown");
2923 char const * mac
= _("unknown mac");
2924 char const * additional
= NULL
;
2926 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2928 case EF_M68K_CF_ISA_A_NODIV
:
2930 additional
= ", nodiv";
2932 case EF_M68K_CF_ISA_A
:
2935 case EF_M68K_CF_ISA_A_PLUS
:
2938 case EF_M68K_CF_ISA_B_NOUSP
:
2940 additional
= ", nousp";
2942 case EF_M68K_CF_ISA_B
:
2945 case EF_M68K_CF_ISA_C
:
2948 case EF_M68K_CF_ISA_C_NODIV
:
2950 additional
= ", nodiv";
2953 strcat (buf
, ", cf, isa ");
2956 strcat (buf
, additional
);
2957 if (e_flags
& EF_M68K_CF_FLOAT
)
2958 strcat (buf
, ", float");
2959 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2964 case EF_M68K_CF_MAC
:
2967 case EF_M68K_CF_EMAC
:
2970 case EF_M68K_CF_EMAC_B
:
2983 switch (e_flags
& EF_MEP_CPU_MASK
)
2985 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2986 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2987 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2988 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2989 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2990 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2991 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2994 switch (e_flags
& EF_MEP_COP_MASK
)
2996 case EF_MEP_COP_NONE
: break;
2997 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2998 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2999 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3000 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3001 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3004 if (e_flags
& EF_MEP_LIBRARY
)
3005 strcat (buf
, ", Built for Library");
3007 if (e_flags
& EF_MEP_INDEX_MASK
)
3008 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3009 e_flags
& EF_MEP_INDEX_MASK
);
3011 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3012 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3013 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3017 if (e_flags
& EF_PPC_EMB
)
3018 strcat (buf
, ", emb");
3020 if (e_flags
& EF_PPC_RELOCATABLE
)
3021 strcat (buf
, _(", relocatable"));
3023 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3024 strcat (buf
, _(", relocatable-lib"));
3028 if (e_flags
& EF_PPC64_ABI
)
3030 char abi
[] = ", abiv0";
3032 abi
[6] += e_flags
& EF_PPC64_ABI
;
3038 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3039 strcat (buf
, ", RH850 ABI");
3041 if (e_flags
& EF_V800_850E3
)
3042 strcat (buf
, ", V3 architecture");
3044 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3045 strcat (buf
, ", FPU not used");
3047 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3048 strcat (buf
, ", regmode: COMMON");
3050 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3051 strcat (buf
, ", r4 not used");
3053 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3054 strcat (buf
, ", r30 not used");
3056 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3057 strcat (buf
, ", r5 not used");
3059 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3060 strcat (buf
, ", r2 not used");
3062 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3064 switch (e_flags
& - e_flags
)
3066 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3067 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3068 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3069 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3070 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3071 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3072 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3073 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3074 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3075 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3076 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3077 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3084 case EM_CYGNUS_V850
:
3085 switch (e_flags
& EF_V850_ARCH
)
3087 case E_V850E3V5_ARCH
:
3088 strcat (buf
, ", v850e3v5");
3090 case E_V850E2V3_ARCH
:
3091 strcat (buf
, ", v850e2v3");
3094 strcat (buf
, ", v850e2");
3097 strcat (buf
, ", v850e1");
3100 strcat (buf
, ", v850e");
3103 strcat (buf
, ", v850");
3106 strcat (buf
, _(", unknown v850 architecture variant"));
3112 case EM_CYGNUS_M32R
:
3113 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3114 strcat (buf
, ", m32r");
3118 case EM_MIPS_RS3_LE
:
3119 if (e_flags
& EF_MIPS_NOREORDER
)
3120 strcat (buf
, ", noreorder");
3122 if (e_flags
& EF_MIPS_PIC
)
3123 strcat (buf
, ", pic");
3125 if (e_flags
& EF_MIPS_CPIC
)
3126 strcat (buf
, ", cpic");
3128 if (e_flags
& EF_MIPS_UCODE
)
3129 strcat (buf
, ", ugen_reserved");
3131 if (e_flags
& EF_MIPS_ABI2
)
3132 strcat (buf
, ", abi2");
3134 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3135 strcat (buf
, ", odk first");
3137 if (e_flags
& EF_MIPS_32BITMODE
)
3138 strcat (buf
, ", 32bitmode");
3140 if (e_flags
& EF_MIPS_NAN2008
)
3141 strcat (buf
, ", nan2008");
3143 if (e_flags
& EF_MIPS_FP64
)
3144 strcat (buf
, ", fp64");
3146 switch ((e_flags
& EF_MIPS_MACH
))
3148 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3149 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3150 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3151 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3152 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3153 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3154 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3155 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3156 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3157 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3158 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3159 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3160 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3161 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3162 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3163 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3164 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3166 /* We simply ignore the field in this case to avoid confusion:
3167 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3170 default: strcat (buf
, _(", unknown CPU")); break;
3173 switch ((e_flags
& EF_MIPS_ABI
))
3175 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3176 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3177 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3178 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3180 /* We simply ignore the field in this case to avoid confusion:
3181 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3182 This means it is likely to be an o32 file, but not for
3185 default: strcat (buf
, _(", unknown ABI")); break;
3188 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3189 strcat (buf
, ", mdmx");
3191 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3192 strcat (buf
, ", mips16");
3194 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3195 strcat (buf
, ", micromips");
3197 switch ((e_flags
& EF_MIPS_ARCH
))
3199 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3200 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3201 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3202 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3203 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3204 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3205 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3206 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3207 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3208 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3209 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3210 default: strcat (buf
, _(", unknown ISA")); break;
3215 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3219 switch ((e_flags
& EF_SH_MACH_MASK
))
3221 case EF_SH1
: strcat (buf
, ", sh1"); break;
3222 case EF_SH2
: strcat (buf
, ", sh2"); break;
3223 case EF_SH3
: strcat (buf
, ", sh3"); break;
3224 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3225 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3226 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3227 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3228 case EF_SH4
: strcat (buf
, ", sh4"); break;
3229 case EF_SH5
: strcat (buf
, ", sh5"); break;
3230 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3231 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3232 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3233 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3234 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3235 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3236 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3237 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3238 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3239 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3240 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3241 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3242 default: strcat (buf
, _(", unknown ISA")); break;
3245 if (e_flags
& EF_SH_PIC
)
3246 strcat (buf
, ", pic");
3248 if (e_flags
& EF_SH_FDPIC
)
3249 strcat (buf
, ", fdpic");
3253 if (e_flags
& EF_OR1K_NODELAY
)
3254 strcat (buf
, ", no delay");
3258 if (e_flags
& EF_SPARC_32PLUS
)
3259 strcat (buf
, ", v8+");
3261 if (e_flags
& EF_SPARC_SUN_US1
)
3262 strcat (buf
, ", ultrasparcI");
3264 if (e_flags
& EF_SPARC_SUN_US3
)
3265 strcat (buf
, ", ultrasparcIII");
3267 if (e_flags
& EF_SPARC_HAL_R1
)
3268 strcat (buf
, ", halr1");
3270 if (e_flags
& EF_SPARC_LEDATA
)
3271 strcat (buf
, ", ledata");
3273 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3274 strcat (buf
, ", tso");
3276 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3277 strcat (buf
, ", pso");
3279 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3280 strcat (buf
, ", rmo");
3284 switch (e_flags
& EF_PARISC_ARCH
)
3286 case EFA_PARISC_1_0
:
3287 strcpy (buf
, ", PA-RISC 1.0");
3289 case EFA_PARISC_1_1
:
3290 strcpy (buf
, ", PA-RISC 1.1");
3292 case EFA_PARISC_2_0
:
3293 strcpy (buf
, ", PA-RISC 2.0");
3298 if (e_flags
& EF_PARISC_TRAPNIL
)
3299 strcat (buf
, ", trapnil");
3300 if (e_flags
& EF_PARISC_EXT
)
3301 strcat (buf
, ", ext");
3302 if (e_flags
& EF_PARISC_LSB
)
3303 strcat (buf
, ", lsb");
3304 if (e_flags
& EF_PARISC_WIDE
)
3305 strcat (buf
, ", wide");
3306 if (e_flags
& EF_PARISC_NO_KABP
)
3307 strcat (buf
, ", no kabp");
3308 if (e_flags
& EF_PARISC_LAZYSWAP
)
3309 strcat (buf
, ", lazyswap");
3314 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3315 strcat (buf
, ", new calling convention");
3317 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3318 strcat (buf
, ", gnu calling convention");
3322 if ((e_flags
& EF_IA_64_ABI64
))
3323 strcat (buf
, ", 64-bit");
3325 strcat (buf
, ", 32-bit");
3326 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3327 strcat (buf
, ", reduced fp model");
3328 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3329 strcat (buf
, ", no function descriptors, constant gp");
3330 else if ((e_flags
& EF_IA_64_CONS_GP
))
3331 strcat (buf
, ", constant gp");
3332 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3333 strcat (buf
, ", absolute");
3334 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3336 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3337 strcat (buf
, ", vms_linkages");
3338 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3340 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3342 case EF_IA_64_VMS_COMCOD_WARNING
:
3343 strcat (buf
, ", warning");
3345 case EF_IA_64_VMS_COMCOD_ERROR
:
3346 strcat (buf
, ", error");
3348 case EF_IA_64_VMS_COMCOD_ABORT
:
3349 strcat (buf
, ", abort");
3352 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3353 e_flags
& EF_IA_64_VMS_COMCOD
);
3354 strcat (buf
, ", <unknown>");
3360 if ((e_flags
& EF_VAX_NONPIC
))
3361 strcat (buf
, ", non-PIC");
3362 if ((e_flags
& EF_VAX_DFLOAT
))
3363 strcat (buf
, ", D-Float");
3364 if ((e_flags
& EF_VAX_GFLOAT
))
3365 strcat (buf
, ", G-Float");
3369 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3370 strcat (buf
, ", mcm");
3371 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3372 strcat (buf
, ", mcm24");
3373 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3374 strcat (buf
, ", gr6");
3378 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3380 case E_FLAG_RL78_ANY_CPU
: break;
3381 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3382 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3383 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3385 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3386 strcat (buf
, ", 64-bit doubles");
3390 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3391 strcat (buf
, ", 64-bit doubles");
3392 if (e_flags
& E_FLAG_RX_DSP
)
3393 strcat (buf
, ", dsp");
3394 if (e_flags
& E_FLAG_RX_PID
)
3395 strcat (buf
, ", pid");
3396 if (e_flags
& E_FLAG_RX_ABI
)
3397 strcat (buf
, ", RX ABI");
3398 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3399 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3400 ? ", uses String instructions" : ", bans String instructions");
3401 if (e_flags
& E_FLAG_RX_V2
)
3402 strcat (buf
, ", V2");
3406 if (e_flags
& EF_S390_HIGH_GPRS
)
3407 strcat (buf
, ", highgprs");
3411 if ((e_flags
& EF_C6000_REL
))
3412 strcat (buf
, ", relocatable module");
3416 strcat (buf
, _(": architecture variant: "));
3417 switch (e_flags
& EF_MSP430_MACH
)
3419 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3420 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3421 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3422 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3423 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3424 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3425 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3426 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3427 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3428 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3429 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3430 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3431 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3432 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3433 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3435 strcat (buf
, _(": unknown")); break;
3438 if (e_flags
& ~ EF_MSP430_MACH
)
3439 strcat (buf
, _(": unknown extra flag bits also present"));
3447 get_osabi_name (unsigned int osabi
)
3449 static char buff
[32];
3453 case ELFOSABI_NONE
: return "UNIX - System V";
3454 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3455 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3456 case ELFOSABI_GNU
: return "UNIX - GNU";
3457 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3458 case ELFOSABI_AIX
: return "UNIX - AIX";
3459 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3460 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3461 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3462 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3463 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3464 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3465 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3466 case ELFOSABI_AROS
: return "AROS";
3467 case ELFOSABI_FENIXOS
: return "FenixOS";
3470 switch (elf_header
.e_machine
)
3475 case ELFOSABI_ARM
: return "ARM";
3486 case ELFOSABI_STANDALONE
: return _("Standalone App");
3495 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3496 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3505 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3511 get_aarch64_segment_type (unsigned long type
)
3515 case PT_AARCH64_ARCHEXT
:
3516 return "AARCH64_ARCHEXT";
3525 get_arm_segment_type (unsigned long type
)
3539 get_mips_segment_type (unsigned long type
)
3543 case PT_MIPS_REGINFO
:
3545 case PT_MIPS_RTPROC
:
3547 case PT_MIPS_OPTIONS
:
3549 case PT_MIPS_ABIFLAGS
:
3559 get_parisc_segment_type (unsigned long type
)
3563 case PT_HP_TLS
: return "HP_TLS";
3564 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3565 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3566 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3567 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3568 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3569 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3570 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3571 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3572 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3573 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3574 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3575 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3576 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3577 case PT_HP_STACK
: return "HP_STACK";
3578 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3579 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3580 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3581 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3590 get_ia64_segment_type (unsigned long type
)
3594 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3595 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3596 case PT_HP_TLS
: return "HP_TLS";
3597 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3598 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3599 case PT_IA_64_HP_STACK
: return "HP_STACK";
3608 get_tic6x_segment_type (unsigned long type
)
3612 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3621 get_segment_type (unsigned long p_type
)
3623 static char buff
[32];
3627 case PT_NULL
: return "NULL";
3628 case PT_LOAD
: return "LOAD";
3629 case PT_DYNAMIC
: return "DYNAMIC";
3630 case PT_INTERP
: return "INTERP";
3631 case PT_NOTE
: return "NOTE";
3632 case PT_SHLIB
: return "SHLIB";
3633 case PT_PHDR
: return "PHDR";
3634 case PT_TLS
: return "TLS";
3636 case PT_GNU_EH_FRAME
:
3637 return "GNU_EH_FRAME";
3638 case PT_GNU_STACK
: return "GNU_STACK";
3639 case PT_GNU_RELRO
: return "GNU_RELRO";
3642 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3644 const char * result
;
3646 switch (elf_header
.e_machine
)
3649 result
= get_aarch64_segment_type (p_type
);
3652 result
= get_arm_segment_type (p_type
);
3655 case EM_MIPS_RS3_LE
:
3656 result
= get_mips_segment_type (p_type
);
3659 result
= get_parisc_segment_type (p_type
);
3662 result
= get_ia64_segment_type (p_type
);
3665 result
= get_tic6x_segment_type (p_type
);
3675 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3677 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3679 const char * result
;
3681 switch (elf_header
.e_machine
)
3684 result
= get_parisc_segment_type (p_type
);
3687 result
= get_ia64_segment_type (p_type
);
3697 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3700 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3707 get_mips_section_type_name (unsigned int sh_type
)
3711 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3712 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3713 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3714 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3715 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3716 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3717 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3718 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3719 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3720 case SHT_MIPS_RELD
: return "MIPS_RELD";
3721 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3722 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3723 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3724 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3725 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3726 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3727 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3728 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3729 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3730 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3731 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3732 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3733 case SHT_MIPS_LINE
: return "MIPS_LINE";
3734 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3735 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3736 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3737 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3738 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3739 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3740 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3741 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3742 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3743 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3744 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3745 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3746 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3747 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3748 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3749 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3750 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3758 get_parisc_section_type_name (unsigned int sh_type
)
3762 case SHT_PARISC_EXT
: return "PARISC_EXT";
3763 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3764 case SHT_PARISC_DOC
: return "PARISC_DOC";
3765 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3766 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3767 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3768 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3776 get_ia64_section_type_name (unsigned int sh_type
)
3778 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3779 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3780 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3784 case SHT_IA_64_EXT
: return "IA_64_EXT";
3785 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3786 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3787 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3788 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3789 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3790 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3791 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3792 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3793 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3801 get_x86_64_section_type_name (unsigned int sh_type
)
3805 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3813 get_aarch64_section_type_name (unsigned int sh_type
)
3817 case SHT_AARCH64_ATTRIBUTES
:
3818 return "AARCH64_ATTRIBUTES";
3826 get_arm_section_type_name (unsigned int sh_type
)
3830 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3831 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3832 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3833 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3834 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3842 get_tic6x_section_type_name (unsigned int sh_type
)
3846 case SHT_C6000_UNWIND
:
3847 return "C6000_UNWIND";
3848 case SHT_C6000_PREEMPTMAP
:
3849 return "C6000_PREEMPTMAP";
3850 case SHT_C6000_ATTRIBUTES
:
3851 return "C6000_ATTRIBUTES";
3856 case SHT_TI_HANDLER
:
3857 return "TI_HANDLER";
3858 case SHT_TI_INITINFO
:
3859 return "TI_INITINFO";
3860 case SHT_TI_PHATTRS
:
3861 return "TI_PHATTRS";
3869 get_msp430x_section_type_name (unsigned int sh_type
)
3873 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3874 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3875 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3876 default: return NULL
;
3881 get_v850_section_type_name (unsigned int sh_type
)
3885 case SHT_V850_SCOMMON
: return "V850 Small Common";
3886 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3887 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3888 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3889 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3890 default: return NULL
;
3895 get_section_type_name (unsigned int sh_type
)
3897 static char buff
[32];
3898 const char * result
;
3902 case SHT_NULL
: return "NULL";
3903 case SHT_PROGBITS
: return "PROGBITS";
3904 case SHT_SYMTAB
: return "SYMTAB";
3905 case SHT_STRTAB
: return "STRTAB";
3906 case SHT_RELA
: return "RELA";
3907 case SHT_HASH
: return "HASH";
3908 case SHT_DYNAMIC
: return "DYNAMIC";
3909 case SHT_NOTE
: return "NOTE";
3910 case SHT_NOBITS
: return "NOBITS";
3911 case SHT_REL
: return "REL";
3912 case SHT_SHLIB
: return "SHLIB";
3913 case SHT_DYNSYM
: return "DYNSYM";
3914 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3915 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3916 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3917 case SHT_GNU_HASH
: return "GNU_HASH";
3918 case SHT_GROUP
: return "GROUP";
3919 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3920 case SHT_GNU_verdef
: return "VERDEF";
3921 case SHT_GNU_verneed
: return "VERNEED";
3922 case SHT_GNU_versym
: return "VERSYM";
3923 case 0x6ffffff0: return "VERSYM";
3924 case 0x6ffffffc: return "VERDEF";
3925 case 0x7ffffffd: return "AUXILIARY";
3926 case 0x7fffffff: return "FILTER";
3927 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3930 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3932 switch (elf_header
.e_machine
)
3935 case EM_MIPS_RS3_LE
:
3936 result
= get_mips_section_type_name (sh_type
);
3939 result
= get_parisc_section_type_name (sh_type
);
3942 result
= get_ia64_section_type_name (sh_type
);
3947 result
= get_x86_64_section_type_name (sh_type
);
3950 result
= get_aarch64_section_type_name (sh_type
);
3953 result
= get_arm_section_type_name (sh_type
);
3956 result
= get_tic6x_section_type_name (sh_type
);
3959 result
= get_msp430x_section_type_name (sh_type
);
3963 case EM_CYGNUS_V850
:
3964 result
= get_v850_section_type_name (sh_type
);
3974 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
3976 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3978 switch (elf_header
.e_machine
)
3981 result
= get_ia64_section_type_name (sh_type
);
3991 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
3993 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3995 switch (elf_header
.e_machine
)
3999 case EM_CYGNUS_V850
:
4000 result
= get_v850_section_type_name (sh_type
);
4010 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4013 /* This message is probably going to be displayed in a 15
4014 character wide field, so put the hex value first. */
4015 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4021 #define OPTION_DEBUG_DUMP 512
4022 #define OPTION_DYN_SYMS 513
4023 #define OPTION_DWARF_DEPTH 514
4024 #define OPTION_DWARF_START 515
4025 #define OPTION_DWARF_CHECK 516
4027 static struct option options
[] =
4029 {"all", no_argument
, 0, 'a'},
4030 {"file-header", no_argument
, 0, 'h'},
4031 {"program-headers", no_argument
, 0, 'l'},
4032 {"headers", no_argument
, 0, 'e'},
4033 {"histogram", no_argument
, 0, 'I'},
4034 {"segments", no_argument
, 0, 'l'},
4035 {"sections", no_argument
, 0, 'S'},
4036 {"section-headers", no_argument
, 0, 'S'},
4037 {"section-groups", no_argument
, 0, 'g'},
4038 {"section-details", no_argument
, 0, 't'},
4039 {"full-section-name",no_argument
, 0, 'N'},
4040 {"symbols", no_argument
, 0, 's'},
4041 {"syms", no_argument
, 0, 's'},
4042 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4043 {"relocs", no_argument
, 0, 'r'},
4044 {"notes", no_argument
, 0, 'n'},
4045 {"dynamic", no_argument
, 0, 'd'},
4046 {"arch-specific", no_argument
, 0, 'A'},
4047 {"version-info", no_argument
, 0, 'V'},
4048 {"use-dynamic", no_argument
, 0, 'D'},
4049 {"unwind", no_argument
, 0, 'u'},
4050 {"archive-index", no_argument
, 0, 'c'},
4051 {"hex-dump", required_argument
, 0, 'x'},
4052 {"relocated-dump", required_argument
, 0, 'R'},
4053 {"string-dump", required_argument
, 0, 'p'},
4054 {"decompress", no_argument
, 0, 'z'},
4055 #ifdef SUPPORT_DISASSEMBLY
4056 {"instruction-dump", required_argument
, 0, 'i'},
4058 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4060 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4061 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4062 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4064 {"version", no_argument
, 0, 'v'},
4065 {"wide", no_argument
, 0, 'W'},
4066 {"help", no_argument
, 0, 'H'},
4067 {0, no_argument
, 0, 0}
4071 usage (FILE * stream
)
4073 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4074 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4075 fprintf (stream
, _(" Options are:\n\
4076 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4077 -h --file-header Display the ELF file header\n\
4078 -l --program-headers Display the program headers\n\
4079 --segments An alias for --program-headers\n\
4080 -S --section-headers Display the sections' header\n\
4081 --sections An alias for --section-headers\n\
4082 -g --section-groups Display the section groups\n\
4083 -t --section-details Display the section details\n\
4084 -e --headers Equivalent to: -h -l -S\n\
4085 -s --syms Display the symbol table\n\
4086 --symbols An alias for --syms\n\
4087 --dyn-syms Display the dynamic symbol table\n\
4088 -n --notes Display the core notes (if present)\n\
4089 -r --relocs Display the relocations (if present)\n\
4090 -u --unwind Display the unwind info (if present)\n\
4091 -d --dynamic Display the dynamic section (if present)\n\
4092 -V --version-info Display the version sections (if present)\n\
4093 -A --arch-specific Display architecture specific information (if any)\n\
4094 -c --archive-index Display the symbol/file index in an archive\n\
4095 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4096 -x --hex-dump=<number|name>\n\
4097 Dump the contents of section <number|name> as bytes\n\
4098 -p --string-dump=<number|name>\n\
4099 Dump the contents of section <number|name> as strings\n\
4100 -R --relocated-dump=<number|name>\n\
4101 Dump the contents of section <number|name> as relocated bytes\n\
4102 -z --decompress Decompress section before dumping it\n\
4103 -w[lLiaprmfFsoRt] or\n\
4104 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4105 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4106 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4108 Display the contents of DWARF2 debug sections\n"));
4109 fprintf (stream
, _("\
4110 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4111 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4113 #ifdef SUPPORT_DISASSEMBLY
4114 fprintf (stream
, _("\
4115 -i --instruction-dump=<number|name>\n\
4116 Disassemble the contents of section <number|name>\n"));
4118 fprintf (stream
, _("\
4119 -I --histogram Display histogram of bucket list lengths\n\
4120 -W --wide Allow output width to exceed 80 characters\n\
4121 @<file> Read options from <file>\n\
4122 -H --help Display this information\n\
4123 -v --version Display the version number of readelf\n"));
4125 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4126 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4128 exit (stream
== stdout
? 0 : 1);
4131 /* Record the fact that the user wants the contents of section number
4132 SECTION to be displayed using the method(s) encoded as flags bits
4133 in TYPE. Note, TYPE can be zero if we are creating the array for
4137 request_dump_bynumber (unsigned int section
, dump_type type
)
4139 if (section
>= num_dump_sects
)
4141 dump_type
* new_dump_sects
;
4143 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4144 sizeof (* dump_sects
));
4146 if (new_dump_sects
== NULL
)
4147 error (_("Out of memory allocating dump request table.\n"));
4150 /* Copy current flag settings. */
4151 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4155 dump_sects
= new_dump_sects
;
4156 num_dump_sects
= section
+ 1;
4161 dump_sects
[section
] |= type
;
4166 /* Request a dump by section name. */
4169 request_dump_byname (const char * section
, dump_type type
)
4171 struct dump_list_entry
* new_request
;
4173 new_request
= (struct dump_list_entry
*)
4174 malloc (sizeof (struct dump_list_entry
));
4176 error (_("Out of memory allocating dump request table.\n"));
4178 new_request
->name
= strdup (section
);
4179 if (!new_request
->name
)
4180 error (_("Out of memory allocating dump request table.\n"));
4182 new_request
->type
= type
;
4184 new_request
->next
= dump_sects_byname
;
4185 dump_sects_byname
= new_request
;
4189 request_dump (dump_type type
)
4195 section
= strtoul (optarg
, & cp
, 0);
4197 if (! *cp
&& section
>= 0)
4198 request_dump_bynumber (section
, type
);
4200 request_dump_byname (optarg
, type
);
4205 parse_args (int argc
, char ** argv
)
4212 while ((c
= getopt_long
4213 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4231 do_section_groups
++;
4239 do_section_groups
++;
4244 do_section_details
++;
4288 request_dump (HEX_DUMP
);
4291 request_dump (STRING_DUMP
);
4294 request_dump (RELOC_DUMP
);
4304 dwarf_select_sections_all ();
4309 dwarf_select_sections_by_letters (optarg
);
4312 case OPTION_DEBUG_DUMP
:
4319 dwarf_select_sections_by_names (optarg
);
4322 case OPTION_DWARF_DEPTH
:
4326 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4329 case OPTION_DWARF_START
:
4333 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4336 case OPTION_DWARF_CHECK
:
4339 case OPTION_DYN_SYMS
:
4342 #ifdef SUPPORT_DISASSEMBLY
4344 request_dump (DISASS_DUMP
);
4348 print_version (program_name
);
4357 /* xgettext:c-format */
4358 error (_("Invalid option '-%c'\n"), c
);
4365 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4366 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4367 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4368 && !do_section_groups
&& !do_archive_index
4374 get_elf_class (unsigned int elf_class
)
4376 static char buff
[32];
4380 case ELFCLASSNONE
: return _("none");
4381 case ELFCLASS32
: return "ELF32";
4382 case ELFCLASS64
: return "ELF64";
4384 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4390 get_data_encoding (unsigned int encoding
)
4392 static char buff
[32];
4396 case ELFDATANONE
: return _("none");
4397 case ELFDATA2LSB
: return _("2's complement, little endian");
4398 case ELFDATA2MSB
: return _("2's complement, big endian");
4400 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4405 /* Decode the data held in 'elf_header'. */
4408 process_file_header (void)
4410 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4411 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4412 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4413 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4416 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4420 init_dwarf_regnames (elf_header
.e_machine
);
4426 printf (_("ELF Header:\n"));
4427 printf (_(" Magic: "));
4428 for (i
= 0; i
< EI_NIDENT
; i
++)
4429 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4431 printf (_(" Class: %s\n"),
4432 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4433 printf (_(" Data: %s\n"),
4434 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4435 printf (_(" Version: %d %s\n"),
4436 elf_header
.e_ident
[EI_VERSION
],
4437 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4439 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4440 ? _("<unknown: %lx>")
4442 printf (_(" OS/ABI: %s\n"),
4443 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4444 printf (_(" ABI Version: %d\n"),
4445 elf_header
.e_ident
[EI_ABIVERSION
]);
4446 printf (_(" Type: %s\n"),
4447 get_file_type (elf_header
.e_type
));
4448 printf (_(" Machine: %s\n"),
4449 get_machine_name (elf_header
.e_machine
));
4450 printf (_(" Version: 0x%lx\n"),
4451 (unsigned long) elf_header
.e_version
);
4453 printf (_(" Entry point address: "));
4454 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4455 printf (_("\n Start of program headers: "));
4456 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4457 printf (_(" (bytes into file)\n Start of section headers: "));
4458 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4459 printf (_(" (bytes into file)\n"));
4461 printf (_(" Flags: 0x%lx%s\n"),
4462 (unsigned long) elf_header
.e_flags
,
4463 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4464 printf (_(" Size of this header: %ld (bytes)\n"),
4465 (long) elf_header
.e_ehsize
);
4466 printf (_(" Size of program headers: %ld (bytes)\n"),
4467 (long) elf_header
.e_phentsize
);
4468 printf (_(" Number of program headers: %ld"),
4469 (long) elf_header
.e_phnum
);
4470 if (section_headers
!= NULL
4471 && elf_header
.e_phnum
== PN_XNUM
4472 && section_headers
[0].sh_info
!= 0)
4473 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4474 putc ('\n', stdout
);
4475 printf (_(" Size of section headers: %ld (bytes)\n"),
4476 (long) elf_header
.e_shentsize
);
4477 printf (_(" Number of section headers: %ld"),
4478 (long) elf_header
.e_shnum
);
4479 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4480 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4481 putc ('\n', stdout
);
4482 printf (_(" Section header string table index: %ld"),
4483 (long) elf_header
.e_shstrndx
);
4484 if (section_headers
!= NULL
4485 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4486 printf (" (%u)", section_headers
[0].sh_link
);
4487 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4488 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4489 printf (_(" <corrupt: out of range>"));
4490 putc ('\n', stdout
);
4493 if (section_headers
!= NULL
)
4495 if (elf_header
.e_phnum
== PN_XNUM
4496 && section_headers
[0].sh_info
!= 0)
4497 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4498 if (elf_header
.e_shnum
== SHN_UNDEF
)
4499 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4500 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4501 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4502 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4503 elf_header
.e_shstrndx
= SHN_UNDEF
;
4504 free (section_headers
);
4505 section_headers
= NULL
;
4512 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4514 Elf32_External_Phdr
* phdrs
;
4515 Elf32_External_Phdr
* external
;
4516 Elf_Internal_Phdr
* internal
;
4518 unsigned int size
= elf_header
.e_phentsize
;
4519 unsigned int num
= elf_header
.e_phnum
;
4521 /* PR binutils/17531: Cope with unexpected section header sizes. */
4522 if (size
== 0 || num
== 0)
4524 if (size
< sizeof * phdrs
)
4526 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4529 if (size
> sizeof * phdrs
)
4530 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4532 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4533 size
, num
, _("program headers"));
4537 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4538 i
< elf_header
.e_phnum
;
4539 i
++, internal
++, external
++)
4541 internal
->p_type
= BYTE_GET (external
->p_type
);
4542 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4543 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4544 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4545 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4546 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4547 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4548 internal
->p_align
= BYTE_GET (external
->p_align
);
4556 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4558 Elf64_External_Phdr
* phdrs
;
4559 Elf64_External_Phdr
* external
;
4560 Elf_Internal_Phdr
* internal
;
4562 unsigned int size
= elf_header
.e_phentsize
;
4563 unsigned int num
= elf_header
.e_phnum
;
4565 /* PR binutils/17531: Cope with unexpected section header sizes. */
4566 if (size
== 0 || num
== 0)
4568 if (size
< sizeof * phdrs
)
4570 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4573 if (size
> sizeof * phdrs
)
4574 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4576 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4577 size
, num
, _("program headers"));
4581 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4582 i
< elf_header
.e_phnum
;
4583 i
++, internal
++, external
++)
4585 internal
->p_type
= BYTE_GET (external
->p_type
);
4586 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4587 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4588 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4589 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4590 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4591 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4592 internal
->p_align
= BYTE_GET (external
->p_align
);
4599 /* Returns 1 if the program headers were read into `program_headers'. */
4602 get_program_headers (FILE * file
)
4604 Elf_Internal_Phdr
* phdrs
;
4606 /* Check cache of prior read. */
4607 if (program_headers
!= NULL
)
4610 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4611 sizeof (Elf_Internal_Phdr
));
4615 error (_("Out of memory reading %u program headers\n"),
4616 elf_header
.e_phnum
);
4621 ? get_32bit_program_headers (file
, phdrs
)
4622 : get_64bit_program_headers (file
, phdrs
))
4624 program_headers
= phdrs
;
4632 /* Returns 1 if the program headers were loaded. */
4635 process_program_headers (FILE * file
)
4637 Elf_Internal_Phdr
* segment
;
4640 if (elf_header
.e_phnum
== 0)
4642 /* PR binutils/12467. */
4643 if (elf_header
.e_phoff
!= 0)
4644 warn (_("possibly corrupt ELF header - it has a non-zero program"
4645 " header offset, but no program headers\n"));
4646 else if (do_segments
)
4647 printf (_("\nThere are no program headers in this file.\n"));
4651 if (do_segments
&& !do_header
)
4653 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4654 printf (_("Entry point "));
4655 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4656 printf (_("\nThere are %d program headers, starting at offset "),
4657 elf_header
.e_phnum
);
4658 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4662 if (! get_program_headers (file
))
4667 if (elf_header
.e_phnum
> 1)
4668 printf (_("\nProgram Headers:\n"));
4670 printf (_("\nProgram Headers:\n"));
4674 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4677 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4681 (_(" Type Offset VirtAddr PhysAddr\n"));
4683 (_(" FileSiz MemSiz Flags Align\n"));
4690 for (i
= 0, segment
= program_headers
;
4691 i
< elf_header
.e_phnum
;
4696 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4700 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4701 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4702 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4703 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4704 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4706 (segment
->p_flags
& PF_R
? 'R' : ' '),
4707 (segment
->p_flags
& PF_W
? 'W' : ' '),
4708 (segment
->p_flags
& PF_X
? 'E' : ' '));
4709 printf ("%#lx", (unsigned long) segment
->p_align
);
4713 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4714 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4717 print_vma (segment
->p_offset
, FULL_HEX
);
4721 print_vma (segment
->p_vaddr
, FULL_HEX
);
4723 print_vma (segment
->p_paddr
, FULL_HEX
);
4726 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4727 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4730 print_vma (segment
->p_filesz
, FULL_HEX
);
4734 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4735 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4738 print_vma (segment
->p_memsz
, FULL_HEX
);
4742 (segment
->p_flags
& PF_R
? 'R' : ' '),
4743 (segment
->p_flags
& PF_W
? 'W' : ' '),
4744 (segment
->p_flags
& PF_X
? 'E' : ' '));
4746 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4747 printf ("%#lx", (unsigned long) segment
->p_align
);
4750 print_vma (segment
->p_align
, PREFIX_HEX
);
4755 print_vma (segment
->p_offset
, FULL_HEX
);
4757 print_vma (segment
->p_vaddr
, FULL_HEX
);
4759 print_vma (segment
->p_paddr
, FULL_HEX
);
4761 print_vma (segment
->p_filesz
, FULL_HEX
);
4763 print_vma (segment
->p_memsz
, FULL_HEX
);
4765 (segment
->p_flags
& PF_R
? 'R' : ' '),
4766 (segment
->p_flags
& PF_W
? 'W' : ' '),
4767 (segment
->p_flags
& PF_X
? 'E' : ' '));
4768 print_vma (segment
->p_align
, HEX
);
4773 putc ('\n', stdout
);
4775 switch (segment
->p_type
)
4779 error (_("more than one dynamic segment\n"));
4781 /* By default, assume that the .dynamic section is the first
4782 section in the DYNAMIC segment. */
4783 dynamic_addr
= segment
->p_offset
;
4784 dynamic_size
= segment
->p_filesz
;
4785 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4786 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4788 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4789 dynamic_addr
= dynamic_size
= 0;
4792 /* Try to locate the .dynamic section. If there is
4793 a section header table, we can easily locate it. */
4794 if (section_headers
!= NULL
)
4796 Elf_Internal_Shdr
* sec
;
4798 sec
= find_section (".dynamic");
4799 if (sec
== NULL
|| sec
->sh_size
== 0)
4801 /* A corresponding .dynamic section is expected, but on
4802 IA-64/OpenVMS it is OK for it to be missing. */
4803 if (!is_ia64_vms ())
4804 error (_("no .dynamic section in the dynamic segment\n"));
4808 if (sec
->sh_type
== SHT_NOBITS
)
4814 dynamic_addr
= sec
->sh_offset
;
4815 dynamic_size
= sec
->sh_size
;
4817 if (dynamic_addr
< segment
->p_offset
4818 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4819 warn (_("the .dynamic section is not contained"
4820 " within the dynamic segment\n"));
4821 else if (dynamic_addr
> segment
->p_offset
)
4822 warn (_("the .dynamic section is not the first section"
4823 " in the dynamic segment.\n"));
4828 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4830 error (_("Unable to find program interpreter name\n"));
4834 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4836 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4837 error (_("Internal error: failed to create format string to display program interpreter\n"));
4839 program_interpreter
[0] = 0;
4840 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4841 error (_("Unable to read program interpreter name\n"));
4844 printf (_(" [Requesting program interpreter: %s]\n"),
4845 program_interpreter
);
4851 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4853 printf (_("\n Section to Segment mapping:\n"));
4854 printf (_(" Segment Sections...\n"));
4856 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4859 Elf_Internal_Shdr
* section
;
4861 segment
= program_headers
+ i
;
4862 section
= section_headers
+ 1;
4864 printf (" %2.2d ", i
);
4866 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4868 if (!ELF_TBSS_SPECIAL (section
, segment
)
4869 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4870 printf ("%s ", printable_section_name (section
));
4881 /* Find the file offset corresponding to VMA by using the program headers. */
4884 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4886 Elf_Internal_Phdr
* seg
;
4888 if (! get_program_headers (file
))
4890 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4894 for (seg
= program_headers
;
4895 seg
< program_headers
+ elf_header
.e_phnum
;
4898 if (seg
->p_type
!= PT_LOAD
)
4901 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4902 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4903 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4906 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4907 (unsigned long) vma
);
4912 /* Allocate memory and load the sections headers into the global pointer
4913 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4914 generate any error messages if the load fails. */
4917 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4919 Elf32_External_Shdr
* shdrs
;
4920 Elf_Internal_Shdr
* internal
;
4922 unsigned int size
= elf_header
.e_shentsize
;
4923 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4925 /* PR binutils/17531: Cope with unexpected section header sizes. */
4926 if (size
== 0 || num
== 0)
4928 if (size
< sizeof * shdrs
)
4931 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4934 if (!probe
&& size
> sizeof * shdrs
)
4935 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4937 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4939 probe
? NULL
: _("section headers"));
4943 if (section_headers
!= NULL
)
4944 free (section_headers
);
4945 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4946 sizeof (Elf_Internal_Shdr
));
4947 if (section_headers
== NULL
)
4950 error (_("Out of memory reading %u section headers\n"), num
);
4954 for (i
= 0, internal
= section_headers
;
4958 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4959 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4960 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4961 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4962 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4963 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4964 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4965 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4966 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4967 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4975 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4977 Elf64_External_Shdr
* shdrs
;
4978 Elf_Internal_Shdr
* internal
;
4980 unsigned int size
= elf_header
.e_shentsize
;
4981 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4983 /* PR binutils/17531: Cope with unexpected section header sizes. */
4984 if (size
== 0 || num
== 0)
4986 if (size
< sizeof * shdrs
)
4989 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4992 if (! probe
&& size
> sizeof * shdrs
)
4993 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4995 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4997 probe
? NULL
: _("section headers"));
5001 if (section_headers
!= NULL
)
5002 free (section_headers
);
5003 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5004 sizeof (Elf_Internal_Shdr
));
5005 if (section_headers
== NULL
)
5008 error (_("Out of memory reading %u section headers\n"), num
);
5012 for (i
= 0, internal
= section_headers
;
5016 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5017 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5018 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5019 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5020 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5021 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5022 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5023 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5024 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5025 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5032 static Elf_Internal_Sym
*
5033 get_32bit_elf_symbols (FILE * file
,
5034 Elf_Internal_Shdr
* section
,
5035 unsigned long * num_syms_return
)
5037 unsigned long number
= 0;
5038 Elf32_External_Sym
* esyms
= NULL
;
5039 Elf_External_Sym_Shndx
* shndx
= NULL
;
5040 Elf_Internal_Sym
* isyms
= NULL
;
5041 Elf_Internal_Sym
* psym
;
5044 if (section
->sh_size
== 0)
5046 if (num_syms_return
!= NULL
)
5047 * num_syms_return
= 0;
5051 /* Run some sanity checks first. */
5052 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5054 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5055 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5059 if (section
->sh_size
> current_file_size
)
5061 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5062 printable_section_name (section
), (unsigned long) section
->sh_size
);
5066 number
= section
->sh_size
/ section
->sh_entsize
;
5068 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5070 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5071 (unsigned long) section
->sh_size
,
5072 printable_section_name (section
),
5073 (unsigned long) section
->sh_entsize
);
5077 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5078 section
->sh_size
, _("symbols"));
5083 elf_section_list
* entry
;
5086 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5087 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5089 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5090 entry
->hdr
->sh_offset
,
5091 1, entry
->hdr
->sh_size
,
5092 _("symbol table section indicies"));
5095 /* PR17531: file: heap-buffer-overflow */
5096 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5098 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5099 printable_section_name (entry
->hdr
),
5100 (unsigned long) entry
->hdr
->sh_size
,
5101 (unsigned long) section
->sh_size
);
5107 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5111 error (_("Out of memory reading %lu symbols\n"),
5112 (unsigned long) number
);
5116 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5118 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5119 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5120 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5121 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5122 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5124 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5125 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5126 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5127 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5128 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5137 if (num_syms_return
!= NULL
)
5138 * num_syms_return
= isyms
== NULL
? 0 : number
;
5143 static Elf_Internal_Sym
*
5144 get_64bit_elf_symbols (FILE * file
,
5145 Elf_Internal_Shdr
* section
,
5146 unsigned long * num_syms_return
)
5148 unsigned long number
= 0;
5149 Elf64_External_Sym
* esyms
= NULL
;
5150 Elf_External_Sym_Shndx
* shndx
= NULL
;
5151 Elf_Internal_Sym
* isyms
= NULL
;
5152 Elf_Internal_Sym
* psym
;
5155 if (section
->sh_size
== 0)
5157 if (num_syms_return
!= NULL
)
5158 * num_syms_return
= 0;
5162 /* Run some sanity checks first. */
5163 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5165 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5166 printable_section_name (section
),
5167 (unsigned long) section
->sh_entsize
);
5171 if (section
->sh_size
> current_file_size
)
5173 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5174 printable_section_name (section
),
5175 (unsigned long) section
->sh_size
);
5179 number
= section
->sh_size
/ section
->sh_entsize
;
5181 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5183 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5184 (unsigned long) section
->sh_size
,
5185 printable_section_name (section
),
5186 (unsigned long) section
->sh_entsize
);
5190 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5191 section
->sh_size
, _("symbols"));
5196 elf_section_list
* entry
;
5199 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5200 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5202 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5203 entry
->hdr
->sh_offset
,
5204 1, entry
->hdr
->sh_size
,
5205 _("symbol table section indicies"));
5208 /* PR17531: file: heap-buffer-overflow */
5209 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5211 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5212 printable_section_name (entry
->hdr
),
5213 (unsigned long) entry
->hdr
->sh_size
,
5214 (unsigned long) section
->sh_size
);
5220 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5224 error (_("Out of memory reading %lu symbols\n"),
5225 (unsigned long) number
);
5229 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5231 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5232 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5233 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5234 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5236 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5238 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5239 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5240 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5242 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5243 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5252 if (num_syms_return
!= NULL
)
5253 * num_syms_return
= isyms
== NULL
? 0 : number
;
5259 get_elf_section_flags (bfd_vma sh_flags
)
5261 static char buff
[1024];
5263 int field_size
= is_32bit_elf
? 8 : 16;
5265 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5266 bfd_vma os_flags
= 0;
5267 bfd_vma proc_flags
= 0;
5268 bfd_vma unknown_flags
= 0;
5276 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5277 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5278 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5279 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5280 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5281 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5282 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5283 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5284 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5285 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5286 /* IA-64 specific. */
5287 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5288 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5289 /* IA-64 OpenVMS specific. */
5290 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5291 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5292 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5293 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5294 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5295 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5297 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5298 /* SPARC specific. */
5299 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5300 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5302 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5303 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5304 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5307 if (do_section_details
)
5309 sprintf (buff
, "[%*.*lx]: ",
5310 field_size
, field_size
, (unsigned long) sh_flags
);
5311 p
+= field_size
+ 4;
5318 flag
= sh_flags
& - sh_flags
;
5321 if (do_section_details
)
5325 case SHF_WRITE
: sindex
= 0; break;
5326 case SHF_ALLOC
: sindex
= 1; break;
5327 case SHF_EXECINSTR
: sindex
= 2; break;
5328 case SHF_MERGE
: sindex
= 3; break;
5329 case SHF_STRINGS
: sindex
= 4; break;
5330 case SHF_INFO_LINK
: sindex
= 5; break;
5331 case SHF_LINK_ORDER
: sindex
= 6; break;
5332 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5333 case SHF_GROUP
: sindex
= 8; break;
5334 case SHF_TLS
: sindex
= 9; break;
5335 case SHF_EXCLUDE
: sindex
= 18; break;
5336 case SHF_COMPRESSED
: sindex
= 20; break;
5340 switch (elf_header
.e_machine
)
5343 if (flag
== SHF_IA_64_SHORT
)
5345 else if (flag
== SHF_IA_64_NORECOV
)
5348 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5351 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5352 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5353 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5354 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5355 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5356 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5367 case EM_OLD_SPARCV9
:
5368 case EM_SPARC32PLUS
:
5371 if (flag
== SHF_ORDERED
)
5378 case SHF_ENTRYSECT
: sindex
= 21; break;
5379 case SHF_ARM_NOREAD
: sindex
= 22; break;
5380 case SHF_COMDEF
: sindex
= 23; break;
5392 if (p
!= buff
+ field_size
+ 4)
5394 if (size
< (10 + 2))
5396 warn (_("Internal error: not enough buffer room for section flag info"));
5397 return _("<unknown>");
5404 size
-= flags
[sindex
].len
;
5405 p
= stpcpy (p
, flags
[sindex
].str
);
5407 else if (flag
& SHF_MASKOS
)
5409 else if (flag
& SHF_MASKPROC
)
5412 unknown_flags
|= flag
;
5418 case SHF_WRITE
: *p
= 'W'; break;
5419 case SHF_ALLOC
: *p
= 'A'; break;
5420 case SHF_EXECINSTR
: *p
= 'X'; break;
5421 case SHF_MERGE
: *p
= 'M'; break;
5422 case SHF_STRINGS
: *p
= 'S'; break;
5423 case SHF_INFO_LINK
: *p
= 'I'; break;
5424 case SHF_LINK_ORDER
: *p
= 'L'; break;
5425 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5426 case SHF_GROUP
: *p
= 'G'; break;
5427 case SHF_TLS
: *p
= 'T'; break;
5428 case SHF_EXCLUDE
: *p
= 'E'; break;
5429 case SHF_COMPRESSED
: *p
= 'C'; break;
5432 if ((elf_header
.e_machine
== EM_X86_64
5433 || elf_header
.e_machine
== EM_L1OM
5434 || elf_header
.e_machine
== EM_K1OM
)
5435 && flag
== SHF_X86_64_LARGE
)
5437 else if (elf_header
.e_machine
== EM_ARM
5438 && flag
== SHF_ARM_NOREAD
)
5440 else if (flag
& SHF_MASKOS
)
5443 sh_flags
&= ~ SHF_MASKOS
;
5445 else if (flag
& SHF_MASKPROC
)
5448 sh_flags
&= ~ SHF_MASKPROC
;
5458 if (do_section_details
)
5462 size
-= 5 + field_size
;
5463 if (p
!= buff
+ field_size
+ 4)
5467 warn (_("Internal error: not enough buffer room for section flag info"));
5468 return _("<unknown>");
5474 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5475 (unsigned long) os_flags
);
5476 p
+= 5 + field_size
;
5480 size
-= 7 + field_size
;
5481 if (p
!= buff
+ field_size
+ 4)
5485 warn (_("Internal error: not enough buffer room for section flag info"));
5486 return _("<unknown>");
5492 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5493 (unsigned long) proc_flags
);
5494 p
+= 7 + field_size
;
5498 size
-= 10 + field_size
;
5499 if (p
!= buff
+ field_size
+ 4)
5503 warn (_("Internal error: not enough buffer room for section flag info"));
5504 return _("<unknown>");
5510 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5511 (unsigned long) unknown_flags
);
5512 p
+= 10 + field_size
;
5521 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5525 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5526 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5527 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5528 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5529 return sizeof (*echdr
);
5533 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5534 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5535 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5536 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5537 return sizeof (*echdr
);
5542 process_section_headers (FILE * file
)
5544 Elf_Internal_Shdr
* section
;
5547 section_headers
= NULL
;
5549 if (elf_header
.e_shnum
== 0)
5551 /* PR binutils/12467. */
5552 if (elf_header
.e_shoff
!= 0)
5553 warn (_("possibly corrupt ELF file header - it has a non-zero"
5554 " section header offset, but no section headers\n"));
5555 else if (do_sections
)
5556 printf (_("\nThere are no sections in this file.\n"));
5561 if (do_sections
&& !do_header
)
5562 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5563 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5567 if (! get_32bit_section_headers (file
, FALSE
))
5570 else if (! get_64bit_section_headers (file
, FALSE
))
5573 /* Read in the string table, so that we have names to display. */
5574 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5575 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5577 section
= section_headers
+ elf_header
.e_shstrndx
;
5579 if (section
->sh_size
!= 0)
5581 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5582 1, section
->sh_size
,
5585 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5589 /* Scan the sections for the dynamic symbol table
5590 and dynamic string table and debug sections. */
5591 dynamic_symbols
= NULL
;
5592 dynamic_strings
= NULL
;
5593 dynamic_syminfo
= NULL
;
5594 symtab_shndx_list
= NULL
;
5596 eh_addr_size
= is_32bit_elf
? 4 : 8;
5597 switch (elf_header
.e_machine
)
5600 case EM_MIPS_RS3_LE
:
5601 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5602 FDE addresses. However, the ABI also has a semi-official ILP32
5603 variant for which the normal FDE address size rules apply.
5605 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5606 section, where XX is the size of longs in bits. Unfortunately,
5607 earlier compilers provided no way of distinguishing ILP32 objects
5608 from LP64 objects, so if there's any doubt, we should assume that
5609 the official LP64 form is being used. */
5610 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5611 && find_section (".gcc_compiled_long32") == NULL
)
5617 switch (elf_header
.e_flags
& EF_H8_MACH
)
5619 case E_H8_MACH_H8300
:
5620 case E_H8_MACH_H8300HN
:
5621 case E_H8_MACH_H8300SN
:
5622 case E_H8_MACH_H8300SXN
:
5625 case E_H8_MACH_H8300H
:
5626 case E_H8_MACH_H8300S
:
5627 case E_H8_MACH_H8300SX
:
5635 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5637 case EF_M32C_CPU_M16C
:
5644 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5647 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5648 if (section->sh_entsize != expected_entsize) \
5651 sprintf_vma (buf, section->sh_entsize); \
5652 /* Note: coded this way so that there is a single string for \
5654 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5655 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5656 (unsigned) expected_entsize); \
5657 section->sh_entsize = expected_entsize; \
5662 #define CHECK_ENTSIZE(section, i, type) \
5663 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5664 sizeof (Elf64_External_##type))
5666 for (i
= 0, section
= section_headers
;
5667 i
< elf_header
.e_shnum
;
5670 char * name
= SECTION_NAME (section
);
5672 if (section
->sh_type
== SHT_DYNSYM
)
5674 if (dynamic_symbols
!= NULL
)
5676 error (_("File contains multiple dynamic symbol tables\n"));
5680 CHECK_ENTSIZE (section
, i
, Sym
);
5681 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5683 else if (section
->sh_type
== SHT_STRTAB
5684 && streq (name
, ".dynstr"))
5686 if (dynamic_strings
!= NULL
)
5688 error (_("File contains multiple dynamic string tables\n"));
5692 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5693 1, section
->sh_size
,
5694 _("dynamic strings"));
5695 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5697 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5699 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5700 entry
->hdr
= section
;
5701 entry
->next
= symtab_shndx_list
;
5702 symtab_shndx_list
= entry
;
5704 else if (section
->sh_type
== SHT_SYMTAB
)
5705 CHECK_ENTSIZE (section
, i
, Sym
);
5706 else if (section
->sh_type
== SHT_GROUP
)
5707 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5708 else if (section
->sh_type
== SHT_REL
)
5709 CHECK_ENTSIZE (section
, i
, Rel
);
5710 else if (section
->sh_type
== SHT_RELA
)
5711 CHECK_ENTSIZE (section
, i
, Rela
);
5712 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5713 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5714 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5715 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5716 || do_debug_addr
|| do_debug_cu_index
)
5717 && (const_strneq (name
, ".debug_")
5718 || const_strneq (name
, ".zdebug_")))
5721 name
+= sizeof (".zdebug_") - 1;
5723 name
+= sizeof (".debug_") - 1;
5726 || (do_debug_info
&& const_strneq (name
, "info"))
5727 || (do_debug_info
&& const_strneq (name
, "types"))
5728 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5729 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5730 || (do_debug_lines
&& const_strneq (name
, "line."))
5731 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5732 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5733 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5734 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5735 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5736 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5737 || (do_debug_frames
&& const_strneq (name
, "frame"))
5738 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5739 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5740 || (do_debug_str
&& const_strneq (name
, "str"))
5741 || (do_debug_loc
&& const_strneq (name
, "loc"))
5742 || (do_debug_addr
&& const_strneq (name
, "addr"))
5743 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5744 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5746 request_dump_bynumber (i
, DEBUG_DUMP
);
5748 /* Linkonce section to be combined with .debug_info at link time. */
5749 else if ((do_debugging
|| do_debug_info
)
5750 && const_strneq (name
, ".gnu.linkonce.wi."))
5751 request_dump_bynumber (i
, DEBUG_DUMP
);
5752 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5753 request_dump_bynumber (i
, DEBUG_DUMP
);
5754 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5755 request_dump_bynumber (i
, DEBUG_DUMP
);
5756 /* Trace sections for Itanium VMS. */
5757 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5758 || do_trace_aranges
)
5759 && const_strneq (name
, ".trace_"))
5761 name
+= sizeof (".trace_") - 1;
5764 || (do_trace_info
&& streq (name
, "info"))
5765 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5766 || (do_trace_aranges
&& streq (name
, "aranges"))
5768 request_dump_bynumber (i
, DEBUG_DUMP
);
5775 if (elf_header
.e_shnum
> 1)
5776 printf (_("\nSection Headers:\n"));
5778 printf (_("\nSection Header:\n"));
5782 if (do_section_details
)
5784 printf (_(" [Nr] Name\n"));
5785 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5789 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5793 if (do_section_details
)
5795 printf (_(" [Nr] Name\n"));
5796 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5800 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5804 if (do_section_details
)
5806 printf (_(" [Nr] Name\n"));
5807 printf (_(" Type Address Offset Link\n"));
5808 printf (_(" Size EntSize Info Align\n"));
5812 printf (_(" [Nr] Name Type Address Offset\n"));
5813 printf (_(" Size EntSize Flags Link Info Align\n"));
5817 if (do_section_details
)
5818 printf (_(" Flags\n"));
5820 for (i
= 0, section
= section_headers
;
5821 i
< elf_header
.e_shnum
;
5824 printf (" [%2u] ", i
);
5825 if (do_section_details
)
5826 printf ("%s\n ", printable_section_name (section
));
5828 print_symbol (-17, SECTION_NAME (section
));
5830 printf (do_wide
? " %-15s " : " %-15.15s ",
5831 get_section_type_name (section
->sh_type
));
5835 const char * link_too_big
= NULL
;
5837 print_vma (section
->sh_addr
, LONG_HEX
);
5839 printf ( " %6.6lx %6.6lx %2.2lx",
5840 (unsigned long) section
->sh_offset
,
5841 (unsigned long) section
->sh_size
,
5842 (unsigned long) section
->sh_entsize
);
5844 if (do_section_details
)
5845 fputs (" ", stdout
);
5847 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5849 if (section
->sh_link
>= elf_header
.e_shnum
)
5852 /* The sh_link value is out of range. Normally this indicates
5853 an error but it can have special values in Solaris binaries. */
5854 switch (elf_header
.e_machine
)
5861 case EM_OLD_SPARCV9
:
5862 case EM_SPARC32PLUS
:
5865 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5866 link_too_big
= "BEFORE";
5867 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5868 link_too_big
= "AFTER";
5875 if (do_section_details
)
5877 if (link_too_big
!= NULL
&& * link_too_big
)
5878 printf ("<%s> ", link_too_big
);
5880 printf ("%2u ", section
->sh_link
);
5881 printf ("%3u %2lu\n", section
->sh_info
,
5882 (unsigned long) section
->sh_addralign
);
5885 printf ("%2u %3u %2lu\n",
5888 (unsigned long) section
->sh_addralign
);
5890 if (link_too_big
&& ! * link_too_big
)
5891 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5892 i
, section
->sh_link
);
5896 print_vma (section
->sh_addr
, LONG_HEX
);
5898 if ((long) section
->sh_offset
== section
->sh_offset
)
5899 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5903 print_vma (section
->sh_offset
, LONG_HEX
);
5906 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5907 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5911 print_vma (section
->sh_size
, LONG_HEX
);
5914 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5915 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5919 print_vma (section
->sh_entsize
, LONG_HEX
);
5922 if (do_section_details
)
5923 fputs (" ", stdout
);
5925 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5927 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5929 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5930 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5933 print_vma (section
->sh_addralign
, DEC
);
5937 else if (do_section_details
)
5939 printf (" %-15.15s ",
5940 get_section_type_name (section
->sh_type
));
5941 print_vma (section
->sh_addr
, LONG_HEX
);
5942 if ((long) section
->sh_offset
== section
->sh_offset
)
5943 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5947 print_vma (section
->sh_offset
, LONG_HEX
);
5949 printf (" %u\n ", section
->sh_link
);
5950 print_vma (section
->sh_size
, LONG_HEX
);
5952 print_vma (section
->sh_entsize
, LONG_HEX
);
5954 printf (" %-16u %lu\n",
5956 (unsigned long) section
->sh_addralign
);
5961 print_vma (section
->sh_addr
, LONG_HEX
);
5962 if ((long) section
->sh_offset
== section
->sh_offset
)
5963 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5967 print_vma (section
->sh_offset
, LONG_HEX
);
5970 print_vma (section
->sh_size
, LONG_HEX
);
5972 print_vma (section
->sh_entsize
, LONG_HEX
);
5974 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5976 printf (" %2u %3u %lu\n",
5979 (unsigned long) section
->sh_addralign
);
5982 if (do_section_details
)
5984 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5985 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5987 /* Minimum section size is 12 bytes for 32-bit compression
5988 header + 12 bytes for compressed data header. */
5989 unsigned char buf
[24];
5990 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5991 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5992 sizeof (buf
), _("compression header")))
5994 Elf_Internal_Chdr chdr
;
5995 get_compression_header (&chdr
, buf
);
5996 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5999 printf (_(" [<unknown>: 0x%x], "),
6001 print_vma (chdr
.ch_size
, LONG_HEX
);
6002 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6008 if (!do_section_details
)
6010 /* The ordering of the letters shown here matches the ordering of the
6011 corresponding SHF_xxx values, and hence the order in which these
6012 letters will be displayed to the user. */
6013 printf (_("Key to Flags:\n\
6014 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6015 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6016 C (compressed), x (unknown), o (OS specific), E (exclude),\n"));
6017 if (elf_header
.e_machine
== EM_X86_64
6018 || elf_header
.e_machine
== EM_L1OM
6019 || elf_header
.e_machine
== EM_K1OM
)
6020 printf (_("l (large), "));
6021 else if (elf_header
.e_machine
== EM_ARM
)
6022 printf (_("y (noread), "));
6023 printf ("p (processor specific)\n");
6030 get_group_flags (unsigned int flags
)
6032 static char buff
[32];
6042 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6049 process_section_groups (FILE * file
)
6051 Elf_Internal_Shdr
* section
;
6053 struct group
* group
;
6054 Elf_Internal_Shdr
* symtab_sec
;
6055 Elf_Internal_Shdr
* strtab_sec
;
6056 Elf_Internal_Sym
* symtab
;
6057 unsigned long num_syms
;
6061 /* Don't process section groups unless needed. */
6062 if (!do_unwind
&& !do_section_groups
)
6065 if (elf_header
.e_shnum
== 0)
6067 if (do_section_groups
)
6068 printf (_("\nThere are no sections to group in this file.\n"));
6073 if (section_headers
== NULL
)
6075 error (_("Section headers are not available!\n"));
6076 /* PR 13622: This can happen with a corrupt ELF header. */
6080 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6081 sizeof (struct group
*));
6083 if (section_headers_groups
== NULL
)
6085 error (_("Out of memory reading %u section group headers\n"),
6086 elf_header
.e_shnum
);
6090 /* Scan the sections for the group section. */
6092 for (i
= 0, section
= section_headers
;
6093 i
< elf_header
.e_shnum
;
6095 if (section
->sh_type
== SHT_GROUP
)
6098 if (group_count
== 0)
6100 if (do_section_groups
)
6101 printf (_("\nThere are no section groups in this file.\n"));
6106 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6108 if (section_groups
== NULL
)
6110 error (_("Out of memory reading %lu groups\n"),
6111 (unsigned long) group_count
);
6121 for (i
= 0, section
= section_headers
, group
= section_groups
;
6122 i
< elf_header
.e_shnum
;
6125 if (section
->sh_type
== SHT_GROUP
)
6127 const char * name
= printable_section_name (section
);
6128 const char * group_name
;
6129 unsigned char * start
;
6130 unsigned char * indices
;
6131 unsigned int entry
, j
, size
;
6132 Elf_Internal_Shdr
* sec
;
6133 Elf_Internal_Sym
* sym
;
6135 /* Get the symbol table. */
6136 if (section
->sh_link
>= elf_header
.e_shnum
6137 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6140 error (_("Bad sh_link in group section `%s'\n"), name
);
6144 if (symtab_sec
!= sec
)
6149 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6154 error (_("Corrupt header in group section `%s'\n"), name
);
6158 if (section
->sh_info
>= num_syms
)
6160 error (_("Bad sh_info in group section `%s'\n"), name
);
6164 sym
= symtab
+ section
->sh_info
;
6166 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6168 if (sym
->st_shndx
== 0
6169 || sym
->st_shndx
>= elf_header
.e_shnum
)
6171 error (_("Bad sh_info in group section `%s'\n"), name
);
6175 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6184 /* Get the string table. */
6185 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6194 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6200 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6201 1, strtab_sec
->sh_size
,
6203 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6205 group_name
= sym
->st_name
< strtab_size
6206 ? strtab
+ sym
->st_name
: _("<corrupt>");
6209 /* PR 17531: file: loop. */
6210 if (section
->sh_entsize
> section
->sh_size
)
6212 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6213 printable_section_name (section
),
6214 (unsigned long) section
->sh_entsize
,
6215 (unsigned long) section
->sh_size
);
6219 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6220 1, section
->sh_size
,
6226 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6227 entry
= byte_get (indices
, 4);
6230 if (do_section_groups
)
6232 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6233 get_group_flags (entry
), i
, name
, group_name
, size
);
6235 printf (_(" [Index] Name\n"));
6238 group
->group_index
= i
;
6240 for (j
= 0; j
< size
; j
++)
6242 struct group_list
* g
;
6244 entry
= byte_get (indices
, 4);
6247 if (entry
>= elf_header
.e_shnum
)
6249 static unsigned num_group_errors
= 0;
6251 if (num_group_errors
++ < 10)
6253 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6254 entry
, i
, elf_header
.e_shnum
- 1);
6255 if (num_group_errors
== 10)
6256 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6261 if (section_headers_groups
[entry
] != NULL
)
6265 static unsigned num_errs
= 0;
6267 if (num_errs
++ < 10)
6269 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6271 section_headers_groups
[entry
]->group_index
);
6273 warn (_("Further error messages about already contained group sections suppressed\n"));
6279 /* Intel C/C++ compiler may put section 0 in a
6280 section group. We just warn it the first time
6281 and ignore it afterwards. */
6282 static int warned
= 0;
6285 error (_("section 0 in group section [%5u]\n"),
6286 section_headers_groups
[entry
]->group_index
);
6292 section_headers_groups
[entry
] = group
;
6294 if (do_section_groups
)
6296 sec
= section_headers
+ entry
;
6297 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6300 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6301 g
->section_index
= entry
;
6302 g
->next
= group
->root
;
6320 /* Data used to display dynamic fixups. */
6322 struct ia64_vms_dynfixup
6324 bfd_vma needed_ident
; /* Library ident number. */
6325 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6326 bfd_vma fixup_needed
; /* Index of the library. */
6327 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6328 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6331 /* Data used to display dynamic relocations. */
6333 struct ia64_vms_dynimgrela
6335 bfd_vma img_rela_cnt
; /* Number of relocations. */
6336 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6339 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6343 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6344 const char *strtab
, unsigned int strtab_sz
)
6346 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6348 const char *lib_name
;
6350 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6351 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6352 _("dynamic section image fixups"));
6356 if (fixup
->needed
< strtab_sz
)
6357 lib_name
= strtab
+ fixup
->needed
;
6360 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6361 (unsigned long) fixup
->needed
);
6364 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6365 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6367 (_("Seg Offset Type SymVec DataType\n"));
6369 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6374 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6375 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6376 type
= BYTE_GET (imfs
[i
].type
);
6377 rtype
= elf_ia64_reloc_type (type
);
6379 printf (" 0x%08x ", type
);
6381 printf (" %-32s ", rtype
);
6382 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6383 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6389 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6392 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6394 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6397 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6398 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6399 _("dynamic section image relocations"));
6403 printf (_("\nImage relocs\n"));
6405 (_("Seg Offset Type Addend Seg Sym Off\n"));
6407 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6412 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6413 printf ("%08" BFD_VMA_FMT
"x ",
6414 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6415 type
= BYTE_GET (imrs
[i
].type
);
6416 rtype
= elf_ia64_reloc_type (type
);
6418 printf ("0x%08x ", type
);
6420 printf ("%-31s ", rtype
);
6421 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6422 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6423 printf ("%08" BFD_VMA_FMT
"x\n",
6424 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6430 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6433 process_ia64_vms_dynamic_relocs (FILE *file
)
6435 struct ia64_vms_dynfixup fixup
;
6436 struct ia64_vms_dynimgrela imgrela
;
6437 Elf_Internal_Dyn
*entry
;
6439 bfd_vma strtab_off
= 0;
6440 bfd_vma strtab_sz
= 0;
6441 char *strtab
= NULL
;
6443 memset (&fixup
, 0, sizeof (fixup
));
6444 memset (&imgrela
, 0, sizeof (imgrela
));
6446 /* Note: the order of the entries is specified by the OpenVMS specs. */
6447 for (entry
= dynamic_section
;
6448 entry
< dynamic_section
+ dynamic_nent
;
6451 switch (entry
->d_tag
)
6453 case DT_IA_64_VMS_STRTAB_OFFSET
:
6454 strtab_off
= entry
->d_un
.d_val
;
6457 strtab_sz
= entry
->d_un
.d_val
;
6459 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6460 1, strtab_sz
, _("dynamic string section"));
6463 case DT_IA_64_VMS_NEEDED_IDENT
:
6464 fixup
.needed_ident
= entry
->d_un
.d_val
;
6467 fixup
.needed
= entry
->d_un
.d_val
;
6469 case DT_IA_64_VMS_FIXUP_NEEDED
:
6470 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6472 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6473 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6475 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6476 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6478 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6481 case DT_IA_64_VMS_IMG_RELA_CNT
:
6482 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6484 case DT_IA_64_VMS_IMG_RELA_OFF
:
6485 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6487 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6507 } dynamic_relocations
[] =
6509 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6510 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6511 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6514 /* Process the reloc section. */
6517 process_relocs (FILE * file
)
6519 unsigned long rel_size
;
6520 unsigned long rel_offset
;
6526 if (do_using_dynamic
)
6530 int has_dynamic_reloc
;
6533 has_dynamic_reloc
= 0;
6535 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6537 is_rela
= dynamic_relocations
[i
].rela
;
6538 name
= dynamic_relocations
[i
].name
;
6539 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6540 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6542 has_dynamic_reloc
|= rel_size
;
6544 if (is_rela
== UNKNOWN
)
6546 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6547 switch (dynamic_info
[DT_PLTREL
])
6561 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6562 name
, rel_offset
, rel_size
);
6564 dump_relocations (file
,
6565 offset_from_vma (file
, rel_offset
, rel_size
),
6567 dynamic_symbols
, num_dynamic_syms
,
6568 dynamic_strings
, dynamic_strings_length
,
6574 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6576 if (! has_dynamic_reloc
)
6577 printf (_("\nThere are no dynamic relocations in this file.\n"));
6581 Elf_Internal_Shdr
* section
;
6585 for (i
= 0, section
= section_headers
;
6586 i
< elf_header
.e_shnum
;
6589 if ( section
->sh_type
!= SHT_RELA
6590 && section
->sh_type
!= SHT_REL
)
6593 rel_offset
= section
->sh_offset
;
6594 rel_size
= section
->sh_size
;
6598 Elf_Internal_Shdr
* strsec
;
6601 printf (_("\nRelocation section "));
6603 if (string_table
== NULL
)
6604 printf ("%d", section
->sh_name
);
6606 printf ("'%s'", printable_section_name (section
));
6608 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6609 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6611 is_rela
= section
->sh_type
== SHT_RELA
;
6613 if (section
->sh_link
!= 0
6614 && section
->sh_link
< elf_header
.e_shnum
)
6616 Elf_Internal_Shdr
* symsec
;
6617 Elf_Internal_Sym
* symtab
;
6618 unsigned long nsyms
;
6619 unsigned long strtablen
= 0;
6620 char * strtab
= NULL
;
6622 symsec
= section_headers
+ section
->sh_link
;
6623 if (symsec
->sh_type
!= SHT_SYMTAB
6624 && symsec
->sh_type
!= SHT_DYNSYM
)
6627 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6632 if (symsec
->sh_link
!= 0
6633 && symsec
->sh_link
< elf_header
.e_shnum
)
6635 strsec
= section_headers
+ symsec
->sh_link
;
6637 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6640 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6643 dump_relocations (file
, rel_offset
, rel_size
,
6644 symtab
, nsyms
, strtab
, strtablen
,
6646 symsec
->sh_type
== SHT_DYNSYM
);
6652 dump_relocations (file
, rel_offset
, rel_size
,
6653 NULL
, 0, NULL
, 0, is_rela
, 0);
6660 printf (_("\nThere are no relocations in this file.\n"));
6666 /* An absolute address consists of a section and an offset. If the
6667 section is NULL, the offset itself is the address, otherwise, the
6668 address equals to LOAD_ADDRESS(section) + offset. */
6672 unsigned short section
;
6676 #define ABSADDR(a) \
6678 ? section_headers [(a).section].sh_addr + (a).offset \
6681 /* Find the nearest symbol at or below ADDR. Returns the symbol
6682 name, if found, and the offset from the symbol to ADDR. */
6685 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6686 unsigned long nsyms
,
6687 const char * strtab
,
6688 unsigned long strtab_size
,
6689 struct absaddr addr
,
6690 const char ** symname
,
6693 bfd_vma dist
= 0x100000;
6694 Elf_Internal_Sym
* sym
;
6695 Elf_Internal_Sym
* beg
;
6696 Elf_Internal_Sym
* end
;
6697 Elf_Internal_Sym
* best
= NULL
;
6699 REMOVE_ARCH_BITS (addr
.offset
);
6701 end
= symtab
+ nsyms
;
6707 sym
= beg
+ (end
- beg
) / 2;
6709 value
= sym
->st_value
;
6710 REMOVE_ARCH_BITS (value
);
6712 if (sym
->st_name
!= 0
6713 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6714 && addr
.offset
>= value
6715 && addr
.offset
- value
< dist
)
6718 dist
= addr
.offset
- value
;
6723 if (addr
.offset
< value
)
6731 *symname
= (best
->st_name
>= strtab_size
6732 ? _("<corrupt>") : strtab
+ best
->st_name
);
6738 *offset
= addr
.offset
;
6742 symcmp (const void *p
, const void *q
)
6744 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6745 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6747 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6750 /* Process the unwind section. */
6752 #include "unwind-ia64.h"
6754 struct ia64_unw_table_entry
6756 struct absaddr start
;
6758 struct absaddr info
;
6761 struct ia64_unw_aux_info
6763 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6764 unsigned long table_len
; /* Length of unwind table. */
6765 unsigned char * info
; /* Unwind info. */
6766 unsigned long info_size
; /* Size of unwind info. */
6767 bfd_vma info_addr
; /* Starting address of unwind info. */
6768 bfd_vma seg_base
; /* Starting address of segment. */
6769 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6770 unsigned long nsyms
; /* Number of symbols. */
6771 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6772 unsigned long nfuns
; /* Number of entries in funtab. */
6773 char * strtab
; /* The string table. */
6774 unsigned long strtab_size
; /* Size of string table. */
6778 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6780 struct ia64_unw_table_entry
* tp
;
6781 unsigned long j
, nfuns
;
6784 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6785 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6786 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6787 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6789 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6791 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6795 const unsigned char * dp
;
6796 const unsigned char * head
;
6797 const unsigned char * end
;
6798 const char * procname
;
6800 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6801 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6803 fputs ("\n<", stdout
);
6807 fputs (procname
, stdout
);
6810 printf ("+%lx", (unsigned long) offset
);
6813 fputs (">: [", stdout
);
6814 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6815 fputc ('-', stdout
);
6816 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6817 printf ("], info at +0x%lx\n",
6818 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6820 /* PR 17531: file: 86232b32. */
6821 if (aux
->info
== NULL
)
6824 /* PR 17531: file: 0997b4d1. */
6825 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6827 warn (_("Invalid offset %lx in table entry %ld\n"),
6828 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6832 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6833 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6835 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6836 (unsigned) UNW_VER (stamp
),
6837 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6838 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6839 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6840 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6842 if (UNW_VER (stamp
) != 1)
6844 printf (_("\tUnknown version.\n"));
6849 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6850 /* PR 17531: file: 16ceda89. */
6851 if (end
> aux
->info
+ aux
->info_size
)
6852 end
= aux
->info
+ aux
->info_size
;
6853 for (dp
= head
+ 8; dp
< end
;)
6854 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6861 slurp_ia64_unwind_table (FILE * file
,
6862 struct ia64_unw_aux_info
* aux
,
6863 Elf_Internal_Shdr
* sec
)
6865 unsigned long size
, nrelas
, i
;
6866 Elf_Internal_Phdr
* seg
;
6867 struct ia64_unw_table_entry
* tep
;
6868 Elf_Internal_Shdr
* relsec
;
6869 Elf_Internal_Rela
* rela
;
6870 Elf_Internal_Rela
* rp
;
6871 unsigned char * table
;
6873 Elf_Internal_Sym
* sym
;
6874 const char * relname
;
6878 /* First, find the starting address of the segment that includes
6881 if (elf_header
.e_phnum
)
6883 if (! get_program_headers (file
))
6886 for (seg
= program_headers
;
6887 seg
< program_headers
+ elf_header
.e_phnum
;
6890 if (seg
->p_type
!= PT_LOAD
)
6893 if (sec
->sh_addr
>= seg
->p_vaddr
6894 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6896 aux
->seg_base
= seg
->p_vaddr
;
6902 /* Second, build the unwind table from the contents of the unwind section: */
6903 size
= sec
->sh_size
;
6904 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6909 aux
->table_len
= size
/ (3 * eh_addr_size
);
6910 aux
->table
= (struct ia64_unw_table_entry
*)
6911 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6914 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6916 tep
->start
.section
= SHN_UNDEF
;
6917 tep
->end
.section
= SHN_UNDEF
;
6918 tep
->info
.section
= SHN_UNDEF
;
6919 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6920 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6921 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6922 tep
->start
.offset
+= aux
->seg_base
;
6923 tep
->end
.offset
+= aux
->seg_base
;
6924 tep
->info
.offset
+= aux
->seg_base
;
6928 /* Third, apply any relocations to the unwind table: */
6929 for (relsec
= section_headers
;
6930 relsec
< section_headers
+ elf_header
.e_shnum
;
6933 if (relsec
->sh_type
!= SHT_RELA
6934 || relsec
->sh_info
>= elf_header
.e_shnum
6935 || section_headers
+ relsec
->sh_info
!= sec
)
6938 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6947 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6949 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6950 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6952 /* PR 17531: file: 9fa67536. */
6953 if (relname
== NULL
)
6955 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6959 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6961 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6965 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6967 /* PR 17531: file: 5bc8d9bf. */
6968 if (i
>= aux
->table_len
)
6970 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6974 switch (rp
->r_offset
/ eh_addr_size
% 3)
6977 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6978 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6981 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6982 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6985 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6986 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7000 ia64_process_unwind (FILE * file
)
7002 Elf_Internal_Shdr
* sec
;
7003 Elf_Internal_Shdr
* unwsec
= NULL
;
7004 Elf_Internal_Shdr
* strsec
;
7005 unsigned long i
, unwcount
= 0, unwstart
= 0;
7006 struct ia64_unw_aux_info aux
;
7008 memset (& aux
, 0, sizeof (aux
));
7010 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7012 if (sec
->sh_type
== SHT_SYMTAB
7013 && sec
->sh_link
< elf_header
.e_shnum
)
7015 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7017 strsec
= section_headers
+ sec
->sh_link
;
7018 if (aux
.strtab
!= NULL
)
7020 error (_("Multiple auxillary string tables encountered\n"));
7023 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7026 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7028 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7033 printf (_("\nThere are no unwind sections in this file.\n"));
7035 while (unwcount
-- > 0)
7040 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7041 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7042 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7047 /* We have already counted the number of SHT_IA64_UNWIND
7048 sections so the loop above should never fail. */
7049 assert (unwsec
!= NULL
);
7052 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7054 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7056 /* We need to find which section group it is in. */
7057 struct group_list
* g
;
7059 if (section_headers_groups
== NULL
7060 || section_headers_groups
[i
] == NULL
)
7061 i
= elf_header
.e_shnum
;
7064 g
= section_headers_groups
[i
]->root
;
7066 for (; g
!= NULL
; g
= g
->next
)
7068 sec
= section_headers
+ g
->section_index
;
7070 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7075 i
= elf_header
.e_shnum
;
7078 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7080 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7081 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7082 suffix
= SECTION_NAME (unwsec
) + len
;
7083 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7085 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7086 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7091 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7092 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7093 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7094 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7096 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7097 suffix
= SECTION_NAME (unwsec
) + len
;
7098 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7100 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7101 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7105 if (i
== elf_header
.e_shnum
)
7107 printf (_("\nCould not find unwind info section for "));
7109 if (string_table
== NULL
)
7110 printf ("%d", unwsec
->sh_name
);
7112 printf ("'%s'", printable_section_name (unwsec
));
7116 aux
.info_addr
= sec
->sh_addr
;
7117 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7120 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7122 printf (_("\nUnwind section "));
7124 if (string_table
== NULL
)
7125 printf ("%d", unwsec
->sh_name
);
7127 printf ("'%s'", printable_section_name (unwsec
));
7129 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7130 (unsigned long) unwsec
->sh_offset
,
7131 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7133 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7134 && aux
.table_len
> 0)
7135 dump_ia64_unwind (& aux
);
7138 free ((char *) aux
.table
);
7140 free ((char *) aux
.info
);
7149 free ((char *) aux
.strtab
);
7152 struct hppa_unw_table_entry
7154 struct absaddr start
;
7156 unsigned int Cannot_unwind
:1; /* 0 */
7157 unsigned int Millicode
:1; /* 1 */
7158 unsigned int Millicode_save_sr0
:1; /* 2 */
7159 unsigned int Region_description
:2; /* 3..4 */
7160 unsigned int reserved1
:1; /* 5 */
7161 unsigned int Entry_SR
:1; /* 6 */
7162 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7163 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7164 unsigned int Args_stored
:1; /* 16 */
7165 unsigned int Variable_Frame
:1; /* 17 */
7166 unsigned int Separate_Package_Body
:1; /* 18 */
7167 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7168 unsigned int Stack_Overflow_Check
:1; /* 20 */
7169 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7170 unsigned int Ada_Region
:1; /* 22 */
7171 unsigned int cxx_info
:1; /* 23 */
7172 unsigned int cxx_try_catch
:1; /* 24 */
7173 unsigned int sched_entry_seq
:1; /* 25 */
7174 unsigned int reserved2
:1; /* 26 */
7175 unsigned int Save_SP
:1; /* 27 */
7176 unsigned int Save_RP
:1; /* 28 */
7177 unsigned int Save_MRP_in_frame
:1; /* 29 */
7178 unsigned int extn_ptr_defined
:1; /* 30 */
7179 unsigned int Cleanup_defined
:1; /* 31 */
7181 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7182 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7183 unsigned int Large_frame
:1; /* 2 */
7184 unsigned int Pseudo_SP_Set
:1; /* 3 */
7185 unsigned int reserved4
:1; /* 4 */
7186 unsigned int Total_frame_size
:27; /* 5..31 */
7189 struct hppa_unw_aux_info
7191 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7192 unsigned long table_len
; /* Length of unwind table. */
7193 bfd_vma seg_base
; /* Starting address of segment. */
7194 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7195 unsigned long nsyms
; /* Number of symbols. */
7196 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7197 unsigned long nfuns
; /* Number of entries in funtab. */
7198 char * strtab
; /* The string table. */
7199 unsigned long strtab_size
; /* Size of string table. */
7203 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7205 struct hppa_unw_table_entry
* tp
;
7206 unsigned long j
, nfuns
;
7208 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7209 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7210 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7211 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7213 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7215 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7218 const char * procname
;
7220 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7221 aux
->strtab_size
, tp
->start
, &procname
,
7224 fputs ("\n<", stdout
);
7228 fputs (procname
, stdout
);
7231 printf ("+%lx", (unsigned long) offset
);
7234 fputs (">: [", stdout
);
7235 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7236 fputc ('-', stdout
);
7237 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7240 #define PF(_m) if (tp->_m) printf (#_m " ");
7241 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7244 PF(Millicode_save_sr0
);
7245 /* PV(Region_description); */
7251 PF(Separate_Package_Body
);
7252 PF(Frame_Extension_Millicode
);
7253 PF(Stack_Overflow_Check
);
7254 PF(Two_Instruction_SP_Increment
);
7258 PF(sched_entry_seq
);
7261 PF(Save_MRP_in_frame
);
7262 PF(extn_ptr_defined
);
7263 PF(Cleanup_defined
);
7264 PF(MPE_XL_interrupt_marker
);
7265 PF(HP_UX_interrupt_marker
);
7268 PV(Total_frame_size
);
7279 slurp_hppa_unwind_table (FILE * file
,
7280 struct hppa_unw_aux_info
* aux
,
7281 Elf_Internal_Shdr
* sec
)
7283 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7284 Elf_Internal_Phdr
* seg
;
7285 struct hppa_unw_table_entry
* tep
;
7286 Elf_Internal_Shdr
* relsec
;
7287 Elf_Internal_Rela
* rela
;
7288 Elf_Internal_Rela
* rp
;
7289 unsigned char * table
;
7291 Elf_Internal_Sym
* sym
;
7292 const char * relname
;
7294 /* First, find the starting address of the segment that includes
7297 if (elf_header
.e_phnum
)
7299 if (! get_program_headers (file
))
7302 for (seg
= program_headers
;
7303 seg
< program_headers
+ elf_header
.e_phnum
;
7306 if (seg
->p_type
!= PT_LOAD
)
7309 if (sec
->sh_addr
>= seg
->p_vaddr
7310 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7312 aux
->seg_base
= seg
->p_vaddr
;
7318 /* Second, build the unwind table from the contents of the unwind
7320 size
= sec
->sh_size
;
7321 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7327 nentries
= size
/ unw_ent_size
;
7328 size
= unw_ent_size
* nentries
;
7330 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7331 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7333 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7335 unsigned int tmp1
, tmp2
;
7337 tep
->start
.section
= SHN_UNDEF
;
7338 tep
->end
.section
= SHN_UNDEF
;
7340 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7341 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7342 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7343 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7345 tep
->start
.offset
+= aux
->seg_base
;
7346 tep
->end
.offset
+= aux
->seg_base
;
7348 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7349 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7350 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7351 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7352 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7353 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7354 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7355 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7356 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7357 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7358 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7359 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7360 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7361 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7362 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7363 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7364 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7365 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7366 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7367 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7368 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7369 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7370 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7371 tep
->Cleanup_defined
= tmp1
& 0x1;
7373 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7374 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7375 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7376 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7377 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7378 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7382 /* Third, apply any relocations to the unwind table. */
7383 for (relsec
= section_headers
;
7384 relsec
< section_headers
+ elf_header
.e_shnum
;
7387 if (relsec
->sh_type
!= SHT_RELA
7388 || relsec
->sh_info
>= elf_header
.e_shnum
7389 || section_headers
+ relsec
->sh_info
!= sec
)
7392 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7396 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7398 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7399 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7401 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7402 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7404 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7408 i
= rp
->r_offset
/ unw_ent_size
;
7410 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7413 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7414 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7417 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7418 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7428 aux
->table_len
= nentries
;
7434 hppa_process_unwind (FILE * file
)
7436 struct hppa_unw_aux_info aux
;
7437 Elf_Internal_Shdr
* unwsec
= NULL
;
7438 Elf_Internal_Shdr
* strsec
;
7439 Elf_Internal_Shdr
* sec
;
7442 if (string_table
== NULL
)
7445 memset (& aux
, 0, sizeof (aux
));
7447 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7449 if (sec
->sh_type
== SHT_SYMTAB
7450 && sec
->sh_link
< elf_header
.e_shnum
)
7452 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7454 strsec
= section_headers
+ sec
->sh_link
;
7455 if (aux
.strtab
!= NULL
)
7457 error (_("Multiple auxillary string tables encountered\n"));
7460 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7463 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7465 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7470 printf (_("\nThere are no unwind sections in this file.\n"));
7472 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7474 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7476 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7477 printable_section_name (sec
),
7478 (unsigned long) sec
->sh_offset
,
7479 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7481 slurp_hppa_unwind_table (file
, &aux
, sec
);
7482 if (aux
.table_len
> 0)
7483 dump_hppa_unwind (&aux
);
7486 free ((char *) aux
.table
);
7494 free ((char *) aux
.strtab
);
7499 unsigned char * data
; /* The unwind data. */
7500 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7501 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7502 unsigned long nrelas
; /* The number of relocations. */
7503 unsigned int rel_type
; /* REL or RELA ? */
7504 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7507 struct arm_unw_aux_info
7509 FILE * file
; /* The file containing the unwind sections. */
7510 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7511 unsigned long nsyms
; /* Number of symbols. */
7512 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7513 unsigned long nfuns
; /* Number of these symbols. */
7514 char * strtab
; /* The file's string table. */
7515 unsigned long strtab_size
; /* Size of string table. */
7519 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7520 bfd_vma fn
, struct absaddr addr
)
7522 const char *procname
;
7525 if (addr
.section
== SHN_UNDEF
)
7528 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7529 aux
->strtab_size
, addr
, &procname
,
7532 print_vma (fn
, PREFIX_HEX
);
7536 fputs (" <", stdout
);
7537 fputs (procname
, stdout
);
7540 printf ("+0x%lx", (unsigned long) sym_offset
);
7541 fputc ('>', stdout
);
7548 arm_free_section (struct arm_section
*arm_sec
)
7550 if (arm_sec
->data
!= NULL
)
7551 free (arm_sec
->data
);
7553 if (arm_sec
->rela
!= NULL
)
7554 free (arm_sec
->rela
);
7557 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7558 cached section and install SEC instead.
7559 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7560 and return its valued in * WORDP, relocating if necessary.
7561 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7562 relocation's offset in ADDR.
7563 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7564 into the string table of the symbol associated with the reloc. If no
7565 reloc was applied store -1 there.
7566 5) Return TRUE upon success, FALSE otherwise. */
7569 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7570 struct arm_section
* arm_sec
,
7571 Elf_Internal_Shdr
* sec
,
7572 bfd_vma word_offset
,
7573 unsigned int * wordp
,
7574 struct absaddr
* addr
,
7577 Elf_Internal_Rela
*rp
;
7578 Elf_Internal_Sym
*sym
;
7579 const char * relname
;
7581 bfd_boolean wrapped
;
7583 if (sec
== NULL
|| arm_sec
== NULL
)
7586 addr
->section
= SHN_UNDEF
;
7589 if (sym_name
!= NULL
)
7590 *sym_name
= (bfd_vma
) -1;
7592 /* If necessary, update the section cache. */
7593 if (sec
!= arm_sec
->sec
)
7595 Elf_Internal_Shdr
*relsec
;
7597 arm_free_section (arm_sec
);
7600 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7601 sec
->sh_size
, _("unwind data"));
7602 arm_sec
->rela
= NULL
;
7603 arm_sec
->nrelas
= 0;
7605 for (relsec
= section_headers
;
7606 relsec
< section_headers
+ elf_header
.e_shnum
;
7609 if (relsec
->sh_info
>= elf_header
.e_shnum
7610 || section_headers
+ relsec
->sh_info
!= sec
7611 /* PR 15745: Check the section type as well. */
7612 || (relsec
->sh_type
!= SHT_REL
7613 && relsec
->sh_type
!= SHT_RELA
))
7616 arm_sec
->rel_type
= relsec
->sh_type
;
7617 if (relsec
->sh_type
== SHT_REL
)
7619 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7621 & arm_sec
->rela
, & arm_sec
->nrelas
))
7624 else /* relsec->sh_type == SHT_RELA */
7626 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7628 & arm_sec
->rela
, & arm_sec
->nrelas
))
7634 arm_sec
->next_rela
= arm_sec
->rela
;
7637 /* If there is no unwind data we can do nothing. */
7638 if (arm_sec
->data
== NULL
)
7641 /* If the offset is invalid then fail. */
7642 if (word_offset
> (sec
->sh_size
- 4)
7644 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7645 || ((bfd_signed_vma
) word_offset
) < 0)
7648 /* Get the word at the required offset. */
7649 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7651 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7652 if (arm_sec
->rela
== NULL
)
7658 /* Look through the relocs to find the one that applies to the provided offset. */
7660 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7662 bfd_vma prelval
, offset
;
7664 if (rp
->r_offset
> word_offset
&& !wrapped
)
7669 if (rp
->r_offset
> word_offset
)
7672 if (rp
->r_offset
& 3)
7674 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7675 (unsigned long) rp
->r_offset
);
7679 if (rp
->r_offset
< word_offset
)
7682 /* PR 17531: file: 027-161405-0.004 */
7683 if (aux
->symtab
== NULL
)
7686 if (arm_sec
->rel_type
== SHT_REL
)
7688 offset
= word
& 0x7fffffff;
7689 if (offset
& 0x40000000)
7690 offset
|= ~ (bfd_vma
) 0x7fffffff;
7692 else if (arm_sec
->rel_type
== SHT_RELA
)
7693 offset
= rp
->r_addend
;
7696 error (_("Unknown section relocation type %d encountered\n"),
7701 /* PR 17531 file: 027-1241568-0.004. */
7702 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7704 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7705 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7709 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7710 offset
+= sym
->st_value
;
7711 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7713 /* Check that we are processing the expected reloc type. */
7714 if (elf_header
.e_machine
== EM_ARM
)
7716 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7717 if (relname
== NULL
)
7719 warn (_("Skipping unknown ARM relocation type: %d\n"),
7720 (int) ELF32_R_TYPE (rp
->r_info
));
7724 if (streq (relname
, "R_ARM_NONE"))
7727 if (! streq (relname
, "R_ARM_PREL31"))
7729 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7733 else if (elf_header
.e_machine
== EM_TI_C6000
)
7735 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7736 if (relname
== NULL
)
7738 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7739 (int) ELF32_R_TYPE (rp
->r_info
));
7743 if (streq (relname
, "R_C6000_NONE"))
7746 if (! streq (relname
, "R_C6000_PREL31"))
7748 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7756 /* This function currently only supports ARM and TI unwinders. */
7757 warn (_("Only TI and ARM unwinders are currently supported\n"));
7761 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7762 addr
->section
= sym
->st_shndx
;
7763 addr
->offset
= offset
;
7766 * sym_name
= sym
->st_name
;
7771 arm_sec
->next_rela
= rp
;
7776 static const char *tic6x_unwind_regnames
[16] =
7778 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7779 "A14", "A13", "A12", "A11", "A10",
7780 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7784 decode_tic6x_unwind_regmask (unsigned int mask
)
7788 for (i
= 12; mask
; mask
>>= 1, i
--)
7792 fputs (tic6x_unwind_regnames
[i
], stdout
);
7794 fputs (", ", stdout
);
7800 if (remaining == 0 && more_words) \
7803 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7804 data_offset, & word, & addr, NULL)) \
7810 #define GET_OP(OP) \
7815 (OP) = word >> 24; \
7820 printf (_("[Truncated opcode]\n")); \
7823 printf ("0x%02x ", OP)
7826 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7828 unsigned int remaining
,
7829 unsigned int more_words
,
7830 bfd_vma data_offset
,
7831 Elf_Internal_Shdr
* data_sec
,
7832 struct arm_section
* data_arm_sec
)
7834 struct absaddr addr
;
7836 /* Decode the unwinding instructions. */
7839 unsigned int op
, op2
;
7848 printf (" 0x%02x ", op
);
7850 if ((op
& 0xc0) == 0x00)
7852 int offset
= ((op
& 0x3f) << 2) + 4;
7854 printf (" vsp = vsp + %d", offset
);
7856 else if ((op
& 0xc0) == 0x40)
7858 int offset
= ((op
& 0x3f) << 2) + 4;
7860 printf (" vsp = vsp - %d", offset
);
7862 else if ((op
& 0xf0) == 0x80)
7865 if (op
== 0x80 && op2
== 0)
7866 printf (_("Refuse to unwind"));
7869 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7874 for (i
= 0; i
< 12; i
++)
7875 if (mask
& (1 << i
))
7881 printf ("r%d", 4 + i
);
7886 else if ((op
& 0xf0) == 0x90)
7888 if (op
== 0x9d || op
== 0x9f)
7889 printf (_(" [Reserved]"));
7891 printf (" vsp = r%d", op
& 0x0f);
7893 else if ((op
& 0xf0) == 0xa0)
7895 int end
= 4 + (op
& 0x07);
7900 for (i
= 4; i
<= end
; i
++)
7916 else if (op
== 0xb0)
7917 printf (_(" finish"));
7918 else if (op
== 0xb1)
7921 if (op2
== 0 || (op2
& 0xf0) != 0)
7922 printf (_("[Spare]"));
7925 unsigned int mask
= op2
& 0x0f;
7930 for (i
= 0; i
< 12; i
++)
7931 if (mask
& (1 << i
))
7942 else if (op
== 0xb2)
7944 unsigned char buf
[9];
7945 unsigned int i
, len
;
7946 unsigned long offset
;
7948 for (i
= 0; i
< sizeof (buf
); i
++)
7951 if ((buf
[i
] & 0x80) == 0)
7954 if (i
== sizeof (buf
))
7955 printf (_("corrupt change to vsp"));
7958 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7959 assert (len
== i
+ 1);
7960 offset
= offset
* 4 + 0x204;
7961 printf ("vsp = vsp + %ld", offset
);
7964 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7966 unsigned int first
, last
;
7973 printf ("pop {D%d", first
);
7975 printf ("-D%d", first
+ last
);
7978 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7980 unsigned int count
= op
& 0x07;
7984 printf ("-D%d", 8 + count
);
7987 else if (op
>= 0xc0 && op
<= 0xc5)
7989 unsigned int count
= op
& 0x07;
7991 printf (" pop {wR10");
7993 printf ("-wR%d", 10 + count
);
7996 else if (op
== 0xc6)
7998 unsigned int first
, last
;
8003 printf ("pop {wR%d", first
);
8005 printf ("-wR%d", first
+ last
);
8008 else if (op
== 0xc7)
8011 if (op2
== 0 || (op2
& 0xf0) != 0)
8012 printf (_("[Spare]"));
8015 unsigned int mask
= op2
& 0x0f;
8020 for (i
= 0; i
< 4; i
++)
8021 if (mask
& (1 << i
))
8027 printf ("wCGR%d", i
);
8033 printf (_(" [unsupported opcode]"));
8039 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8041 unsigned int remaining
,
8042 unsigned int more_words
,
8043 bfd_vma data_offset
,
8044 Elf_Internal_Shdr
* data_sec
,
8045 struct arm_section
* data_arm_sec
)
8047 struct absaddr addr
;
8049 /* Decode the unwinding instructions. */
8052 unsigned int op
, op2
;
8061 printf (" 0x%02x ", op
);
8063 if ((op
& 0xc0) == 0x00)
8065 int offset
= ((op
& 0x3f) << 3) + 8;
8066 printf (" sp = sp + %d", offset
);
8068 else if ((op
& 0xc0) == 0x80)
8071 if (op
== 0x80 && op2
== 0)
8072 printf (_("Refuse to unwind"));
8075 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8077 printf ("pop compact {");
8081 decode_tic6x_unwind_regmask (mask
);
8085 else if ((op
& 0xf0) == 0xc0)
8093 unsigned int offset
;
8097 /* Scan entire instruction first so that GET_OP output is not
8098 interleaved with disassembly. */
8100 for (i
= 0; nregs
< (op
& 0xf); i
++)
8106 regpos
[nregs
].offset
= i
* 2;
8107 regpos
[nregs
].reg
= reg
;
8114 regpos
[nregs
].offset
= i
* 2 + 1;
8115 regpos
[nregs
].reg
= reg
;
8120 printf (_("pop frame {"));
8122 for (i
= i
* 2; i
> 0; i
--)
8124 if (regpos
[reg
].offset
== i
- 1)
8126 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8133 fputs (name
, stdout
);
8140 else if (op
== 0xd0)
8141 printf (" MOV FP, SP");
8142 else if (op
== 0xd1)
8143 printf (" __c6xabi_pop_rts");
8144 else if (op
== 0xd2)
8146 unsigned char buf
[9];
8147 unsigned int i
, len
;
8148 unsigned long offset
;
8150 for (i
= 0; i
< sizeof (buf
); i
++)
8153 if ((buf
[i
] & 0x80) == 0)
8156 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8157 if (i
== sizeof (buf
))
8159 printf ("<corrupt sp adjust>\n");
8160 warn (_("Corrupt stack pointer adjustment detected\n"));
8164 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8165 assert (len
== i
+ 1);
8166 offset
= offset
* 8 + 0x408;
8167 printf (_("sp = sp + %ld"), offset
);
8169 else if ((op
& 0xf0) == 0xe0)
8171 if ((op
& 0x0f) == 7)
8174 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8178 printf (_(" [unsupported opcode]"));
8185 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8189 offset
= word
& 0x7fffffff;
8190 if (offset
& 0x40000000)
8191 offset
|= ~ (bfd_vma
) 0x7fffffff;
8193 if (elf_header
.e_machine
== EM_TI_C6000
)
8196 return offset
+ where
;
8200 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8202 unsigned int remaining
,
8203 bfd_vma data_offset
,
8204 Elf_Internal_Shdr
* data_sec
,
8205 struct arm_section
* data_arm_sec
)
8208 unsigned int more_words
= 0;
8209 struct absaddr addr
;
8210 bfd_vma sym_name
= (bfd_vma
) -1;
8214 /* Fetch the first word.
8215 Note - when decoding an object file the address extracted
8216 here will always be 0. So we also pass in the sym_name
8217 parameter so that we can find the symbol associated with
8218 the personality routine. */
8219 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8220 & word
, & addr
, & sym_name
))
8226 if ((word
& 0x80000000) == 0)
8228 /* Expand prel31 for personality routine. */
8230 const char *procname
;
8232 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8233 printf (_(" Personality routine: "));
8235 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8236 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8238 procname
= aux
->strtab
+ sym_name
;
8239 print_vma (fn
, PREFIX_HEX
);
8242 fputs (" <", stdout
);
8243 fputs (procname
, stdout
);
8244 fputc ('>', stdout
);
8248 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8249 fputc ('\n', stdout
);
8251 /* The GCC personality routines use the standard compact
8252 encoding, starting with one byte giving the number of
8254 if (procname
!= NULL
8255 && (const_strneq (procname
, "__gcc_personality_v0")
8256 || const_strneq (procname
, "__gxx_personality_v0")
8257 || const_strneq (procname
, "__gcj_personality_v0")
8258 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8265 printf (_(" [Truncated data]\n"));
8268 more_words
= word
>> 24;
8278 /* ARM EHABI Section 6.3:
8280 An exception-handling table entry for the compact model looks like:
8284 1 0 index Data for personalityRoutine[index] */
8286 if (elf_header
.e_machine
== EM_ARM
8287 && (word
& 0x70000000))
8288 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8290 per_index
= (word
>> 24) & 0x7f;
8291 printf (_(" Compact model index: %d\n"), per_index
);
8298 else if (per_index
< 3)
8300 more_words
= (word
>> 16) & 0xff;
8306 switch (elf_header
.e_machine
)
8311 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8312 data_offset
, data_sec
, data_arm_sec
);
8316 warn (_("Unknown ARM compact model index encountered\n"));
8317 printf (_(" [reserved]\n"));
8324 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8325 data_offset
, data_sec
, data_arm_sec
);
8327 else if (per_index
< 5)
8329 if (((word
>> 17) & 0x7f) == 0x7f)
8330 printf (_(" Restore stack from frame pointer\n"));
8332 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8333 printf (_(" Registers restored: "));
8335 printf (" (compact) ");
8336 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8338 printf (_(" Return register: %s\n"),
8339 tic6x_unwind_regnames
[word
& 0xf]);
8342 printf (_(" [reserved (%d)]\n"), per_index
);
8346 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8347 elf_header
.e_machine
);
8350 /* Decode the descriptors. Not implemented. */
8354 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8356 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8357 unsigned int i
, exidx_len
;
8358 unsigned long j
, nfuns
;
8360 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8361 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8362 exidx_len
= exidx_sec
->sh_size
/ 8;
8364 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8365 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8366 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8367 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8369 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8371 for (i
= 0; i
< exidx_len
; i
++)
8373 unsigned int exidx_fn
, exidx_entry
;
8374 struct absaddr fn_addr
, entry_addr
;
8377 fputc ('\n', stdout
);
8379 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8380 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8381 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8382 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8385 arm_free_section (& exidx_arm_sec
);
8386 arm_free_section (& extab_arm_sec
);
8390 /* ARM EHABI, Section 5:
8391 An index table entry consists of 2 words.
8392 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8393 if (exidx_fn
& 0x80000000)
8394 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8396 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8398 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8399 fputs (": ", stdout
);
8401 if (exidx_entry
== 1)
8403 print_vma (exidx_entry
, PREFIX_HEX
);
8404 fputs (" [cantunwind]\n", stdout
);
8406 else if (exidx_entry
& 0x80000000)
8408 print_vma (exidx_entry
, PREFIX_HEX
);
8409 fputc ('\n', stdout
);
8410 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8414 bfd_vma table
, table_offset
= 0;
8415 Elf_Internal_Shdr
*table_sec
;
8417 fputs ("@", stdout
);
8418 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8419 print_vma (table
, PREFIX_HEX
);
8422 /* Locate the matching .ARM.extab. */
8423 if (entry_addr
.section
!= SHN_UNDEF
8424 && entry_addr
.section
< elf_header
.e_shnum
)
8426 table_sec
= section_headers
+ entry_addr
.section
;
8427 table_offset
= entry_addr
.offset
;
8429 if (table_offset
> table_sec
->sh_size
8430 || ((bfd_signed_vma
) table_offset
) < 0)
8432 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8433 (unsigned long) table_offset
,
8434 printable_section_name (table_sec
));
8440 table_sec
= find_section_by_address (table
);
8441 if (table_sec
!= NULL
)
8442 table_offset
= table
- table_sec
->sh_addr
;
8444 if (table_sec
== NULL
)
8446 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8447 (unsigned long) table
);
8450 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8458 arm_free_section (&exidx_arm_sec
);
8459 arm_free_section (&extab_arm_sec
);
8462 /* Used for both ARM and C6X unwinding tables. */
8465 arm_process_unwind (FILE *file
)
8467 struct arm_unw_aux_info aux
;
8468 Elf_Internal_Shdr
*unwsec
= NULL
;
8469 Elf_Internal_Shdr
*strsec
;
8470 Elf_Internal_Shdr
*sec
;
8472 unsigned int sec_type
;
8474 switch (elf_header
.e_machine
)
8477 sec_type
= SHT_ARM_EXIDX
;
8481 sec_type
= SHT_C6000_UNWIND
;
8485 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8486 elf_header
.e_machine
);
8490 if (string_table
== NULL
)
8493 memset (& aux
, 0, sizeof (aux
));
8496 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8498 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8500 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8502 strsec
= section_headers
+ sec
->sh_link
;
8504 /* PR binutils/17531 file: 011-12666-0.004. */
8505 if (aux
.strtab
!= NULL
)
8507 error (_("Multiple string tables found in file.\n"));
8510 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8511 1, strsec
->sh_size
, _("string table"));
8512 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8514 else if (sec
->sh_type
== sec_type
)
8519 printf (_("\nThere are no unwind sections in this file.\n"));
8521 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8523 if (sec
->sh_type
== sec_type
)
8525 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8526 printable_section_name (sec
),
8527 (unsigned long) sec
->sh_offset
,
8528 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8530 dump_arm_unwind (&aux
, sec
);
8537 free ((char *) aux
.strtab
);
8541 process_unwind (FILE * file
)
8543 struct unwind_handler
8546 void (* handler
)(FILE *);
8549 { EM_ARM
, arm_process_unwind
},
8550 { EM_IA_64
, ia64_process_unwind
},
8551 { EM_PARISC
, hppa_process_unwind
},
8552 { EM_TI_C6000
, arm_process_unwind
},
8560 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8561 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8563 handlers
[i
].handler (file
);
8567 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8568 get_machine_name (elf_header
.e_machine
));
8572 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8574 switch (entry
->d_tag
)
8577 if (entry
->d_un
.d_val
== 0)
8581 static const char * opts
[] =
8583 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8584 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8585 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8586 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8592 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8593 if (entry
->d_un
.d_val
& (1 << cnt
))
8595 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8601 case DT_MIPS_IVERSION
:
8602 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8603 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8607 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8608 /* Note: coded this way so that there is a single string for translation. */
8609 printf (_("<corrupt: %s>"), buf
);
8613 case DT_MIPS_TIME_STAMP
:
8617 time_t atime
= entry
->d_un
.d_val
;
8619 tmp
= gmtime (&atime
);
8620 /* PR 17531: file: 6accc532. */
8622 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8624 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8625 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8626 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8627 printf (_("Time Stamp: %s"), timebuf
);
8631 case DT_MIPS_RLD_VERSION
:
8632 case DT_MIPS_LOCAL_GOTNO
:
8633 case DT_MIPS_CONFLICTNO
:
8634 case DT_MIPS_LIBLISTNO
:
8635 case DT_MIPS_SYMTABNO
:
8636 case DT_MIPS_UNREFEXTNO
:
8637 case DT_MIPS_HIPAGENO
:
8638 case DT_MIPS_DELTA_CLASS_NO
:
8639 case DT_MIPS_DELTA_INSTANCE_NO
:
8640 case DT_MIPS_DELTA_RELOC_NO
:
8641 case DT_MIPS_DELTA_SYM_NO
:
8642 case DT_MIPS_DELTA_CLASSSYM_NO
:
8643 case DT_MIPS_COMPACT_SIZE
:
8644 print_vma (entry
->d_un
.d_ptr
, DEC
);
8648 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8654 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8656 switch (entry
->d_tag
)
8658 case DT_HP_DLD_FLAGS
:
8667 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8668 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8669 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8670 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8671 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8672 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8673 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8674 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8675 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8676 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8677 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8678 { DT_HP_GST
, "HP_GST" },
8679 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8680 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8681 { DT_HP_NODELETE
, "HP_NODELETE" },
8682 { DT_HP_GROUP
, "HP_GROUP" },
8683 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8687 bfd_vma val
= entry
->d_un
.d_val
;
8689 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8690 if (val
& flags
[cnt
].bit
)
8694 fputs (flags
[cnt
].str
, stdout
);
8696 val
^= flags
[cnt
].bit
;
8699 if (val
!= 0 || first
)
8703 print_vma (val
, HEX
);
8709 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8717 /* VMS vs Unix time offset and factor. */
8719 #define VMS_EPOCH_OFFSET 35067168000000000LL
8720 #define VMS_GRANULARITY_FACTOR 10000000
8722 /* Display a VMS time in a human readable format. */
8725 print_vms_time (bfd_int64_t vmstime
)
8730 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8731 tm
= gmtime (&unxtime
);
8732 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8733 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8734 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8739 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8741 switch (entry
->d_tag
)
8743 case DT_IA_64_PLT_RESERVE
:
8744 /* First 3 slots reserved. */
8745 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8747 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8750 case DT_IA_64_VMS_LINKTIME
:
8752 print_vms_time (entry
->d_un
.d_val
);
8756 case DT_IA_64_VMS_LNKFLAGS
:
8757 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8758 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8759 printf (" CALL_DEBUG");
8760 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8761 printf (" NOP0BUFS");
8762 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8763 printf (" P0IMAGE");
8764 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8765 printf (" MKTHREADS");
8766 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8767 printf (" UPCALLS");
8768 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8770 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8771 printf (" INITIALIZE");
8772 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8774 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8775 printf (" EXE_INIT");
8776 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8777 printf (" TBK_IN_IMG");
8778 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8779 printf (" DBG_IN_IMG");
8780 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8781 printf (" TBK_IN_DSF");
8782 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8783 printf (" DBG_IN_DSF");
8784 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8785 printf (" SIGNATURES");
8786 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8787 printf (" REL_SEG_OFF");
8791 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8798 get_32bit_dynamic_section (FILE * file
)
8800 Elf32_External_Dyn
* edyn
;
8801 Elf32_External_Dyn
* ext
;
8802 Elf_Internal_Dyn
* entry
;
8804 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8805 dynamic_size
, _("dynamic section"));
8809 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8810 might not have the luxury of section headers. Look for the DT_NULL
8811 terminator to determine the number of entries. */
8812 for (ext
= edyn
, dynamic_nent
= 0;
8813 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8817 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8821 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8823 if (dynamic_section
== NULL
)
8825 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8826 (unsigned long) dynamic_nent
);
8831 for (ext
= edyn
, entry
= dynamic_section
;
8832 entry
< dynamic_section
+ dynamic_nent
;
8835 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8836 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8845 get_64bit_dynamic_section (FILE * file
)
8847 Elf64_External_Dyn
* edyn
;
8848 Elf64_External_Dyn
* ext
;
8849 Elf_Internal_Dyn
* entry
;
8851 /* Read in the data. */
8852 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8853 dynamic_size
, _("dynamic section"));
8857 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8858 might not have the luxury of section headers. Look for the DT_NULL
8859 terminator to determine the number of entries. */
8860 for (ext
= edyn
, dynamic_nent
= 0;
8861 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8862 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8866 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8870 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8872 if (dynamic_section
== NULL
)
8874 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8875 (unsigned long) dynamic_nent
);
8880 /* Convert from external to internal formats. */
8881 for (ext
= edyn
, entry
= dynamic_section
;
8882 entry
< dynamic_section
+ dynamic_nent
;
8885 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8886 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8895 print_dynamic_flags (bfd_vma flags
)
8903 flag
= flags
& - flags
;
8913 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8914 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8915 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8916 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8917 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8918 default: fputs (_("unknown"), stdout
); break;
8924 /* Parse and display the contents of the dynamic section. */
8927 process_dynamic_section (FILE * file
)
8929 Elf_Internal_Dyn
* entry
;
8931 if (dynamic_size
== 0)
8934 printf (_("\nThere is no dynamic section in this file.\n"));
8941 if (! get_32bit_dynamic_section (file
))
8944 else if (! get_64bit_dynamic_section (file
))
8947 /* Find the appropriate symbol table. */
8948 if (dynamic_symbols
== NULL
)
8950 for (entry
= dynamic_section
;
8951 entry
< dynamic_section
+ dynamic_nent
;
8954 Elf_Internal_Shdr section
;
8956 if (entry
->d_tag
!= DT_SYMTAB
)
8959 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8961 /* Since we do not know how big the symbol table is,
8962 we default to reading in the entire file (!) and
8963 processing that. This is overkill, I know, but it
8965 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8967 if (archive_file_offset
!= 0)
8968 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8971 if (fseek (file
, 0, SEEK_END
))
8972 error (_("Unable to seek to end of file!\n"));
8974 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8978 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8980 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8981 section
.sh_name
= string_table_length
;
8983 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8984 if (num_dynamic_syms
< 1)
8986 error (_("Unable to determine the number of symbols to load\n"));
8992 /* Similarly find a string table. */
8993 if (dynamic_strings
== NULL
)
8995 for (entry
= dynamic_section
;
8996 entry
< dynamic_section
+ dynamic_nent
;
8999 unsigned long offset
;
9002 if (entry
->d_tag
!= DT_STRTAB
)
9005 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9007 /* Since we do not know how big the string table is,
9008 we default to reading in the entire file (!) and
9009 processing that. This is overkill, I know, but it
9012 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9014 if (archive_file_offset
!= 0)
9015 str_tab_len
= archive_file_size
- offset
;
9018 if (fseek (file
, 0, SEEK_END
))
9019 error (_("Unable to seek to end of file\n"));
9020 str_tab_len
= ftell (file
) - offset
;
9023 if (str_tab_len
< 1)
9026 (_("Unable to determine the length of the dynamic string table\n"));
9030 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9032 _("dynamic string table"));
9033 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9038 /* And find the syminfo section if available. */
9039 if (dynamic_syminfo
== NULL
)
9041 unsigned long syminsz
= 0;
9043 for (entry
= dynamic_section
;
9044 entry
< dynamic_section
+ dynamic_nent
;
9047 if (entry
->d_tag
== DT_SYMINENT
)
9049 /* Note: these braces are necessary to avoid a syntax
9050 error from the SunOS4 C compiler. */
9051 /* PR binutils/17531: A corrupt file can trigger this test.
9052 So do not use an assert, instead generate an error message. */
9053 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9054 error (_("Bad value (%d) for SYMINENT entry\n"),
9055 (int) entry
->d_un
.d_val
);
9057 else if (entry
->d_tag
== DT_SYMINSZ
)
9058 syminsz
= entry
->d_un
.d_val
;
9059 else if (entry
->d_tag
== DT_SYMINFO
)
9060 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9064 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9066 Elf_External_Syminfo
* extsyminfo
;
9067 Elf_External_Syminfo
* extsym
;
9068 Elf_Internal_Syminfo
* syminfo
;
9070 /* There is a syminfo section. Read the data. */
9071 extsyminfo
= (Elf_External_Syminfo
*)
9072 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9073 _("symbol information"));
9077 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9078 if (dynamic_syminfo
== NULL
)
9080 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9081 (unsigned long) syminsz
);
9085 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9086 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9087 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9088 ++syminfo
, ++extsym
)
9090 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9091 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9098 if (do_dynamic
&& dynamic_addr
)
9099 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9100 dynamic_addr
, (unsigned long) dynamic_nent
);
9102 printf (_(" Tag Type Name/Value\n"));
9104 for (entry
= dynamic_section
;
9105 entry
< dynamic_section
+ dynamic_nent
;
9113 print_vma (entry
->d_tag
, FULL_HEX
);
9114 dtype
= get_dynamic_type (entry
->d_tag
);
9115 printf (" (%s)%*s", dtype
,
9116 ((is_32bit_elf
? 27 : 19)
9117 - (int) strlen (dtype
)),
9121 switch (entry
->d_tag
)
9125 print_dynamic_flags (entry
->d_un
.d_val
);
9135 switch (entry
->d_tag
)
9138 printf (_("Auxiliary library"));
9142 printf (_("Filter library"));
9146 printf (_("Configuration file"));
9150 printf (_("Dependency audit library"));
9154 printf (_("Audit library"));
9158 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9159 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9163 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9172 printf (_("Flags:"));
9174 if (entry
->d_un
.d_val
== 0)
9175 printf (_(" None\n"));
9178 unsigned long int val
= entry
->d_un
.d_val
;
9180 if (val
& DTF_1_PARINIT
)
9182 printf (" PARINIT");
9183 val
^= DTF_1_PARINIT
;
9185 if (val
& DTF_1_CONFEXP
)
9187 printf (" CONFEXP");
9188 val
^= DTF_1_CONFEXP
;
9191 printf (" %lx", val
);
9200 printf (_("Flags:"));
9202 if (entry
->d_un
.d_val
== 0)
9203 printf (_(" None\n"));
9206 unsigned long int val
= entry
->d_un
.d_val
;
9208 if (val
& DF_P1_LAZYLOAD
)
9210 printf (" LAZYLOAD");
9211 val
^= DF_P1_LAZYLOAD
;
9213 if (val
& DF_P1_GROUPPERM
)
9215 printf (" GROUPPERM");
9216 val
^= DF_P1_GROUPPERM
;
9219 printf (" %lx", val
);
9228 printf (_("Flags:"));
9229 if (entry
->d_un
.d_val
== 0)
9230 printf (_(" None\n"));
9233 unsigned long int val
= entry
->d_un
.d_val
;
9240 if (val
& DF_1_GLOBAL
)
9245 if (val
& DF_1_GROUP
)
9250 if (val
& DF_1_NODELETE
)
9252 printf (" NODELETE");
9253 val
^= DF_1_NODELETE
;
9255 if (val
& DF_1_LOADFLTR
)
9257 printf (" LOADFLTR");
9258 val
^= DF_1_LOADFLTR
;
9260 if (val
& DF_1_INITFIRST
)
9262 printf (" INITFIRST");
9263 val
^= DF_1_INITFIRST
;
9265 if (val
& DF_1_NOOPEN
)
9270 if (val
& DF_1_ORIGIN
)
9275 if (val
& DF_1_DIRECT
)
9280 if (val
& DF_1_TRANS
)
9285 if (val
& DF_1_INTERPOSE
)
9287 printf (" INTERPOSE");
9288 val
^= DF_1_INTERPOSE
;
9290 if (val
& DF_1_NODEFLIB
)
9292 printf (" NODEFLIB");
9293 val
^= DF_1_NODEFLIB
;
9295 if (val
& DF_1_NODUMP
)
9300 if (val
& DF_1_CONFALT
)
9302 printf (" CONFALT");
9303 val
^= DF_1_CONFALT
;
9305 if (val
& DF_1_ENDFILTEE
)
9307 printf (" ENDFILTEE");
9308 val
^= DF_1_ENDFILTEE
;
9310 if (val
& DF_1_DISPRELDNE
)
9312 printf (" DISPRELDNE");
9313 val
^= DF_1_DISPRELDNE
;
9315 if (val
& DF_1_DISPRELPND
)
9317 printf (" DISPRELPND");
9318 val
^= DF_1_DISPRELPND
;
9320 if (val
& DF_1_NODIRECT
)
9322 printf (" NODIRECT");
9323 val
^= DF_1_NODIRECT
;
9325 if (val
& DF_1_IGNMULDEF
)
9327 printf (" IGNMULDEF");
9328 val
^= DF_1_IGNMULDEF
;
9330 if (val
& DF_1_NOKSYMS
)
9332 printf (" NOKSYMS");
9333 val
^= DF_1_NOKSYMS
;
9335 if (val
& DF_1_NOHDR
)
9340 if (val
& DF_1_EDITED
)
9345 if (val
& DF_1_NORELOC
)
9347 printf (" NORELOC");
9348 val
^= DF_1_NORELOC
;
9350 if (val
& DF_1_SYMINTPOSE
)
9352 printf (" SYMINTPOSE");
9353 val
^= DF_1_SYMINTPOSE
;
9355 if (val
& DF_1_GLOBAUDIT
)
9357 printf (" GLOBAUDIT");
9358 val
^= DF_1_GLOBAUDIT
;
9360 if (val
& DF_1_SINGLETON
)
9362 printf (" SINGLETON");
9363 val
^= DF_1_SINGLETON
;
9365 if (val
& DF_1_STUB
)
9376 printf (" %lx", val
);
9383 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9385 puts (get_dynamic_type (entry
->d_un
.d_val
));
9405 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9411 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9412 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9418 switch (entry
->d_tag
)
9421 printf (_("Shared library: [%s]"), name
);
9423 if (streq (name
, program_interpreter
))
9424 printf (_(" program interpreter"));
9428 printf (_("Library soname: [%s]"), name
);
9432 printf (_("Library rpath: [%s]"), name
);
9436 printf (_("Library runpath: [%s]"), name
);
9440 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9445 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9458 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9462 case DT_INIT_ARRAYSZ
:
9463 case DT_FINI_ARRAYSZ
:
9464 case DT_GNU_CONFLICTSZ
:
9465 case DT_GNU_LIBLISTSZ
:
9468 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9469 printf (_(" (bytes)\n"));
9479 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9492 if (entry
->d_tag
== DT_USED
9493 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9495 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9499 printf (_("Not needed object: [%s]\n"), name
);
9504 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9510 /* The value of this entry is ignored. */
9515 case DT_GNU_PRELINKED
:
9519 time_t atime
= entry
->d_un
.d_val
;
9521 tmp
= gmtime (&atime
);
9522 /* PR 17533 file: 041-1244816-0.004. */
9524 printf (_("<corrupt time val: %lx"),
9525 (unsigned long) atime
);
9527 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9528 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9529 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9535 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9538 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9544 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9545 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9550 switch (elf_header
.e_machine
)
9553 case EM_MIPS_RS3_LE
:
9554 dynamic_section_mips_val (entry
);
9557 dynamic_section_parisc_val (entry
);
9560 dynamic_section_ia64_val (entry
);
9563 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9575 get_ver_flags (unsigned int flags
)
9577 static char buff
[32];
9584 if (flags
& VER_FLG_BASE
)
9585 strcat (buff
, "BASE ");
9587 if (flags
& VER_FLG_WEAK
)
9589 if (flags
& VER_FLG_BASE
)
9590 strcat (buff
, "| ");
9592 strcat (buff
, "WEAK ");
9595 if (flags
& VER_FLG_INFO
)
9597 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9598 strcat (buff
, "| ");
9600 strcat (buff
, "INFO ");
9603 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9604 strcat (buff
, _("| <unknown>"));
9609 /* Display the contents of the version sections. */
9612 process_version_sections (FILE * file
)
9614 Elf_Internal_Shdr
* section
;
9621 for (i
= 0, section
= section_headers
;
9622 i
< elf_header
.e_shnum
;
9625 switch (section
->sh_type
)
9627 case SHT_GNU_verdef
:
9629 Elf_External_Verdef
* edefs
;
9636 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9637 printable_section_name (section
),
9640 printf (_(" Addr: 0x"));
9641 printf_vma (section
->sh_addr
);
9642 printf (_(" Offset: %#08lx Link: %u (%s)"),
9643 (unsigned long) section
->sh_offset
, section
->sh_link
,
9644 printable_section_name_from_index (section
->sh_link
));
9646 edefs
= (Elf_External_Verdef
*)
9647 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9648 _("version definition section"));
9651 endbuf
= (char *) edefs
+ section
->sh_size
;
9653 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9656 Elf_External_Verdef
* edef
;
9657 Elf_Internal_Verdef ent
;
9658 Elf_External_Verdaux
* eaux
;
9659 Elf_Internal_Verdaux aux
;
9663 /* Check for very large indicies. */
9664 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9667 vstart
= ((char *) edefs
) + idx
;
9668 if (vstart
+ sizeof (*edef
) > endbuf
)
9671 edef
= (Elf_External_Verdef
*) vstart
;
9673 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9674 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9675 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9676 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9677 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9678 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9679 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9681 printf (_(" %#06x: Rev: %d Flags: %s"),
9682 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9684 printf (_(" Index: %d Cnt: %d "),
9685 ent
.vd_ndx
, ent
.vd_cnt
);
9687 /* Check for overflow. */
9688 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9691 vstart
+= ent
.vd_aux
;
9693 eaux
= (Elf_External_Verdaux
*) vstart
;
9695 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9696 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9698 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9699 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9701 printf (_("Name index: %ld\n"), aux
.vda_name
);
9703 isum
= idx
+ ent
.vd_aux
;
9705 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9707 /* Check for overflow. */
9708 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9711 isum
+= aux
.vda_next
;
9712 vstart
+= aux
.vda_next
;
9714 eaux
= (Elf_External_Verdaux
*) vstart
;
9715 if (vstart
+ sizeof (*eaux
) > endbuf
)
9718 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9719 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9721 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9722 printf (_(" %#06x: Parent %d: %s\n"),
9723 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9725 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9726 isum
, j
, aux
.vda_name
);
9730 printf (_(" Version def aux past end of section\n"));
9732 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9733 if (idx
+ ent
.vd_next
<= idx
)
9739 if (cnt
< section
->sh_info
)
9740 printf (_(" Version definition past end of section\n"));
9746 case SHT_GNU_verneed
:
9748 Elf_External_Verneed
* eneed
;
9755 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9756 printable_section_name (section
), section
->sh_info
);
9758 printf (_(" Addr: 0x"));
9759 printf_vma (section
->sh_addr
);
9760 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9761 (unsigned long) section
->sh_offset
, section
->sh_link
,
9762 printable_section_name_from_index (section
->sh_link
));
9764 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9765 section
->sh_offset
, 1,
9767 _("Version Needs section"));
9770 endbuf
= (char *) eneed
+ section
->sh_size
;
9772 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9774 Elf_External_Verneed
* entry
;
9775 Elf_Internal_Verneed ent
;
9780 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9783 vstart
= ((char *) eneed
) + idx
;
9784 if (vstart
+ sizeof (*entry
) > endbuf
)
9787 entry
= (Elf_External_Verneed
*) vstart
;
9789 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9790 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9791 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9792 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9793 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9795 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9797 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9798 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9800 printf (_(" File: %lx"), ent
.vn_file
);
9802 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9804 /* Check for overflow. */
9805 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9807 vstart
+= ent
.vn_aux
;
9809 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9811 Elf_External_Vernaux
* eaux
;
9812 Elf_Internal_Vernaux aux
;
9814 if (vstart
+ sizeof (*eaux
) > endbuf
)
9816 eaux
= (Elf_External_Vernaux
*) vstart
;
9818 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9819 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9820 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9821 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9822 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9824 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9825 printf (_(" %#06x: Name: %s"),
9826 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9828 printf (_(" %#06x: Name index: %lx"),
9829 isum
, aux
.vna_name
);
9831 printf (_(" Flags: %s Version: %d\n"),
9832 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9834 /* Check for overflow. */
9835 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9836 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9838 warn (_("Invalid vna_next field of %lx\n"),
9843 isum
+= aux
.vna_next
;
9844 vstart
+= aux
.vna_next
;
9848 warn (_("Missing Version Needs auxillary information\n"));
9850 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9852 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9853 cnt
= section
->sh_info
;
9859 if (cnt
< section
->sh_info
)
9860 warn (_("Missing Version Needs information\n"));
9866 case SHT_GNU_versym
:
9868 Elf_Internal_Shdr
* link_section
;
9871 unsigned char * edata
;
9872 unsigned short * data
;
9874 Elf_Internal_Sym
* symbols
;
9875 Elf_Internal_Shdr
* string_sec
;
9876 unsigned long num_syms
;
9879 if (section
->sh_link
>= elf_header
.e_shnum
)
9882 link_section
= section_headers
+ section
->sh_link
;
9883 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9885 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9890 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9891 if (symbols
== NULL
)
9894 string_sec
= section_headers
+ link_section
->sh_link
;
9896 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9897 string_sec
->sh_size
,
9898 _("version string table"));
9905 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9906 printable_section_name (section
), (unsigned long) total
);
9908 printf (_(" Addr: "));
9909 printf_vma (section
->sh_addr
);
9910 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9911 (unsigned long) section
->sh_offset
, section
->sh_link
,
9912 printable_section_name (link_section
));
9914 off
= offset_from_vma (file
,
9915 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9916 total
* sizeof (short));
9917 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9919 _("version symbol data"));
9927 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9929 for (cnt
= total
; cnt
--;)
9930 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9935 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9939 char *invalid
= _("*invalid*");
9941 printf (" %03x:", cnt
);
9943 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9944 switch (data
[cnt
+ j
])
9947 fputs (_(" 0 (*local*) "), stdout
);
9951 fputs (_(" 1 (*global*) "), stdout
);
9955 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9956 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9958 /* If this index value is greater than the size of the symbols
9959 array, break to avoid an out-of-bounds read. */
9960 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9962 warn (_("invalid index into symbol array\n"));
9967 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9969 Elf_Internal_Verneed ivn
;
9970 unsigned long offset
;
9972 offset
= offset_from_vma
9973 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9974 sizeof (Elf_External_Verneed
));
9978 Elf_Internal_Vernaux ivna
;
9979 Elf_External_Verneed evn
;
9980 Elf_External_Vernaux evna
;
9981 unsigned long a_off
;
9983 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9984 _("version need")) == NULL
)
9987 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9988 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9990 a_off
= offset
+ ivn
.vn_aux
;
9994 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9995 1, _("version need aux (2)")) == NULL
)
10002 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10003 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10006 a_off
+= ivna
.vna_next
;
10008 while (ivna
.vna_other
!= data
[cnt
+ j
]
10009 && ivna
.vna_next
!= 0);
10011 if (ivna
.vna_other
== data
[cnt
+ j
])
10013 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10015 if (ivna
.vna_name
>= string_sec
->sh_size
)
10018 name
= strtab
+ ivna
.vna_name
;
10022 offset
+= ivn
.vn_next
;
10024 while (ivn
.vn_next
);
10027 if (data
[cnt
+ j
] != 0x8001
10028 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10030 Elf_Internal_Verdef ivd
;
10031 Elf_External_Verdef evd
;
10032 unsigned long offset
;
10034 offset
= offset_from_vma
10035 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10040 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10041 _("version def")) == NULL
)
10044 /* PR 17531: file: 046-1082287-0.004. */
10045 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10050 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10051 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10054 offset
+= ivd
.vd_next
;
10056 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10057 && ivd
.vd_next
!= 0);
10059 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10061 Elf_External_Verdaux evda
;
10062 Elf_Internal_Verdaux ivda
;
10064 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10066 if (get_data (&evda
, file
,
10067 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10069 _("version def aux")) == NULL
)
10072 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10074 if (ivda
.vda_name
>= string_sec
->sh_size
)
10076 else if (name
!= NULL
&& name
!= invalid
)
10077 name
= _("*both*");
10079 name
= strtab
+ ivda
.vda_name
;
10083 nn
+= printf ("(%s%-*s",
10085 12 - (int) strlen (name
),
10089 printf ("%*c", 18 - nn
, ' ');
10107 printf (_("\nNo version information found in this file.\n"));
10112 static const char *
10113 get_symbol_binding (unsigned int binding
)
10115 static char buff
[32];
10119 case STB_LOCAL
: return "LOCAL";
10120 case STB_GLOBAL
: return "GLOBAL";
10121 case STB_WEAK
: return "WEAK";
10123 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10124 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10126 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10128 if (binding
== STB_GNU_UNIQUE
10129 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10130 /* GNU is still using the default value 0. */
10131 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10133 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10136 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10141 static const char *
10142 get_symbol_type (unsigned int type
)
10144 static char buff
[32];
10148 case STT_NOTYPE
: return "NOTYPE";
10149 case STT_OBJECT
: return "OBJECT";
10150 case STT_FUNC
: return "FUNC";
10151 case STT_SECTION
: return "SECTION";
10152 case STT_FILE
: return "FILE";
10153 case STT_COMMON
: return "COMMON";
10154 case STT_TLS
: return "TLS";
10155 case STT_RELC
: return "RELC";
10156 case STT_SRELC
: return "SRELC";
10158 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10160 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10161 return "THUMB_FUNC";
10163 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10166 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10167 return "PARISC_MILLI";
10169 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10171 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10173 if (elf_header
.e_machine
== EM_PARISC
)
10175 if (type
== STT_HP_OPAQUE
)
10176 return "HP_OPAQUE";
10177 if (type
== STT_HP_STUB
)
10181 if (type
== STT_GNU_IFUNC
10182 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10183 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10184 /* GNU is still using the default value 0. */
10185 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10188 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10191 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10196 static const char *
10197 get_symbol_visibility (unsigned int visibility
)
10199 switch (visibility
)
10201 case STV_DEFAULT
: return "DEFAULT";
10202 case STV_INTERNAL
: return "INTERNAL";
10203 case STV_HIDDEN
: return "HIDDEN";
10204 case STV_PROTECTED
: return "PROTECTED";
10206 error (_("Unrecognized visibility value: %u"), visibility
);
10207 return _("<unknown>");
10211 static const char *
10212 get_mips_symbol_other (unsigned int other
)
10222 case STO_MICROMIPS
:
10223 return "MICROMIPS";
10224 case STO_MICROMIPS
| STO_MIPS_PIC
:
10225 return "MICROMIPS, MIPS PIC";
10233 static const char *
10234 get_ia64_symbol_other (unsigned int other
)
10236 if (is_ia64_vms ())
10238 static char res
[32];
10242 /* Function types is for images and .STB files only. */
10243 switch (elf_header
.e_type
)
10247 switch (VMS_ST_FUNC_TYPE (other
))
10249 case VMS_SFT_CODE_ADDR
:
10250 strcat (res
, " CA");
10252 case VMS_SFT_SYMV_IDX
:
10253 strcat (res
, " VEC");
10256 strcat (res
, " FD");
10258 case VMS_SFT_RESERVE
:
10259 strcat (res
, " RSV");
10262 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10263 VMS_ST_FUNC_TYPE (other
));
10264 strcat (res
, " <unknown>");
10271 switch (VMS_ST_LINKAGE (other
))
10273 case VMS_STL_IGNORE
:
10274 strcat (res
, " IGN");
10276 case VMS_STL_RESERVE
:
10277 strcat (res
, " RSV");
10280 strcat (res
, " STD");
10283 strcat (res
, " LNK");
10286 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10287 VMS_ST_LINKAGE (other
));
10288 strcat (res
, " <unknown>");
10300 static const char *
10301 get_ppc64_symbol_other (unsigned int other
)
10303 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10305 static char buf
[32];
10306 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10307 PPC64_LOCAL_ENTRY_OFFSET (other
));
10313 static const char *
10314 get_symbol_other (unsigned int other
)
10316 const char * result
= NULL
;
10317 static char buff
[32];
10322 switch (elf_header
.e_machine
)
10325 result
= get_mips_symbol_other (other
);
10328 result
= get_ia64_symbol_other (other
);
10331 result
= get_ppc64_symbol_other (other
);
10340 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10344 static const char *
10345 get_symbol_index_type (unsigned int type
)
10347 static char buff
[32];
10351 case SHN_UNDEF
: return "UND";
10352 case SHN_ABS
: return "ABS";
10353 case SHN_COMMON
: return "COM";
10355 if (type
== SHN_IA_64_ANSI_COMMON
10356 && elf_header
.e_machine
== EM_IA_64
10357 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10359 else if ((elf_header
.e_machine
== EM_X86_64
10360 || elf_header
.e_machine
== EM_L1OM
10361 || elf_header
.e_machine
== EM_K1OM
)
10362 && type
== SHN_X86_64_LCOMMON
)
10363 return "LARGE_COM";
10364 else if ((type
== SHN_MIPS_SCOMMON
10365 && elf_header
.e_machine
== EM_MIPS
)
10366 || (type
== SHN_TIC6X_SCOMMON
10367 && elf_header
.e_machine
== EM_TI_C6000
))
10369 else if (type
== SHN_MIPS_SUNDEFINED
10370 && elf_header
.e_machine
== EM_MIPS
)
10372 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10373 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10374 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10375 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10376 else if (type
>= SHN_LORESERVE
)
10377 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10378 else if (type
>= elf_header
.e_shnum
)
10379 sprintf (buff
, _("bad section index[%3d]"), type
);
10381 sprintf (buff
, "%3d", type
);
10389 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10391 unsigned char * e_data
;
10394 /* If the size_t type is smaller than the bfd_size_type, eg because
10395 you are building a 32-bit tool on a 64-bit host, then make sure
10396 that when (number) is cast to (size_t) no information is lost. */
10397 if (sizeof (size_t) < sizeof (bfd_size_type
)
10398 && (bfd_size_type
) ((size_t) number
) != number
)
10400 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10401 " elements of size %u\n"),
10406 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10407 attempting to allocate memory when the read is bound to fail. */
10408 if (ent_size
* number
> current_file_size
)
10410 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10415 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10416 if (e_data
== NULL
)
10418 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10423 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10425 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10426 number
* ent_size
);
10431 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10432 if (i_data
== NULL
)
10434 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10435 " dynamic entries\n"),
10442 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10450 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10452 Elf_Internal_Sym
* psym
;
10455 n
= print_vma (si
, DEC_5
);
10457 fputs (&" "[n
], stdout
);
10458 printf (" %3lu: ", hn
);
10460 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10462 printf (_("<No info available for dynamic symbol number %lu>\n"),
10463 (unsigned long) si
);
10467 psym
= dynamic_symbols
+ si
;
10468 print_vma (psym
->st_value
, LONG_HEX
);
10470 print_vma (psym
->st_size
, DEC_5
);
10472 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10473 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10474 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10475 /* Check to see if any other bits in the st_other field are set.
10476 Note - displaying this information disrupts the layout of the
10477 table being generated, but for the moment this case is very
10479 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10480 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10481 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10482 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10483 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10485 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10489 static const char *
10490 get_symbol_version_string (FILE *file
, int is_dynsym
,
10491 const char *strtab
,
10492 unsigned long int strtab_size
,
10493 unsigned int si
, Elf_Internal_Sym
*psym
,
10494 enum versioned_symbol_info
*sym_info
,
10495 unsigned short *vna_other
)
10497 unsigned char data
[2];
10498 unsigned short vers_data
;
10499 unsigned long offset
;
10502 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10505 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10506 sizeof data
+ si
* sizeof (vers_data
));
10508 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10509 sizeof (data
), 1, _("version data")) == NULL
)
10512 vers_data
= byte_get (data
, 2);
10514 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10517 /* Usually we'd only see verdef for defined symbols, and verneed for
10518 undefined symbols. However, symbols defined by the linker in
10519 .dynbss for variables copied from a shared library in order to
10520 avoid text relocations are defined yet have verneed. We could
10521 use a heuristic to detect the special case, for example, check
10522 for verneed first on symbols defined in SHT_NOBITS sections, but
10523 it is simpler and more reliable to just look for both verdef and
10524 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10526 if (psym
->st_shndx
!= SHN_UNDEF
10527 && vers_data
!= 0x8001
10528 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10530 Elf_Internal_Verdef ivd
;
10531 Elf_Internal_Verdaux ivda
;
10532 Elf_External_Verdaux evda
;
10535 off
= offset_from_vma (file
,
10536 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10537 sizeof (Elf_External_Verdef
));
10541 Elf_External_Verdef evd
;
10543 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10544 _("version def")) == NULL
)
10552 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10553 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10554 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10557 off
+= ivd
.vd_next
;
10559 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10561 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10563 off
-= ivd
.vd_next
;
10566 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10567 _("version def aux")) != NULL
)
10569 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10571 if (psym
->st_name
!= ivda
.vda_name
)
10573 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10574 ? symbol_hidden
: symbol_public
);
10575 return (ivda
.vda_name
< strtab_size
10576 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10582 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10584 Elf_External_Verneed evn
;
10585 Elf_Internal_Verneed ivn
;
10586 Elf_Internal_Vernaux ivna
;
10588 offset
= offset_from_vma (file
,
10589 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10593 unsigned long vna_off
;
10595 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10596 _("version need")) == NULL
)
10599 ivna
.vna_other
= 0;
10604 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10605 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10607 vna_off
= offset
+ ivn
.vn_aux
;
10611 Elf_External_Vernaux evna
;
10613 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10614 _("version need aux (3)")) == NULL
)
10617 ivna
.vna_other
= 0;
10622 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10623 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10624 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10627 vna_off
+= ivna
.vna_next
;
10629 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10631 if (ivna
.vna_other
== vers_data
)
10634 offset
+= ivn
.vn_next
;
10636 while (ivn
.vn_next
!= 0);
10638 if (ivna
.vna_other
== vers_data
)
10640 *sym_info
= symbol_undefined
;
10641 *vna_other
= ivna
.vna_other
;
10642 return (ivna
.vna_name
< strtab_size
10643 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10649 /* Dump the symbol table. */
10651 process_symbol_table (FILE * file
)
10653 Elf_Internal_Shdr
* section
;
10654 bfd_size_type nbuckets
= 0;
10655 bfd_size_type nchains
= 0;
10656 bfd_vma
* buckets
= NULL
;
10657 bfd_vma
* chains
= NULL
;
10658 bfd_vma ngnubuckets
= 0;
10659 bfd_vma
* gnubuckets
= NULL
;
10660 bfd_vma
* gnuchains
= NULL
;
10661 bfd_vma gnusymidx
= 0;
10662 bfd_size_type ngnuchains
= 0;
10664 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10667 if (dynamic_info
[DT_HASH
]
10669 || (do_using_dynamic
10671 && dynamic_strings
!= NULL
)))
10673 unsigned char nb
[8];
10674 unsigned char nc
[8];
10675 unsigned int hash_ent_size
= 4;
10677 if ((elf_header
.e_machine
== EM_ALPHA
10678 || elf_header
.e_machine
== EM_S390
10679 || elf_header
.e_machine
== EM_S390_OLD
)
10680 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10684 (archive_file_offset
10685 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10686 sizeof nb
+ sizeof nc
)),
10689 error (_("Unable to seek to start of dynamic information\n"));
10693 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10695 error (_("Failed to read in number of buckets\n"));
10699 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10701 error (_("Failed to read in number of chains\n"));
10705 nbuckets
= byte_get (nb
, hash_ent_size
);
10706 nchains
= byte_get (nc
, hash_ent_size
);
10708 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10709 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10712 if (buckets
== NULL
|| chains
== NULL
)
10714 if (do_using_dynamic
)
10725 if (dynamic_info_DT_GNU_HASH
10727 || (do_using_dynamic
10729 && dynamic_strings
!= NULL
)))
10731 unsigned char nb
[16];
10732 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10733 bfd_vma buckets_vma
;
10736 (archive_file_offset
10737 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10741 error (_("Unable to seek to start of dynamic information\n"));
10745 if (fread (nb
, 16, 1, file
) != 1)
10747 error (_("Failed to read in number of buckets\n"));
10751 ngnubuckets
= byte_get (nb
, 4);
10752 gnusymidx
= byte_get (nb
+ 4, 4);
10753 bitmaskwords
= byte_get (nb
+ 8, 4);
10754 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10756 buckets_vma
+= bitmaskwords
* 4;
10758 buckets_vma
+= bitmaskwords
* 8;
10761 (archive_file_offset
10762 + offset_from_vma (file
, buckets_vma
, 4)),
10765 error (_("Unable to seek to start of dynamic information\n"));
10769 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10771 if (gnubuckets
== NULL
)
10774 for (i
= 0; i
< ngnubuckets
; i
++)
10775 if (gnubuckets
[i
] != 0)
10777 if (gnubuckets
[i
] < gnusymidx
)
10780 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10781 maxchain
= gnubuckets
[i
];
10784 if (maxchain
== 0xffffffff)
10787 maxchain
-= gnusymidx
;
10790 (archive_file_offset
10791 + offset_from_vma (file
, buckets_vma
10792 + 4 * (ngnubuckets
+ maxchain
), 4)),
10795 error (_("Unable to seek to start of dynamic information\n"));
10801 if (fread (nb
, 4, 1, file
) != 1)
10803 error (_("Failed to determine last chain length\n"));
10807 if (maxchain
+ 1 == 0)
10812 while ((byte_get (nb
, 4) & 1) == 0);
10815 (archive_file_offset
10816 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10819 error (_("Unable to seek to start of dynamic information\n"));
10823 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10824 ngnuchains
= maxchain
;
10827 if (gnuchains
== NULL
)
10832 if (do_using_dynamic
)
10837 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10839 && do_using_dynamic
10840 && dynamic_strings
!= NULL
10841 && dynamic_symbols
!= NULL
)
10845 if (dynamic_info
[DT_HASH
])
10849 printf (_("\nSymbol table for image:\n"));
10851 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10853 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10855 for (hn
= 0; hn
< nbuckets
; hn
++)
10860 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10861 print_dynamic_symbol (si
, hn
);
10865 if (dynamic_info_DT_GNU_HASH
)
10867 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10869 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10871 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10873 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10874 if (gnubuckets
[hn
] != 0)
10876 bfd_vma si
= gnubuckets
[hn
];
10877 bfd_vma off
= si
- gnusymidx
;
10881 print_dynamic_symbol (si
, hn
);
10884 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10888 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10889 && section_headers
!= NULL
)
10893 for (i
= 0, section
= section_headers
;
10894 i
< elf_header
.e_shnum
;
10898 char * strtab
= NULL
;
10899 unsigned long int strtab_size
= 0;
10900 Elf_Internal_Sym
* symtab
;
10901 Elf_Internal_Sym
* psym
;
10902 unsigned long num_syms
;
10904 if ((section
->sh_type
!= SHT_SYMTAB
10905 && section
->sh_type
!= SHT_DYNSYM
)
10907 && section
->sh_type
== SHT_SYMTAB
))
10910 if (section
->sh_entsize
== 0)
10912 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10913 printable_section_name (section
));
10917 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10918 printable_section_name (section
),
10919 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10922 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10924 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10926 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10927 if (symtab
== NULL
)
10930 if (section
->sh_link
== elf_header
.e_shstrndx
)
10932 strtab
= string_table
;
10933 strtab_size
= string_table_length
;
10935 else if (section
->sh_link
< elf_header
.e_shnum
)
10937 Elf_Internal_Shdr
* string_sec
;
10939 string_sec
= section_headers
+ section
->sh_link
;
10941 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10942 1, string_sec
->sh_size
,
10943 _("string table"));
10944 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10947 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10949 const char *version_string
;
10950 enum versioned_symbol_info sym_info
;
10951 unsigned short vna_other
;
10953 printf ("%6d: ", si
);
10954 print_vma (psym
->st_value
, LONG_HEX
);
10956 print_vma (psym
->st_size
, DEC_5
);
10957 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10958 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10959 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10960 /* Check to see if any other bits in the st_other field are set.
10961 Note - displaying this information disrupts the layout of the
10962 table being generated, but for the moment this case is very rare. */
10963 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10964 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10965 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10966 print_symbol (25, psym
->st_name
< strtab_size
10967 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10970 = get_symbol_version_string (file
,
10971 section
->sh_type
== SHT_DYNSYM
,
10972 strtab
, strtab_size
, si
,
10973 psym
, &sym_info
, &vna_other
);
10974 if (version_string
)
10976 if (sym_info
== symbol_undefined
)
10977 printf ("@%s (%d)", version_string
, vna_other
);
10979 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10987 if (strtab
!= string_table
)
10993 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10995 if (do_histogram
&& buckets
!= NULL
)
10997 unsigned long * lengths
;
10998 unsigned long * counts
;
11001 unsigned long maxlength
= 0;
11002 unsigned long nzero_counts
= 0;
11003 unsigned long nsyms
= 0;
11004 unsigned long chained
;
11006 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11007 (unsigned long) nbuckets
);
11009 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11010 if (lengths
== NULL
)
11012 error (_("Out of memory allocating space for histogram buckets\n"));
11016 printf (_(" Length Number %% of total Coverage\n"));
11017 for (hn
= 0; hn
< nbuckets
; ++hn
)
11019 for (si
= buckets
[hn
], chained
= 0;
11020 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11021 si
= chains
[si
], ++chained
)
11024 if (maxlength
< ++lengths
[hn
])
11028 /* PR binutils/17531: A corrupt binary could contain broken
11029 histogram data. Do not go into an infinite loop trying
11031 if (chained
> nchains
)
11033 error (_("histogram chain is corrupt\n"));
11038 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11039 if (counts
== NULL
)
11042 error (_("Out of memory allocating space for histogram counts\n"));
11046 for (hn
= 0; hn
< nbuckets
; ++hn
)
11047 ++counts
[lengths
[hn
]];
11052 printf (" 0 %-10lu (%5.1f%%)\n",
11053 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11054 for (i
= 1; i
<= maxlength
; ++i
)
11056 nzero_counts
+= counts
[i
] * i
;
11057 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11058 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11059 (nzero_counts
* 100.0) / nsyms
);
11067 if (buckets
!= NULL
)
11073 if (do_histogram
&& gnubuckets
!= NULL
)
11075 unsigned long * lengths
;
11076 unsigned long * counts
;
11078 unsigned long maxlength
= 0;
11079 unsigned long nzero_counts
= 0;
11080 unsigned long nsyms
= 0;
11082 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11083 (unsigned long) ngnubuckets
);
11085 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11086 if (lengths
== NULL
)
11088 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11092 printf (_(" Length Number %% of total Coverage\n"));
11094 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11095 if (gnubuckets
[hn
] != 0)
11097 bfd_vma off
, length
= 1;
11099 for (off
= gnubuckets
[hn
] - gnusymidx
;
11100 /* PR 17531 file: 010-77222-0.004. */
11101 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11104 lengths
[hn
] = length
;
11105 if (length
> maxlength
)
11106 maxlength
= length
;
11110 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11111 if (counts
== NULL
)
11114 error (_("Out of memory allocating space for gnu histogram counts\n"));
11118 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11119 ++counts
[lengths
[hn
]];
11121 if (ngnubuckets
> 0)
11124 printf (" 0 %-10lu (%5.1f%%)\n",
11125 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11126 for (j
= 1; j
<= maxlength
; ++j
)
11128 nzero_counts
+= counts
[j
] * j
;
11129 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11130 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11131 (nzero_counts
* 100.0) / nsyms
);
11145 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11149 if (dynamic_syminfo
== NULL
11151 /* No syminfo, this is ok. */
11154 /* There better should be a dynamic symbol section. */
11155 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11159 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11160 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11162 printf (_(" Num: Name BoundTo Flags\n"));
11163 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11165 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11167 printf ("%4d: ", i
);
11168 if (i
>= num_dynamic_syms
)
11169 printf (_("<corrupt index>"));
11170 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11171 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11173 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11176 switch (dynamic_syminfo
[i
].si_boundto
)
11178 case SYMINFO_BT_SELF
:
11179 fputs ("SELF ", stdout
);
11181 case SYMINFO_BT_PARENT
:
11182 fputs ("PARENT ", stdout
);
11185 if (dynamic_syminfo
[i
].si_boundto
> 0
11186 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11187 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11189 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11193 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11197 if (flags
& SYMINFO_FLG_DIRECT
)
11198 printf (" DIRECT");
11199 if (flags
& SYMINFO_FLG_PASSTHRU
)
11200 printf (" PASSTHRU");
11201 if (flags
& SYMINFO_FLG_COPY
)
11203 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11204 printf (" LAZYLOAD");
11212 /* Check to see if the given reloc needs to be handled in a target specific
11213 manner. If so then process the reloc and return TRUE otherwise return
11217 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11218 unsigned char * start
,
11219 Elf_Internal_Sym
* symtab
)
11221 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11223 switch (elf_header
.e_machine
)
11226 case EM_MSP430_OLD
:
11228 static Elf_Internal_Sym
* saved_sym
= NULL
;
11230 switch (reloc_type
)
11232 case 10: /* R_MSP430_SYM_DIFF */
11233 if (uses_msp430x_relocs ())
11235 case 21: /* R_MSP430X_SYM_DIFF */
11236 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11239 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11240 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11241 goto handle_sym_diff
;
11243 case 5: /* R_MSP430_16_BYTE */
11244 case 9: /* R_MSP430_8 */
11245 if (uses_msp430x_relocs ())
11247 goto handle_sym_diff
;
11249 case 2: /* R_MSP430_ABS16 */
11250 case 15: /* R_MSP430X_ABS16 */
11251 if (! uses_msp430x_relocs ())
11253 goto handle_sym_diff
;
11256 if (saved_sym
!= NULL
)
11260 value
= reloc
->r_addend
11261 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11262 - saved_sym
->st_value
);
11264 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11272 if (saved_sym
!= NULL
)
11273 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11280 case EM_CYGNUS_MN10300
:
11282 static Elf_Internal_Sym
* saved_sym
= NULL
;
11284 switch (reloc_type
)
11286 case 34: /* R_MN10300_ALIGN */
11288 case 33: /* R_MN10300_SYM_DIFF */
11289 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11291 case 1: /* R_MN10300_32 */
11292 case 2: /* R_MN10300_16 */
11293 if (saved_sym
!= NULL
)
11297 value
= reloc
->r_addend
11298 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11299 - saved_sym
->st_value
);
11301 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11308 if (saved_sym
!= NULL
)
11309 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11317 static bfd_vma saved_sym1
= 0;
11318 static bfd_vma saved_sym2
= 0;
11319 static bfd_vma value
;
11321 switch (reloc_type
)
11323 case 0x80: /* R_RL78_SYM. */
11324 saved_sym1
= saved_sym2
;
11325 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11326 saved_sym2
+= reloc
->r_addend
;
11329 case 0x83: /* R_RL78_OPsub. */
11330 value
= saved_sym1
- saved_sym2
;
11331 saved_sym2
= saved_sym1
= 0;
11335 case 0x41: /* R_RL78_ABS32. */
11336 byte_put (start
+ reloc
->r_offset
, value
, 4);
11340 case 0x43: /* R_RL78_ABS16. */
11341 byte_put (start
+ reloc
->r_offset
, value
, 2);
11355 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11356 DWARF debug sections. This is a target specific test. Note - we do not
11357 go through the whole including-target-headers-multiple-times route, (as
11358 we have already done with <elf/h8.h>) because this would become very
11359 messy and even then this function would have to contain target specific
11360 information (the names of the relocs instead of their numeric values).
11361 FIXME: This is not the correct way to solve this problem. The proper way
11362 is to have target specific reloc sizing and typing functions created by
11363 the reloc-macros.h header, in the same way that it already creates the
11364 reloc naming functions. */
11367 is_32bit_abs_reloc (unsigned int reloc_type
)
11369 switch (elf_header
.e_machine
)
11373 return reloc_type
== 1; /* R_386_32. */
11375 return reloc_type
== 1; /* R_68K_32. */
11377 return reloc_type
== 1; /* R_860_32. */
11379 return reloc_type
== 2; /* R_960_32. */
11381 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11383 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11385 return reloc_type
== 1; /* R_ARC_32. */
11386 case EM_ARC_COMPACT
:
11387 case EM_ARC_COMPACT2
:
11388 return reloc_type
== 4; /* R_ARC_32. */
11390 return reloc_type
== 2; /* R_ARM_ABS32 */
11393 return reloc_type
== 1;
11394 case EM_ADAPTEVA_EPIPHANY
:
11395 return reloc_type
== 3;
11397 return reloc_type
== 0x12; /* R_byte4_data. */
11399 return reloc_type
== 3; /* R_CRIS_32. */
11401 return reloc_type
== 3; /* R_CR16_NUM32. */
11403 return reloc_type
== 15; /* R_CRX_NUM32. */
11404 case EM_CYGNUS_FRV
:
11405 return reloc_type
== 1;
11406 case EM_CYGNUS_D10V
:
11408 return reloc_type
== 6; /* R_D10V_32. */
11409 case EM_CYGNUS_D30V
:
11411 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11413 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11414 case EM_CYGNUS_FR30
:
11416 return reloc_type
== 3; /* R_FR30_32. */
11418 return reloc_type
== 1; /* R_FT32_32. */
11422 return reloc_type
== 1; /* R_H8_DIR32. */
11424 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11425 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11428 return reloc_type
== 2; /* R_IP2K_32. */
11430 return reloc_type
== 2; /* R_IQ2000_32. */
11431 case EM_LATTICEMICO32
:
11432 return reloc_type
== 3; /* R_LM32_32. */
11435 return reloc_type
== 3; /* R_M32C_32. */
11437 return reloc_type
== 34; /* R_M32R_32_RELA. */
11440 return reloc_type
== 6; /* R_M68HC11_32. */
11442 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11443 case EM_CYGNUS_MEP
:
11444 return reloc_type
== 4; /* R_MEP_32. */
11446 return reloc_type
== 2; /* R_METAG_ADDR32. */
11447 case EM_MICROBLAZE
:
11448 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11450 return reloc_type
== 2; /* R_MIPS_32. */
11452 return reloc_type
== 4; /* R_MMIX_32. */
11453 case EM_CYGNUS_MN10200
:
11455 return reloc_type
== 1; /* R_MN10200_32. */
11456 case EM_CYGNUS_MN10300
:
11458 return reloc_type
== 1; /* R_MN10300_32. */
11460 return reloc_type
== 1; /* R_MOXIE_32. */
11461 case EM_MSP430_OLD
:
11463 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11465 return reloc_type
== 2; /* R_MT_32. */
11467 return reloc_type
== 20; /* R_NDS32_RELA. */
11468 case EM_ALTERA_NIOS2
:
11469 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11471 return reloc_type
== 1; /* R_NIOS_32. */
11473 return reloc_type
== 1; /* R_OR1K_32. */
11475 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11476 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11479 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11481 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11483 return reloc_type
== 1; /* R_PPC_ADDR32. */
11485 return reloc_type
== 1; /* R_RL78_DIR32. */
11487 return reloc_type
== 1; /* R_RX_DIR32. */
11489 return reloc_type
== 1; /* R_I370_ADDR31. */
11492 return reloc_type
== 4; /* R_S390_32. */
11494 return reloc_type
== 8; /* R_SCORE_ABS32. */
11496 return reloc_type
== 1; /* R_SH_DIR32. */
11497 case EM_SPARC32PLUS
:
11500 return reloc_type
== 3 /* R_SPARC_32. */
11501 || reloc_type
== 23; /* R_SPARC_UA32. */
11503 return reloc_type
== 6; /* R_SPU_ADDR32 */
11505 return reloc_type
== 1; /* R_C6000_ABS32. */
11507 return reloc_type
== 2; /* R_TILEGX_32. */
11509 return reloc_type
== 1; /* R_TILEPRO_32. */
11510 case EM_CYGNUS_V850
:
11512 return reloc_type
== 6; /* R_V850_ABS32. */
11514 return reloc_type
== 0x33; /* R_V810_WORD. */
11516 return reloc_type
== 1; /* R_VAX_32. */
11518 return reloc_type
== 3; /* R_VISIUM_32. */
11522 return reloc_type
== 10; /* R_X86_64_32. */
11525 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11527 return reloc_type
== 4; /* R_XGATE_32. */
11529 return reloc_type
== 1; /* R_XSTROMY16_32. */
11530 case EM_XTENSA_OLD
:
11532 return reloc_type
== 1; /* R_XTENSA_32. */
11535 static unsigned int prev_warn
= 0;
11537 /* Avoid repeating the same warning multiple times. */
11538 if (prev_warn
!= elf_header
.e_machine
)
11539 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11540 elf_header
.e_machine
);
11541 prev_warn
= elf_header
.e_machine
;
11547 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11548 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11551 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11553 switch (elf_header
.e_machine
)
11557 return reloc_type
== 2; /* R_386_PC32. */
11559 return reloc_type
== 4; /* R_68K_PC32. */
11561 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11562 case EM_ADAPTEVA_EPIPHANY
:
11563 return reloc_type
== 6;
11565 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11566 case EM_ARC_COMPACT
:
11567 case EM_ARC_COMPACT2
:
11568 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11570 return reloc_type
== 3; /* R_ARM_REL32 */
11571 case EM_MICROBLAZE
:
11572 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11574 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11576 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11578 return reloc_type
== 26; /* R_PPC_REL32. */
11580 return reloc_type
== 26; /* R_PPC64_REL32. */
11583 return reloc_type
== 5; /* R_390_PC32. */
11585 return reloc_type
== 2; /* R_SH_REL32. */
11586 case EM_SPARC32PLUS
:
11589 return reloc_type
== 6; /* R_SPARC_DISP32. */
11591 return reloc_type
== 13; /* R_SPU_REL32. */
11593 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11595 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11597 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11601 return reloc_type
== 2; /* R_X86_64_PC32. */
11602 case EM_XTENSA_OLD
:
11604 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11606 /* Do not abort or issue an error message here. Not all targets use
11607 pc-relative 32-bit relocs in their DWARF debug information and we
11608 have already tested for target coverage in is_32bit_abs_reloc. A
11609 more helpful warning message will be generated by apply_relocations
11610 anyway, so just return. */
11615 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11616 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11619 is_64bit_abs_reloc (unsigned int reloc_type
)
11621 switch (elf_header
.e_machine
)
11624 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11626 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11628 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11630 return reloc_type
== 80; /* R_PARISC_DIR64. */
11632 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11633 case EM_SPARC32PLUS
:
11636 return reloc_type
== 54; /* R_SPARC_UA64. */
11640 return reloc_type
== 1; /* R_X86_64_64. */
11643 return reloc_type
== 22; /* R_S390_64. */
11645 return reloc_type
== 1; /* R_TILEGX_64. */
11647 return reloc_type
== 18; /* R_MIPS_64. */
11653 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11654 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11657 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11659 switch (elf_header
.e_machine
)
11662 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11664 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11666 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11668 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11670 return reloc_type
== 44; /* R_PPC64_REL64. */
11671 case EM_SPARC32PLUS
:
11674 return reloc_type
== 46; /* R_SPARC_DISP64. */
11678 return reloc_type
== 24; /* R_X86_64_PC64. */
11681 return reloc_type
== 23; /* R_S390_PC64. */
11683 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11689 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11690 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11693 is_24bit_abs_reloc (unsigned int reloc_type
)
11695 switch (elf_header
.e_machine
)
11697 case EM_CYGNUS_MN10200
:
11699 return reloc_type
== 4; /* R_MN10200_24. */
11705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11706 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11709 is_16bit_abs_reloc (unsigned int reloc_type
)
11711 switch (elf_header
.e_machine
)
11714 case EM_ARC_COMPACT
:
11715 case EM_ARC_COMPACT2
:
11716 return reloc_type
== 2; /* R_ARC_16. */
11719 return reloc_type
== 4; /* R_AVR_16. */
11720 case EM_ADAPTEVA_EPIPHANY
:
11721 return reloc_type
== 5;
11722 case EM_CYGNUS_D10V
:
11724 return reloc_type
== 3; /* R_D10V_16. */
11728 return reloc_type
== R_H8_DIR16
;
11731 return reloc_type
== 1; /* R_IP2K_16. */
11734 return reloc_type
== 1; /* R_M32C_16 */
11736 if (uses_msp430x_relocs ())
11737 return reloc_type
== 2; /* R_MSP430_ABS16. */
11738 case EM_MSP430_OLD
:
11739 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11741 return reloc_type
== 19; /* R_NDS32_RELA. */
11742 case EM_ALTERA_NIOS2
:
11743 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11745 return reloc_type
== 9; /* R_NIOS_16. */
11747 return reloc_type
== 2; /* R_OR1K_16. */
11749 return reloc_type
== 2; /* R_C6000_ABS16. */
11752 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11753 case EM_CYGNUS_MN10200
:
11755 return reloc_type
== 2; /* R_MN10200_16. */
11756 case EM_CYGNUS_MN10300
:
11758 return reloc_type
== 2; /* R_MN10300_16. */
11760 return reloc_type
== 2; /* R_VISIUM_16. */
11762 return reloc_type
== 3; /* R_XGATE_16. */
11768 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11769 relocation entries (possibly formerly used for SHT_GROUP sections). */
11772 is_none_reloc (unsigned int reloc_type
)
11774 switch (elf_header
.e_machine
)
11776 case EM_68K
: /* R_68K_NONE. */
11777 case EM_386
: /* R_386_NONE. */
11778 case EM_SPARC32PLUS
:
11780 case EM_SPARC
: /* R_SPARC_NONE. */
11781 case EM_MIPS
: /* R_MIPS_NONE. */
11782 case EM_PARISC
: /* R_PARISC_NONE. */
11783 case EM_ALPHA
: /* R_ALPHA_NONE. */
11784 case EM_ADAPTEVA_EPIPHANY
:
11785 case EM_PPC
: /* R_PPC_NONE. */
11786 case EM_PPC64
: /* R_PPC64_NONE. */
11787 case EM_ARC
: /* R_ARC_NONE. */
11788 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11789 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11790 case EM_ARM
: /* R_ARM_NONE. */
11791 case EM_IA_64
: /* R_IA64_NONE. */
11792 case EM_SH
: /* R_SH_NONE. */
11794 case EM_S390
: /* R_390_NONE. */
11795 case EM_CRIS
: /* R_CRIS_NONE. */
11796 case EM_X86_64
: /* R_X86_64_NONE. */
11797 case EM_L1OM
: /* R_X86_64_NONE. */
11798 case EM_K1OM
: /* R_X86_64_NONE. */
11799 case EM_MN10300
: /* R_MN10300_NONE. */
11800 case EM_FT32
: /* R_FT32_NONE. */
11801 case EM_MOXIE
: /* R_MOXIE_NONE. */
11802 case EM_M32R
: /* R_M32R_NONE. */
11803 case EM_TI_C6000
:/* R_C6000_NONE. */
11804 case EM_TILEGX
: /* R_TILEGX_NONE. */
11805 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11807 case EM_C166
: /* R_XC16X_NONE. */
11808 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11809 case EM_NIOS32
: /* R_NIOS_NONE. */
11810 case EM_OR1K
: /* R_OR1K_NONE. */
11811 return reloc_type
== 0;
11813 return reloc_type
== 0 || reloc_type
== 256;
11815 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11816 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11817 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11818 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11819 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11820 case EM_XTENSA_OLD
:
11822 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11823 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11824 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11825 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11827 return reloc_type
== 3; /* R_METAG_NONE. */
11832 /* Returns TRUE if there is a relocation against
11833 section NAME at OFFSET bytes. */
11836 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11838 Elf_Internal_Rela
* relocs
;
11839 Elf_Internal_Rela
* rp
;
11841 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11844 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11846 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11847 if (rp
->r_offset
== offset
)
11853 /* Apply relocations to a section.
11854 Note: So far support has been added only for those relocations
11855 which can be found in debug sections.
11856 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11857 loaded relocs. It is then the caller's responsibility to free them.
11858 FIXME: Add support for more relocations ? */
11861 apply_relocations (void * file
,
11862 const Elf_Internal_Shdr
* section
,
11863 unsigned char * start
,
11864 bfd_size_type size
,
11865 void ** relocs_return
,
11866 unsigned long * num_relocs_return
)
11868 Elf_Internal_Shdr
* relsec
;
11869 unsigned char * end
= start
+ size
;
11871 if (relocs_return
!= NULL
)
11873 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11874 * num_relocs_return
= 0;
11877 if (elf_header
.e_type
!= ET_REL
)
11880 /* Find the reloc section associated with the section. */
11881 for (relsec
= section_headers
;
11882 relsec
< section_headers
+ elf_header
.e_shnum
;
11885 bfd_boolean is_rela
;
11886 unsigned long num_relocs
;
11887 Elf_Internal_Rela
* relocs
;
11888 Elf_Internal_Rela
* rp
;
11889 Elf_Internal_Shdr
* symsec
;
11890 Elf_Internal_Sym
* symtab
;
11891 unsigned long num_syms
;
11892 Elf_Internal_Sym
* sym
;
11894 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11895 || relsec
->sh_info
>= elf_header
.e_shnum
11896 || section_headers
+ relsec
->sh_info
!= section
11897 || relsec
->sh_size
== 0
11898 || relsec
->sh_link
>= elf_header
.e_shnum
)
11901 is_rela
= relsec
->sh_type
== SHT_RELA
;
11905 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11906 relsec
->sh_size
, & relocs
, & num_relocs
))
11911 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11912 relsec
->sh_size
, & relocs
, & num_relocs
))
11916 /* SH uses RELA but uses in place value instead of the addend field. */
11917 if (elf_header
.e_machine
== EM_SH
)
11920 symsec
= section_headers
+ relsec
->sh_link
;
11921 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11923 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11926 unsigned int reloc_type
;
11927 unsigned int reloc_size
;
11928 unsigned char * rloc
;
11929 unsigned long sym_index
;
11931 reloc_type
= get_reloc_type (rp
->r_info
);
11933 if (target_specific_reloc_handling (rp
, start
, symtab
))
11935 else if (is_none_reloc (reloc_type
))
11937 else if (is_32bit_abs_reloc (reloc_type
)
11938 || is_32bit_pcrel_reloc (reloc_type
))
11940 else if (is_64bit_abs_reloc (reloc_type
)
11941 || is_64bit_pcrel_reloc (reloc_type
))
11943 else if (is_24bit_abs_reloc (reloc_type
))
11945 else if (is_16bit_abs_reloc (reloc_type
))
11949 static unsigned int prev_reloc
= 0;
11950 if (reloc_type
!= prev_reloc
)
11951 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11952 reloc_type
, printable_section_name (section
));
11953 prev_reloc
= reloc_type
;
11957 rloc
= start
+ rp
->r_offset
;
11958 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11960 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11961 (unsigned long) rp
->r_offset
,
11962 printable_section_name (section
));
11966 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11967 if (sym_index
>= num_syms
)
11969 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11970 sym_index
, printable_section_name (section
));
11973 sym
= symtab
+ sym_index
;
11975 /* If the reloc has a symbol associated with it,
11976 make sure that it is of an appropriate type.
11978 Relocations against symbols without type can happen.
11979 Gcc -feliminate-dwarf2-dups may generate symbols
11980 without type for debug info.
11982 Icc generates relocations against function symbols
11983 instead of local labels.
11985 Relocations against object symbols can happen, eg when
11986 referencing a global array. For an example of this see
11987 the _clz.o binary in libgcc.a. */
11989 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
11990 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11992 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11993 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11994 (long int)(rp
- relocs
),
11995 printable_section_name (relsec
));
12001 addend
+= rp
->r_addend
;
12002 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12003 partial_inplace. */
12005 || (elf_header
.e_machine
== EM_XTENSA
12006 && reloc_type
== 1)
12007 || ((elf_header
.e_machine
== EM_PJ
12008 || elf_header
.e_machine
== EM_PJ_OLD
)
12009 && reloc_type
== 1)
12010 || ((elf_header
.e_machine
== EM_D30V
12011 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12012 && reloc_type
== 12))
12013 addend
+= byte_get (rloc
, reloc_size
);
12015 if (is_32bit_pcrel_reloc (reloc_type
)
12016 || is_64bit_pcrel_reloc (reloc_type
))
12018 /* On HPPA, all pc-relative relocations are biased by 8. */
12019 if (elf_header
.e_machine
== EM_PARISC
)
12021 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12025 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12032 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12033 * num_relocs_return
= num_relocs
;
12042 #ifdef SUPPORT_DISASSEMBLY
12044 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12046 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12048 /* FIXME: XXX -- to be done --- XXX */
12054 /* Reads in the contents of SECTION from FILE, returning a pointer
12055 to a malloc'ed buffer or NULL if something went wrong. */
12058 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12060 bfd_size_type num_bytes
;
12062 num_bytes
= section
->sh_size
;
12064 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12066 printf (_("\nSection '%s' has no data to dump.\n"),
12067 printable_section_name (section
));
12071 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12072 _("section contents"));
12075 /* Uncompresses a section that was compressed using zlib, in place. */
12078 uncompress_section_contents (unsigned char **buffer
,
12079 dwarf_size_type uncompressed_size
,
12080 dwarf_size_type
*size
)
12082 dwarf_size_type compressed_size
= *size
;
12083 unsigned char * compressed_buffer
= *buffer
;
12084 unsigned char * uncompressed_buffer
;
12088 /* It is possible the section consists of several compressed
12089 buffers concatenated together, so we uncompress in a loop. */
12090 /* PR 18313: The state field in the z_stream structure is supposed
12091 to be invisible to the user (ie us), but some compilers will
12092 still complain about it being used without initialisation. So
12093 we first zero the entire z_stream structure and then set the fields
12095 memset (& strm
, 0, sizeof strm
);
12096 strm
.avail_in
= compressed_size
;
12097 strm
.next_in
= (Bytef
*) compressed_buffer
;
12098 strm
.avail_out
= uncompressed_size
;
12099 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12101 rc
= inflateInit (& strm
);
12102 while (strm
.avail_in
> 0)
12106 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12107 + (uncompressed_size
- strm
.avail_out
));
12108 rc
= inflate (&strm
, Z_FINISH
);
12109 if (rc
!= Z_STREAM_END
)
12111 rc
= inflateReset (& strm
);
12113 rc
= inflateEnd (& strm
);
12115 || strm
.avail_out
!= 0)
12118 *buffer
= uncompressed_buffer
;
12119 *size
= uncompressed_size
;
12123 free (uncompressed_buffer
);
12124 /* Indicate decompression failure. */
12130 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12132 Elf_Internal_Shdr
* relsec
;
12133 bfd_size_type num_bytes
;
12134 unsigned char * data
;
12135 unsigned char * end
;
12136 unsigned char * real_start
;
12137 unsigned char * start
;
12138 bfd_boolean some_strings_shown
;
12140 real_start
= start
= (unsigned char *) get_section_contents (section
,
12144 num_bytes
= section
->sh_size
;
12146 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12148 if (decompress_dumps
)
12150 dwarf_size_type new_size
= num_bytes
;
12151 dwarf_size_type uncompressed_size
= 0;
12153 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12155 Elf_Internal_Chdr chdr
;
12156 unsigned int compression_header_size
12157 = get_compression_header (& chdr
, (unsigned char *) start
);
12159 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12161 warn (_("section '%s' has unsupported compress type: %d\n"),
12162 printable_section_name (section
), chdr
.ch_type
);
12165 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12167 warn (_("compressed section '%s' is corrupted\n"),
12168 printable_section_name (section
));
12171 uncompressed_size
= chdr
.ch_size
;
12172 start
+= compression_header_size
;
12173 new_size
-= compression_header_size
;
12175 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12177 /* Read the zlib header. In this case, it should be "ZLIB"
12178 followed by the uncompressed section size, 8 bytes in
12179 big-endian order. */
12180 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12181 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12182 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12183 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12184 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12185 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12186 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12187 uncompressed_size
+= start
[11];
12192 if (uncompressed_size
12193 && uncompress_section_contents (& start
,
12194 uncompressed_size
, & new_size
))
12195 num_bytes
= new_size
;
12198 /* If the section being dumped has relocations against it the user might
12199 be expecting these relocations to have been applied. Check for this
12200 case and issue a warning message in order to avoid confusion.
12201 FIXME: Maybe we ought to have an option that dumps a section with
12202 relocs applied ? */
12203 for (relsec
= section_headers
;
12204 relsec
< section_headers
+ elf_header
.e_shnum
;
12207 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12208 || relsec
->sh_info
>= elf_header
.e_shnum
12209 || section_headers
+ relsec
->sh_info
!= section
12210 || relsec
->sh_size
== 0
12211 || relsec
->sh_link
>= elf_header
.e_shnum
)
12214 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12219 end
= start
+ num_bytes
;
12220 some_strings_shown
= FALSE
;
12224 while (!ISPRINT (* data
))
12225 if (++ data
>= end
)
12230 size_t maxlen
= end
- data
;
12233 /* PR 11128: Use two separate invocations in order to work
12234 around bugs in the Solaris 8 implementation of printf. */
12235 printf (" [%6tx] ", data
- start
);
12237 printf (" [%6Ix] ", (size_t) (data
- start
));
12241 print_symbol ((int) maxlen
, (const char *) data
);
12243 data
+= strnlen ((const char *) data
, maxlen
);
12247 printf (_("<corrupt>\n"));
12250 some_strings_shown
= TRUE
;
12254 if (! some_strings_shown
)
12255 printf (_(" No strings found in this section."));
12263 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12265 bfd_boolean relocate
)
12267 Elf_Internal_Shdr
* relsec
;
12268 bfd_size_type bytes
;
12269 bfd_size_type section_size
;
12271 unsigned char * data
;
12272 unsigned char * real_start
;
12273 unsigned char * start
;
12275 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12278 section_size
= section
->sh_size
;
12280 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12282 if (decompress_dumps
)
12284 dwarf_size_type new_size
= section_size
;
12285 dwarf_size_type uncompressed_size
= 0;
12287 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12289 Elf_Internal_Chdr chdr
;
12290 unsigned int compression_header_size
12291 = get_compression_header (& chdr
, start
);
12293 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12295 warn (_("section '%s' has unsupported compress type: %d\n"),
12296 printable_section_name (section
), chdr
.ch_type
);
12299 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12301 warn (_("compressed section '%s' is corrupted\n"),
12302 printable_section_name (section
));
12305 uncompressed_size
= chdr
.ch_size
;
12306 start
+= compression_header_size
;
12307 new_size
-= compression_header_size
;
12309 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12311 /* Read the zlib header. In this case, it should be "ZLIB"
12312 followed by the uncompressed section size, 8 bytes in
12313 big-endian order. */
12314 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12315 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12316 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12317 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12318 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12319 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12320 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12321 uncompressed_size
+= start
[11];
12326 if (uncompressed_size
12327 && uncompress_section_contents (& start
, uncompressed_size
,
12329 section_size
= new_size
;
12334 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12338 /* If the section being dumped has relocations against it the user might
12339 be expecting these relocations to have been applied. Check for this
12340 case and issue a warning message in order to avoid confusion.
12341 FIXME: Maybe we ought to have an option that dumps a section with
12342 relocs applied ? */
12343 for (relsec
= section_headers
;
12344 relsec
< section_headers
+ elf_header
.e_shnum
;
12347 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12348 || relsec
->sh_info
>= elf_header
.e_shnum
12349 || section_headers
+ relsec
->sh_info
!= section
12350 || relsec
->sh_size
== 0
12351 || relsec
->sh_link
>= elf_header
.e_shnum
)
12354 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12359 addr
= section
->sh_addr
;
12360 bytes
= section_size
;
12369 lbytes
= (bytes
> 16 ? 16 : bytes
);
12371 printf (" 0x%8.8lx ", (unsigned long) addr
);
12373 for (j
= 0; j
< 16; j
++)
12376 printf ("%2.2x", data
[j
]);
12384 for (j
= 0; j
< lbytes
; j
++)
12387 if (k
>= ' ' && k
< 0x7f)
12406 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12407 const Elf_Internal_Shdr
* sec
, void * file
)
12409 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12412 /* If it is already loaded, do nothing. */
12413 if (section
->start
!= NULL
)
12416 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12417 section
->address
= sec
->sh_addr
;
12418 section
->user_data
= NULL
;
12419 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12421 sec
->sh_size
, buf
);
12422 if (section
->start
== NULL
)
12426 unsigned char *start
= section
->start
;
12427 dwarf_size_type size
= sec
->sh_size
;
12428 dwarf_size_type uncompressed_size
= 0;
12430 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12432 Elf_Internal_Chdr chdr
;
12433 unsigned int compression_header_size
12434 = get_compression_header (&chdr
, start
);
12435 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12437 warn (_("section '%s' has unsupported compress type: %d\n"),
12438 section
->name
, chdr
.ch_type
);
12441 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12443 warn (_("compressed section '%s' is corrupted\n"),
12447 uncompressed_size
= chdr
.ch_size
;
12448 start
+= compression_header_size
;
12449 size
-= compression_header_size
;
12451 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12453 /* Read the zlib header. In this case, it should be "ZLIB"
12454 followed by the uncompressed section size, 8 bytes in
12455 big-endian order. */
12456 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12457 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12458 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12459 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12460 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12461 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12462 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12463 uncompressed_size
+= start
[11];
12468 if (uncompressed_size
12469 && uncompress_section_contents (&start
, uncompressed_size
,
12472 /* Free the compressed buffer, update the section buffer
12473 and the section size if uncompress is successful. */
12474 free (section
->start
);
12475 section
->start
= start
;
12477 section
->size
= size
;
12480 if (section
->start
== NULL
)
12483 if (debug_displays
[debug
].relocate
)
12484 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12485 & section
->reloc_info
, & section
->num_relocs
);
12488 section
->reloc_info
= NULL
;
12489 section
->num_relocs
= 0;
12495 /* If this is not NULL, load_debug_section will only look for sections
12496 within the list of sections given here. */
12497 unsigned int *section_subset
= NULL
;
12500 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12502 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12503 Elf_Internal_Shdr
* sec
;
12505 /* Locate the debug section. */
12506 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12508 section
->name
= section
->uncompressed_name
;
12511 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12513 section
->name
= section
->compressed_name
;
12518 /* If we're loading from a subset of sections, and we've loaded
12519 a section matching this name before, it's likely that it's a
12521 if (section_subset
!= NULL
)
12522 free_debug_section (debug
);
12524 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12528 free_debug_section (enum dwarf_section_display_enum debug
)
12530 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12532 if (section
->start
== NULL
)
12535 free ((char *) section
->start
);
12536 section
->start
= NULL
;
12537 section
->address
= 0;
12542 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12544 char * name
= SECTION_NAME (section
);
12545 const char * print_name
= printable_section_name (section
);
12546 bfd_size_type length
;
12550 length
= section
->sh_size
;
12553 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12556 if (section
->sh_type
== SHT_NOBITS
)
12558 /* There is no point in dumping the contents of a debugging section
12559 which has the NOBITS type - the bits in the file will be random.
12560 This can happen when a file containing a .eh_frame section is
12561 stripped with the --only-keep-debug command line option. */
12562 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12567 if (const_strneq (name
, ".gnu.linkonce.wi."))
12568 name
= ".debug_info";
12570 /* See if we know how to display the contents of this section. */
12571 for (i
= 0; i
< max
; i
++)
12572 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12573 || (i
== line
&& const_strneq (name
, ".debug_line."))
12574 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12576 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12577 int secondary
= (section
!= find_section (name
));
12580 free_debug_section ((enum dwarf_section_display_enum
) i
);
12582 if (i
== line
&& const_strneq (name
, ".debug_line."))
12584 else if (streq (sec
->uncompressed_name
, name
))
12585 sec
->name
= sec
->uncompressed_name
;
12587 sec
->name
= sec
->compressed_name
;
12588 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12591 /* If this debug section is part of a CU/TU set in a .dwp file,
12592 restrict load_debug_section to the sections in that set. */
12593 section_subset
= find_cu_tu_set (file
, shndx
);
12595 result
&= debug_displays
[i
].display (sec
, file
);
12597 section_subset
= NULL
;
12599 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12600 free_debug_section ((enum dwarf_section_display_enum
) i
);
12608 printf (_("Unrecognized debug section: %s\n"), print_name
);
12615 /* Set DUMP_SECTS for all sections where dumps were requested
12616 based on section name. */
12619 initialise_dumps_byname (void)
12621 struct dump_list_entry
* cur
;
12623 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12628 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12629 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12631 request_dump_bynumber (i
, cur
->type
);
12636 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12642 process_section_contents (FILE * file
)
12644 Elf_Internal_Shdr
* section
;
12650 initialise_dumps_byname ();
12652 for (i
= 0, section
= section_headers
;
12653 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12656 #ifdef SUPPORT_DISASSEMBLY
12657 if (dump_sects
[i
] & DISASS_DUMP
)
12658 disassemble_section (section
, file
);
12660 if (dump_sects
[i
] & HEX_DUMP
)
12661 dump_section_as_bytes (section
, file
, FALSE
);
12663 if (dump_sects
[i
] & RELOC_DUMP
)
12664 dump_section_as_bytes (section
, file
, TRUE
);
12666 if (dump_sects
[i
] & STRING_DUMP
)
12667 dump_section_as_strings (section
, file
);
12669 if (dump_sects
[i
] & DEBUG_DUMP
)
12670 display_debug_section (i
, section
, file
);
12673 /* Check to see if the user requested a
12674 dump of a section that does not exist. */
12675 while (i
++ < num_dump_sects
)
12677 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12681 process_mips_fpe_exception (int mask
)
12686 if (mask
& OEX_FPU_INEX
)
12687 fputs ("INEX", stdout
), first
= 0;
12688 if (mask
& OEX_FPU_UFLO
)
12689 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12690 if (mask
& OEX_FPU_OFLO
)
12691 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12692 if (mask
& OEX_FPU_DIV0
)
12693 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12694 if (mask
& OEX_FPU_INVAL
)
12695 printf ("%sINVAL", first
? "" : "|");
12698 fputs ("0", stdout
);
12701 /* Display's the value of TAG at location P. If TAG is
12702 greater than 0 it is assumed to be an unknown tag, and
12703 a message is printed to this effect. Otherwise it is
12704 assumed that a message has already been printed.
12706 If the bottom bit of TAG is set it assumed to have a
12707 string value, otherwise it is assumed to have an integer
12710 Returns an updated P pointing to the first unread byte
12711 beyond the end of TAG's value.
12713 Reads at or beyond END will not be made. */
12715 static unsigned char *
12716 display_tag_value (int tag
,
12718 const unsigned char * const end
)
12723 printf (" Tag_unknown_%d: ", tag
);
12727 warn (_("<corrupt tag>\n"));
12731 /* PR 17531 file: 027-19978-0.004. */
12732 size_t maxlen
= (end
- p
) - 1;
12737 print_symbol ((int) maxlen
, (const char *) p
);
12738 p
+= strnlen ((char *) p
, maxlen
) + 1;
12742 printf (_("<corrupt string tag>"));
12743 p
= (unsigned char *) end
;
12751 val
= read_uleb128 (p
, &len
, end
);
12753 printf ("%ld (0x%lx)\n", val
, val
);
12760 /* ARM EABI attributes section. */
12765 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12767 const char ** table
;
12768 } arm_attr_public_tag
;
12770 static const char * arm_attr_tag_CPU_arch
[] =
12771 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12772 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12774 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12775 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12776 {"No", "Thumb-1", "Thumb-2", "Yes"};
12777 static const char * arm_attr_tag_FP_arch
[] =
12778 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12779 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12780 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12781 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12782 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12783 "NEON for ARMv8.1"};
12784 static const char * arm_attr_tag_PCS_config
[] =
12785 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12786 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12787 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12788 {"V6", "SB", "TLS", "Unused"};
12789 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12790 {"Absolute", "PC-relative", "SB-relative", "None"};
12791 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12792 {"Absolute", "PC-relative", "None"};
12793 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12794 {"None", "direct", "GOT-indirect"};
12795 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12796 {"None", "??? 1", "2", "??? 3", "4"};
12797 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12798 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12799 {"Unused", "Needed", "Sign only"};
12800 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12801 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12802 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12803 {"Unused", "Finite", "RTABI", "IEEE 754"};
12804 static const char * arm_attr_tag_ABI_enum_size
[] =
12805 {"Unused", "small", "int", "forced to int"};
12806 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12807 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12808 static const char * arm_attr_tag_ABI_VFP_args
[] =
12809 {"AAPCS", "VFP registers", "custom", "compatible"};
12810 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12811 {"AAPCS", "WMMX registers", "custom"};
12812 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12813 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12814 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12815 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12816 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12817 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12818 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12819 static const char * arm_attr_tag_FP_HP_extension
[] =
12820 {"Not Allowed", "Allowed"};
12821 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12822 {"None", "IEEE 754", "Alternative Format"};
12823 static const char * arm_attr_tag_MPextension_use
[] =
12824 {"Not Allowed", "Allowed"};
12825 static const char * arm_attr_tag_DIV_use
[] =
12826 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12827 "Allowed in v7-A with integer division extension"};
12828 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12829 static const char * arm_attr_tag_Virtualization_use
[] =
12830 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12831 "TrustZone and Virtualization Extensions"};
12832 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12833 {"Not Allowed", "Allowed"};
12835 #define LOOKUP(id, name) \
12836 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12837 static arm_attr_public_tag arm_attr_public_tags
[] =
12839 {4, "CPU_raw_name", 1, NULL
},
12840 {5, "CPU_name", 1, NULL
},
12841 LOOKUP(6, CPU_arch
),
12842 {7, "CPU_arch_profile", 0, NULL
},
12843 LOOKUP(8, ARM_ISA_use
),
12844 LOOKUP(9, THUMB_ISA_use
),
12845 LOOKUP(10, FP_arch
),
12846 LOOKUP(11, WMMX_arch
),
12847 LOOKUP(12, Advanced_SIMD_arch
),
12848 LOOKUP(13, PCS_config
),
12849 LOOKUP(14, ABI_PCS_R9_use
),
12850 LOOKUP(15, ABI_PCS_RW_data
),
12851 LOOKUP(16, ABI_PCS_RO_data
),
12852 LOOKUP(17, ABI_PCS_GOT_use
),
12853 LOOKUP(18, ABI_PCS_wchar_t
),
12854 LOOKUP(19, ABI_FP_rounding
),
12855 LOOKUP(20, ABI_FP_denormal
),
12856 LOOKUP(21, ABI_FP_exceptions
),
12857 LOOKUP(22, ABI_FP_user_exceptions
),
12858 LOOKUP(23, ABI_FP_number_model
),
12859 {24, "ABI_align_needed", 0, NULL
},
12860 {25, "ABI_align_preserved", 0, NULL
},
12861 LOOKUP(26, ABI_enum_size
),
12862 LOOKUP(27, ABI_HardFP_use
),
12863 LOOKUP(28, ABI_VFP_args
),
12864 LOOKUP(29, ABI_WMMX_args
),
12865 LOOKUP(30, ABI_optimization_goals
),
12866 LOOKUP(31, ABI_FP_optimization_goals
),
12867 {32, "compatibility", 0, NULL
},
12868 LOOKUP(34, CPU_unaligned_access
),
12869 LOOKUP(36, FP_HP_extension
),
12870 LOOKUP(38, ABI_FP_16bit_format
),
12871 LOOKUP(42, MPextension_use
),
12872 LOOKUP(44, DIV_use
),
12873 {64, "nodefaults", 0, NULL
},
12874 {65, "also_compatible_with", 0, NULL
},
12875 LOOKUP(66, T2EE_use
),
12876 {67, "conformance", 1, NULL
},
12877 LOOKUP(68, Virtualization_use
),
12878 LOOKUP(70, MPextension_use_legacy
)
12882 static unsigned char *
12883 display_arm_attribute (unsigned char * p
,
12884 const unsigned char * const end
)
12889 arm_attr_public_tag
* attr
;
12893 tag
= read_uleb128 (p
, &len
, end
);
12896 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12898 if (arm_attr_public_tags
[i
].tag
== tag
)
12900 attr
= &arm_attr_public_tags
[i
];
12907 printf (" Tag_%s: ", attr
->name
);
12908 switch (attr
->type
)
12913 case 7: /* Tag_CPU_arch_profile. */
12914 val
= read_uleb128 (p
, &len
, end
);
12918 case 0: printf (_("None\n")); break;
12919 case 'A': printf (_("Application\n")); break;
12920 case 'R': printf (_("Realtime\n")); break;
12921 case 'M': printf (_("Microcontroller\n")); break;
12922 case 'S': printf (_("Application or Realtime\n")); break;
12923 default: printf ("??? (%d)\n", val
); break;
12927 case 24: /* Tag_align_needed. */
12928 val
= read_uleb128 (p
, &len
, end
);
12932 case 0: printf (_("None\n")); break;
12933 case 1: printf (_("8-byte\n")); break;
12934 case 2: printf (_("4-byte\n")); break;
12935 case 3: printf ("??? 3\n"); break;
12938 printf (_("8-byte and up to %d-byte extended\n"),
12941 printf ("??? (%d)\n", val
);
12946 case 25: /* Tag_align_preserved. */
12947 val
= read_uleb128 (p
, &len
, end
);
12951 case 0: printf (_("None\n")); break;
12952 case 1: printf (_("8-byte, except leaf SP\n")); break;
12953 case 2: printf (_("8-byte\n")); break;
12954 case 3: printf ("??? 3\n"); break;
12957 printf (_("8-byte and up to %d-byte extended\n"),
12960 printf ("??? (%d)\n", val
);
12965 case 32: /* Tag_compatibility. */
12967 val
= read_uleb128 (p
, &len
, end
);
12969 printf (_("flag = %d, vendor = "), val
);
12972 size_t maxlen
= (end
- p
) - 1;
12974 print_symbol ((int) maxlen
, (const char *) p
);
12975 p
+= strnlen ((char *) p
, maxlen
) + 1;
12979 printf (_("<corrupt>"));
12980 p
= (unsigned char *) end
;
12986 case 64: /* Tag_nodefaults. */
12987 /* PR 17531: file: 001-505008-0.01. */
12990 printf (_("True\n"));
12993 case 65: /* Tag_also_compatible_with. */
12994 val
= read_uleb128 (p
, &len
, end
);
12996 if (val
== 6 /* Tag_CPU_arch. */)
12998 val
= read_uleb128 (p
, &len
, end
);
13000 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13001 printf ("??? (%d)\n", val
);
13003 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13007 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13012 printf (_("<unknown: %d>\n"), tag
);
13018 return display_tag_value (-1, p
, end
);
13020 return display_tag_value (0, p
, end
);
13023 assert (attr
->type
& 0x80);
13024 val
= read_uleb128 (p
, &len
, end
);
13026 type
= attr
->type
& 0x7f;
13028 printf ("??? (%d)\n", val
);
13030 printf ("%s\n", attr
->table
[val
]);
13035 return display_tag_value (tag
, p
, end
);
13038 static unsigned char *
13039 display_gnu_attribute (unsigned char * p
,
13040 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13041 const unsigned char * const end
)
13047 tag
= read_uleb128 (p
, &len
, end
);
13050 /* Tag_compatibility is the only generic GNU attribute defined at
13054 val
= read_uleb128 (p
, &len
, end
);
13057 printf (_("flag = %d, vendor = "), val
);
13060 printf (_("<corrupt>\n"));
13061 warn (_("corrupt vendor attribute\n"));
13067 size_t maxlen
= (end
- p
) - 1;
13069 print_symbol ((int) maxlen
, (const char *) p
);
13070 p
+= strnlen ((char *) p
, maxlen
) + 1;
13074 printf (_("<corrupt>"));
13075 p
= (unsigned char *) end
;
13082 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13083 return display_proc_gnu_attribute (p
, tag
, end
);
13085 return display_tag_value (tag
, p
, end
);
13088 static unsigned char *
13089 display_power_gnu_attribute (unsigned char * p
,
13091 const unsigned char * const end
)
13096 if (tag
== Tag_GNU_Power_ABI_FP
)
13098 val
= read_uleb128 (p
, &len
, end
);
13100 printf (" Tag_GNU_Power_ABI_FP: ");
13105 printf (_("Hard or soft float\n"));
13108 printf (_("Hard float\n"));
13111 printf (_("Soft float\n"));
13114 printf (_("Single-precision hard float\n"));
13117 printf ("??? (%d)\n", val
);
13123 if (tag
== Tag_GNU_Power_ABI_Vector
)
13125 val
= read_uleb128 (p
, &len
, end
);
13127 printf (" Tag_GNU_Power_ABI_Vector: ");
13131 printf (_("Any\n"));
13134 printf (_("Generic\n"));
13137 printf ("AltiVec\n");
13143 printf ("??? (%d)\n", val
);
13149 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13153 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13157 val
= read_uleb128 (p
, &len
, end
);
13159 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13163 printf (_("Any\n"));
13166 printf ("r3/r4\n");
13169 printf (_("Memory\n"));
13172 printf ("??? (%d)\n", val
);
13178 return display_tag_value (tag
& 1, p
, end
);
13181 static unsigned char *
13182 display_s390_gnu_attribute (unsigned char * p
,
13184 const unsigned char * const end
)
13189 if (tag
== Tag_GNU_S390_ABI_Vector
)
13191 val
= read_uleb128 (p
, &len
, end
);
13193 printf (" Tag_GNU_S390_ABI_Vector: ");
13198 printf (_("any\n"));
13201 printf (_("software\n"));
13204 printf (_("hardware\n"));
13207 printf ("??? (%d)\n", val
);
13213 return display_tag_value (tag
& 1, p
, end
);
13217 display_sparc_hwcaps (int mask
)
13223 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13224 fputs ("mul32", stdout
), first
= 0;
13225 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13226 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13227 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13228 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13229 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13230 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13231 if (mask
& ELF_SPARC_HWCAP_POPC
)
13232 printf ("%spopc", first
? "" : "|"), first
= 0;
13233 if (mask
& ELF_SPARC_HWCAP_VIS
)
13234 printf ("%svis", first
? "" : "|"), first
= 0;
13235 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13236 printf ("%svis2", first
? "" : "|"), first
= 0;
13237 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13238 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13239 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13240 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13241 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13242 printf ("%svis3", first
? "" : "|"), first
= 0;
13243 if (mask
& ELF_SPARC_HWCAP_HPC
)
13244 printf ("%shpc", first
? "" : "|"), first
= 0;
13245 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13246 printf ("%srandom", first
? "" : "|"), first
= 0;
13247 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13248 printf ("%strans", first
? "" : "|"), first
= 0;
13249 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13250 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13251 if (mask
& ELF_SPARC_HWCAP_IMA
)
13252 printf ("%sima", first
? "" : "|"), first
= 0;
13253 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13254 printf ("%scspare", first
? "" : "|"), first
= 0;
13257 fputc ('0', stdout
);
13258 fputc ('\n', stdout
);
13262 display_sparc_hwcaps2 (int mask
)
13268 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13269 fputs ("fjathplus", stdout
), first
= 0;
13270 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13271 printf ("%svis3b", first
? "" : "|"), first
= 0;
13272 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13273 printf ("%sadp", first
? "" : "|"), first
= 0;
13274 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13275 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13276 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13277 printf ("%smwait", first
? "" : "|"), first
= 0;
13278 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13279 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13280 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13281 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13282 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13283 printf ("%snsec", first
? "" : "|"), first
= 0;
13284 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13285 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13286 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13287 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13288 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13289 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13292 fputc ('0', stdout
);
13293 fputc ('\n', stdout
);
13296 static unsigned char *
13297 display_sparc_gnu_attribute (unsigned char * p
,
13299 const unsigned char * const end
)
13304 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13306 val
= read_uleb128 (p
, &len
, end
);
13308 printf (" Tag_GNU_Sparc_HWCAPS: ");
13309 display_sparc_hwcaps (val
);
13312 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13314 val
= read_uleb128 (p
, &len
, end
);
13316 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13317 display_sparc_hwcaps2 (val
);
13321 return display_tag_value (tag
, p
, end
);
13325 print_mips_fp_abi_value (int val
)
13329 case Val_GNU_MIPS_ABI_FP_ANY
:
13330 printf (_("Hard or soft float\n"));
13332 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13333 printf (_("Hard float (double precision)\n"));
13335 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13336 printf (_("Hard float (single precision)\n"));
13338 case Val_GNU_MIPS_ABI_FP_SOFT
:
13339 printf (_("Soft float\n"));
13341 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13342 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13344 case Val_GNU_MIPS_ABI_FP_XX
:
13345 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13347 case Val_GNU_MIPS_ABI_FP_64
:
13348 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13350 case Val_GNU_MIPS_ABI_FP_64A
:
13351 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13353 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13354 printf (_("NaN 2008 compatibility\n"));
13357 printf ("??? (%d)\n", val
);
13362 static unsigned char *
13363 display_mips_gnu_attribute (unsigned char * p
,
13365 const unsigned char * const end
)
13367 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13372 val
= read_uleb128 (p
, &len
, end
);
13374 printf (" Tag_GNU_MIPS_ABI_FP: ");
13376 print_mips_fp_abi_value (val
);
13381 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13386 val
= read_uleb128 (p
, &len
, end
);
13388 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13392 case Val_GNU_MIPS_ABI_MSA_ANY
:
13393 printf (_("Any MSA or not\n"));
13395 case Val_GNU_MIPS_ABI_MSA_128
:
13396 printf (_("128-bit MSA\n"));
13399 printf ("??? (%d)\n", val
);
13405 return display_tag_value (tag
& 1, p
, end
);
13408 static unsigned char *
13409 display_tic6x_attribute (unsigned char * p
,
13410 const unsigned char * const end
)
13416 tag
= read_uleb128 (p
, &len
, end
);
13422 val
= read_uleb128 (p
, &len
, end
);
13424 printf (" Tag_ISA: ");
13428 case C6XABI_Tag_ISA_none
:
13429 printf (_("None\n"));
13431 case C6XABI_Tag_ISA_C62X
:
13434 case C6XABI_Tag_ISA_C67X
:
13437 case C6XABI_Tag_ISA_C67XP
:
13438 printf ("C67x+\n");
13440 case C6XABI_Tag_ISA_C64X
:
13443 case C6XABI_Tag_ISA_C64XP
:
13444 printf ("C64x+\n");
13446 case C6XABI_Tag_ISA_C674X
:
13447 printf ("C674x\n");
13450 printf ("??? (%d)\n", val
);
13455 case Tag_ABI_wchar_t
:
13456 val
= read_uleb128 (p
, &len
, end
);
13458 printf (" Tag_ABI_wchar_t: ");
13462 printf (_("Not used\n"));
13465 printf (_("2 bytes\n"));
13468 printf (_("4 bytes\n"));
13471 printf ("??? (%d)\n", val
);
13476 case Tag_ABI_stack_align_needed
:
13477 val
= read_uleb128 (p
, &len
, end
);
13479 printf (" Tag_ABI_stack_align_needed: ");
13483 printf (_("8-byte\n"));
13486 printf (_("16-byte\n"));
13489 printf ("??? (%d)\n", val
);
13494 case Tag_ABI_stack_align_preserved
:
13495 val
= read_uleb128 (p
, &len
, end
);
13497 printf (" Tag_ABI_stack_align_preserved: ");
13501 printf (_("8-byte\n"));
13504 printf (_("16-byte\n"));
13507 printf ("??? (%d)\n", val
);
13513 val
= read_uleb128 (p
, &len
, end
);
13515 printf (" Tag_ABI_DSBT: ");
13519 printf (_("DSBT addressing not used\n"));
13522 printf (_("DSBT addressing used\n"));
13525 printf ("??? (%d)\n", val
);
13531 val
= read_uleb128 (p
, &len
, end
);
13533 printf (" Tag_ABI_PID: ");
13537 printf (_("Data addressing position-dependent\n"));
13540 printf (_("Data addressing position-independent, GOT near DP\n"));
13543 printf (_("Data addressing position-independent, GOT far from DP\n"));
13546 printf ("??? (%d)\n", val
);
13552 val
= read_uleb128 (p
, &len
, end
);
13554 printf (" Tag_ABI_PIC: ");
13558 printf (_("Code addressing position-dependent\n"));
13561 printf (_("Code addressing position-independent\n"));
13564 printf ("??? (%d)\n", val
);
13569 case Tag_ABI_array_object_alignment
:
13570 val
= read_uleb128 (p
, &len
, end
);
13572 printf (" Tag_ABI_array_object_alignment: ");
13576 printf (_("8-byte\n"));
13579 printf (_("4-byte\n"));
13582 printf (_("16-byte\n"));
13585 printf ("??? (%d)\n", val
);
13590 case Tag_ABI_array_object_align_expected
:
13591 val
= read_uleb128 (p
, &len
, end
);
13593 printf (" Tag_ABI_array_object_align_expected: ");
13597 printf (_("8-byte\n"));
13600 printf (_("4-byte\n"));
13603 printf (_("16-byte\n"));
13606 printf ("??? (%d)\n", val
);
13611 case Tag_ABI_compatibility
:
13613 val
= read_uleb128 (p
, &len
, end
);
13615 printf (" Tag_ABI_compatibility: ");
13616 printf (_("flag = %d, vendor = "), val
);
13619 size_t maxlen
= (end
- p
) - 1;
13621 print_symbol ((int) maxlen
, (const char *) p
);
13622 p
+= strnlen ((char *) p
, maxlen
) + 1;
13626 printf (_("<corrupt>"));
13627 p
= (unsigned char *) end
;
13633 case Tag_ABI_conformance
:
13635 printf (" Tag_ABI_conformance: \"");
13638 size_t maxlen
= (end
- p
) - 1;
13640 print_symbol ((int) maxlen
, (const char *) p
);
13641 p
+= strnlen ((char *) p
, maxlen
) + 1;
13645 printf (_("<corrupt>"));
13646 p
= (unsigned char *) end
;
13653 return display_tag_value (tag
, p
, end
);
13657 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13659 unsigned long addr
= 0;
13660 size_t bytes
= end
- p
;
13667 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13669 printf (" 0x%8.8lx ", addr
);
13671 for (j
= 0; j
< 16; j
++)
13674 printf ("%2.2x", p
[j
]);
13682 for (j
= 0; j
< lbytes
; j
++)
13685 if (k
>= ' ' && k
< 0x7f)
13701 static unsigned char *
13702 display_msp430x_attribute (unsigned char * p
,
13703 const unsigned char * const end
)
13709 tag
= read_uleb128 (p
, & len
, end
);
13714 case OFBA_MSPABI_Tag_ISA
:
13715 val
= read_uleb128 (p
, &len
, end
);
13717 printf (" Tag_ISA: ");
13720 case 0: printf (_("None\n")); break;
13721 case 1: printf (_("MSP430\n")); break;
13722 case 2: printf (_("MSP430X\n")); break;
13723 default: printf ("??? (%d)\n", val
); break;
13727 case OFBA_MSPABI_Tag_Code_Model
:
13728 val
= read_uleb128 (p
, &len
, end
);
13730 printf (" Tag_Code_Model: ");
13733 case 0: printf (_("None\n")); break;
13734 case 1: printf (_("Small\n")); break;
13735 case 2: printf (_("Large\n")); break;
13736 default: printf ("??? (%d)\n", val
); break;
13740 case OFBA_MSPABI_Tag_Data_Model
:
13741 val
= read_uleb128 (p
, &len
, end
);
13743 printf (" Tag_Data_Model: ");
13746 case 0: printf (_("None\n")); break;
13747 case 1: printf (_("Small\n")); break;
13748 case 2: printf (_("Large\n")); break;
13749 case 3: printf (_("Restricted Large\n")); break;
13750 default: printf ("??? (%d)\n", val
); break;
13755 printf (_(" <unknown tag %d>: "), tag
);
13762 size_t maxlen
= (end
- p
) - 1;
13764 print_symbol ((int) maxlen
, (const char *) p
);
13765 p
+= strnlen ((char *) p
, maxlen
) + 1;
13769 printf (_("<corrupt>"));
13770 p
= (unsigned char *) end
;
13776 val
= read_uleb128 (p
, &len
, end
);
13778 printf ("%d (0x%x)\n", val
, val
);
13788 process_attributes (FILE * file
,
13789 const char * public_name
,
13790 unsigned int proc_type
,
13791 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13792 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13794 Elf_Internal_Shdr
* sect
;
13797 /* Find the section header so that we get the size. */
13798 for (i
= 0, sect
= section_headers
;
13799 i
< elf_header
.e_shnum
;
13802 unsigned char * contents
;
13805 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13808 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13809 sect
->sh_size
, _("attributes"));
13810 if (contents
== NULL
)
13816 bfd_vma section_len
;
13818 section_len
= sect
->sh_size
- 1;
13821 while (section_len
> 0)
13824 unsigned int namelen
;
13825 bfd_boolean public_section
;
13826 bfd_boolean gnu_section
;
13828 if (section_len
<= 4)
13830 error (_("Tag section ends prematurely\n"));
13833 attr_len
= byte_get (p
, 4);
13836 if (attr_len
> section_len
)
13838 error (_("Bad attribute length (%u > %u)\n"),
13839 (unsigned) attr_len
, (unsigned) section_len
);
13840 attr_len
= section_len
;
13842 /* PR 17531: file: 001-101425-0.004 */
13843 else if (attr_len
< 5)
13845 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13849 section_len
-= attr_len
;
13852 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13853 if (namelen
== 0 || namelen
>= attr_len
)
13855 error (_("Corrupt attribute section name\n"));
13859 printf (_("Attribute Section: "));
13860 print_symbol (INT_MAX
, (const char *) p
);
13863 if (public_name
&& streq ((char *) p
, public_name
))
13864 public_section
= TRUE
;
13866 public_section
= FALSE
;
13868 if (streq ((char *) p
, "gnu"))
13869 gnu_section
= TRUE
;
13871 gnu_section
= FALSE
;
13874 attr_len
-= namelen
;
13876 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13881 unsigned char * end
;
13883 /* PR binutils/17531: Safe handling of corrupt files. */
13886 error (_("Unused bytes at end of section\n"));
13892 size
= byte_get (p
, 4);
13893 if (size
> attr_len
)
13895 error (_("Bad subsection length (%u > %u)\n"),
13896 (unsigned) size
, (unsigned) attr_len
);
13899 /* PR binutils/17531: Safe handling of corrupt files. */
13902 error (_("Bad subsection length (%u < 6)\n"),
13909 end
= p
+ size
- 1;
13910 assert (end
<= contents
+ sect
->sh_size
);
13916 printf (_("File Attributes\n"));
13919 printf (_("Section Attributes:"));
13922 printf (_("Symbol Attributes:"));
13928 val
= read_uleb128 (p
, &j
, end
);
13932 printf (" %d", val
);
13937 printf (_("Unknown tag: %d\n"), tag
);
13938 public_section
= FALSE
;
13942 if (public_section
&& display_pub_attribute
!= NULL
)
13945 p
= display_pub_attribute (p
, end
);
13948 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13951 p
= display_gnu_attribute (p
,
13952 display_proc_gnu_attribute
,
13958 printf (_(" Unknown attribute:\n"));
13959 display_raw_attribute (p
, end
);
13968 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13976 process_arm_specific (FILE * file
)
13978 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13979 display_arm_attribute
, NULL
);
13983 process_power_specific (FILE * file
)
13985 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13986 display_power_gnu_attribute
);
13990 process_s390_specific (FILE * file
)
13992 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13993 display_s390_gnu_attribute
);
13997 process_sparc_specific (FILE * file
)
13999 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14000 display_sparc_gnu_attribute
);
14004 process_tic6x_specific (FILE * file
)
14006 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14007 display_tic6x_attribute
, NULL
);
14011 process_msp430x_specific (FILE * file
)
14013 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14014 display_msp430x_attribute
, NULL
);
14017 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14018 Print the Address, Access and Initial fields of an entry at VMA ADDR
14019 and return the VMA of the next entry, or -1 if there was a problem.
14020 Does not read from DATA_END or beyond. */
14023 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14024 unsigned char * data_end
)
14027 print_vma (addr
, LONG_HEX
);
14029 if (addr
< pltgot
+ 0xfff0)
14030 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14032 printf ("%10s", "");
14035 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14039 unsigned char * from
= data
+ addr
- pltgot
;
14041 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14043 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14044 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14045 return (bfd_vma
) -1;
14049 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14050 print_vma (entry
, LONG_HEX
);
14053 return addr
+ (is_32bit_elf
? 4 : 8);
14056 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14057 PLTGOT. Print the Address and Initial fields of an entry at VMA
14058 ADDR and return the VMA of the next entry. */
14061 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14064 print_vma (addr
, LONG_HEX
);
14067 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14072 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14073 print_vma (entry
, LONG_HEX
);
14075 return addr
+ (is_32bit_elf
? 4 : 8);
14079 print_mips_ases (unsigned int mask
)
14081 if (mask
& AFL_ASE_DSP
)
14082 fputs ("\n\tDSP ASE", stdout
);
14083 if (mask
& AFL_ASE_DSPR2
)
14084 fputs ("\n\tDSP R2 ASE", stdout
);
14085 if (mask
& AFL_ASE_EVA
)
14086 fputs ("\n\tEnhanced VA Scheme", stdout
);
14087 if (mask
& AFL_ASE_MCU
)
14088 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14089 if (mask
& AFL_ASE_MDMX
)
14090 fputs ("\n\tMDMX ASE", stdout
);
14091 if (mask
& AFL_ASE_MIPS3D
)
14092 fputs ("\n\tMIPS-3D ASE", stdout
);
14093 if (mask
& AFL_ASE_MT
)
14094 fputs ("\n\tMT ASE", stdout
);
14095 if (mask
& AFL_ASE_SMARTMIPS
)
14096 fputs ("\n\tSmartMIPS ASE", stdout
);
14097 if (mask
& AFL_ASE_VIRT
)
14098 fputs ("\n\tVZ ASE", stdout
);
14099 if (mask
& AFL_ASE_MSA
)
14100 fputs ("\n\tMSA ASE", stdout
);
14101 if (mask
& AFL_ASE_MIPS16
)
14102 fputs ("\n\tMIPS16 ASE", stdout
);
14103 if (mask
& AFL_ASE_MICROMIPS
)
14104 fputs ("\n\tMICROMIPS ASE", stdout
);
14105 if (mask
& AFL_ASE_XPA
)
14106 fputs ("\n\tXPA ASE", stdout
);
14108 fprintf (stdout
, "\n\t%s", _("None"));
14109 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14110 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14114 print_mips_isa_ext (unsigned int isa_ext
)
14119 fputs (_("None"), stdout
);
14122 fputs ("RMI XLR", stdout
);
14124 case AFL_EXT_OCTEON3
:
14125 fputs ("Cavium Networks Octeon3", stdout
);
14127 case AFL_EXT_OCTEON2
:
14128 fputs ("Cavium Networks Octeon2", stdout
);
14130 case AFL_EXT_OCTEONP
:
14131 fputs ("Cavium Networks OcteonP", stdout
);
14133 case AFL_EXT_LOONGSON_3A
:
14134 fputs ("Loongson 3A", stdout
);
14136 case AFL_EXT_OCTEON
:
14137 fputs ("Cavium Networks Octeon", stdout
);
14140 fputs ("Toshiba R5900", stdout
);
14143 fputs ("MIPS R4650", stdout
);
14146 fputs ("LSI R4010", stdout
);
14149 fputs ("NEC VR4100", stdout
);
14152 fputs ("Toshiba R3900", stdout
);
14154 case AFL_EXT_10000
:
14155 fputs ("MIPS R10000", stdout
);
14158 fputs ("Broadcom SB-1", stdout
);
14161 fputs ("NEC VR4111/VR4181", stdout
);
14164 fputs ("NEC VR4120", stdout
);
14167 fputs ("NEC VR5400", stdout
);
14170 fputs ("NEC VR5500", stdout
);
14172 case AFL_EXT_LOONGSON_2E
:
14173 fputs ("ST Microelectronics Loongson 2E", stdout
);
14175 case AFL_EXT_LOONGSON_2F
:
14176 fputs ("ST Microelectronics Loongson 2F", stdout
);
14179 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14184 get_mips_reg_size (int reg_size
)
14186 return (reg_size
== AFL_REG_NONE
) ? 0
14187 : (reg_size
== AFL_REG_32
) ? 32
14188 : (reg_size
== AFL_REG_64
) ? 64
14189 : (reg_size
== AFL_REG_128
) ? 128
14194 process_mips_specific (FILE * file
)
14196 Elf_Internal_Dyn
* entry
;
14197 Elf_Internal_Shdr
*sect
= NULL
;
14198 size_t liblist_offset
= 0;
14199 size_t liblistno
= 0;
14200 size_t conflictsno
= 0;
14201 size_t options_offset
= 0;
14202 size_t conflicts_offset
= 0;
14203 size_t pltrelsz
= 0;
14205 bfd_vma pltgot
= 0;
14206 bfd_vma mips_pltgot
= 0;
14207 bfd_vma jmprel
= 0;
14208 bfd_vma local_gotno
= 0;
14209 bfd_vma gotsym
= 0;
14210 bfd_vma symtabno
= 0;
14212 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14213 display_mips_gnu_attribute
);
14215 sect
= find_section (".MIPS.abiflags");
14219 Elf_External_ABIFlags_v0
*abiflags_ext
;
14220 Elf_Internal_ABIFlags_v0 abiflags_in
;
14222 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14223 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14226 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14227 sect
->sh_size
, _("MIPS ABI Flags section"));
14230 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14231 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14232 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14233 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14234 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14235 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14236 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14237 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14238 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14239 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14240 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14242 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14243 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14244 if (abiflags_in
.isa_rev
> 1)
14245 printf ("r%d", abiflags_in
.isa_rev
);
14246 printf ("\nGPR size: %d",
14247 get_mips_reg_size (abiflags_in
.gpr_size
));
14248 printf ("\nCPR1 size: %d",
14249 get_mips_reg_size (abiflags_in
.cpr1_size
));
14250 printf ("\nCPR2 size: %d",
14251 get_mips_reg_size (abiflags_in
.cpr2_size
));
14252 fputs ("\nFP ABI: ", stdout
);
14253 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14254 fputs ("ISA Extension: ", stdout
);
14255 print_mips_isa_ext (abiflags_in
.isa_ext
);
14256 fputs ("\nASEs:", stdout
);
14257 print_mips_ases (abiflags_in
.ases
);
14258 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14259 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14260 fputc ('\n', stdout
);
14261 free (abiflags_ext
);
14266 /* We have a lot of special sections. Thanks SGI! */
14267 if (dynamic_section
== NULL
)
14268 /* No information available. */
14271 for (entry
= dynamic_section
;
14272 /* PR 17531 file: 012-50589-0.004. */
14273 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14275 switch (entry
->d_tag
)
14277 case DT_MIPS_LIBLIST
:
14279 = offset_from_vma (file
, entry
->d_un
.d_val
,
14280 liblistno
* sizeof (Elf32_External_Lib
));
14282 case DT_MIPS_LIBLISTNO
:
14283 liblistno
= entry
->d_un
.d_val
;
14285 case DT_MIPS_OPTIONS
:
14286 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14288 case DT_MIPS_CONFLICT
:
14290 = offset_from_vma (file
, entry
->d_un
.d_val
,
14291 conflictsno
* sizeof (Elf32_External_Conflict
));
14293 case DT_MIPS_CONFLICTNO
:
14294 conflictsno
= entry
->d_un
.d_val
;
14297 pltgot
= entry
->d_un
.d_ptr
;
14299 case DT_MIPS_LOCAL_GOTNO
:
14300 local_gotno
= entry
->d_un
.d_val
;
14302 case DT_MIPS_GOTSYM
:
14303 gotsym
= entry
->d_un
.d_val
;
14305 case DT_MIPS_SYMTABNO
:
14306 symtabno
= entry
->d_un
.d_val
;
14308 case DT_MIPS_PLTGOT
:
14309 mips_pltgot
= entry
->d_un
.d_ptr
;
14312 pltrel
= entry
->d_un
.d_val
;
14315 pltrelsz
= entry
->d_un
.d_val
;
14318 jmprel
= entry
->d_un
.d_ptr
;
14324 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14326 Elf32_External_Lib
* elib
;
14329 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14331 sizeof (Elf32_External_Lib
),
14332 _("liblist section data"));
14335 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14336 (unsigned long) liblistno
);
14337 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14340 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14347 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14348 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14349 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14350 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14351 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14353 tmp
= gmtime (&atime
);
14354 snprintf (timebuf
, sizeof (timebuf
),
14355 "%04u-%02u-%02uT%02u:%02u:%02u",
14356 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14357 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14359 printf ("%3lu: ", (unsigned long) cnt
);
14360 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14361 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14363 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14364 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14365 liblist
.l_version
);
14367 if (liblist
.l_flags
== 0)
14371 static const struct
14378 { " EXACT_MATCH", LL_EXACT_MATCH
},
14379 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14380 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14381 { " EXPORTS", LL_EXPORTS
},
14382 { " DELAY_LOAD", LL_DELAY_LOAD
},
14383 { " DELTA", LL_DELTA
}
14385 int flags
= liblist
.l_flags
;
14388 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14389 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14391 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14392 flags
^= l_flags_vals
[fcnt
].bit
;
14395 printf (" %#x", (unsigned int) flags
);
14405 if (options_offset
!= 0)
14407 Elf_External_Options
* eopt
;
14408 Elf_Internal_Options
* iopt
;
14409 Elf_Internal_Options
* option
;
14412 sect
= section_headers
;
14414 /* Find the section header so that we get the size. */
14415 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14416 /* PR 17533 file: 012-277276-0.004. */
14419 error (_("No MIPS_OPTIONS header found\n"));
14423 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14424 sect
->sh_size
, _("options"));
14427 iopt
= (Elf_Internal_Options
*)
14428 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14431 error (_("Out of memory allocatinf space for MIPS options\n"));
14438 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14440 Elf_External_Options
* eoption
;
14442 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14444 option
->kind
= BYTE_GET (eoption
->kind
);
14445 option
->size
= BYTE_GET (eoption
->size
);
14446 option
->section
= BYTE_GET (eoption
->section
);
14447 option
->info
= BYTE_GET (eoption
->info
);
14449 /* PR 17531: file: ffa0fa3b. */
14450 if (option
->size
< sizeof (* eopt
)
14451 || offset
+ option
->size
> sect
->sh_size
)
14453 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14456 offset
+= option
->size
;
14462 printf (_("\nSection '%s' contains %d entries:\n"),
14463 printable_section_name (sect
), cnt
);
14472 switch (option
->kind
)
14475 /* This shouldn't happen. */
14476 printf (" NULL %d %lx", option
->section
, option
->info
);
14479 printf (" REGINFO ");
14480 if (elf_header
.e_machine
== EM_MIPS
)
14483 Elf32_External_RegInfo
* ereg
;
14484 Elf32_RegInfo reginfo
;
14486 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14487 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14488 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14489 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14490 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14491 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14492 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14494 printf ("GPR %08lx GP 0x%lx\n",
14495 reginfo
.ri_gprmask
,
14496 (unsigned long) reginfo
.ri_gp_value
);
14497 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14498 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14499 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14504 Elf64_External_RegInfo
* ereg
;
14505 Elf64_Internal_RegInfo reginfo
;
14507 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14508 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14509 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14510 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14511 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14512 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14513 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14515 printf ("GPR %08lx GP 0x",
14516 reginfo
.ri_gprmask
);
14517 printf_vma (reginfo
.ri_gp_value
);
14520 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14521 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14522 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14526 case ODK_EXCEPTIONS
:
14527 fputs (" EXCEPTIONS fpe_min(", stdout
);
14528 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14529 fputs (") fpe_max(", stdout
);
14530 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14531 fputs (")", stdout
);
14533 if (option
->info
& OEX_PAGE0
)
14534 fputs (" PAGE0", stdout
);
14535 if (option
->info
& OEX_SMM
)
14536 fputs (" SMM", stdout
);
14537 if (option
->info
& OEX_FPDBUG
)
14538 fputs (" FPDBUG", stdout
);
14539 if (option
->info
& OEX_DISMISS
)
14540 fputs (" DISMISS", stdout
);
14543 fputs (" PAD ", stdout
);
14544 if (option
->info
& OPAD_PREFIX
)
14545 fputs (" PREFIX", stdout
);
14546 if (option
->info
& OPAD_POSTFIX
)
14547 fputs (" POSTFIX", stdout
);
14548 if (option
->info
& OPAD_SYMBOL
)
14549 fputs (" SYMBOL", stdout
);
14552 fputs (" HWPATCH ", stdout
);
14553 if (option
->info
& OHW_R4KEOP
)
14554 fputs (" R4KEOP", stdout
);
14555 if (option
->info
& OHW_R8KPFETCH
)
14556 fputs (" R8KPFETCH", stdout
);
14557 if (option
->info
& OHW_R5KEOP
)
14558 fputs (" R5KEOP", stdout
);
14559 if (option
->info
& OHW_R5KCVTL
)
14560 fputs (" R5KCVTL", stdout
);
14563 fputs (" FILL ", stdout
);
14564 /* XXX Print content of info word? */
14567 fputs (" TAGS ", stdout
);
14568 /* XXX Print content of info word? */
14571 fputs (" HWAND ", stdout
);
14572 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14573 fputs (" R4KEOP_CHECKED", stdout
);
14574 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14575 fputs (" R4KEOP_CLEAN", stdout
);
14578 fputs (" HWOR ", stdout
);
14579 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14580 fputs (" R4KEOP_CHECKED", stdout
);
14581 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14582 fputs (" R4KEOP_CLEAN", stdout
);
14585 printf (" GP_GROUP %#06lx self-contained %#06lx",
14586 option
->info
& OGP_GROUP
,
14587 (option
->info
& OGP_SELF
) >> 16);
14590 printf (" IDENT %#06lx self-contained %#06lx",
14591 option
->info
& OGP_GROUP
,
14592 (option
->info
& OGP_SELF
) >> 16);
14595 /* This shouldn't happen. */
14596 printf (" %3d ??? %d %lx",
14597 option
->kind
, option
->section
, option
->info
);
14601 len
= sizeof (* eopt
);
14602 while (len
< option
->size
)
14604 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14606 if (ISPRINT (datum
))
14607 printf ("%c", datum
);
14609 printf ("\\%03o", datum
);
14612 fputs ("\n", stdout
);
14614 offset
+= option
->size
;
14622 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14624 Elf32_Conflict
* iconf
;
14627 if (dynamic_symbols
== NULL
)
14629 error (_("conflict list found without a dynamic symbol table\n"));
14633 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14636 error (_("Out of memory allocating space for dynamic conflicts\n"));
14642 Elf32_External_Conflict
* econf32
;
14644 econf32
= (Elf32_External_Conflict
*)
14645 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14646 sizeof (* econf32
), _("conflict"));
14650 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14651 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14657 Elf64_External_Conflict
* econf64
;
14659 econf64
= (Elf64_External_Conflict
*)
14660 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14661 sizeof (* econf64
), _("conflict"));
14665 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14666 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14671 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14672 (unsigned long) conflictsno
);
14673 puts (_(" Num: Index Value Name"));
14675 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14677 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14679 if (iconf
[cnt
] >= num_dynamic_syms
)
14680 printf (_("<corrupt symbol index>"));
14683 Elf_Internal_Sym
* psym
;
14685 psym
= & dynamic_symbols
[iconf
[cnt
]];
14686 print_vma (psym
->st_value
, FULL_HEX
);
14688 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14689 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14691 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14699 if (pltgot
!= 0 && local_gotno
!= 0)
14701 bfd_vma ent
, local_end
, global_end
;
14703 unsigned char * data
;
14704 unsigned char * data_end
;
14708 addr_size
= (is_32bit_elf
? 4 : 8);
14709 local_end
= pltgot
+ local_gotno
* addr_size
;
14711 /* PR binutils/17533 file: 012-111227-0.004 */
14712 if (symtabno
< gotsym
)
14714 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14715 (unsigned long) gotsym
, (unsigned long) symtabno
);
14719 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14720 /* PR 17531: file: 54c91a34. */
14721 if (global_end
< local_end
)
14723 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14727 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14728 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14729 global_end
- pltgot
, 1,
14730 _("Global Offset Table data"));
14733 data_end
= data
+ (global_end
- pltgot
);
14735 printf (_("\nPrimary GOT:\n"));
14736 printf (_(" Canonical gp value: "));
14737 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14740 printf (_(" Reserved entries:\n"));
14741 printf (_(" %*s %10s %*s Purpose\n"),
14742 addr_size
* 2, _("Address"), _("Access"),
14743 addr_size
* 2, _("Initial"));
14744 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14745 printf (_(" Lazy resolver\n"));
14746 if (ent
== (bfd_vma
) -1)
14747 goto got_print_fail
;
14749 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14750 >> (addr_size
* 8 - 1)) != 0)
14752 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14753 printf (_(" Module pointer (GNU extension)\n"));
14754 if (ent
== (bfd_vma
) -1)
14755 goto got_print_fail
;
14759 if (ent
< local_end
)
14761 printf (_(" Local entries:\n"));
14762 printf (" %*s %10s %*s\n",
14763 addr_size
* 2, _("Address"), _("Access"),
14764 addr_size
* 2, _("Initial"));
14765 while (ent
< local_end
)
14767 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14769 if (ent
== (bfd_vma
) -1)
14770 goto got_print_fail
;
14775 if (gotsym
< symtabno
)
14779 printf (_(" Global entries:\n"));
14780 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14781 addr_size
* 2, _("Address"),
14783 addr_size
* 2, _("Initial"),
14784 addr_size
* 2, _("Sym.Val."),
14786 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14787 _("Ndx"), _("Name"));
14789 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14791 for (i
= gotsym
; i
< symtabno
; i
++)
14793 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14796 if (dynamic_symbols
== NULL
)
14797 printf (_("<no dynamic symbols>"));
14798 else if (i
< num_dynamic_syms
)
14800 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14802 print_vma (psym
->st_value
, LONG_HEX
);
14803 printf (" %-7s %3s ",
14804 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14805 get_symbol_index_type (psym
->st_shndx
));
14807 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14808 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14810 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14813 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14814 (unsigned long) i
);
14817 if (ent
== (bfd_vma
) -1)
14828 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14831 size_t offset
, rel_offset
;
14832 unsigned long count
, i
;
14833 unsigned char * data
;
14834 int addr_size
, sym_width
;
14835 Elf_Internal_Rela
* rels
;
14837 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14838 if (pltrel
== DT_RELA
)
14840 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14845 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14850 addr_size
= (is_32bit_elf
? 4 : 8);
14851 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14853 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14854 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14855 1, _("Procedure Linkage Table data"));
14859 printf ("\nPLT GOT:\n\n");
14860 printf (_(" Reserved entries:\n"));
14861 printf (_(" %*s %*s Purpose\n"),
14862 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14863 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14864 printf (_(" PLT lazy resolver\n"));
14865 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14866 printf (_(" Module pointer\n"));
14869 printf (_(" Entries:\n"));
14870 printf (" %*s %*s %*s %-7s %3s %s\n",
14871 addr_size
* 2, _("Address"),
14872 addr_size
* 2, _("Initial"),
14873 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14874 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14875 for (i
= 0; i
< count
; i
++)
14877 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14879 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14882 if (idx
>= num_dynamic_syms
)
14883 printf (_("<corrupt symbol index: %lu>"), idx
);
14886 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14888 print_vma (psym
->st_value
, LONG_HEX
);
14889 printf (" %-7s %3s ",
14890 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14891 get_symbol_index_type (psym
->st_shndx
));
14892 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14893 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14895 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14910 process_nds32_specific (FILE * file
)
14912 Elf_Internal_Shdr
*sect
= NULL
;
14914 sect
= find_section (".nds32_e_flags");
14917 unsigned int *flag
;
14919 printf ("\nNDS32 elf flags section:\n");
14920 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14921 sect
->sh_size
, _("NDS32 elf flags section"));
14923 switch ((*flag
) & 0x3)
14926 printf ("(VEC_SIZE):\tNo entry.\n");
14929 printf ("(VEC_SIZE):\t4 bytes\n");
14932 printf ("(VEC_SIZE):\t16 bytes\n");
14935 printf ("(VEC_SIZE):\treserved\n");
14944 process_gnu_liblist (FILE * file
)
14946 Elf_Internal_Shdr
* section
;
14947 Elf_Internal_Shdr
* string_sec
;
14948 Elf32_External_Lib
* elib
;
14950 size_t strtab_size
;
14957 for (i
= 0, section
= section_headers
;
14958 i
< elf_header
.e_shnum
;
14961 switch (section
->sh_type
)
14963 case SHT_GNU_LIBLIST
:
14964 if (section
->sh_link
>= elf_header
.e_shnum
)
14967 elib
= (Elf32_External_Lib
*)
14968 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14969 _("liblist section data"));
14973 string_sec
= section_headers
+ section
->sh_link
;
14975 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14976 string_sec
->sh_size
,
14977 _("liblist string table"));
14979 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14985 strtab_size
= string_sec
->sh_size
;
14987 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14988 printable_section_name (section
),
14989 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14991 puts (_(" Library Time Stamp Checksum Version Flags"));
14993 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15001 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15002 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15003 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15004 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15005 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15007 tmp
= gmtime (&atime
);
15008 snprintf (timebuf
, sizeof (timebuf
),
15009 "%04u-%02u-%02uT%02u:%02u:%02u",
15010 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15011 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15013 printf ("%3lu: ", (unsigned long) cnt
);
15015 printf ("%-20s", liblist
.l_name
< strtab_size
15016 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15018 printf ("%-20.20s", liblist
.l_name
< strtab_size
15019 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15020 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15021 liblist
.l_version
, liblist
.l_flags
);
15032 static const char *
15033 get_note_type (unsigned e_type
)
15035 static char buff
[64];
15037 if (elf_header
.e_type
== ET_CORE
)
15041 return _("NT_AUXV (auxiliary vector)");
15043 return _("NT_PRSTATUS (prstatus structure)");
15045 return _("NT_FPREGSET (floating point registers)");
15047 return _("NT_PRPSINFO (prpsinfo structure)");
15048 case NT_TASKSTRUCT
:
15049 return _("NT_TASKSTRUCT (task structure)");
15051 return _("NT_PRXFPREG (user_xfpregs structure)");
15053 return _("NT_PPC_VMX (ppc Altivec registers)");
15055 return _("NT_PPC_VSX (ppc VSX registers)");
15057 return _("NT_386_TLS (x86 TLS information)");
15058 case NT_386_IOPERM
:
15059 return _("NT_386_IOPERM (x86 I/O permissions)");
15060 case NT_X86_XSTATE
:
15061 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15062 case NT_S390_HIGH_GPRS
:
15063 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15064 case NT_S390_TIMER
:
15065 return _("NT_S390_TIMER (s390 timer register)");
15066 case NT_S390_TODCMP
:
15067 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15068 case NT_S390_TODPREG
:
15069 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15071 return _("NT_S390_CTRS (s390 control registers)");
15072 case NT_S390_PREFIX
:
15073 return _("NT_S390_PREFIX (s390 prefix register)");
15074 case NT_S390_LAST_BREAK
:
15075 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15076 case NT_S390_SYSTEM_CALL
:
15077 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15079 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15080 case NT_S390_VXRS_LOW
:
15081 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15082 case NT_S390_VXRS_HIGH
:
15083 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15085 return _("NT_ARM_VFP (arm VFP registers)");
15087 return _("NT_ARM_TLS (AArch TLS registers)");
15088 case NT_ARM_HW_BREAK
:
15089 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15090 case NT_ARM_HW_WATCH
:
15091 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15093 return _("NT_PSTATUS (pstatus structure)");
15095 return _("NT_FPREGS (floating point registers)");
15097 return _("NT_PSINFO (psinfo structure)");
15099 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15101 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15102 case NT_WIN32PSTATUS
:
15103 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15105 return _("NT_SIGINFO (siginfo_t data)");
15107 return _("NT_FILE (mapped files)");
15115 return _("NT_VERSION (version)");
15117 return _("NT_ARCH (architecture)");
15122 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15127 print_core_note (Elf_Internal_Note
*pnote
)
15129 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15130 bfd_vma count
, page_size
;
15131 unsigned char *descdata
, *filenames
, *descend
;
15133 if (pnote
->type
!= NT_FILE
)
15139 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15140 /* Still "successful". */
15145 if (pnote
->descsz
< 2 * addr_size
)
15147 printf (_(" Malformed note - too short for header\n"));
15151 descdata
= (unsigned char *) pnote
->descdata
;
15152 descend
= descdata
+ pnote
->descsz
;
15154 if (descdata
[pnote
->descsz
- 1] != '\0')
15156 printf (_(" Malformed note - does not end with \\0\n"));
15160 count
= byte_get (descdata
, addr_size
);
15161 descdata
+= addr_size
;
15163 page_size
= byte_get (descdata
, addr_size
);
15164 descdata
+= addr_size
;
15166 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15168 printf (_(" Malformed note - too short for supplied file count\n"));
15172 printf (_(" Page size: "));
15173 print_vma (page_size
, DEC
);
15176 printf (_(" %*s%*s%*s\n"),
15177 (int) (2 + 2 * addr_size
), _("Start"),
15178 (int) (4 + 2 * addr_size
), _("End"),
15179 (int) (4 + 2 * addr_size
), _("Page Offset"));
15180 filenames
= descdata
+ count
* 3 * addr_size
;
15181 while (count
-- > 0)
15183 bfd_vma start
, end
, file_ofs
;
15185 if (filenames
== descend
)
15187 printf (_(" Malformed note - filenames end too early\n"));
15191 start
= byte_get (descdata
, addr_size
);
15192 descdata
+= addr_size
;
15193 end
= byte_get (descdata
, addr_size
);
15194 descdata
+= addr_size
;
15195 file_ofs
= byte_get (descdata
, addr_size
);
15196 descdata
+= addr_size
;
15199 print_vma (start
, FULL_HEX
);
15201 print_vma (end
, FULL_HEX
);
15203 print_vma (file_ofs
, FULL_HEX
);
15204 printf ("\n %s\n", filenames
);
15206 filenames
+= 1 + strlen ((char *) filenames
);
15212 static const char *
15213 get_gnu_elf_note_type (unsigned e_type
)
15215 static char buff
[64];
15219 case NT_GNU_ABI_TAG
:
15220 return _("NT_GNU_ABI_TAG (ABI version tag)");
15222 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15223 case NT_GNU_BUILD_ID
:
15224 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15225 case NT_GNU_GOLD_VERSION
:
15226 return _("NT_GNU_GOLD_VERSION (gold version)");
15231 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15236 print_gnu_note (Elf_Internal_Note
*pnote
)
15238 switch (pnote
->type
)
15240 case NT_GNU_BUILD_ID
:
15244 printf (_(" Build ID: "));
15245 for (i
= 0; i
< pnote
->descsz
; ++i
)
15246 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15251 case NT_GNU_ABI_TAG
:
15253 unsigned long os
, major
, minor
, subminor
;
15254 const char *osname
;
15256 /* PR 17531: file: 030-599401-0.004. */
15257 if (pnote
->descsz
< 16)
15259 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15263 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15264 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15265 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15266 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15270 case GNU_ABI_TAG_LINUX
:
15273 case GNU_ABI_TAG_HURD
:
15276 case GNU_ABI_TAG_SOLARIS
:
15277 osname
= "Solaris";
15279 case GNU_ABI_TAG_FREEBSD
:
15280 osname
= "FreeBSD";
15282 case GNU_ABI_TAG_NETBSD
:
15285 case GNU_ABI_TAG_SYLLABLE
:
15286 osname
= "Syllable";
15288 case GNU_ABI_TAG_NACL
:
15292 osname
= "Unknown";
15296 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15297 major
, minor
, subminor
);
15301 case NT_GNU_GOLD_VERSION
:
15305 printf (_(" Version: "));
15306 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15307 printf ("%c", pnote
->descdata
[i
]);
15316 static const char *
15317 get_v850_elf_note_type (enum v850_notes n_type
)
15319 static char buff
[64];
15323 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15324 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15325 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15326 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15327 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15328 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15330 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15336 print_v850_note (Elf_Internal_Note
* pnote
)
15340 if (pnote
->descsz
!= 4)
15342 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15346 printf (_("not set\n"));
15350 switch (pnote
->type
)
15352 case V850_NOTE_ALIGNMENT
:
15355 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15356 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15360 case V850_NOTE_DATA_SIZE
:
15363 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15364 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15368 case V850_NOTE_FPU_INFO
:
15371 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15372 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15376 case V850_NOTE_MMU_INFO
:
15377 case V850_NOTE_CACHE_INFO
:
15378 case V850_NOTE_SIMD_INFO
:
15379 if (val
== EF_RH850_SIMD
)
15381 printf (_("yes\n"));
15387 /* An 'unknown note type' message will already have been displayed. */
15391 printf (_("unknown value: %x\n"), val
);
15396 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15398 unsigned int version
;
15400 switch (pnote
->type
)
15402 case NT_NETBSD_IDENT
:
15403 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15404 if ((version
/ 10000) % 100)
15405 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15406 version
, version
/ 100000000, (version
/ 1000000) % 100,
15407 (version
/ 10000) % 100 > 26 ? "Z" : "",
15408 'A' + (version
/ 10000) % 26);
15410 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15411 version
, version
/ 100000000, (version
/ 1000000) % 100,
15412 (version
/ 100) % 100);
15415 case NT_NETBSD_MARCH
:
15416 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15424 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15429 static const char *
15430 get_freebsd_elfcore_note_type (unsigned e_type
)
15434 case NT_FREEBSD_THRMISC
:
15435 return _("NT_THRMISC (thrmisc structure)");
15436 case NT_FREEBSD_PROCSTAT_PROC
:
15437 return _("NT_PROCSTAT_PROC (proc data)");
15438 case NT_FREEBSD_PROCSTAT_FILES
:
15439 return _("NT_PROCSTAT_FILES (files data)");
15440 case NT_FREEBSD_PROCSTAT_VMMAP
:
15441 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15442 case NT_FREEBSD_PROCSTAT_GROUPS
:
15443 return _("NT_PROCSTAT_GROUPS (groups data)");
15444 case NT_FREEBSD_PROCSTAT_UMASK
:
15445 return _("NT_PROCSTAT_UMASK (umask data)");
15446 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15447 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15448 case NT_FREEBSD_PROCSTAT_OSREL
:
15449 return _("NT_PROCSTAT_OSREL (osreldate data)");
15450 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15451 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15452 case NT_FREEBSD_PROCSTAT_AUXV
:
15453 return _("NT_PROCSTAT_AUXV (auxv data)");
15455 return get_note_type (e_type
);
15458 static const char *
15459 get_netbsd_elfcore_note_type (unsigned e_type
)
15461 static char buff
[64];
15463 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15465 /* NetBSD core "procinfo" structure. */
15466 return _("NetBSD procinfo structure");
15469 /* As of Jan 2002 there are no other machine-independent notes
15470 defined for NetBSD core files. If the note type is less
15471 than the start of the machine-dependent note types, we don't
15474 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15476 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15480 switch (elf_header
.e_machine
)
15482 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15483 and PT_GETFPREGS == mach+2. */
15488 case EM_SPARC32PLUS
:
15492 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15493 return _("PT_GETREGS (reg structure)");
15494 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15495 return _("PT_GETFPREGS (fpreg structure)");
15501 /* On all other arch's, PT_GETREGS == mach+1 and
15502 PT_GETFPREGS == mach+3. */
15506 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15507 return _("PT_GETREGS (reg structure)");
15508 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15509 return _("PT_GETFPREGS (fpreg structure)");
15515 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15516 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15520 static const char *
15521 get_stapsdt_note_type (unsigned e_type
)
15523 static char buff
[64];
15528 return _("NT_STAPSDT (SystemTap probe descriptors)");
15534 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15539 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15541 int addr_size
= is_32bit_elf
? 4 : 8;
15542 char *data
= pnote
->descdata
;
15543 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15544 bfd_vma pc
, base_addr
, semaphore
;
15545 char *provider
, *probe
, *arg_fmt
;
15547 pc
= byte_get ((unsigned char *) data
, addr_size
);
15549 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15551 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15555 data
+= strlen (data
) + 1;
15557 data
+= strlen (data
) + 1;
15559 data
+= strlen (data
) + 1;
15561 printf (_(" Provider: %s\n"), provider
);
15562 printf (_(" Name: %s\n"), probe
);
15563 printf (_(" Location: "));
15564 print_vma (pc
, FULL_HEX
);
15565 printf (_(", Base: "));
15566 print_vma (base_addr
, FULL_HEX
);
15567 printf (_(", Semaphore: "));
15568 print_vma (semaphore
, FULL_HEX
);
15570 printf (_(" Arguments: %s\n"), arg_fmt
);
15572 return data
== data_end
;
15575 static const char *
15576 get_ia64_vms_note_type (unsigned e_type
)
15578 static char buff
[64];
15583 return _("NT_VMS_MHD (module header)");
15585 return _("NT_VMS_LNM (language name)");
15587 return _("NT_VMS_SRC (source files)");
15589 return "NT_VMS_TITLE";
15591 return _("NT_VMS_EIDC (consistency check)");
15592 case NT_VMS_FPMODE
:
15593 return _("NT_VMS_FPMODE (FP mode)");
15594 case NT_VMS_LINKTIME
:
15595 return "NT_VMS_LINKTIME";
15596 case NT_VMS_IMGNAM
:
15597 return _("NT_VMS_IMGNAM (image name)");
15599 return _("NT_VMS_IMGID (image id)");
15600 case NT_VMS_LINKID
:
15601 return _("NT_VMS_LINKID (link id)");
15602 case NT_VMS_IMGBID
:
15603 return _("NT_VMS_IMGBID (build id)");
15604 case NT_VMS_GSTNAM
:
15605 return _("NT_VMS_GSTNAM (sym table name)");
15606 case NT_VMS_ORIG_DYN
:
15607 return "NT_VMS_ORIG_DYN";
15608 case NT_VMS_PATCHTIME
:
15609 return "NT_VMS_PATCHTIME";
15611 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15617 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15619 switch (pnote
->type
)
15622 if (pnote
->descsz
> 36)
15624 size_t l
= strlen (pnote
->descdata
+ 34);
15625 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15626 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15627 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15628 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15631 printf (_(" Invalid size\n"));
15634 printf (_(" Language: %s\n"), pnote
->descdata
);
15637 case NT_VMS_FPMODE
:
15638 printf (_(" Floating Point mode: "));
15639 printf ("0x%016" BFD_VMA_FMT
"x\n",
15640 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15642 case NT_VMS_LINKTIME
:
15643 printf (_(" Link time: "));
15645 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15648 case NT_VMS_PATCHTIME
:
15649 printf (_(" Patch time: "));
15651 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15654 case NT_VMS_ORIG_DYN
:
15655 printf (_(" Major id: %u, minor id: %u\n"),
15656 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15657 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15658 printf (_(" Last modified : "));
15660 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15661 printf (_("\n Link flags : "));
15662 printf ("0x%016" BFD_VMA_FMT
"x\n",
15663 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15664 printf (_(" Header flags: 0x%08x\n"),
15665 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15666 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15669 case NT_VMS_IMGNAM
:
15670 printf (_(" Image name: %s\n"), pnote
->descdata
);
15672 case NT_VMS_GSTNAM
:
15673 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15676 printf (_(" Image id: %s\n"), pnote
->descdata
);
15678 case NT_VMS_LINKID
:
15679 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15687 /* Note that by the ELF standard, the name field is already null byte
15688 terminated, and namesz includes the terminating null byte.
15689 I.E. the value of namesz for the name "FSF" is 4.
15691 If the value of namesz is zero, there is no name present. */
15693 process_note (Elf_Internal_Note
* pnote
)
15695 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15698 if (pnote
->namesz
== 0)
15699 /* If there is no note name, then use the default set of
15700 note type strings. */
15701 nt
= get_note_type (pnote
->type
);
15703 else if (const_strneq (pnote
->namedata
, "GNU"))
15704 /* GNU-specific object file notes. */
15705 nt
= get_gnu_elf_note_type (pnote
->type
);
15707 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
15708 /* FreeBSD-specific core file notes. */
15709 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
15711 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15712 /* NetBSD-specific core file notes. */
15713 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15715 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15716 /* NetBSD-specific core file notes. */
15717 return process_netbsd_elf_note (pnote
);
15719 else if (strneq (pnote
->namedata
, "SPU/", 4))
15721 /* SPU-specific core file notes. */
15722 nt
= pnote
->namedata
+ 4;
15726 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15727 /* VMS/ia64-specific file notes. */
15728 nt
= get_ia64_vms_note_type (pnote
->type
);
15730 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15731 nt
= get_stapsdt_note_type (pnote
->type
);
15734 /* Don't recognize this note name; just use the default set of
15735 note type strings. */
15736 nt
= get_note_type (pnote
->type
);
15738 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15740 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15741 return print_ia64_vms_note (pnote
);
15742 else if (const_strneq (pnote
->namedata
, "GNU"))
15743 return print_gnu_note (pnote
);
15744 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15745 return print_stapsdt_note (pnote
);
15746 else if (const_strneq (pnote
->namedata
, "CORE"))
15747 return print_core_note (pnote
);
15754 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15756 Elf_External_Note
* pnotes
;
15757 Elf_External_Note
* external
;
15764 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15766 if (pnotes
== NULL
)
15771 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15772 (unsigned long) offset
, (unsigned long) length
);
15773 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15775 end
= (char *) pnotes
+ length
;
15776 while ((char *) external
< end
)
15778 Elf_Internal_Note inote
;
15781 char * temp
= NULL
;
15782 size_t data_remaining
= end
- (char *) external
;
15784 if (!is_ia64_vms ())
15786 /* PR binutils/15191
15787 Make sure that there is enough data to read. */
15788 min_notesz
= offsetof (Elf_External_Note
, name
);
15789 if (data_remaining
< min_notesz
)
15791 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15792 (int) data_remaining
);
15795 inote
.type
= BYTE_GET (external
->type
);
15796 inote
.namesz
= BYTE_GET (external
->namesz
);
15797 inote
.namedata
= external
->name
;
15798 inote
.descsz
= BYTE_GET (external
->descsz
);
15799 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15800 /* PR 17531: file: 3443835e. */
15801 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15803 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15804 inote
.descdata
= inote
.namedata
;
15808 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15809 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15813 Elf64_External_VMS_Note
*vms_external
;
15815 /* PR binutils/15191
15816 Make sure that there is enough data to read. */
15817 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15818 if (data_remaining
< min_notesz
)
15820 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15821 (int) data_remaining
);
15825 vms_external
= (Elf64_External_VMS_Note
*) external
;
15826 inote
.type
= BYTE_GET (vms_external
->type
);
15827 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15828 inote
.namedata
= vms_external
->name
;
15829 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15830 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15831 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15832 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15835 if (inote
.descdata
< (char *) external
+ min_notesz
15836 || next
< (char *) external
+ min_notesz
15837 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15838 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15839 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15840 || data_remaining
< (size_t)(next
- (char *) external
))
15842 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15843 (unsigned long) ((char *) external
- (char *) pnotes
));
15844 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15845 inote
.type
, inote
.namesz
, inote
.descsz
);
15849 external
= (Elf_External_Note
*) next
;
15851 /* Verify that name is null terminated. It appears that at least
15852 one version of Linux (RedHat 6.0) generates corefiles that don't
15853 comply with the ELF spec by failing to include the null byte in
15855 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15857 temp
= (char *) malloc (inote
.namesz
+ 1);
15860 error (_("Out of memory allocating space for inote name\n"));
15865 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15866 temp
[inote
.namesz
] = 0;
15868 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15869 inote
.namedata
= temp
;
15872 res
&= process_note (& inote
);
15887 process_corefile_note_segments (FILE * file
)
15889 Elf_Internal_Phdr
* segment
;
15893 if (! get_program_headers (file
))
15896 for (i
= 0, segment
= program_headers
;
15897 i
< elf_header
.e_phnum
;
15900 if (segment
->p_type
== PT_NOTE
)
15901 res
&= process_corefile_note_segment (file
,
15902 (bfd_vma
) segment
->p_offset
,
15903 (bfd_vma
) segment
->p_filesz
);
15910 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15912 Elf_External_Note
* pnotes
;
15913 Elf_External_Note
* external
;
15920 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15922 if (pnotes
== NULL
)
15926 end
= (char*) pnotes
+ length
;
15928 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15929 (unsigned long) offset
, (unsigned long) length
);
15931 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15933 Elf_External_Note
* next
;
15934 Elf_Internal_Note inote
;
15936 inote
.type
= BYTE_GET (external
->type
);
15937 inote
.namesz
= BYTE_GET (external
->namesz
);
15938 inote
.namedata
= external
->name
;
15939 inote
.descsz
= BYTE_GET (external
->descsz
);
15940 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15941 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15943 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15945 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15946 inote
.descdata
= inote
.namedata
;
15950 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15952 if ( ((char *) next
> end
)
15953 || ((char *) next
< (char *) pnotes
))
15955 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15956 (unsigned long) ((char *) external
- (char *) pnotes
));
15957 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15958 inote
.type
, inote
.namesz
, inote
.descsz
);
15964 /* Prevent out-of-bounds indexing. */
15965 if ( inote
.namedata
+ inote
.namesz
> end
15966 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15968 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15969 (unsigned long) ((char *) external
- (char *) pnotes
));
15970 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15971 inote
.type
, inote
.namesz
, inote
.descsz
);
15975 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15977 if (! print_v850_note (& inote
))
15980 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15981 inote
.namesz
, inote
.descsz
);
15991 process_note_sections (FILE * file
)
15993 Elf_Internal_Shdr
* section
;
15998 for (i
= 0, section
= section_headers
;
15999 i
< elf_header
.e_shnum
&& section
!= NULL
;
16002 if (section
->sh_type
== SHT_NOTE
)
16004 res
&= process_corefile_note_segment (file
,
16005 (bfd_vma
) section
->sh_offset
,
16006 (bfd_vma
) section
->sh_size
);
16010 if (( elf_header
.e_machine
== EM_V800
16011 || elf_header
.e_machine
== EM_V850
16012 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16013 && section
->sh_type
== SHT_RENESAS_INFO
)
16015 res
&= process_v850_notes (file
,
16016 (bfd_vma
) section
->sh_offset
,
16017 (bfd_vma
) section
->sh_size
);
16023 /* Try processing NOTE segments instead. */
16024 return process_corefile_note_segments (file
);
16030 process_notes (FILE * file
)
16032 /* If we have not been asked to display the notes then do nothing. */
16036 if (elf_header
.e_type
!= ET_CORE
)
16037 return process_note_sections (file
);
16039 /* No program headers means no NOTE segment. */
16040 if (elf_header
.e_phnum
> 0)
16041 return process_corefile_note_segments (file
);
16043 printf (_("No note segments present in the core file.\n"));
16048 process_arch_specific (FILE * file
)
16053 switch (elf_header
.e_machine
)
16056 return process_arm_specific (file
);
16058 case EM_MIPS_RS3_LE
:
16059 return process_mips_specific (file
);
16062 return process_nds32_specific (file
);
16065 return process_power_specific (file
);
16069 return process_s390_specific (file
);
16072 case EM_SPARC32PLUS
:
16074 return process_sparc_specific (file
);
16077 return process_tic6x_specific (file
);
16080 return process_msp430x_specific (file
);
16088 get_file_header (FILE * file
)
16090 /* Read in the identity array. */
16091 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16094 /* Determine how to read the rest of the header. */
16095 switch (elf_header
.e_ident
[EI_DATA
])
16097 default: /* fall through */
16098 case ELFDATANONE
: /* fall through */
16100 byte_get
= byte_get_little_endian
;
16101 byte_put
= byte_put_little_endian
;
16104 byte_get
= byte_get_big_endian
;
16105 byte_put
= byte_put_big_endian
;
16109 /* For now we only support 32 bit and 64 bit ELF files. */
16110 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16112 /* Read in the rest of the header. */
16115 Elf32_External_Ehdr ehdr32
;
16117 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16120 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16121 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16122 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16123 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16124 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16125 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16126 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16127 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16128 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16129 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16130 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16131 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16132 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16136 Elf64_External_Ehdr ehdr64
;
16138 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16139 we will not be able to cope with the 64bit data found in
16140 64 ELF files. Detect this now and abort before we start
16141 overwriting things. */
16142 if (sizeof (bfd_vma
) < 8)
16144 error (_("This instance of readelf has been built without support for a\n\
16145 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16149 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16152 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16153 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16154 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16155 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16156 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16157 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16158 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16159 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16160 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16161 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16162 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16163 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16164 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16167 if (elf_header
.e_shoff
)
16169 /* There may be some extensions in the first section header. Don't
16170 bomb if we can't read it. */
16172 get_32bit_section_headers (file
, TRUE
);
16174 get_64bit_section_headers (file
, TRUE
);
16180 /* Process one ELF object file according to the command line options.
16181 This file may actually be stored in an archive. The file is
16182 positioned at the start of the ELF object. */
16185 process_object (char * file_name
, FILE * file
)
16189 if (! get_file_header (file
))
16191 error (_("%s: Failed to read file header\n"), file_name
);
16195 /* Initialise per file variables. */
16196 for (i
= ARRAY_SIZE (version_info
); i
--;)
16197 version_info
[i
] = 0;
16199 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16200 dynamic_info
[i
] = 0;
16201 dynamic_info_DT_GNU_HASH
= 0;
16203 /* Process the file. */
16205 printf (_("\nFile: %s\n"), file_name
);
16207 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16208 Note we do this even if cmdline_dump_sects is empty because we
16209 must make sure that the dump_sets array is zeroed out before each
16210 object file is processed. */
16211 if (num_dump_sects
> num_cmdline_dump_sects
)
16212 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16214 if (num_cmdline_dump_sects
> 0)
16216 if (num_dump_sects
== 0)
16217 /* A sneaky way of allocating the dump_sects array. */
16218 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16220 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16221 memcpy (dump_sects
, cmdline_dump_sects
,
16222 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16225 if (! process_file_header ())
16228 if (! process_section_headers (file
))
16230 /* Without loaded section headers we cannot process lots of
16232 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16234 if (! do_using_dynamic
)
16235 do_syms
= do_dyn_syms
= do_reloc
= 0;
16238 if (! process_section_groups (file
))
16240 /* Without loaded section groups we cannot process unwind. */
16244 if (process_program_headers (file
))
16245 process_dynamic_section (file
);
16247 process_relocs (file
);
16249 process_unwind (file
);
16251 process_symbol_table (file
);
16253 process_syminfo (file
);
16255 process_version_sections (file
);
16257 process_section_contents (file
);
16259 process_notes (file
);
16261 process_gnu_liblist (file
);
16263 process_arch_specific (file
);
16265 if (program_headers
)
16267 free (program_headers
);
16268 program_headers
= NULL
;
16271 if (section_headers
)
16273 free (section_headers
);
16274 section_headers
= NULL
;
16279 free (string_table
);
16280 string_table
= NULL
;
16281 string_table_length
= 0;
16284 if (dynamic_strings
)
16286 free (dynamic_strings
);
16287 dynamic_strings
= NULL
;
16288 dynamic_strings_length
= 0;
16291 if (dynamic_symbols
)
16293 free (dynamic_symbols
);
16294 dynamic_symbols
= NULL
;
16295 num_dynamic_syms
= 0;
16298 if (dynamic_syminfo
)
16300 free (dynamic_syminfo
);
16301 dynamic_syminfo
= NULL
;
16304 if (dynamic_section
)
16306 free (dynamic_section
);
16307 dynamic_section
= NULL
;
16310 if (section_headers_groups
)
16312 free (section_headers_groups
);
16313 section_headers_groups
= NULL
;
16316 if (section_groups
)
16318 struct group_list
* g
;
16319 struct group_list
* next
;
16321 for (i
= 0; i
< group_count
; i
++)
16323 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16330 free (section_groups
);
16331 section_groups
= NULL
;
16334 free_debug_memory ();
16339 /* Process an ELF archive.
16340 On entry the file is positioned just after the ARMAG string. */
16343 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16345 struct archive_info arch
;
16346 struct archive_info nested_arch
;
16352 /* The ARCH structure is used to hold information about this archive. */
16353 arch
.file_name
= NULL
;
16355 arch
.index_array
= NULL
;
16356 arch
.sym_table
= NULL
;
16357 arch
.longnames
= NULL
;
16359 /* The NESTED_ARCH structure is used as a single-item cache of information
16360 about a nested archive (when members of a thin archive reside within
16361 another regular archive file). */
16362 nested_arch
.file_name
= NULL
;
16363 nested_arch
.file
= NULL
;
16364 nested_arch
.index_array
= NULL
;
16365 nested_arch
.sym_table
= NULL
;
16366 nested_arch
.longnames
= NULL
;
16368 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16374 if (do_archive_index
)
16376 if (arch
.sym_table
== NULL
)
16377 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16380 unsigned long i
, l
;
16381 unsigned long current_pos
;
16383 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16384 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16385 current_pos
= ftell (file
);
16387 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16389 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16391 char * member_name
;
16393 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16395 if (member_name
!= NULL
)
16397 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16399 if (qualified_name
!= NULL
)
16401 printf (_("Contents of binary %s at offset "), qualified_name
);
16402 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16404 free (qualified_name
);
16409 if (l
>= arch
.sym_size
)
16411 error (_("%s: end of the symbol table reached before the end of the index\n"),
16415 /* PR 17531: file: 0b6630b2. */
16416 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16417 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16420 if (arch
.uses_64bit_indicies
)
16425 if (l
< arch
.sym_size
)
16426 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16427 file_name
, arch
.sym_size
- l
);
16429 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16431 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16437 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16438 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16439 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16440 && !do_section_groups
&& !do_dyn_syms
)
16442 ret
= 0; /* Archive index only. */
16453 char * qualified_name
;
16455 /* Read the next archive header. */
16456 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16458 error (_("%s: failed to seek to next archive header\n"), file_name
);
16461 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16462 if (got
!= sizeof arch
.arhdr
)
16466 error (_("%s: failed to read archive header\n"), file_name
);
16470 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16472 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16477 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16479 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16480 if (archive_file_size
& 01)
16481 ++archive_file_size
;
16483 name
= get_archive_member_name (&arch
, &nested_arch
);
16486 error (_("%s: bad archive file name\n"), file_name
);
16490 namelen
= strlen (name
);
16492 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16493 if (qualified_name
== NULL
)
16495 error (_("%s: bad archive file name\n"), file_name
);
16500 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16502 /* This is a proxy for an external member of a thin archive. */
16503 FILE * member_file
;
16504 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16505 if (member_file_name
== NULL
)
16511 member_file
= fopen (member_file_name
, "rb");
16512 if (member_file
== NULL
)
16514 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16515 free (member_file_name
);
16520 archive_file_offset
= arch
.nested_member_origin
;
16522 ret
|= process_object (qualified_name
, member_file
);
16524 fclose (member_file
);
16525 free (member_file_name
);
16527 else if (is_thin_archive
)
16529 /* PR 15140: Allow for corrupt thin archives. */
16530 if (nested_arch
.file
== NULL
)
16532 error (_("%s: contains corrupt thin archive: %s\n"),
16538 /* This is a proxy for a member of a nested archive. */
16539 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16541 /* The nested archive file will have been opened and setup by
16542 get_archive_member_name. */
16543 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16545 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16550 ret
|= process_object (qualified_name
, nested_arch
.file
);
16554 archive_file_offset
= arch
.next_arhdr_offset
;
16555 arch
.next_arhdr_offset
+= archive_file_size
;
16557 ret
|= process_object (qualified_name
, file
);
16560 if (dump_sects
!= NULL
)
16564 num_dump_sects
= 0;
16567 free (qualified_name
);
16571 if (nested_arch
.file
!= NULL
)
16572 fclose (nested_arch
.file
);
16573 release_archive (&nested_arch
);
16574 release_archive (&arch
);
16580 process_file (char * file_name
)
16583 struct stat statbuf
;
16584 char armag
[SARMAG
];
16587 if (stat (file_name
, &statbuf
) < 0)
16589 if (errno
== ENOENT
)
16590 error (_("'%s': No such file\n"), file_name
);
16592 error (_("Could not locate '%s'. System error message: %s\n"),
16593 file_name
, strerror (errno
));
16597 if (! S_ISREG (statbuf
.st_mode
))
16599 error (_("'%s' is not an ordinary file\n"), file_name
);
16603 file
= fopen (file_name
, "rb");
16606 error (_("Input file '%s' is not readable.\n"), file_name
);
16610 if (fread (armag
, SARMAG
, 1, file
) != 1)
16612 error (_("%s: Failed to read file's magic number\n"), file_name
);
16617 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16619 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16620 ret
= process_archive (file_name
, file
, FALSE
);
16621 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16622 ret
= process_archive (file_name
, file
, TRUE
);
16625 if (do_archive_index
)
16626 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16630 archive_file_size
= archive_file_offset
= 0;
16631 ret
= process_object (file_name
, file
);
16636 current_file_size
= 0;
16640 #ifdef SUPPORT_DISASSEMBLY
16641 /* Needed by the i386 disassembler. For extra credit, someone could
16642 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16646 print_address (unsigned int addr
, FILE * outfile
)
16648 fprintf (outfile
,"0x%8.8x", addr
);
16651 /* Needed by the i386 disassembler. */
16653 db_task_printsym (unsigned int addr
)
16655 print_address (addr
, stderr
);
16660 main (int argc
, char ** argv
)
16664 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16665 setlocale (LC_MESSAGES
, "");
16667 #if defined (HAVE_SETLOCALE)
16668 setlocale (LC_CTYPE
, "");
16670 bindtextdomain (PACKAGE
, LOCALEDIR
);
16671 textdomain (PACKAGE
);
16673 expandargv (&argc
, &argv
);
16675 parse_args (argc
, argv
);
16677 if (num_dump_sects
> 0)
16679 /* Make a copy of the dump_sects array. */
16680 cmdline_dump_sects
= (dump_type
*)
16681 malloc (num_dump_sects
* sizeof (* dump_sects
));
16682 if (cmdline_dump_sects
== NULL
)
16683 error (_("Out of memory allocating dump request table.\n"));
16686 memcpy (cmdline_dump_sects
, dump_sects
,
16687 num_dump_sects
* sizeof (* dump_sects
));
16688 num_cmdline_dump_sects
= num_dump_sects
;
16692 if (optind
< (argc
- 1))
16694 else if (optind
>= argc
)
16696 warn (_("Nothing to do.\n"));
16701 while (optind
< argc
)
16702 err
|= process_file (argv
[optind
++]);
16704 if (dump_sects
!= NULL
)
16706 if (cmdline_dump_sects
!= NULL
)
16707 free (cmdline_dump_sects
);