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
);
1297 rtype
= elf_msp430_reloc_type (type
);
1301 rtype
= elf_nds32_reloc_type (type
);
1305 rtype
= elf_ppc_reloc_type (type
);
1309 rtype
= elf_ppc64_reloc_type (type
);
1313 case EM_MIPS_RS3_LE
:
1314 rtype
= elf_mips_reloc_type (type
);
1318 rtype
= elf_alpha_reloc_type (type
);
1322 rtype
= elf_arm_reloc_type (type
);
1326 case EM_ARC_COMPACT
:
1327 case EM_ARC_COMPACT2
:
1328 rtype
= elf_arc_reloc_type (type
);
1332 rtype
= elf_hppa_reloc_type (type
);
1338 rtype
= elf_h8_reloc_type (type
);
1342 rtype
= elf_or1k_reloc_type (type
);
1347 rtype
= elf_pj_reloc_type (type
);
1350 rtype
= elf_ia64_reloc_type (type
);
1354 rtype
= elf_cris_reloc_type (type
);
1358 rtype
= elf_i860_reloc_type (type
);
1364 rtype
= elf_x86_64_reloc_type (type
);
1368 rtype
= i370_reloc_type (type
);
1373 rtype
= elf_s390_reloc_type (type
);
1377 rtype
= elf_score_reloc_type (type
);
1381 rtype
= elf_xstormy16_reloc_type (type
);
1385 rtype
= elf_crx_reloc_type (type
);
1389 rtype
= elf_vax_reloc_type (type
);
1393 rtype
= elf_visium_reloc_type (type
);
1396 case EM_ADAPTEVA_EPIPHANY
:
1397 rtype
= elf_epiphany_reloc_type (type
);
1402 rtype
= elf_ip2k_reloc_type (type
);
1406 rtype
= elf_iq2000_reloc_type (type
);
1411 rtype
= elf_xtensa_reloc_type (type
);
1414 case EM_LATTICEMICO32
:
1415 rtype
= elf_lm32_reloc_type (type
);
1420 rtype
= elf_m32c_reloc_type (type
);
1424 rtype
= elf_mt_reloc_type (type
);
1428 rtype
= elf_bfin_reloc_type (type
);
1432 rtype
= elf_mep_reloc_type (type
);
1436 rtype
= elf_cr16_reloc_type (type
);
1440 case EM_MICROBLAZE_OLD
:
1441 rtype
= elf_microblaze_reloc_type (type
);
1445 rtype
= elf_rl78_reloc_type (type
);
1449 rtype
= elf_rx_reloc_type (type
);
1453 rtype
= elf_metag_reloc_type (type
);
1458 rtype
= elf_xc16x_reloc_type (type
);
1462 rtype
= elf_tic6x_reloc_type (type
);
1466 rtype
= elf_tilegx_reloc_type (type
);
1470 rtype
= elf_tilepro_reloc_type (type
);
1474 rtype
= elf_xgate_reloc_type (type
);
1477 case EM_ALTERA_NIOS2
:
1478 rtype
= elf_nios2_reloc_type (type
);
1483 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1485 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1487 if (elf_header
.e_machine
== EM_ALPHA
1489 && streq (rtype
, "R_ALPHA_LITUSE")
1492 switch (rels
[i
].r_addend
)
1494 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1495 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1496 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1497 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1498 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1499 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1500 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1501 default: rtype
= NULL
;
1504 printf (" (%s)", rtype
);
1508 printf (_("<unknown addend: %lx>"),
1509 (unsigned long) rels
[i
].r_addend
);
1512 else if (symtab_index
)
1514 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1515 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1518 Elf_Internal_Sym
* psym
;
1519 const char * version_string
;
1520 enum versioned_symbol_info sym_info
;
1521 unsigned short vna_other
;
1523 psym
= symtab
+ symtab_index
;
1526 = get_symbol_version_string (file
, is_dynsym
,
1535 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1539 unsigned int width
= is_32bit_elf
? 8 : 14;
1541 /* Relocations against GNU_IFUNC symbols do not use the value
1542 of the symbol as the address to relocate against. Instead
1543 they invoke the function named by the symbol and use its
1544 result as the address for relocation.
1546 To indicate this to the user, do not display the value of
1547 the symbol in the "Symbols's Value" field. Instead show
1548 its name followed by () as a hint that the symbol is
1552 || psym
->st_name
== 0
1553 || psym
->st_name
>= strtablen
)
1556 name
= strtab
+ psym
->st_name
;
1558 len
= print_symbol (width
, name
);
1560 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1562 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1566 print_vma (psym
->st_value
, LONG_HEX
);
1568 printf (is_32bit_elf
? " " : " ");
1571 if (psym
->st_name
== 0)
1573 const char * sec_name
= "<null>";
1576 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1578 if (psym
->st_shndx
< elf_header
.e_shnum
)
1579 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1580 else if (psym
->st_shndx
== SHN_ABS
)
1582 else if (psym
->st_shndx
== SHN_COMMON
)
1583 sec_name
= "COMMON";
1584 else if ((elf_header
.e_machine
== EM_MIPS
1585 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1586 || (elf_header
.e_machine
== EM_TI_C6000
1587 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1588 sec_name
= "SCOMMON";
1589 else if (elf_header
.e_machine
== EM_MIPS
1590 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1591 sec_name
= "SUNDEF";
1592 else if ((elf_header
.e_machine
== EM_X86_64
1593 || elf_header
.e_machine
== EM_L1OM
1594 || elf_header
.e_machine
== EM_K1OM
)
1595 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1596 sec_name
= "LARGE_COMMON";
1597 else if (elf_header
.e_machine
== EM_IA_64
1598 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1599 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1600 sec_name
= "ANSI_COM";
1601 else if (is_ia64_vms ()
1602 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1603 sec_name
= "VMS_SYMVEC";
1606 sprintf (name_buf
, "<section 0x%x>",
1607 (unsigned int) psym
->st_shndx
);
1608 sec_name
= name_buf
;
1611 print_symbol (22, sec_name
);
1613 else if (strtab
== NULL
)
1614 printf (_("<string table index: %3ld>"), psym
->st_name
);
1615 else if (psym
->st_name
>= strtablen
)
1616 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1619 print_symbol (22, strtab
+ psym
->st_name
);
1621 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1627 bfd_vma off
= rels
[i
].r_addend
;
1629 if ((bfd_signed_vma
) off
< 0)
1630 printf (" - %" BFD_VMA_FMT
"x", - off
);
1632 printf (" + %" BFD_VMA_FMT
"x", off
);
1638 bfd_vma off
= rels
[i
].r_addend
;
1640 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1641 if ((bfd_signed_vma
) off
< 0)
1642 printf ("-%" BFD_VMA_FMT
"x", - off
);
1644 printf ("%" BFD_VMA_FMT
"x", off
);
1647 if (elf_header
.e_machine
== EM_SPARCV9
1649 && streq (rtype
, "R_SPARC_OLO10"))
1650 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1655 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1657 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1658 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1659 const char * rtype2
= elf_mips_reloc_type (type2
);
1660 const char * rtype3
= elf_mips_reloc_type (type3
);
1662 printf (" Type2: ");
1665 printf (_("unrecognized: %-7lx"),
1666 (unsigned long) type2
& 0xffffffff);
1668 printf ("%-17.17s", rtype2
);
1670 printf ("\n Type3: ");
1673 printf (_("unrecognized: %-7lx"),
1674 (unsigned long) type3
& 0xffffffff);
1676 printf ("%-17.17s", rtype3
);
1687 get_mips_dynamic_type (unsigned long type
)
1691 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1692 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1693 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1694 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1695 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1696 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1697 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1698 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1699 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1700 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1701 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1702 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1703 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1704 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1705 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1706 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1707 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1708 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1709 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1710 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1711 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1712 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1713 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1714 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1715 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1716 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1717 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1718 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1719 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1720 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1721 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1722 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1723 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1724 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1725 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1726 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1727 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1728 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1729 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1730 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1731 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1732 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1733 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1734 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1735 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1736 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1743 get_sparc64_dynamic_type (unsigned long type
)
1747 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1754 get_ppc_dynamic_type (unsigned long type
)
1758 case DT_PPC_GOT
: return "PPC_GOT";
1759 case DT_PPC_OPT
: return "PPC_OPT";
1766 get_ppc64_dynamic_type (unsigned long type
)
1770 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1771 case DT_PPC64_OPD
: return "PPC64_OPD";
1772 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1773 case DT_PPC64_OPT
: return "PPC64_OPT";
1780 get_parisc_dynamic_type (unsigned long type
)
1784 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1785 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1786 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1787 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1788 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1789 case DT_HP_PREINIT
: return "HP_PREINIT";
1790 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1791 case DT_HP_NEEDED
: return "HP_NEEDED";
1792 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1793 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1794 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1795 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1796 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1797 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1798 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1799 case DT_HP_FILTERED
: return "HP_FILTERED";
1800 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1801 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1802 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1803 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1804 case DT_PLT
: return "PLT";
1805 case DT_PLT_SIZE
: return "PLT_SIZE";
1806 case DT_DLT
: return "DLT";
1807 case DT_DLT_SIZE
: return "DLT_SIZE";
1814 get_ia64_dynamic_type (unsigned long type
)
1818 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1819 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1820 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1821 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1822 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1823 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1824 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1825 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1826 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1828 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1829 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1830 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1831 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1832 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1833 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1834 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1835 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1836 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1837 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1838 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1839 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1840 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1841 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1842 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1843 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1844 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1845 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1846 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1847 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1848 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1855 get_solaris_section_type (unsigned long type
)
1859 case 0x6fffffee: return "SUNW_ancillary";
1860 case 0x6fffffef: return "SUNW_capchain";
1861 case 0x6ffffff0: return "SUNW_capinfo";
1862 case 0x6ffffff1: return "SUNW_symsort";
1863 case 0x6ffffff2: return "SUNW_tlssort";
1864 case 0x6ffffff3: return "SUNW_LDYNSYM";
1865 case 0x6ffffff4: return "SUNW_dof";
1866 case 0x6ffffff5: return "SUNW_cap";
1867 case 0x6ffffff6: return "SUNW_SIGNATURE";
1868 case 0x6ffffff7: return "SUNW_ANNOTATE";
1869 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1870 case 0x6ffffff9: return "SUNW_DEBUG";
1871 case 0x6ffffffa: return "SUNW_move";
1872 case 0x6ffffffb: return "SUNW_COMDAT";
1873 case 0x6ffffffc: return "SUNW_syminfo";
1874 case 0x6ffffffd: return "SUNW_verdef";
1875 case 0x6ffffffe: return "SUNW_verneed";
1876 case 0x6fffffff: return "SUNW_versym";
1877 case 0x70000000: return "SPARC_GOTDATA";
1878 default: return NULL
;
1883 get_alpha_dynamic_type (unsigned long type
)
1887 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1894 get_score_dynamic_type (unsigned long type
)
1898 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1899 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1900 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1901 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1902 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1903 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1910 get_tic6x_dynamic_type (unsigned long type
)
1914 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1915 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1916 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1917 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1918 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1919 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1926 get_nios2_dynamic_type (unsigned long type
)
1930 case DT_NIOS2_GP
: return "NIOS2_GP";
1937 get_solaris_dynamic_type (unsigned long type
)
1941 case 0x6000000d: return "SUNW_AUXILIARY";
1942 case 0x6000000e: return "SUNW_RTLDINF";
1943 case 0x6000000f: return "SUNW_FILTER";
1944 case 0x60000010: return "SUNW_CAP";
1945 case 0x60000011: return "SUNW_SYMTAB";
1946 case 0x60000012: return "SUNW_SYMSZ";
1947 case 0x60000013: return "SUNW_SORTENT";
1948 case 0x60000014: return "SUNW_SYMSORT";
1949 case 0x60000015: return "SUNW_SYMSORTSZ";
1950 case 0x60000016: return "SUNW_TLSSORT";
1951 case 0x60000017: return "SUNW_TLSSORTSZ";
1952 case 0x60000018: return "SUNW_CAPINFO";
1953 case 0x60000019: return "SUNW_STRPAD";
1954 case 0x6000001a: return "SUNW_CAPCHAIN";
1955 case 0x6000001b: return "SUNW_LDMACH";
1956 case 0x6000001d: return "SUNW_CAPCHAINENT";
1957 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1958 case 0x60000021: return "SUNW_PARENT";
1959 case 0x60000023: return "SUNW_ASLR";
1960 case 0x60000025: return "SUNW_RELAX";
1961 case 0x60000029: return "SUNW_NXHEAP";
1962 case 0x6000002b: return "SUNW_NXSTACK";
1964 case 0x70000001: return "SPARC_REGISTER";
1965 case 0x7ffffffd: return "AUXILIARY";
1966 case 0x7ffffffe: return "USED";
1967 case 0x7fffffff: return "FILTER";
1969 default: return NULL
;
1974 get_dynamic_type (unsigned long type
)
1976 static char buff
[64];
1980 case DT_NULL
: return "NULL";
1981 case DT_NEEDED
: return "NEEDED";
1982 case DT_PLTRELSZ
: return "PLTRELSZ";
1983 case DT_PLTGOT
: return "PLTGOT";
1984 case DT_HASH
: return "HASH";
1985 case DT_STRTAB
: return "STRTAB";
1986 case DT_SYMTAB
: return "SYMTAB";
1987 case DT_RELA
: return "RELA";
1988 case DT_RELASZ
: return "RELASZ";
1989 case DT_RELAENT
: return "RELAENT";
1990 case DT_STRSZ
: return "STRSZ";
1991 case DT_SYMENT
: return "SYMENT";
1992 case DT_INIT
: return "INIT";
1993 case DT_FINI
: return "FINI";
1994 case DT_SONAME
: return "SONAME";
1995 case DT_RPATH
: return "RPATH";
1996 case DT_SYMBOLIC
: return "SYMBOLIC";
1997 case DT_REL
: return "REL";
1998 case DT_RELSZ
: return "RELSZ";
1999 case DT_RELENT
: return "RELENT";
2000 case DT_PLTREL
: return "PLTREL";
2001 case DT_DEBUG
: return "DEBUG";
2002 case DT_TEXTREL
: return "TEXTREL";
2003 case DT_JMPREL
: return "JMPREL";
2004 case DT_BIND_NOW
: return "BIND_NOW";
2005 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2006 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2007 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2008 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2009 case DT_RUNPATH
: return "RUNPATH";
2010 case DT_FLAGS
: return "FLAGS";
2012 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2013 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2014 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2016 case DT_CHECKSUM
: return "CHECKSUM";
2017 case DT_PLTPADSZ
: return "PLTPADSZ";
2018 case DT_MOVEENT
: return "MOVEENT";
2019 case DT_MOVESZ
: return "MOVESZ";
2020 case DT_FEATURE
: return "FEATURE";
2021 case DT_POSFLAG_1
: return "POSFLAG_1";
2022 case DT_SYMINSZ
: return "SYMINSZ";
2023 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2025 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2026 case DT_CONFIG
: return "CONFIG";
2027 case DT_DEPAUDIT
: return "DEPAUDIT";
2028 case DT_AUDIT
: return "AUDIT";
2029 case DT_PLTPAD
: return "PLTPAD";
2030 case DT_MOVETAB
: return "MOVETAB";
2031 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2033 case DT_VERSYM
: return "VERSYM";
2035 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2036 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2037 case DT_RELACOUNT
: return "RELACOUNT";
2038 case DT_RELCOUNT
: return "RELCOUNT";
2039 case DT_FLAGS_1
: return "FLAGS_1";
2040 case DT_VERDEF
: return "VERDEF";
2041 case DT_VERDEFNUM
: return "VERDEFNUM";
2042 case DT_VERNEED
: return "VERNEED";
2043 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2045 case DT_AUXILIARY
: return "AUXILIARY";
2046 case DT_USED
: return "USED";
2047 case DT_FILTER
: return "FILTER";
2049 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2050 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2051 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2052 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2053 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2054 case DT_GNU_HASH
: return "GNU_HASH";
2057 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2059 const char * result
;
2061 switch (elf_header
.e_machine
)
2064 case EM_MIPS_RS3_LE
:
2065 result
= get_mips_dynamic_type (type
);
2068 result
= get_sparc64_dynamic_type (type
);
2071 result
= get_ppc_dynamic_type (type
);
2074 result
= get_ppc64_dynamic_type (type
);
2077 result
= get_ia64_dynamic_type (type
);
2080 result
= get_alpha_dynamic_type (type
);
2083 result
= get_score_dynamic_type (type
);
2086 result
= get_tic6x_dynamic_type (type
);
2088 case EM_ALTERA_NIOS2
:
2089 result
= get_nios2_dynamic_type (type
);
2092 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2093 result
= get_solaris_dynamic_type (type
);
2102 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2104 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2105 || (elf_header
.e_machine
== EM_PARISC
2106 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2108 const char * result
;
2110 switch (elf_header
.e_machine
)
2113 result
= get_parisc_dynamic_type (type
);
2116 result
= get_ia64_dynamic_type (type
);
2119 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2120 result
= get_solaris_dynamic_type (type
);
2129 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2133 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2140 get_file_type (unsigned e_type
)
2142 static char buff
[32];
2146 case ET_NONE
: return _("NONE (None)");
2147 case ET_REL
: return _("REL (Relocatable file)");
2148 case ET_EXEC
: return _("EXEC (Executable file)");
2149 case ET_DYN
: return _("DYN (Shared object file)");
2150 case ET_CORE
: return _("CORE (Core file)");
2153 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2154 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2155 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2156 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2158 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2164 get_machine_name (unsigned e_machine
)
2166 static char buff
[64]; /* XXX */
2170 case EM_NONE
: return _("None");
2171 case EM_AARCH64
: return "AArch64";
2172 case EM_M32
: return "WE32100";
2173 case EM_SPARC
: return "Sparc";
2174 case EM_SPU
: return "SPU";
2175 case EM_386
: return "Intel 80386";
2176 case EM_68K
: return "MC68000";
2177 case EM_88K
: return "MC88000";
2178 case EM_IAMCU
: return "Intel MCU";
2179 case EM_860
: return "Intel 80860";
2180 case EM_MIPS
: return "MIPS R3000";
2181 case EM_S370
: return "IBM System/370";
2182 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2183 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2184 case EM_PARISC
: return "HPPA";
2185 case EM_PPC_OLD
: return "Power PC (old)";
2186 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2187 case EM_960
: return "Intel 90860";
2188 case EM_PPC
: return "PowerPC";
2189 case EM_PPC64
: return "PowerPC64";
2190 case EM_FR20
: return "Fujitsu FR20";
2191 case EM_FT32
: return "FTDI FT32";
2192 case EM_RH32
: return "TRW RH32";
2193 case EM_MCORE
: return "MCORE";
2194 case EM_ARM
: return "ARM";
2195 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2196 case EM_SH
: return "Renesas / SuperH SH";
2197 case EM_SPARCV9
: return "Sparc v9";
2198 case EM_TRICORE
: return "Siemens Tricore";
2199 case EM_ARC
: return "ARC";
2200 case EM_ARC_COMPACT
: return "ARCompact";
2201 case EM_ARC_COMPACT2
: return "ARCv2";
2202 case EM_H8_300
: return "Renesas H8/300";
2203 case EM_H8_300H
: return "Renesas H8/300H";
2204 case EM_H8S
: return "Renesas H8S";
2205 case EM_H8_500
: return "Renesas H8/500";
2206 case EM_IA_64
: return "Intel IA-64";
2207 case EM_MIPS_X
: return "Stanford MIPS-X";
2208 case EM_COLDFIRE
: return "Motorola Coldfire";
2209 case EM_ALPHA
: return "Alpha";
2210 case EM_CYGNUS_D10V
:
2211 case EM_D10V
: return "d10v";
2212 case EM_CYGNUS_D30V
:
2213 case EM_D30V
: return "d30v";
2214 case EM_CYGNUS_M32R
:
2215 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2216 case EM_CYGNUS_V850
:
2217 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2218 case EM_V850
: return "Renesas V850";
2219 case EM_CYGNUS_MN10300
:
2220 case EM_MN10300
: return "mn10300";
2221 case EM_CYGNUS_MN10200
:
2222 case EM_MN10200
: return "mn10200";
2223 case EM_MOXIE
: return "Moxie";
2224 case EM_CYGNUS_FR30
:
2225 case EM_FR30
: return "Fujitsu FR30";
2226 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2228 case EM_PJ
: return "picoJava";
2229 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2230 case EM_PCP
: return "Siemens PCP";
2231 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2232 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2233 case EM_STARCORE
: return "Motorola Star*Core processor";
2234 case EM_ME16
: return "Toyota ME16 processor";
2235 case EM_ST100
: return "STMicroelectronics ST100 processor";
2236 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2237 case EM_PDSP
: return "Sony DSP processor";
2238 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2239 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2240 case EM_FX66
: return "Siemens FX66 microcontroller";
2241 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2242 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2243 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2244 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2245 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2246 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2247 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2248 case EM_SVX
: return "Silicon Graphics SVx";
2249 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2250 case EM_VAX
: return "Digital VAX";
2251 case EM_VISIUM
: return "CDS VISIUMcore processor";
2253 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2254 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2255 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2256 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2257 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2258 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2259 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2260 case EM_PRISM
: return "Vitesse Prism";
2261 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2262 case EM_L1OM
: return "Intel L1OM";
2263 case EM_K1OM
: return "Intel K1OM";
2265 case EM_S390
: return "IBM S/390";
2266 case EM_SCORE
: return "SUNPLUS S+Core";
2267 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2268 case EM_OR1K
: return "OpenRISC 1000";
2269 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2270 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2271 case EM_DLX
: return "OpenDLX";
2273 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2274 case EM_IQ2000
: return "Vitesse IQ2000";
2276 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2277 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2278 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2279 case EM_NS32K
: return "National Semiconductor 32000 series";
2280 case EM_TPC
: return "Tenor Network TPC processor";
2281 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2282 case EM_MAX
: return "MAX Processor";
2283 case EM_CR
: return "National Semiconductor CompactRISC";
2284 case EM_F2MC16
: return "Fujitsu F2MC16";
2285 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2286 case EM_LATTICEMICO32
: return "Lattice Mico32";
2288 case EM_M32C
: return "Renesas M32c";
2289 case EM_MT
: return "Morpho Techologies MT processor";
2290 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2291 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2292 case EM_SEP
: return "Sharp embedded microprocessor";
2293 case EM_ARCA
: return "Arca RISC microprocessor";
2294 case EM_UNICORE
: return "Unicore";
2295 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2296 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2297 case EM_NIOS32
: return "Altera Nios";
2298 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2300 case EM_XC16X
: return "Infineon Technologies xc16x";
2301 case EM_M16C
: return "Renesas M16C series microprocessors";
2302 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2303 case EM_CE
: return "Freescale Communication Engine RISC core";
2304 case EM_TSK3000
: return "Altium TSK3000 core";
2305 case EM_RS08
: return "Freescale RS08 embedded processor";
2306 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2307 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2308 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2309 case EM_SE_C17
: return "Seiko Epson C17 family";
2310 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2311 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2312 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2313 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2314 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2315 case EM_R32C
: return "Renesas R32C series microprocessors";
2316 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2317 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2318 case EM_8051
: return "Intel 8051 and variants";
2319 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2320 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2321 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2322 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2323 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2324 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2325 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2326 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2329 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2330 case EM_RL78
: return "Renesas RL78";
2331 case EM_RX
: return "Renesas RX";
2332 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2333 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2334 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2335 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2336 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2337 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2338 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2339 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2340 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2341 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2342 case EM_CUDA
: return "NVIDIA CUDA architecture";
2343 case EM_XGATE
: return "Motorola XGATE embedded processor";
2344 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2345 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2346 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2347 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2348 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2349 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2350 case EM_BA1
: return "Beyond BA1 CPU architecture";
2351 case EM_BA2
: return "Beyond BA2 CPU architecture";
2352 case EM_XCORE
: return "XMOS xCORE processor family";
2353 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2354 case EM_KM32
: return "KM211 KM32 32-bit processor";
2355 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2356 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2357 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2358 case EM_KVARC
: return "KM211 KVARC processor";
2359 case EM_CDP
: return "Paneve CDP architecture family";
2360 case EM_COGE
: return "Cognitive Smart Memory Processor";
2361 case EM_COOL
: return "Bluechip Systems CoolEngine";
2362 case EM_NORC
: return "Nanoradio Optimized RISC";
2363 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2364 case EM_Z80
: return "Zilog Z80";
2365 case EM_AMDGPU
: return "AMD GPU architecture";
2366 case EM_RISCV
: return "RISC-V";
2368 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2374 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2376 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2377 other compilers don't a specific architecture type in the e_flags, and
2378 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2379 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2382 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2383 but also sets a specific architecture type in the e_flags field.
2385 However, when decoding the flags we don't worry if we see an
2386 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2387 ARCEM architecture type. */
2389 switch (e_flags
& EF_ARC_MACH_MSK
)
2391 /* We only expect these to occur for EM_ARC_COMPACT2. */
2392 case EF_ARC_CPU_ARCV2EM
:
2393 strcat (buf
, ", ARC EM");
2395 case EF_ARC_CPU_ARCV2HS
:
2396 strcat (buf
, ", ARC HS");
2399 /* We only expect these to occur for EM_ARC_COMPACT. */
2400 case E_ARC_MACH_ARC600
:
2401 strcat (buf
, ", ARC600");
2403 case E_ARC_MACH_ARC601
:
2404 strcat (buf
, ", ARC601");
2406 case E_ARC_MACH_ARC700
:
2407 strcat (buf
, ", ARC700");
2410 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2411 new ELF with new architecture being read by an old version of
2412 readelf, or (c) An ELF built with non-GNU compiler that does not
2413 set the architecture in the e_flags. */
2415 if (e_machine
== EM_ARC_COMPACT
)
2416 strcat (buf
, ", Unknown ARCompact");
2418 strcat (buf
, ", Unknown ARC");
2422 switch (e_flags
& EF_ARC_OSABI_MSK
)
2424 case E_ARC_OSABI_ORIG
:
2425 strcat (buf
, ", (ABI:legacy)");
2427 case E_ARC_OSABI_V2
:
2428 strcat (buf
, ", (ABI:v2)");
2430 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2431 case E_ARC_OSABI_V3
:
2432 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2435 strcat (buf
, ", unrecognised ARC OSABI flag");
2441 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2446 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2447 e_flags
&= ~ EF_ARM_EABIMASK
;
2449 /* Handle "generic" ARM flags. */
2450 if (e_flags
& EF_ARM_RELEXEC
)
2452 strcat (buf
, ", relocatable executable");
2453 e_flags
&= ~ EF_ARM_RELEXEC
;
2456 /* Now handle EABI specific flags. */
2460 strcat (buf
, ", <unrecognized EABI>");
2465 case EF_ARM_EABI_VER1
:
2466 strcat (buf
, ", Version1 EABI");
2471 /* Process flags one bit at a time. */
2472 flag
= e_flags
& - e_flags
;
2477 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2478 strcat (buf
, ", sorted symbol tables");
2488 case EF_ARM_EABI_VER2
:
2489 strcat (buf
, ", Version2 EABI");
2494 /* Process flags one bit at a time. */
2495 flag
= e_flags
& - e_flags
;
2500 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2501 strcat (buf
, ", sorted symbol tables");
2504 case EF_ARM_DYNSYMSUSESEGIDX
:
2505 strcat (buf
, ", dynamic symbols use segment index");
2508 case EF_ARM_MAPSYMSFIRST
:
2509 strcat (buf
, ", mapping symbols precede others");
2519 case EF_ARM_EABI_VER3
:
2520 strcat (buf
, ", Version3 EABI");
2523 case EF_ARM_EABI_VER4
:
2524 strcat (buf
, ", Version4 EABI");
2529 /* Process flags one bit at a time. */
2530 flag
= e_flags
& - e_flags
;
2536 strcat (buf
, ", BE8");
2540 strcat (buf
, ", LE8");
2551 case EF_ARM_EABI_VER5
:
2552 strcat (buf
, ", Version5 EABI");
2557 /* Process flags one bit at a time. */
2558 flag
= e_flags
& - e_flags
;
2564 strcat (buf
, ", BE8");
2568 strcat (buf
, ", LE8");
2571 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2572 strcat (buf
, ", soft-float ABI");
2575 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2576 strcat (buf
, ", hard-float ABI");
2586 case EF_ARM_EABI_UNKNOWN
:
2587 strcat (buf
, ", GNU EABI");
2592 /* Process flags one bit at a time. */
2593 flag
= e_flags
& - e_flags
;
2598 case EF_ARM_INTERWORK
:
2599 strcat (buf
, ", interworking enabled");
2602 case EF_ARM_APCS_26
:
2603 strcat (buf
, ", uses APCS/26");
2606 case EF_ARM_APCS_FLOAT
:
2607 strcat (buf
, ", uses APCS/float");
2611 strcat (buf
, ", position independent");
2615 strcat (buf
, ", 8 bit structure alignment");
2618 case EF_ARM_NEW_ABI
:
2619 strcat (buf
, ", uses new ABI");
2622 case EF_ARM_OLD_ABI
:
2623 strcat (buf
, ", uses old ABI");
2626 case EF_ARM_SOFT_FLOAT
:
2627 strcat (buf
, ", software FP");
2630 case EF_ARM_VFP_FLOAT
:
2631 strcat (buf
, ", VFP");
2634 case EF_ARM_MAVERICK_FLOAT
:
2635 strcat (buf
, ", Maverick FP");
2646 strcat (buf
,_(", <unknown>"));
2650 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2652 --size
; /* Leave space for null terminator. */
2654 switch (e_flags
& EF_AVR_MACH
)
2656 case E_AVR_MACH_AVR1
:
2657 strncat (buf
, ", avr:1", size
);
2659 case E_AVR_MACH_AVR2
:
2660 strncat (buf
, ", avr:2", size
);
2662 case E_AVR_MACH_AVR25
:
2663 strncat (buf
, ", avr:25", size
);
2665 case E_AVR_MACH_AVR3
:
2666 strncat (buf
, ", avr:3", size
);
2668 case E_AVR_MACH_AVR31
:
2669 strncat (buf
, ", avr:31", size
);
2671 case E_AVR_MACH_AVR35
:
2672 strncat (buf
, ", avr:35", size
);
2674 case E_AVR_MACH_AVR4
:
2675 strncat (buf
, ", avr:4", size
);
2677 case E_AVR_MACH_AVR5
:
2678 strncat (buf
, ", avr:5", size
);
2680 case E_AVR_MACH_AVR51
:
2681 strncat (buf
, ", avr:51", size
);
2683 case E_AVR_MACH_AVR6
:
2684 strncat (buf
, ", avr:6", size
);
2686 case E_AVR_MACH_AVRTINY
:
2687 strncat (buf
, ", avr:100", size
);
2689 case E_AVR_MACH_XMEGA1
:
2690 strncat (buf
, ", avr:101", size
);
2692 case E_AVR_MACH_XMEGA2
:
2693 strncat (buf
, ", avr:102", size
);
2695 case E_AVR_MACH_XMEGA3
:
2696 strncat (buf
, ", avr:103", size
);
2698 case E_AVR_MACH_XMEGA4
:
2699 strncat (buf
, ", avr:104", size
);
2701 case E_AVR_MACH_XMEGA5
:
2702 strncat (buf
, ", avr:105", size
);
2704 case E_AVR_MACH_XMEGA6
:
2705 strncat (buf
, ", avr:106", size
);
2707 case E_AVR_MACH_XMEGA7
:
2708 strncat (buf
, ", avr:107", size
);
2711 strncat (buf
, ", avr:<unknown>", size
);
2715 size
-= strlen (buf
);
2716 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2717 strncat (buf
, ", link-relax", size
);
2721 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2730 static const char *ABI_STRINGS
[] =
2732 "ABI v0", /* use r5 as return register; only used in N1213HC */
2733 "ABI v1", /* use r0 as return register */
2734 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2735 "ABI v2fp", /* for FPU */
2739 static const char *VER_STRINGS
[] =
2741 "Andes ELF V1.3 or older",
2745 static const char *ARCH_STRINGS
[] =
2754 abi
= EF_NDS_ABI
& e_flags
;
2755 arch
= EF_NDS_ARCH
& e_flags
;
2756 config
= EF_NDS_INST
& e_flags
;
2757 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2759 memset (buf
, 0, size
);
2766 case E_NDS_ABI_V2FP
:
2767 case E_NDS_ABI_AABI
:
2768 case E_NDS_ABI_V2FP_PLUS
:
2769 /* In case there are holes in the array. */
2770 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2774 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2780 case E_NDS32_ELF_VER_1_2
:
2781 case E_NDS32_ELF_VER_1_3
:
2782 case E_NDS32_ELF_VER_1_4
:
2783 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2787 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2791 if (E_NDS_ABI_V0
== abi
)
2793 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2794 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2795 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2796 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2802 case E_NDS_ARCH_STAR_V1_0
:
2803 case E_NDS_ARCH_STAR_V2_0
:
2804 case E_NDS_ARCH_STAR_V3_0
:
2805 case E_NDS_ARCH_STAR_V3_M
:
2806 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2810 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2811 /* ARCH version determines how the e_flags are interpreted.
2812 If it is unknown, we cannot proceed. */
2816 /* Newer ABI; Now handle architecture specific flags. */
2817 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2819 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2820 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2822 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2823 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2825 if (config
& E_NDS32_HAS_DIV_INST
)
2826 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2828 if (config
& E_NDS32_HAS_16BIT_INST
)
2829 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2833 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2835 if (version
<= E_NDS32_ELF_VER_1_3
)
2836 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2838 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2841 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2842 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2844 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2845 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2847 if (config
& E_NDS32_HAS_16BIT_INST
)
2849 if (version
<= E_NDS32_ELF_VER_1_3
)
2850 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2852 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2856 if (config
& E_NDS32_HAS_EXT_INST
)
2857 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2859 if (config
& E_NDS32_HAS_EXT2_INST
)
2860 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2862 if (config
& E_NDS32_HAS_FPU_INST
)
2865 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2868 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2871 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2874 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2877 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2882 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2884 case E_NDS32_FPU_REG_8SP_4DP
:
2885 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2887 case E_NDS32_FPU_REG_16SP_8DP
:
2888 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2890 case E_NDS32_FPU_REG_32SP_16DP
:
2891 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2893 case E_NDS32_FPU_REG_32SP_32DP
:
2894 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2899 if (config
& E_NDS32_HAS_AUDIO_INST
)
2900 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2902 if (config
& E_NDS32_HAS_STRING_INST
)
2903 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2905 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2906 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2908 if (config
& E_NDS32_HAS_VIDEO_INST
)
2910 if (version
<= E_NDS32_ELF_VER_1_3
)
2911 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2913 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2916 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2917 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2919 if (config
& E_NDS32_HAS_L2C_INST
)
2920 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2924 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2926 static char buf
[1024];
2937 case EM_ARC_COMPACT2
:
2938 case EM_ARC_COMPACT
:
2939 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2943 decode_ARM_machine_flags (e_flags
, buf
);
2947 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2951 if (e_flags
& EF_BFIN_PIC
)
2952 strcat (buf
, ", PIC");
2954 if (e_flags
& EF_BFIN_FDPIC
)
2955 strcat (buf
, ", FDPIC");
2957 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2958 strcat (buf
, ", code in L1");
2960 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2961 strcat (buf
, ", data in L1");
2966 switch (e_flags
& EF_FRV_CPU_MASK
)
2968 case EF_FRV_CPU_GENERIC
:
2972 strcat (buf
, ", fr???");
2975 case EF_FRV_CPU_FR300
:
2976 strcat (buf
, ", fr300");
2979 case EF_FRV_CPU_FR400
:
2980 strcat (buf
, ", fr400");
2982 case EF_FRV_CPU_FR405
:
2983 strcat (buf
, ", fr405");
2986 case EF_FRV_CPU_FR450
:
2987 strcat (buf
, ", fr450");
2990 case EF_FRV_CPU_FR500
:
2991 strcat (buf
, ", fr500");
2993 case EF_FRV_CPU_FR550
:
2994 strcat (buf
, ", fr550");
2997 case EF_FRV_CPU_SIMPLE
:
2998 strcat (buf
, ", simple");
3000 case EF_FRV_CPU_TOMCAT
:
3001 strcat (buf
, ", tomcat");
3007 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3008 strcat (buf
, ", m68000");
3009 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3010 strcat (buf
, ", cpu32");
3011 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3012 strcat (buf
, ", fido_a");
3015 char const * isa
= _("unknown");
3016 char const * mac
= _("unknown mac");
3017 char const * additional
= NULL
;
3019 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3021 case EF_M68K_CF_ISA_A_NODIV
:
3023 additional
= ", nodiv";
3025 case EF_M68K_CF_ISA_A
:
3028 case EF_M68K_CF_ISA_A_PLUS
:
3031 case EF_M68K_CF_ISA_B_NOUSP
:
3033 additional
= ", nousp";
3035 case EF_M68K_CF_ISA_B
:
3038 case EF_M68K_CF_ISA_C
:
3041 case EF_M68K_CF_ISA_C_NODIV
:
3043 additional
= ", nodiv";
3046 strcat (buf
, ", cf, isa ");
3049 strcat (buf
, additional
);
3050 if (e_flags
& EF_M68K_CF_FLOAT
)
3051 strcat (buf
, ", float");
3052 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3057 case EF_M68K_CF_MAC
:
3060 case EF_M68K_CF_EMAC
:
3063 case EF_M68K_CF_EMAC_B
:
3076 switch (e_flags
& EF_MEP_CPU_MASK
)
3078 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3079 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3080 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3081 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3082 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3083 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3084 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3087 switch (e_flags
& EF_MEP_COP_MASK
)
3089 case EF_MEP_COP_NONE
: break;
3090 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3091 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3092 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3093 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3094 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3097 if (e_flags
& EF_MEP_LIBRARY
)
3098 strcat (buf
, ", Built for Library");
3100 if (e_flags
& EF_MEP_INDEX_MASK
)
3101 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3102 e_flags
& EF_MEP_INDEX_MASK
);
3104 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3105 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3106 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3110 if (e_flags
& EF_PPC_EMB
)
3111 strcat (buf
, ", emb");
3113 if (e_flags
& EF_PPC_RELOCATABLE
)
3114 strcat (buf
, _(", relocatable"));
3116 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3117 strcat (buf
, _(", relocatable-lib"));
3121 if (e_flags
& EF_PPC64_ABI
)
3123 char abi
[] = ", abiv0";
3125 abi
[6] += e_flags
& EF_PPC64_ABI
;
3131 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3132 strcat (buf
, ", RH850 ABI");
3134 if (e_flags
& EF_V800_850E3
)
3135 strcat (buf
, ", V3 architecture");
3137 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3138 strcat (buf
, ", FPU not used");
3140 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3141 strcat (buf
, ", regmode: COMMON");
3143 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3144 strcat (buf
, ", r4 not used");
3146 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3147 strcat (buf
, ", r30 not used");
3149 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3150 strcat (buf
, ", r5 not used");
3152 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3153 strcat (buf
, ", r2 not used");
3155 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3157 switch (e_flags
& - e_flags
)
3159 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3160 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3161 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3162 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3163 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3164 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3165 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3166 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3167 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3168 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3169 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3170 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3177 case EM_CYGNUS_V850
:
3178 switch (e_flags
& EF_V850_ARCH
)
3180 case E_V850E3V5_ARCH
:
3181 strcat (buf
, ", v850e3v5");
3183 case E_V850E2V3_ARCH
:
3184 strcat (buf
, ", v850e2v3");
3187 strcat (buf
, ", v850e2");
3190 strcat (buf
, ", v850e1");
3193 strcat (buf
, ", v850e");
3196 strcat (buf
, ", v850");
3199 strcat (buf
, _(", unknown v850 architecture variant"));
3205 case EM_CYGNUS_M32R
:
3206 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3207 strcat (buf
, ", m32r");
3211 case EM_MIPS_RS3_LE
:
3212 if (e_flags
& EF_MIPS_NOREORDER
)
3213 strcat (buf
, ", noreorder");
3215 if (e_flags
& EF_MIPS_PIC
)
3216 strcat (buf
, ", pic");
3218 if (e_flags
& EF_MIPS_CPIC
)
3219 strcat (buf
, ", cpic");
3221 if (e_flags
& EF_MIPS_UCODE
)
3222 strcat (buf
, ", ugen_reserved");
3224 if (e_flags
& EF_MIPS_ABI2
)
3225 strcat (buf
, ", abi2");
3227 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3228 strcat (buf
, ", odk first");
3230 if (e_flags
& EF_MIPS_32BITMODE
)
3231 strcat (buf
, ", 32bitmode");
3233 if (e_flags
& EF_MIPS_NAN2008
)
3234 strcat (buf
, ", nan2008");
3236 if (e_flags
& EF_MIPS_FP64
)
3237 strcat (buf
, ", fp64");
3239 switch ((e_flags
& EF_MIPS_MACH
))
3241 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3242 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3243 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3244 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3245 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3246 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3247 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3248 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3249 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3250 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3251 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3252 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3253 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3254 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3255 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3256 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3257 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3259 /* We simply ignore the field in this case to avoid confusion:
3260 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3263 default: strcat (buf
, _(", unknown CPU")); break;
3266 switch ((e_flags
& EF_MIPS_ABI
))
3268 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3269 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3270 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3271 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3273 /* We simply ignore the field in this case to avoid confusion:
3274 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3275 This means it is likely to be an o32 file, but not for
3278 default: strcat (buf
, _(", unknown ABI")); break;
3281 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3282 strcat (buf
, ", mdmx");
3284 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3285 strcat (buf
, ", mips16");
3287 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3288 strcat (buf
, ", micromips");
3290 switch ((e_flags
& EF_MIPS_ARCH
))
3292 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3293 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3294 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3295 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3296 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3297 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3298 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3299 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3300 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3301 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3302 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3303 default: strcat (buf
, _(", unknown ISA")); break;
3308 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3312 switch ((e_flags
& EF_SH_MACH_MASK
))
3314 case EF_SH1
: strcat (buf
, ", sh1"); break;
3315 case EF_SH2
: strcat (buf
, ", sh2"); break;
3316 case EF_SH3
: strcat (buf
, ", sh3"); break;
3317 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3318 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3319 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3320 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3321 case EF_SH4
: strcat (buf
, ", sh4"); break;
3322 case EF_SH5
: strcat (buf
, ", sh5"); break;
3323 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3324 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3325 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3326 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3327 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3328 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3329 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3330 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3331 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3332 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3333 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3334 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3335 default: strcat (buf
, _(", unknown ISA")); break;
3338 if (e_flags
& EF_SH_PIC
)
3339 strcat (buf
, ", pic");
3341 if (e_flags
& EF_SH_FDPIC
)
3342 strcat (buf
, ", fdpic");
3346 if (e_flags
& EF_OR1K_NODELAY
)
3347 strcat (buf
, ", no delay");
3351 if (e_flags
& EF_SPARC_32PLUS
)
3352 strcat (buf
, ", v8+");
3354 if (e_flags
& EF_SPARC_SUN_US1
)
3355 strcat (buf
, ", ultrasparcI");
3357 if (e_flags
& EF_SPARC_SUN_US3
)
3358 strcat (buf
, ", ultrasparcIII");
3360 if (e_flags
& EF_SPARC_HAL_R1
)
3361 strcat (buf
, ", halr1");
3363 if (e_flags
& EF_SPARC_LEDATA
)
3364 strcat (buf
, ", ledata");
3366 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3367 strcat (buf
, ", tso");
3369 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3370 strcat (buf
, ", pso");
3372 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3373 strcat (buf
, ", rmo");
3377 switch (e_flags
& EF_PARISC_ARCH
)
3379 case EFA_PARISC_1_0
:
3380 strcpy (buf
, ", PA-RISC 1.0");
3382 case EFA_PARISC_1_1
:
3383 strcpy (buf
, ", PA-RISC 1.1");
3385 case EFA_PARISC_2_0
:
3386 strcpy (buf
, ", PA-RISC 2.0");
3391 if (e_flags
& EF_PARISC_TRAPNIL
)
3392 strcat (buf
, ", trapnil");
3393 if (e_flags
& EF_PARISC_EXT
)
3394 strcat (buf
, ", ext");
3395 if (e_flags
& EF_PARISC_LSB
)
3396 strcat (buf
, ", lsb");
3397 if (e_flags
& EF_PARISC_WIDE
)
3398 strcat (buf
, ", wide");
3399 if (e_flags
& EF_PARISC_NO_KABP
)
3400 strcat (buf
, ", no kabp");
3401 if (e_flags
& EF_PARISC_LAZYSWAP
)
3402 strcat (buf
, ", lazyswap");
3407 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3408 strcat (buf
, ", new calling convention");
3410 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3411 strcat (buf
, ", gnu calling convention");
3415 if ((e_flags
& EF_IA_64_ABI64
))
3416 strcat (buf
, ", 64-bit");
3418 strcat (buf
, ", 32-bit");
3419 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3420 strcat (buf
, ", reduced fp model");
3421 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3422 strcat (buf
, ", no function descriptors, constant gp");
3423 else if ((e_flags
& EF_IA_64_CONS_GP
))
3424 strcat (buf
, ", constant gp");
3425 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3426 strcat (buf
, ", absolute");
3427 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3429 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3430 strcat (buf
, ", vms_linkages");
3431 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3433 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3435 case EF_IA_64_VMS_COMCOD_WARNING
:
3436 strcat (buf
, ", warning");
3438 case EF_IA_64_VMS_COMCOD_ERROR
:
3439 strcat (buf
, ", error");
3441 case EF_IA_64_VMS_COMCOD_ABORT
:
3442 strcat (buf
, ", abort");
3445 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3446 e_flags
& EF_IA_64_VMS_COMCOD
);
3447 strcat (buf
, ", <unknown>");
3453 if ((e_flags
& EF_VAX_NONPIC
))
3454 strcat (buf
, ", non-PIC");
3455 if ((e_flags
& EF_VAX_DFLOAT
))
3456 strcat (buf
, ", D-Float");
3457 if ((e_flags
& EF_VAX_GFLOAT
))
3458 strcat (buf
, ", G-Float");
3462 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3463 strcat (buf
, ", mcm");
3464 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3465 strcat (buf
, ", mcm24");
3466 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3467 strcat (buf
, ", gr6");
3471 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3473 case E_FLAG_RL78_ANY_CPU
: break;
3474 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3475 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3476 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3478 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3479 strcat (buf
, ", 64-bit doubles");
3483 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3484 strcat (buf
, ", 64-bit doubles");
3485 if (e_flags
& E_FLAG_RX_DSP
)
3486 strcat (buf
, ", dsp");
3487 if (e_flags
& E_FLAG_RX_PID
)
3488 strcat (buf
, ", pid");
3489 if (e_flags
& E_FLAG_RX_ABI
)
3490 strcat (buf
, ", RX ABI");
3491 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3492 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3493 ? ", uses String instructions" : ", bans String instructions");
3494 if (e_flags
& E_FLAG_RX_V2
)
3495 strcat (buf
, ", V2");
3499 if (e_flags
& EF_S390_HIGH_GPRS
)
3500 strcat (buf
, ", highgprs");
3504 if ((e_flags
& EF_C6000_REL
))
3505 strcat (buf
, ", relocatable module");
3509 strcat (buf
, _(": architecture variant: "));
3510 switch (e_flags
& EF_MSP430_MACH
)
3512 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3513 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3514 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3515 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3516 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3517 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3518 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3519 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3520 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3521 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3522 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3523 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3524 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3525 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3526 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3528 strcat (buf
, _(": unknown")); break;
3531 if (e_flags
& ~ EF_MSP430_MACH
)
3532 strcat (buf
, _(": unknown extra flag bits also present"));
3540 get_osabi_name (unsigned int osabi
)
3542 static char buff
[32];
3546 case ELFOSABI_NONE
: return "UNIX - System V";
3547 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3548 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3549 case ELFOSABI_GNU
: return "UNIX - GNU";
3550 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3551 case ELFOSABI_AIX
: return "UNIX - AIX";
3552 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3553 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3554 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3555 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3556 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3557 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3558 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3559 case ELFOSABI_AROS
: return "AROS";
3560 case ELFOSABI_FENIXOS
: return "FenixOS";
3561 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3562 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3565 switch (elf_header
.e_machine
)
3570 case ELFOSABI_ARM
: return "ARM";
3581 case ELFOSABI_STANDALONE
: return _("Standalone App");
3590 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3591 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3600 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3606 get_aarch64_segment_type (unsigned long type
)
3610 case PT_AARCH64_ARCHEXT
:
3611 return "AARCH64_ARCHEXT";
3620 get_arm_segment_type (unsigned long type
)
3634 get_mips_segment_type (unsigned long type
)
3638 case PT_MIPS_REGINFO
:
3640 case PT_MIPS_RTPROC
:
3642 case PT_MIPS_OPTIONS
:
3644 case PT_MIPS_ABIFLAGS
:
3654 get_parisc_segment_type (unsigned long type
)
3658 case PT_HP_TLS
: return "HP_TLS";
3659 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3660 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3661 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3662 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3663 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3664 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3665 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3666 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3667 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3668 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3669 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3670 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3671 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3672 case PT_HP_STACK
: return "HP_STACK";
3673 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3674 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3675 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3676 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3685 get_ia64_segment_type (unsigned long type
)
3689 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3690 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3691 case PT_HP_TLS
: return "HP_TLS";
3692 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3693 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3694 case PT_IA_64_HP_STACK
: return "HP_STACK";
3703 get_tic6x_segment_type (unsigned long type
)
3707 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3716 get_solaris_segment_type (unsigned long type
)
3720 case 0x6464e550: return "PT_SUNW_UNWIND";
3721 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3722 case 0x6ffffff7: return "PT_LOSUNW";
3723 case 0x6ffffffa: return "PT_SUNWBSS";
3724 case 0x6ffffffb: return "PT_SUNWSTACK";
3725 case 0x6ffffffc: return "PT_SUNWDTRACE";
3726 case 0x6ffffffd: return "PT_SUNWCAP";
3727 case 0x6fffffff: return "PT_HISUNW";
3728 default: return NULL
;
3733 get_segment_type (unsigned long p_type
)
3735 static char buff
[32];
3739 case PT_NULL
: return "NULL";
3740 case PT_LOAD
: return "LOAD";
3741 case PT_DYNAMIC
: return "DYNAMIC";
3742 case PT_INTERP
: return "INTERP";
3743 case PT_NOTE
: return "NOTE";
3744 case PT_SHLIB
: return "SHLIB";
3745 case PT_PHDR
: return "PHDR";
3746 case PT_TLS
: return "TLS";
3748 case PT_GNU_EH_FRAME
:
3749 return "GNU_EH_FRAME";
3750 case PT_GNU_STACK
: return "GNU_STACK";
3751 case PT_GNU_RELRO
: return "GNU_RELRO";
3754 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3756 const char * result
;
3758 switch (elf_header
.e_machine
)
3761 result
= get_aarch64_segment_type (p_type
);
3764 result
= get_arm_segment_type (p_type
);
3767 case EM_MIPS_RS3_LE
:
3768 result
= get_mips_segment_type (p_type
);
3771 result
= get_parisc_segment_type (p_type
);
3774 result
= get_ia64_segment_type (p_type
);
3777 result
= get_tic6x_segment_type (p_type
);
3787 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3789 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3791 const char * result
;
3793 switch (elf_header
.e_machine
)
3796 result
= get_parisc_segment_type (p_type
);
3799 result
= get_ia64_segment_type (p_type
);
3802 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3803 result
= get_solaris_segment_type (p_type
);
3812 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3815 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3822 get_mips_section_type_name (unsigned int sh_type
)
3826 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3827 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3828 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3829 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3830 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3831 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3832 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3833 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3834 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3835 case SHT_MIPS_RELD
: return "MIPS_RELD";
3836 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3837 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3838 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3839 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3840 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3841 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3842 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3843 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3844 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3845 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3846 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3847 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3848 case SHT_MIPS_LINE
: return "MIPS_LINE";
3849 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3850 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3851 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3852 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3853 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3854 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3855 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3856 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3857 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3858 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3859 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3860 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3861 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3862 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3863 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3864 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3865 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3873 get_parisc_section_type_name (unsigned int sh_type
)
3877 case SHT_PARISC_EXT
: return "PARISC_EXT";
3878 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3879 case SHT_PARISC_DOC
: return "PARISC_DOC";
3880 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3881 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3882 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3883 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3891 get_ia64_section_type_name (unsigned int sh_type
)
3893 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3894 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3895 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3899 case SHT_IA_64_EXT
: return "IA_64_EXT";
3900 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3901 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3902 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3903 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3904 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3905 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3906 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3907 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3908 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3916 get_x86_64_section_type_name (unsigned int sh_type
)
3920 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3928 get_aarch64_section_type_name (unsigned int sh_type
)
3932 case SHT_AARCH64_ATTRIBUTES
:
3933 return "AARCH64_ATTRIBUTES";
3941 get_arm_section_type_name (unsigned int sh_type
)
3945 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3946 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3947 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3948 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3949 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3957 get_tic6x_section_type_name (unsigned int sh_type
)
3961 case SHT_C6000_UNWIND
:
3962 return "C6000_UNWIND";
3963 case SHT_C6000_PREEMPTMAP
:
3964 return "C6000_PREEMPTMAP";
3965 case SHT_C6000_ATTRIBUTES
:
3966 return "C6000_ATTRIBUTES";
3971 case SHT_TI_HANDLER
:
3972 return "TI_HANDLER";
3973 case SHT_TI_INITINFO
:
3974 return "TI_INITINFO";
3975 case SHT_TI_PHATTRS
:
3976 return "TI_PHATTRS";
3984 get_msp430x_section_type_name (unsigned int sh_type
)
3988 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3989 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3990 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3991 default: return NULL
;
3996 get_v850_section_type_name (unsigned int sh_type
)
4000 case SHT_V850_SCOMMON
: return "V850 Small Common";
4001 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4002 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4003 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4004 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4005 default: return NULL
;
4010 get_section_type_name (unsigned int sh_type
)
4012 static char buff
[32];
4013 const char * result
;
4017 case SHT_NULL
: return "NULL";
4018 case SHT_PROGBITS
: return "PROGBITS";
4019 case SHT_SYMTAB
: return "SYMTAB";
4020 case SHT_STRTAB
: return "STRTAB";
4021 case SHT_RELA
: return "RELA";
4022 case SHT_HASH
: return "HASH";
4023 case SHT_DYNAMIC
: return "DYNAMIC";
4024 case SHT_NOTE
: return "NOTE";
4025 case SHT_NOBITS
: return "NOBITS";
4026 case SHT_REL
: return "REL";
4027 case SHT_SHLIB
: return "SHLIB";
4028 case SHT_DYNSYM
: return "DYNSYM";
4029 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4030 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4031 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4032 case SHT_GNU_HASH
: return "GNU_HASH";
4033 case SHT_GROUP
: return "GROUP";
4034 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4035 case SHT_GNU_verdef
: return "VERDEF";
4036 case SHT_GNU_verneed
: return "VERNEED";
4037 case SHT_GNU_versym
: return "VERSYM";
4038 case 0x6ffffff0: return "VERSYM";
4039 case 0x6ffffffc: return "VERDEF";
4040 case 0x7ffffffd: return "AUXILIARY";
4041 case 0x7fffffff: return "FILTER";
4042 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4045 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4047 switch (elf_header
.e_machine
)
4050 case EM_MIPS_RS3_LE
:
4051 result
= get_mips_section_type_name (sh_type
);
4054 result
= get_parisc_section_type_name (sh_type
);
4057 result
= get_ia64_section_type_name (sh_type
);
4062 result
= get_x86_64_section_type_name (sh_type
);
4065 result
= get_aarch64_section_type_name (sh_type
);
4068 result
= get_arm_section_type_name (sh_type
);
4071 result
= get_tic6x_section_type_name (sh_type
);
4074 result
= get_msp430x_section_type_name (sh_type
);
4078 case EM_CYGNUS_V850
:
4079 result
= get_v850_section_type_name (sh_type
);
4089 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4091 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4093 switch (elf_header
.e_machine
)
4096 result
= get_ia64_section_type_name (sh_type
);
4099 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4100 result
= get_solaris_section_type (sh_type
);
4109 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4111 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4113 switch (elf_header
.e_machine
)
4117 case EM_CYGNUS_V850
:
4118 result
= get_v850_section_type_name (sh_type
);
4128 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4131 /* This message is probably going to be displayed in a 15
4132 character wide field, so put the hex value first. */
4133 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4139 #define OPTION_DEBUG_DUMP 512
4140 #define OPTION_DYN_SYMS 513
4141 #define OPTION_DWARF_DEPTH 514
4142 #define OPTION_DWARF_START 515
4143 #define OPTION_DWARF_CHECK 516
4145 static struct option options
[] =
4147 {"all", no_argument
, 0, 'a'},
4148 {"file-header", no_argument
, 0, 'h'},
4149 {"program-headers", no_argument
, 0, 'l'},
4150 {"headers", no_argument
, 0, 'e'},
4151 {"histogram", no_argument
, 0, 'I'},
4152 {"segments", no_argument
, 0, 'l'},
4153 {"sections", no_argument
, 0, 'S'},
4154 {"section-headers", no_argument
, 0, 'S'},
4155 {"section-groups", no_argument
, 0, 'g'},
4156 {"section-details", no_argument
, 0, 't'},
4157 {"full-section-name",no_argument
, 0, 'N'},
4158 {"symbols", no_argument
, 0, 's'},
4159 {"syms", no_argument
, 0, 's'},
4160 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4161 {"relocs", no_argument
, 0, 'r'},
4162 {"notes", no_argument
, 0, 'n'},
4163 {"dynamic", no_argument
, 0, 'd'},
4164 {"arch-specific", no_argument
, 0, 'A'},
4165 {"version-info", no_argument
, 0, 'V'},
4166 {"use-dynamic", no_argument
, 0, 'D'},
4167 {"unwind", no_argument
, 0, 'u'},
4168 {"archive-index", no_argument
, 0, 'c'},
4169 {"hex-dump", required_argument
, 0, 'x'},
4170 {"relocated-dump", required_argument
, 0, 'R'},
4171 {"string-dump", required_argument
, 0, 'p'},
4172 {"decompress", no_argument
, 0, 'z'},
4173 #ifdef SUPPORT_DISASSEMBLY
4174 {"instruction-dump", required_argument
, 0, 'i'},
4176 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4178 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4179 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4180 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4182 {"version", no_argument
, 0, 'v'},
4183 {"wide", no_argument
, 0, 'W'},
4184 {"help", no_argument
, 0, 'H'},
4185 {0, no_argument
, 0, 0}
4189 usage (FILE * stream
)
4191 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4192 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4193 fprintf (stream
, _(" Options are:\n\
4194 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4195 -h --file-header Display the ELF file header\n\
4196 -l --program-headers Display the program headers\n\
4197 --segments An alias for --program-headers\n\
4198 -S --section-headers Display the sections' header\n\
4199 --sections An alias for --section-headers\n\
4200 -g --section-groups Display the section groups\n\
4201 -t --section-details Display the section details\n\
4202 -e --headers Equivalent to: -h -l -S\n\
4203 -s --syms Display the symbol table\n\
4204 --symbols An alias for --syms\n\
4205 --dyn-syms Display the dynamic symbol table\n\
4206 -n --notes Display the core notes (if present)\n\
4207 -r --relocs Display the relocations (if present)\n\
4208 -u --unwind Display the unwind info (if present)\n\
4209 -d --dynamic Display the dynamic section (if present)\n\
4210 -V --version-info Display the version sections (if present)\n\
4211 -A --arch-specific Display architecture specific information (if any)\n\
4212 -c --archive-index Display the symbol/file index in an archive\n\
4213 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4214 -x --hex-dump=<number|name>\n\
4215 Dump the contents of section <number|name> as bytes\n\
4216 -p --string-dump=<number|name>\n\
4217 Dump the contents of section <number|name> as strings\n\
4218 -R --relocated-dump=<number|name>\n\
4219 Dump the contents of section <number|name> as relocated bytes\n\
4220 -z --decompress Decompress section before dumping it\n\
4221 -w[lLiaprmfFsoRt] or\n\
4222 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4223 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4224 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4226 Display the contents of DWARF2 debug sections\n"));
4227 fprintf (stream
, _("\
4228 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4229 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4231 #ifdef SUPPORT_DISASSEMBLY
4232 fprintf (stream
, _("\
4233 -i --instruction-dump=<number|name>\n\
4234 Disassemble the contents of section <number|name>\n"));
4236 fprintf (stream
, _("\
4237 -I --histogram Display histogram of bucket list lengths\n\
4238 -W --wide Allow output width to exceed 80 characters\n\
4239 @<file> Read options from <file>\n\
4240 -H --help Display this information\n\
4241 -v --version Display the version number of readelf\n"));
4243 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4244 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4246 exit (stream
== stdout
? 0 : 1);
4249 /* Record the fact that the user wants the contents of section number
4250 SECTION to be displayed using the method(s) encoded as flags bits
4251 in TYPE. Note, TYPE can be zero if we are creating the array for
4255 request_dump_bynumber (unsigned int section
, dump_type type
)
4257 if (section
>= num_dump_sects
)
4259 dump_type
* new_dump_sects
;
4261 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4262 sizeof (* dump_sects
));
4264 if (new_dump_sects
== NULL
)
4265 error (_("Out of memory allocating dump request table.\n"));
4270 /* Copy current flag settings. */
4271 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4276 dump_sects
= new_dump_sects
;
4277 num_dump_sects
= section
+ 1;
4282 dump_sects
[section
] |= type
;
4287 /* Request a dump by section name. */
4290 request_dump_byname (const char * section
, dump_type type
)
4292 struct dump_list_entry
* new_request
;
4294 new_request
= (struct dump_list_entry
*)
4295 malloc (sizeof (struct dump_list_entry
));
4297 error (_("Out of memory allocating dump request table.\n"));
4299 new_request
->name
= strdup (section
);
4300 if (!new_request
->name
)
4301 error (_("Out of memory allocating dump request table.\n"));
4303 new_request
->type
= type
;
4305 new_request
->next
= dump_sects_byname
;
4306 dump_sects_byname
= new_request
;
4310 request_dump (dump_type type
)
4316 section
= strtoul (optarg
, & cp
, 0);
4318 if (! *cp
&& section
>= 0)
4319 request_dump_bynumber (section
, type
);
4321 request_dump_byname (optarg
, type
);
4326 parse_args (int argc
, char ** argv
)
4333 while ((c
= getopt_long
4334 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4352 do_section_groups
++;
4360 do_section_groups
++;
4365 do_section_details
++;
4409 request_dump (HEX_DUMP
);
4412 request_dump (STRING_DUMP
);
4415 request_dump (RELOC_DUMP
);
4425 dwarf_select_sections_all ();
4430 dwarf_select_sections_by_letters (optarg
);
4433 case OPTION_DEBUG_DUMP
:
4440 dwarf_select_sections_by_names (optarg
);
4443 case OPTION_DWARF_DEPTH
:
4447 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4450 case OPTION_DWARF_START
:
4454 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4457 case OPTION_DWARF_CHECK
:
4460 case OPTION_DYN_SYMS
:
4463 #ifdef SUPPORT_DISASSEMBLY
4465 request_dump (DISASS_DUMP
);
4469 print_version (program_name
);
4478 /* xgettext:c-format */
4479 error (_("Invalid option '-%c'\n"), c
);
4486 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4487 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4488 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4489 && !do_section_groups
&& !do_archive_index
4495 get_elf_class (unsigned int elf_class
)
4497 static char buff
[32];
4501 case ELFCLASSNONE
: return _("none");
4502 case ELFCLASS32
: return "ELF32";
4503 case ELFCLASS64
: return "ELF64";
4505 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4511 get_data_encoding (unsigned int encoding
)
4513 static char buff
[32];
4517 case ELFDATANONE
: return _("none");
4518 case ELFDATA2LSB
: return _("2's complement, little endian");
4519 case ELFDATA2MSB
: return _("2's complement, big endian");
4521 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4526 /* Decode the data held in 'elf_header'. */
4529 process_file_header (void)
4531 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4532 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4533 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4534 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4537 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4541 init_dwarf_regnames (elf_header
.e_machine
);
4547 printf (_("ELF Header:\n"));
4548 printf (_(" Magic: "));
4549 for (i
= 0; i
< EI_NIDENT
; i
++)
4550 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4552 printf (_(" Class: %s\n"),
4553 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4554 printf (_(" Data: %s\n"),
4555 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4556 printf (_(" Version: %d %s\n"),
4557 elf_header
.e_ident
[EI_VERSION
],
4558 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4560 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4561 ? _("<unknown: %lx>")
4563 printf (_(" OS/ABI: %s\n"),
4564 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4565 printf (_(" ABI Version: %d\n"),
4566 elf_header
.e_ident
[EI_ABIVERSION
]);
4567 printf (_(" Type: %s\n"),
4568 get_file_type (elf_header
.e_type
));
4569 printf (_(" Machine: %s\n"),
4570 get_machine_name (elf_header
.e_machine
));
4571 printf (_(" Version: 0x%lx\n"),
4572 (unsigned long) elf_header
.e_version
);
4574 printf (_(" Entry point address: "));
4575 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4576 printf (_("\n Start of program headers: "));
4577 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4578 printf (_(" (bytes into file)\n Start of section headers: "));
4579 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4580 printf (_(" (bytes into file)\n"));
4582 printf (_(" Flags: 0x%lx%s\n"),
4583 (unsigned long) elf_header
.e_flags
,
4584 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4585 printf (_(" Size of this header: %ld (bytes)\n"),
4586 (long) elf_header
.e_ehsize
);
4587 printf (_(" Size of program headers: %ld (bytes)\n"),
4588 (long) elf_header
.e_phentsize
);
4589 printf (_(" Number of program headers: %ld"),
4590 (long) elf_header
.e_phnum
);
4591 if (section_headers
!= NULL
4592 && elf_header
.e_phnum
== PN_XNUM
4593 && section_headers
[0].sh_info
!= 0)
4594 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4595 putc ('\n', stdout
);
4596 printf (_(" Size of section headers: %ld (bytes)\n"),
4597 (long) elf_header
.e_shentsize
);
4598 printf (_(" Number of section headers: %ld"),
4599 (long) elf_header
.e_shnum
);
4600 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4601 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4602 putc ('\n', stdout
);
4603 printf (_(" Section header string table index: %ld"),
4604 (long) elf_header
.e_shstrndx
);
4605 if (section_headers
!= NULL
4606 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4607 printf (" (%u)", section_headers
[0].sh_link
);
4608 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4609 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4610 printf (_(" <corrupt: out of range>"));
4611 putc ('\n', stdout
);
4614 if (section_headers
!= NULL
)
4616 if (elf_header
.e_phnum
== PN_XNUM
4617 && section_headers
[0].sh_info
!= 0)
4618 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4619 if (elf_header
.e_shnum
== SHN_UNDEF
)
4620 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4621 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4622 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4623 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4624 elf_header
.e_shstrndx
= SHN_UNDEF
;
4625 free (section_headers
);
4626 section_headers
= NULL
;
4633 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4635 Elf32_External_Phdr
* phdrs
;
4636 Elf32_External_Phdr
* external
;
4637 Elf_Internal_Phdr
* internal
;
4639 unsigned int size
= elf_header
.e_phentsize
;
4640 unsigned int num
= elf_header
.e_phnum
;
4642 /* PR binutils/17531: Cope with unexpected section header sizes. */
4643 if (size
== 0 || num
== 0)
4645 if (size
< sizeof * phdrs
)
4647 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4650 if (size
> sizeof * phdrs
)
4651 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4653 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4654 size
, num
, _("program headers"));
4658 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4659 i
< elf_header
.e_phnum
;
4660 i
++, internal
++, external
++)
4662 internal
->p_type
= BYTE_GET (external
->p_type
);
4663 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4664 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4665 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4666 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4667 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4668 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4669 internal
->p_align
= BYTE_GET (external
->p_align
);
4677 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4679 Elf64_External_Phdr
* phdrs
;
4680 Elf64_External_Phdr
* external
;
4681 Elf_Internal_Phdr
* internal
;
4683 unsigned int size
= elf_header
.e_phentsize
;
4684 unsigned int num
= elf_header
.e_phnum
;
4686 /* PR binutils/17531: Cope with unexpected section header sizes. */
4687 if (size
== 0 || num
== 0)
4689 if (size
< sizeof * phdrs
)
4691 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4694 if (size
> sizeof * phdrs
)
4695 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4697 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4698 size
, num
, _("program headers"));
4702 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4703 i
< elf_header
.e_phnum
;
4704 i
++, internal
++, external
++)
4706 internal
->p_type
= BYTE_GET (external
->p_type
);
4707 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4708 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4709 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4710 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4711 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4712 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4713 internal
->p_align
= BYTE_GET (external
->p_align
);
4720 /* Returns 1 if the program headers were read into `program_headers'. */
4723 get_program_headers (FILE * file
)
4725 Elf_Internal_Phdr
* phdrs
;
4727 /* Check cache of prior read. */
4728 if (program_headers
!= NULL
)
4731 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4732 sizeof (Elf_Internal_Phdr
));
4736 error (_("Out of memory reading %u program headers\n"),
4737 elf_header
.e_phnum
);
4742 ? get_32bit_program_headers (file
, phdrs
)
4743 : get_64bit_program_headers (file
, phdrs
))
4745 program_headers
= phdrs
;
4753 /* Returns 1 if the program headers were loaded. */
4756 process_program_headers (FILE * file
)
4758 Elf_Internal_Phdr
* segment
;
4761 if (elf_header
.e_phnum
== 0)
4763 /* PR binutils/12467. */
4764 if (elf_header
.e_phoff
!= 0)
4765 warn (_("possibly corrupt ELF header - it has a non-zero program"
4766 " header offset, but no program headers\n"));
4767 else if (do_segments
)
4768 printf (_("\nThere are no program headers in this file.\n"));
4772 if (do_segments
&& !do_header
)
4774 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4775 printf (_("Entry point "));
4776 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4777 printf (_("\nThere are %d program headers, starting at offset "),
4778 elf_header
.e_phnum
);
4779 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4783 if (! get_program_headers (file
))
4788 if (elf_header
.e_phnum
> 1)
4789 printf (_("\nProgram Headers:\n"));
4791 printf (_("\nProgram Headers:\n"));
4795 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4798 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4802 (_(" Type Offset VirtAddr PhysAddr\n"));
4804 (_(" FileSiz MemSiz Flags Align\n"));
4811 for (i
= 0, segment
= program_headers
;
4812 i
< elf_header
.e_phnum
;
4817 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4821 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4822 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4823 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4824 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4825 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4827 (segment
->p_flags
& PF_R
? 'R' : ' '),
4828 (segment
->p_flags
& PF_W
? 'W' : ' '),
4829 (segment
->p_flags
& PF_X
? 'E' : ' '));
4830 printf ("%#lx", (unsigned long) segment
->p_align
);
4834 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4835 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4838 print_vma (segment
->p_offset
, FULL_HEX
);
4842 print_vma (segment
->p_vaddr
, FULL_HEX
);
4844 print_vma (segment
->p_paddr
, FULL_HEX
);
4847 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4848 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4851 print_vma (segment
->p_filesz
, FULL_HEX
);
4855 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4856 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4859 print_vma (segment
->p_memsz
, FULL_HEX
);
4863 (segment
->p_flags
& PF_R
? 'R' : ' '),
4864 (segment
->p_flags
& PF_W
? 'W' : ' '),
4865 (segment
->p_flags
& PF_X
? 'E' : ' '));
4867 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4868 printf ("%#lx", (unsigned long) segment
->p_align
);
4871 print_vma (segment
->p_align
, PREFIX_HEX
);
4876 print_vma (segment
->p_offset
, FULL_HEX
);
4878 print_vma (segment
->p_vaddr
, FULL_HEX
);
4880 print_vma (segment
->p_paddr
, FULL_HEX
);
4882 print_vma (segment
->p_filesz
, FULL_HEX
);
4884 print_vma (segment
->p_memsz
, FULL_HEX
);
4886 (segment
->p_flags
& PF_R
? 'R' : ' '),
4887 (segment
->p_flags
& PF_W
? 'W' : ' '),
4888 (segment
->p_flags
& PF_X
? 'E' : ' '));
4889 print_vma (segment
->p_align
, HEX
);
4894 putc ('\n', stdout
);
4896 switch (segment
->p_type
)
4900 error (_("more than one dynamic segment\n"));
4902 /* By default, assume that the .dynamic section is the first
4903 section in the DYNAMIC segment. */
4904 dynamic_addr
= segment
->p_offset
;
4905 dynamic_size
= segment
->p_filesz
;
4906 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4907 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4909 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4910 dynamic_addr
= dynamic_size
= 0;
4913 /* Try to locate the .dynamic section. If there is
4914 a section header table, we can easily locate it. */
4915 if (section_headers
!= NULL
)
4917 Elf_Internal_Shdr
* sec
;
4919 sec
= find_section (".dynamic");
4920 if (sec
== NULL
|| sec
->sh_size
== 0)
4922 /* A corresponding .dynamic section is expected, but on
4923 IA-64/OpenVMS it is OK for it to be missing. */
4924 if (!is_ia64_vms ())
4925 error (_("no .dynamic section in the dynamic segment\n"));
4929 if (sec
->sh_type
== SHT_NOBITS
)
4935 dynamic_addr
= sec
->sh_offset
;
4936 dynamic_size
= sec
->sh_size
;
4938 if (dynamic_addr
< segment
->p_offset
4939 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4940 warn (_("the .dynamic section is not contained"
4941 " within the dynamic segment\n"));
4942 else if (dynamic_addr
> segment
->p_offset
)
4943 warn (_("the .dynamic section is not the first section"
4944 " in the dynamic segment.\n"));
4949 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4951 error (_("Unable to find program interpreter name\n"));
4955 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4957 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4958 error (_("Internal error: failed to create format string to display program interpreter\n"));
4960 program_interpreter
[0] = 0;
4961 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4962 error (_("Unable to read program interpreter name\n"));
4965 printf (_(" [Requesting program interpreter: %s]\n"),
4966 program_interpreter
);
4972 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4974 printf (_("\n Section to Segment mapping:\n"));
4975 printf (_(" Segment Sections...\n"));
4977 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4980 Elf_Internal_Shdr
* section
;
4982 segment
= program_headers
+ i
;
4983 section
= section_headers
+ 1;
4985 printf (" %2.2d ", i
);
4987 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4989 if (!ELF_TBSS_SPECIAL (section
, segment
)
4990 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4991 printf ("%s ", printable_section_name (section
));
5002 /* Find the file offset corresponding to VMA by using the program headers. */
5005 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5007 Elf_Internal_Phdr
* seg
;
5009 if (! get_program_headers (file
))
5011 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5015 for (seg
= program_headers
;
5016 seg
< program_headers
+ elf_header
.e_phnum
;
5019 if (seg
->p_type
!= PT_LOAD
)
5022 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5023 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5024 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5027 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5028 (unsigned long) vma
);
5033 /* Allocate memory and load the sections headers into the global pointer
5034 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5035 generate any error messages if the load fails. */
5038 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5040 Elf32_External_Shdr
* shdrs
;
5041 Elf_Internal_Shdr
* internal
;
5043 unsigned int size
= elf_header
.e_shentsize
;
5044 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5046 /* PR binutils/17531: Cope with unexpected section header sizes. */
5047 if (size
== 0 || num
== 0)
5049 if (size
< sizeof * shdrs
)
5052 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5055 if (!probe
&& size
> sizeof * shdrs
)
5056 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5058 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5060 probe
? NULL
: _("section headers"));
5064 if (section_headers
!= NULL
)
5065 free (section_headers
);
5066 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5067 sizeof (Elf_Internal_Shdr
));
5068 if (section_headers
== NULL
)
5071 error (_("Out of memory reading %u section headers\n"), num
);
5075 for (i
= 0, internal
= section_headers
;
5079 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5080 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5081 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5082 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5083 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5084 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5085 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5086 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5087 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5088 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5089 if (!probe
&& internal
->sh_link
> num
)
5090 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5091 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5092 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5100 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5102 Elf64_External_Shdr
* shdrs
;
5103 Elf_Internal_Shdr
* internal
;
5105 unsigned int size
= elf_header
.e_shentsize
;
5106 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5108 /* PR binutils/17531: Cope with unexpected section header sizes. */
5109 if (size
== 0 || num
== 0)
5111 if (size
< sizeof * shdrs
)
5114 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5117 if (! probe
&& size
> sizeof * shdrs
)
5118 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5120 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5122 probe
? NULL
: _("section headers"));
5126 if (section_headers
!= NULL
)
5127 free (section_headers
);
5128 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5129 sizeof (Elf_Internal_Shdr
));
5130 if (section_headers
== NULL
)
5133 error (_("Out of memory reading %u section headers\n"), num
);
5137 for (i
= 0, internal
= section_headers
;
5141 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5142 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5143 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5144 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5145 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5146 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5147 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5148 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5149 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5150 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5151 if (!probe
&& internal
->sh_link
> num
)
5152 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5153 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5154 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5161 static Elf_Internal_Sym
*
5162 get_32bit_elf_symbols (FILE * file
,
5163 Elf_Internal_Shdr
* section
,
5164 unsigned long * num_syms_return
)
5166 unsigned long number
= 0;
5167 Elf32_External_Sym
* esyms
= NULL
;
5168 Elf_External_Sym_Shndx
* shndx
= NULL
;
5169 Elf_Internal_Sym
* isyms
= NULL
;
5170 Elf_Internal_Sym
* psym
;
5173 if (section
->sh_size
== 0)
5175 if (num_syms_return
!= NULL
)
5176 * num_syms_return
= 0;
5180 /* Run some sanity checks first. */
5181 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5183 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5184 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5188 if (section
->sh_size
> current_file_size
)
5190 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5191 printable_section_name (section
), (unsigned long) section
->sh_size
);
5195 number
= section
->sh_size
/ section
->sh_entsize
;
5197 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5199 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5200 (unsigned long) section
->sh_size
,
5201 printable_section_name (section
),
5202 (unsigned long) section
->sh_entsize
);
5206 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5207 section
->sh_size
, _("symbols"));
5212 elf_section_list
* entry
;
5215 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5216 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5218 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5219 entry
->hdr
->sh_offset
,
5220 1, entry
->hdr
->sh_size
,
5221 _("symbol table section indicies"));
5224 /* PR17531: file: heap-buffer-overflow */
5225 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5227 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5228 printable_section_name (entry
->hdr
),
5229 (unsigned long) entry
->hdr
->sh_size
,
5230 (unsigned long) section
->sh_size
);
5236 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5240 error (_("Out of memory reading %lu symbols\n"),
5241 (unsigned long) number
);
5245 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5247 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5248 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5249 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5250 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5251 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5253 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5254 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5255 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5256 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5257 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5266 if (num_syms_return
!= NULL
)
5267 * num_syms_return
= isyms
== NULL
? 0 : number
;
5272 static Elf_Internal_Sym
*
5273 get_64bit_elf_symbols (FILE * file
,
5274 Elf_Internal_Shdr
* section
,
5275 unsigned long * num_syms_return
)
5277 unsigned long number
= 0;
5278 Elf64_External_Sym
* esyms
= NULL
;
5279 Elf_External_Sym_Shndx
* shndx
= NULL
;
5280 Elf_Internal_Sym
* isyms
= NULL
;
5281 Elf_Internal_Sym
* psym
;
5284 if (section
->sh_size
== 0)
5286 if (num_syms_return
!= NULL
)
5287 * num_syms_return
= 0;
5291 /* Run some sanity checks first. */
5292 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5294 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5295 printable_section_name (section
),
5296 (unsigned long) section
->sh_entsize
);
5300 if (section
->sh_size
> current_file_size
)
5302 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5303 printable_section_name (section
),
5304 (unsigned long) section
->sh_size
);
5308 number
= section
->sh_size
/ section
->sh_entsize
;
5310 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5312 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5313 (unsigned long) section
->sh_size
,
5314 printable_section_name (section
),
5315 (unsigned long) section
->sh_entsize
);
5319 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5320 section
->sh_size
, _("symbols"));
5325 elf_section_list
* entry
;
5328 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5329 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5331 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5332 entry
->hdr
->sh_offset
,
5333 1, entry
->hdr
->sh_size
,
5334 _("symbol table section indicies"));
5337 /* PR17531: file: heap-buffer-overflow */
5338 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5340 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5341 printable_section_name (entry
->hdr
),
5342 (unsigned long) entry
->hdr
->sh_size
,
5343 (unsigned long) section
->sh_size
);
5349 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5353 error (_("Out of memory reading %lu symbols\n"),
5354 (unsigned long) number
);
5358 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5360 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5361 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5362 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5363 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5365 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5367 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5368 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5369 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5371 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5372 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5381 if (num_syms_return
!= NULL
)
5382 * num_syms_return
= isyms
== NULL
? 0 : number
;
5388 get_elf_section_flags (bfd_vma sh_flags
)
5390 static char buff
[1024];
5392 int field_size
= is_32bit_elf
? 8 : 16;
5394 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5395 bfd_vma os_flags
= 0;
5396 bfd_vma proc_flags
= 0;
5397 bfd_vma unknown_flags
= 0;
5405 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5406 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5407 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5408 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5409 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5410 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5411 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5412 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5413 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5414 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5415 /* IA-64 specific. */
5416 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5417 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5418 /* IA-64 OpenVMS specific. */
5419 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5420 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5421 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5422 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5423 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5424 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5426 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5427 /* SPARC specific. */
5428 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5429 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5431 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5432 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5433 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5436 if (do_section_details
)
5438 sprintf (buff
, "[%*.*lx]: ",
5439 field_size
, field_size
, (unsigned long) sh_flags
);
5440 p
+= field_size
+ 4;
5447 flag
= sh_flags
& - sh_flags
;
5450 if (do_section_details
)
5454 case SHF_WRITE
: sindex
= 0; break;
5455 case SHF_ALLOC
: sindex
= 1; break;
5456 case SHF_EXECINSTR
: sindex
= 2; break;
5457 case SHF_MERGE
: sindex
= 3; break;
5458 case SHF_STRINGS
: sindex
= 4; break;
5459 case SHF_INFO_LINK
: sindex
= 5; break;
5460 case SHF_LINK_ORDER
: sindex
= 6; break;
5461 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5462 case SHF_GROUP
: sindex
= 8; break;
5463 case SHF_TLS
: sindex
= 9; break;
5464 case SHF_EXCLUDE
: sindex
= 18; break;
5465 case SHF_COMPRESSED
: sindex
= 20; break;
5469 switch (elf_header
.e_machine
)
5472 if (flag
== SHF_IA_64_SHORT
)
5474 else if (flag
== SHF_IA_64_NORECOV
)
5477 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5480 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5481 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5482 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5483 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5484 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5485 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5496 case EM_OLD_SPARCV9
:
5497 case EM_SPARC32PLUS
:
5500 if (flag
== SHF_ORDERED
)
5507 case SHF_ENTRYSECT
: sindex
= 21; break;
5508 case SHF_ARM_PURECODE
: sindex
= 22; break;
5509 case SHF_COMDEF
: sindex
= 23; break;
5521 if (p
!= buff
+ field_size
+ 4)
5523 if (size
< (10 + 2))
5525 warn (_("Internal error: not enough buffer room for section flag info"));
5526 return _("<unknown>");
5533 size
-= flags
[sindex
].len
;
5534 p
= stpcpy (p
, flags
[sindex
].str
);
5536 else if (flag
& SHF_MASKOS
)
5538 else if (flag
& SHF_MASKPROC
)
5541 unknown_flags
|= flag
;
5547 case SHF_WRITE
: *p
= 'W'; break;
5548 case SHF_ALLOC
: *p
= 'A'; break;
5549 case SHF_EXECINSTR
: *p
= 'X'; break;
5550 case SHF_MERGE
: *p
= 'M'; break;
5551 case SHF_STRINGS
: *p
= 'S'; break;
5552 case SHF_INFO_LINK
: *p
= 'I'; break;
5553 case SHF_LINK_ORDER
: *p
= 'L'; break;
5554 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5555 case SHF_GROUP
: *p
= 'G'; break;
5556 case SHF_TLS
: *p
= 'T'; break;
5557 case SHF_EXCLUDE
: *p
= 'E'; break;
5558 case SHF_COMPRESSED
: *p
= 'C'; break;
5561 if ((elf_header
.e_machine
== EM_X86_64
5562 || elf_header
.e_machine
== EM_L1OM
5563 || elf_header
.e_machine
== EM_K1OM
)
5564 && flag
== SHF_X86_64_LARGE
)
5566 else if (elf_header
.e_machine
== EM_ARM
5567 && flag
== SHF_ARM_PURECODE
)
5569 else if (flag
& SHF_MASKOS
)
5572 sh_flags
&= ~ SHF_MASKOS
;
5574 else if (flag
& SHF_MASKPROC
)
5577 sh_flags
&= ~ SHF_MASKPROC
;
5587 if (do_section_details
)
5591 size
-= 5 + field_size
;
5592 if (p
!= buff
+ field_size
+ 4)
5596 warn (_("Internal error: not enough buffer room for section flag info"));
5597 return _("<unknown>");
5603 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5604 (unsigned long) os_flags
);
5605 p
+= 5 + field_size
;
5609 size
-= 7 + field_size
;
5610 if (p
!= buff
+ field_size
+ 4)
5614 warn (_("Internal error: not enough buffer room for section flag info"));
5615 return _("<unknown>");
5621 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5622 (unsigned long) proc_flags
);
5623 p
+= 7 + field_size
;
5627 size
-= 10 + field_size
;
5628 if (p
!= buff
+ field_size
+ 4)
5632 warn (_("Internal error: not enough buffer room for section flag info"));
5633 return _("<unknown>");
5639 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5640 (unsigned long) unknown_flags
);
5641 p
+= 10 + field_size
;
5650 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5654 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5656 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5657 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5658 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5659 return sizeof (*echdr
);
5663 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5665 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5666 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5667 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5668 return sizeof (*echdr
);
5673 process_section_headers (FILE * file
)
5675 Elf_Internal_Shdr
* section
;
5678 section_headers
= NULL
;
5680 if (elf_header
.e_shnum
== 0)
5682 /* PR binutils/12467. */
5683 if (elf_header
.e_shoff
!= 0)
5684 warn (_("possibly corrupt ELF file header - it has a non-zero"
5685 " section header offset, but no section headers\n"));
5686 else if (do_sections
)
5687 printf (_("\nThere are no sections in this file.\n"));
5692 if (do_sections
&& !do_header
)
5693 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5694 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5698 if (! get_32bit_section_headers (file
, FALSE
))
5701 else if (! get_64bit_section_headers (file
, FALSE
))
5704 /* Read in the string table, so that we have names to display. */
5705 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5706 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5708 section
= section_headers
+ elf_header
.e_shstrndx
;
5710 if (section
->sh_size
!= 0)
5712 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5713 1, section
->sh_size
,
5716 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5720 /* Scan the sections for the dynamic symbol table
5721 and dynamic string table and debug sections. */
5722 dynamic_symbols
= NULL
;
5723 dynamic_strings
= NULL
;
5724 dynamic_syminfo
= NULL
;
5725 symtab_shndx_list
= NULL
;
5727 eh_addr_size
= is_32bit_elf
? 4 : 8;
5728 switch (elf_header
.e_machine
)
5731 case EM_MIPS_RS3_LE
:
5732 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5733 FDE addresses. However, the ABI also has a semi-official ILP32
5734 variant for which the normal FDE address size rules apply.
5736 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5737 section, where XX is the size of longs in bits. Unfortunately,
5738 earlier compilers provided no way of distinguishing ILP32 objects
5739 from LP64 objects, so if there's any doubt, we should assume that
5740 the official LP64 form is being used. */
5741 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5742 && find_section (".gcc_compiled_long32") == NULL
)
5748 switch (elf_header
.e_flags
& EF_H8_MACH
)
5750 case E_H8_MACH_H8300
:
5751 case E_H8_MACH_H8300HN
:
5752 case E_H8_MACH_H8300SN
:
5753 case E_H8_MACH_H8300SXN
:
5756 case E_H8_MACH_H8300H
:
5757 case E_H8_MACH_H8300S
:
5758 case E_H8_MACH_H8300SX
:
5766 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5768 case EF_M32C_CPU_M16C
:
5775 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5778 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5779 if (section->sh_entsize != expected_entsize) \
5782 sprintf_vma (buf, section->sh_entsize); \
5783 /* Note: coded this way so that there is a single string for \
5785 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5786 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5787 (unsigned) expected_entsize); \
5788 section->sh_entsize = expected_entsize; \
5793 #define CHECK_ENTSIZE(section, i, type) \
5794 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5795 sizeof (Elf64_External_##type))
5797 for (i
= 0, section
= section_headers
;
5798 i
< elf_header
.e_shnum
;
5801 char * name
= SECTION_NAME (section
);
5803 if (section
->sh_type
== SHT_DYNSYM
)
5805 if (dynamic_symbols
!= NULL
)
5807 error (_("File contains multiple dynamic symbol tables\n"));
5811 CHECK_ENTSIZE (section
, i
, Sym
);
5812 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5814 else if (section
->sh_type
== SHT_STRTAB
5815 && streq (name
, ".dynstr"))
5817 if (dynamic_strings
!= NULL
)
5819 error (_("File contains multiple dynamic string tables\n"));
5823 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5824 1, section
->sh_size
,
5825 _("dynamic strings"));
5826 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5828 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5830 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5831 entry
->hdr
= section
;
5832 entry
->next
= symtab_shndx_list
;
5833 symtab_shndx_list
= entry
;
5835 else if (section
->sh_type
== SHT_SYMTAB
)
5836 CHECK_ENTSIZE (section
, i
, Sym
);
5837 else if (section
->sh_type
== SHT_GROUP
)
5838 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5839 else if (section
->sh_type
== SHT_REL
)
5840 CHECK_ENTSIZE (section
, i
, Rel
);
5841 else if (section
->sh_type
== SHT_RELA
)
5842 CHECK_ENTSIZE (section
, i
, Rela
);
5843 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5844 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5845 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5846 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5847 || do_debug_addr
|| do_debug_cu_index
)
5848 && (const_strneq (name
, ".debug_")
5849 || const_strneq (name
, ".zdebug_")))
5852 name
+= sizeof (".zdebug_") - 1;
5854 name
+= sizeof (".debug_") - 1;
5857 || (do_debug_info
&& const_strneq (name
, "info"))
5858 || (do_debug_info
&& const_strneq (name
, "types"))
5859 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5860 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5861 || (do_debug_lines
&& const_strneq (name
, "line."))
5862 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5863 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5864 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5865 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5866 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5867 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5868 || (do_debug_frames
&& const_strneq (name
, "frame"))
5869 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5870 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5871 || (do_debug_str
&& const_strneq (name
, "str"))
5872 || (do_debug_loc
&& const_strneq (name
, "loc"))
5873 || (do_debug_addr
&& const_strneq (name
, "addr"))
5874 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5875 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5877 request_dump_bynumber (i
, DEBUG_DUMP
);
5879 /* Linkonce section to be combined with .debug_info at link time. */
5880 else if ((do_debugging
|| do_debug_info
)
5881 && const_strneq (name
, ".gnu.linkonce.wi."))
5882 request_dump_bynumber (i
, DEBUG_DUMP
);
5883 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5884 request_dump_bynumber (i
, DEBUG_DUMP
);
5885 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5886 request_dump_bynumber (i
, DEBUG_DUMP
);
5887 /* Trace sections for Itanium VMS. */
5888 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5889 || do_trace_aranges
)
5890 && const_strneq (name
, ".trace_"))
5892 name
+= sizeof (".trace_") - 1;
5895 || (do_trace_info
&& streq (name
, "info"))
5896 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5897 || (do_trace_aranges
&& streq (name
, "aranges"))
5899 request_dump_bynumber (i
, DEBUG_DUMP
);
5906 if (elf_header
.e_shnum
> 1)
5907 printf (_("\nSection Headers:\n"));
5909 printf (_("\nSection Header:\n"));
5913 if (do_section_details
)
5915 printf (_(" [Nr] Name\n"));
5916 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5920 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5924 if (do_section_details
)
5926 printf (_(" [Nr] Name\n"));
5927 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5931 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5935 if (do_section_details
)
5937 printf (_(" [Nr] Name\n"));
5938 printf (_(" Type Address Offset Link\n"));
5939 printf (_(" Size EntSize Info Align\n"));
5943 printf (_(" [Nr] Name Type Address Offset\n"));
5944 printf (_(" Size EntSize Flags Link Info Align\n"));
5948 if (do_section_details
)
5949 printf (_(" Flags\n"));
5951 for (i
= 0, section
= section_headers
;
5952 i
< elf_header
.e_shnum
;
5955 /* Run some sanity checks on the section header. */
5957 /* Check the sh_link field. */
5958 switch (section
->sh_type
)
5960 case SHT_SYMTAB_SHNDX
:
5964 case SHT_GNU_versym
:
5967 if (section
->sh_link
< 1
5968 || section
->sh_link
> elf_header
.e_shnum
5969 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
5970 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
5971 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
5972 i
, section
->sh_link
);
5978 case SHT_GNU_verneed
:
5979 case SHT_GNU_verdef
:
5980 case SHT_GNU_LIBLIST
:
5981 if (section
->sh_link
< 1
5982 || section
->sh_link
> elf_header
.e_shnum
5983 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
5984 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
5985 i
, section
->sh_link
);
5988 case SHT_INIT_ARRAY
:
5989 case SHT_FINI_ARRAY
:
5990 case SHT_PREINIT_ARRAY
:
5991 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
5992 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5993 i
, section
->sh_link
);
5997 /* FIXME: Add support for target specific section types. */
5998 #if 0 /* Currently we do not check other section types as there are too
5999 many special cases. Stab sections for example have a type
6000 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6002 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6003 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6004 i
, section
->sh_link
);
6009 /* Check the sh_info field. */
6010 switch (section
->sh_type
)
6014 if (section
->sh_info
< 1
6015 || section
->sh_info
> elf_header
.e_shnum
6016 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6017 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6018 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6019 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6020 /* FIXME: Are other section types valid ? */
6021 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6023 if (section
->sh_info
== 0
6024 && (streq (SECTION_NAME (section
), ".rel.dyn")
6025 || streq (SECTION_NAME (section
), ".rela.dyn")))
6026 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6027 of zero. No idea why. I would have expected the index
6028 of the .plt section. */
6031 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6032 i
, section
->sh_info
);
6038 case SHT_SYMTAB_SHNDX
:
6039 case SHT_INIT_ARRAY
:
6040 case SHT_FINI_ARRAY
:
6041 case SHT_PREINIT_ARRAY
:
6042 if (section
->sh_info
!= 0)
6043 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6044 i
, section
->sh_info
);
6050 /* A symbol index - we assume that it is valid. */
6054 /* FIXME: Add support for target specific section types. */
6055 if (section
->sh_type
== SHT_NOBITS
)
6056 /* NOBITS section headers with non-zero sh_info fields can be
6057 created when a binary is stripped of everything but its debug
6058 information. The stripped sections have their headers preserved but their types set to SHT_NOBITS. so do not check this type of section. */
6060 else if (section
->sh_flags
& SHF_INFO_LINK
)
6062 if (section
->sh_info
< 1 || section
->sh_info
> elf_header
.e_shnum
)
6063 warn (_("[%2u]: Expected link to another section in info field"), i
);
6065 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6066 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6067 i
, section
->sh_info
);
6071 printf (" [%2u] ", i
);
6072 if (do_section_details
)
6073 printf ("%s\n ", printable_section_name (section
));
6075 print_symbol (-17, SECTION_NAME (section
));
6077 printf (do_wide
? " %-15s " : " %-15.15s ",
6078 get_section_type_name (section
->sh_type
));
6082 const char * link_too_big
= NULL
;
6084 print_vma (section
->sh_addr
, LONG_HEX
);
6086 printf ( " %6.6lx %6.6lx %2.2lx",
6087 (unsigned long) section
->sh_offset
,
6088 (unsigned long) section
->sh_size
,
6089 (unsigned long) section
->sh_entsize
);
6091 if (do_section_details
)
6092 fputs (" ", stdout
);
6094 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6096 if (section
->sh_link
>= elf_header
.e_shnum
)
6099 /* The sh_link value is out of range. Normally this indicates
6100 an error but it can have special values in Solaris binaries. */
6101 switch (elf_header
.e_machine
)
6108 case EM_OLD_SPARCV9
:
6109 case EM_SPARC32PLUS
:
6112 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6113 link_too_big
= "BEFORE";
6114 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6115 link_too_big
= "AFTER";
6122 if (do_section_details
)
6124 if (link_too_big
!= NULL
&& * link_too_big
)
6125 printf ("<%s> ", link_too_big
);
6127 printf ("%2u ", section
->sh_link
);
6128 printf ("%3u %2lu\n", section
->sh_info
,
6129 (unsigned long) section
->sh_addralign
);
6132 printf ("%2u %3u %2lu\n",
6135 (unsigned long) section
->sh_addralign
);
6137 if (link_too_big
&& ! * link_too_big
)
6138 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6139 i
, section
->sh_link
);
6143 print_vma (section
->sh_addr
, LONG_HEX
);
6145 if ((long) section
->sh_offset
== section
->sh_offset
)
6146 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6150 print_vma (section
->sh_offset
, LONG_HEX
);
6153 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6154 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6158 print_vma (section
->sh_size
, LONG_HEX
);
6161 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6162 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6166 print_vma (section
->sh_entsize
, LONG_HEX
);
6169 if (do_section_details
)
6170 fputs (" ", stdout
);
6172 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6174 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6176 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6177 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6180 print_vma (section
->sh_addralign
, DEC
);
6184 else if (do_section_details
)
6186 printf (" %-15.15s ",
6187 get_section_type_name (section
->sh_type
));
6188 print_vma (section
->sh_addr
, LONG_HEX
);
6189 if ((long) section
->sh_offset
== section
->sh_offset
)
6190 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6194 print_vma (section
->sh_offset
, LONG_HEX
);
6196 printf (" %u\n ", section
->sh_link
);
6197 print_vma (section
->sh_size
, LONG_HEX
);
6199 print_vma (section
->sh_entsize
, LONG_HEX
);
6201 printf (" %-16u %lu\n",
6203 (unsigned long) section
->sh_addralign
);
6208 print_vma (section
->sh_addr
, LONG_HEX
);
6209 if ((long) section
->sh_offset
== section
->sh_offset
)
6210 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6214 print_vma (section
->sh_offset
, LONG_HEX
);
6217 print_vma (section
->sh_size
, LONG_HEX
);
6219 print_vma (section
->sh_entsize
, LONG_HEX
);
6221 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6223 printf (" %2u %3u %lu\n",
6226 (unsigned long) section
->sh_addralign
);
6229 if (do_section_details
)
6231 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6232 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6234 /* Minimum section size is 12 bytes for 32-bit compression
6235 header + 12 bytes for compressed data header. */
6236 unsigned char buf
[24];
6238 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6239 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6240 sizeof (buf
), _("compression header")))
6242 Elf_Internal_Chdr chdr
;
6244 (void) get_compression_header (&chdr
, buf
);
6246 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6249 printf (_(" [<unknown>: 0x%x], "),
6251 print_vma (chdr
.ch_size
, LONG_HEX
);
6252 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6258 if (!do_section_details
)
6260 /* The ordering of the letters shown here matches the ordering of the
6261 corresponding SHF_xxx values, and hence the order in which these
6262 letters will be displayed to the user. */
6263 printf (_("Key to Flags:\n\
6264 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6265 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6266 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6267 if (elf_header
.e_machine
== EM_X86_64
6268 || elf_header
.e_machine
== EM_L1OM
6269 || elf_header
.e_machine
== EM_K1OM
)
6270 printf (_("l (large), "));
6271 else if (elf_header
.e_machine
== EM_ARM
)
6272 printf (_("y (purecode), "));
6273 printf ("p (processor specific)\n");
6280 get_group_flags (unsigned int flags
)
6282 static char buff
[32];
6286 else if (flags
== GRP_COMDAT
)
6289 snprintf (buff
, 14, _("[0x%x: "), flags
);
6291 flags
&= ~ GRP_COMDAT
;
6292 if (flags
& GRP_MASKOS
)
6294 strcat (buff
, "<OS specific>");
6295 flags
&= ~ GRP_MASKOS
;
6298 if (flags
& GRP_MASKPROC
)
6300 strcat (buff
, "<PROC specific>");
6301 flags
&= ~ GRP_MASKPROC
;
6305 strcat (buff
, "<unknown>");
6312 process_section_groups (FILE * file
)
6314 Elf_Internal_Shdr
* section
;
6316 struct group
* group
;
6317 Elf_Internal_Shdr
* symtab_sec
;
6318 Elf_Internal_Shdr
* strtab_sec
;
6319 Elf_Internal_Sym
* symtab
;
6320 unsigned long num_syms
;
6324 /* Don't process section groups unless needed. */
6325 if (!do_unwind
&& !do_section_groups
)
6328 if (elf_header
.e_shnum
== 0)
6330 if (do_section_groups
)
6331 printf (_("\nThere are no sections to group in this file.\n"));
6336 if (section_headers
== NULL
)
6338 error (_("Section headers are not available!\n"));
6339 /* PR 13622: This can happen with a corrupt ELF header. */
6343 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6344 sizeof (struct group
*));
6346 if (section_headers_groups
== NULL
)
6348 error (_("Out of memory reading %u section group headers\n"),
6349 elf_header
.e_shnum
);
6353 /* Scan the sections for the group section. */
6355 for (i
= 0, section
= section_headers
;
6356 i
< elf_header
.e_shnum
;
6358 if (section
->sh_type
== SHT_GROUP
)
6361 if (group_count
== 0)
6363 if (do_section_groups
)
6364 printf (_("\nThere are no section groups in this file.\n"));
6369 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6371 if (section_groups
== NULL
)
6373 error (_("Out of memory reading %lu groups\n"),
6374 (unsigned long) group_count
);
6384 for (i
= 0, section
= section_headers
, group
= section_groups
;
6385 i
< elf_header
.e_shnum
;
6388 if (section
->sh_type
== SHT_GROUP
)
6390 const char * name
= printable_section_name (section
);
6391 const char * group_name
;
6392 unsigned char * start
;
6393 unsigned char * indices
;
6394 unsigned int entry
, j
, size
;
6395 Elf_Internal_Shdr
* sec
;
6396 Elf_Internal_Sym
* sym
;
6398 /* Get the symbol table. */
6399 if (section
->sh_link
>= elf_header
.e_shnum
6400 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6403 error (_("Bad sh_link in group section `%s'\n"), name
);
6407 if (symtab_sec
!= sec
)
6412 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6417 error (_("Corrupt header in group section `%s'\n"), name
);
6421 if (section
->sh_info
>= num_syms
)
6423 error (_("Bad sh_info in group section `%s'\n"), name
);
6427 sym
= symtab
+ section
->sh_info
;
6429 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6431 if (sym
->st_shndx
== 0
6432 || sym
->st_shndx
>= elf_header
.e_shnum
)
6434 error (_("Bad sh_info in group section `%s'\n"), name
);
6438 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6447 /* Get the string table. */
6448 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6457 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6463 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6464 1, strtab_sec
->sh_size
,
6466 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6468 group_name
= sym
->st_name
< strtab_size
6469 ? strtab
+ sym
->st_name
: _("<corrupt>");
6472 /* PR 17531: file: loop. */
6473 if (section
->sh_entsize
> section
->sh_size
)
6475 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6476 printable_section_name (section
),
6477 (unsigned long) section
->sh_entsize
,
6478 (unsigned long) section
->sh_size
);
6482 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6483 1, section
->sh_size
,
6489 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6490 entry
= byte_get (indices
, 4);
6493 if (do_section_groups
)
6495 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6496 get_group_flags (entry
), i
, name
, group_name
, size
);
6498 printf (_(" [Index] Name\n"));
6501 group
->group_index
= i
;
6503 for (j
= 0; j
< size
; j
++)
6505 struct group_list
* g
;
6507 entry
= byte_get (indices
, 4);
6510 if (entry
>= elf_header
.e_shnum
)
6512 static unsigned num_group_errors
= 0;
6514 if (num_group_errors
++ < 10)
6516 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6517 entry
, i
, elf_header
.e_shnum
- 1);
6518 if (num_group_errors
== 10)
6519 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6524 if (section_headers_groups
[entry
] != NULL
)
6528 static unsigned num_errs
= 0;
6530 if (num_errs
++ < 10)
6532 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6534 section_headers_groups
[entry
]->group_index
);
6536 warn (_("Further error messages about already contained group sections suppressed\n"));
6542 /* Intel C/C++ compiler may put section 0 in a
6543 section group. We just warn it the first time
6544 and ignore it afterwards. */
6545 static int warned
= 0;
6548 error (_("section 0 in group section [%5u]\n"),
6549 section_headers_groups
[entry
]->group_index
);
6555 section_headers_groups
[entry
] = group
;
6557 if (do_section_groups
)
6559 sec
= section_headers
+ entry
;
6560 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6563 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6564 g
->section_index
= entry
;
6565 g
->next
= group
->root
;
6583 /* Data used to display dynamic fixups. */
6585 struct ia64_vms_dynfixup
6587 bfd_vma needed_ident
; /* Library ident number. */
6588 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6589 bfd_vma fixup_needed
; /* Index of the library. */
6590 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6591 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6594 /* Data used to display dynamic relocations. */
6596 struct ia64_vms_dynimgrela
6598 bfd_vma img_rela_cnt
; /* Number of relocations. */
6599 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6602 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6606 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6607 const char *strtab
, unsigned int strtab_sz
)
6609 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6611 const char *lib_name
;
6613 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6614 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6615 _("dynamic section image fixups"));
6619 if (fixup
->needed
< strtab_sz
)
6620 lib_name
= strtab
+ fixup
->needed
;
6623 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6624 (unsigned long) fixup
->needed
);
6627 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6628 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6630 (_("Seg Offset Type SymVec DataType\n"));
6632 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6637 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6638 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6639 type
= BYTE_GET (imfs
[i
].type
);
6640 rtype
= elf_ia64_reloc_type (type
);
6642 printf (" 0x%08x ", type
);
6644 printf (" %-32s ", rtype
);
6645 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6646 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6652 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6655 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6657 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6660 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6661 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6662 _("dynamic section image relocations"));
6666 printf (_("\nImage relocs\n"));
6668 (_("Seg Offset Type Addend Seg Sym Off\n"));
6670 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6675 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6676 printf ("%08" BFD_VMA_FMT
"x ",
6677 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6678 type
= BYTE_GET (imrs
[i
].type
);
6679 rtype
= elf_ia64_reloc_type (type
);
6681 printf ("0x%08x ", type
);
6683 printf ("%-31s ", rtype
);
6684 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6685 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6686 printf ("%08" BFD_VMA_FMT
"x\n",
6687 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6693 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6696 process_ia64_vms_dynamic_relocs (FILE *file
)
6698 struct ia64_vms_dynfixup fixup
;
6699 struct ia64_vms_dynimgrela imgrela
;
6700 Elf_Internal_Dyn
*entry
;
6702 bfd_vma strtab_off
= 0;
6703 bfd_vma strtab_sz
= 0;
6704 char *strtab
= NULL
;
6706 memset (&fixup
, 0, sizeof (fixup
));
6707 memset (&imgrela
, 0, sizeof (imgrela
));
6709 /* Note: the order of the entries is specified by the OpenVMS specs. */
6710 for (entry
= dynamic_section
;
6711 entry
< dynamic_section
+ dynamic_nent
;
6714 switch (entry
->d_tag
)
6716 case DT_IA_64_VMS_STRTAB_OFFSET
:
6717 strtab_off
= entry
->d_un
.d_val
;
6720 strtab_sz
= entry
->d_un
.d_val
;
6722 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6723 1, strtab_sz
, _("dynamic string section"));
6726 case DT_IA_64_VMS_NEEDED_IDENT
:
6727 fixup
.needed_ident
= entry
->d_un
.d_val
;
6730 fixup
.needed
= entry
->d_un
.d_val
;
6732 case DT_IA_64_VMS_FIXUP_NEEDED
:
6733 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6735 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6736 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6738 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6739 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6741 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6744 case DT_IA_64_VMS_IMG_RELA_CNT
:
6745 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6747 case DT_IA_64_VMS_IMG_RELA_OFF
:
6748 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6750 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6770 } dynamic_relocations
[] =
6772 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6773 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6774 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6777 /* Process the reloc section. */
6780 process_relocs (FILE * file
)
6782 unsigned long rel_size
;
6783 unsigned long rel_offset
;
6789 if (do_using_dynamic
)
6793 int has_dynamic_reloc
;
6796 has_dynamic_reloc
= 0;
6798 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6800 is_rela
= dynamic_relocations
[i
].rela
;
6801 name
= dynamic_relocations
[i
].name
;
6802 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6803 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6805 has_dynamic_reloc
|= rel_size
;
6807 if (is_rela
== UNKNOWN
)
6809 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6810 switch (dynamic_info
[DT_PLTREL
])
6824 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6825 name
, rel_offset
, rel_size
);
6827 dump_relocations (file
,
6828 offset_from_vma (file
, rel_offset
, rel_size
),
6830 dynamic_symbols
, num_dynamic_syms
,
6831 dynamic_strings
, dynamic_strings_length
,
6837 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6839 if (! has_dynamic_reloc
)
6840 printf (_("\nThere are no dynamic relocations in this file.\n"));
6844 Elf_Internal_Shdr
* section
;
6848 for (i
= 0, section
= section_headers
;
6849 i
< elf_header
.e_shnum
;
6852 if ( section
->sh_type
!= SHT_RELA
6853 && section
->sh_type
!= SHT_REL
)
6856 rel_offset
= section
->sh_offset
;
6857 rel_size
= section
->sh_size
;
6861 Elf_Internal_Shdr
* strsec
;
6864 printf (_("\nRelocation section "));
6866 if (string_table
== NULL
)
6867 printf ("%d", section
->sh_name
);
6869 printf ("'%s'", printable_section_name (section
));
6871 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6872 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6874 is_rela
= section
->sh_type
== SHT_RELA
;
6876 if (section
->sh_link
!= 0
6877 && section
->sh_link
< elf_header
.e_shnum
)
6879 Elf_Internal_Shdr
* symsec
;
6880 Elf_Internal_Sym
* symtab
;
6881 unsigned long nsyms
;
6882 unsigned long strtablen
= 0;
6883 char * strtab
= NULL
;
6885 symsec
= section_headers
+ section
->sh_link
;
6886 if (symsec
->sh_type
!= SHT_SYMTAB
6887 && symsec
->sh_type
!= SHT_DYNSYM
)
6890 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6895 if (symsec
->sh_link
!= 0
6896 && symsec
->sh_link
< elf_header
.e_shnum
)
6898 strsec
= section_headers
+ symsec
->sh_link
;
6900 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6903 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6906 dump_relocations (file
, rel_offset
, rel_size
,
6907 symtab
, nsyms
, strtab
, strtablen
,
6909 symsec
->sh_type
== SHT_DYNSYM
);
6915 dump_relocations (file
, rel_offset
, rel_size
,
6916 NULL
, 0, NULL
, 0, is_rela
, 0);
6923 printf (_("\nThere are no relocations in this file.\n"));
6929 /* An absolute address consists of a section and an offset. If the
6930 section is NULL, the offset itself is the address, otherwise, the
6931 address equals to LOAD_ADDRESS(section) + offset. */
6935 unsigned short section
;
6939 #define ABSADDR(a) \
6941 ? section_headers [(a).section].sh_addr + (a).offset \
6944 /* Find the nearest symbol at or below ADDR. Returns the symbol
6945 name, if found, and the offset from the symbol to ADDR. */
6948 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6949 unsigned long nsyms
,
6950 const char * strtab
,
6951 unsigned long strtab_size
,
6952 struct absaddr addr
,
6953 const char ** symname
,
6956 bfd_vma dist
= 0x100000;
6957 Elf_Internal_Sym
* sym
;
6958 Elf_Internal_Sym
* beg
;
6959 Elf_Internal_Sym
* end
;
6960 Elf_Internal_Sym
* best
= NULL
;
6962 REMOVE_ARCH_BITS (addr
.offset
);
6964 end
= symtab
+ nsyms
;
6970 sym
= beg
+ (end
- beg
) / 2;
6972 value
= sym
->st_value
;
6973 REMOVE_ARCH_BITS (value
);
6975 if (sym
->st_name
!= 0
6976 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6977 && addr
.offset
>= value
6978 && addr
.offset
- value
< dist
)
6981 dist
= addr
.offset
- value
;
6986 if (addr
.offset
< value
)
6994 *symname
= (best
->st_name
>= strtab_size
6995 ? _("<corrupt>") : strtab
+ best
->st_name
);
7001 *offset
= addr
.offset
;
7005 symcmp (const void *p
, const void *q
)
7007 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7008 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7010 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7013 /* Process the unwind section. */
7015 #include "unwind-ia64.h"
7017 struct ia64_unw_table_entry
7019 struct absaddr start
;
7021 struct absaddr info
;
7024 struct ia64_unw_aux_info
7026 struct ia64_unw_table_entry
*table
; /* Unwind table. */
7027 unsigned long table_len
; /* Length of unwind table. */
7028 unsigned char * info
; /* Unwind info. */
7029 unsigned long info_size
; /* Size of unwind info. */
7030 bfd_vma info_addr
; /* Starting address of unwind info. */
7031 bfd_vma seg_base
; /* Starting address of segment. */
7032 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7033 unsigned long nsyms
; /* Number of symbols. */
7034 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7035 unsigned long nfuns
; /* Number of entries in funtab. */
7036 char * strtab
; /* The string table. */
7037 unsigned long strtab_size
; /* Size of string table. */
7041 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7043 struct ia64_unw_table_entry
* tp
;
7044 unsigned long j
, nfuns
;
7047 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7048 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7049 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7050 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7052 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7054 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7058 const unsigned char * dp
;
7059 const unsigned char * head
;
7060 const unsigned char * end
;
7061 const char * procname
;
7063 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7064 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7066 fputs ("\n<", stdout
);
7070 fputs (procname
, stdout
);
7073 printf ("+%lx", (unsigned long) offset
);
7076 fputs (">: [", stdout
);
7077 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7078 fputc ('-', stdout
);
7079 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7080 printf ("], info at +0x%lx\n",
7081 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7083 /* PR 17531: file: 86232b32. */
7084 if (aux
->info
== NULL
)
7087 /* PR 17531: file: 0997b4d1. */
7088 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7090 warn (_("Invalid offset %lx in table entry %ld\n"),
7091 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7095 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7096 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7098 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7099 (unsigned) UNW_VER (stamp
),
7100 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7101 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7102 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7103 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7105 if (UNW_VER (stamp
) != 1)
7107 printf (_("\tUnknown version.\n"));
7112 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7113 /* PR 17531: file: 16ceda89. */
7114 if (end
> aux
->info
+ aux
->info_size
)
7115 end
= aux
->info
+ aux
->info_size
;
7116 for (dp
= head
+ 8; dp
< end
;)
7117 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7124 slurp_ia64_unwind_table (FILE * file
,
7125 struct ia64_unw_aux_info
* aux
,
7126 Elf_Internal_Shdr
* sec
)
7128 unsigned long size
, nrelas
, i
;
7129 Elf_Internal_Phdr
* seg
;
7130 struct ia64_unw_table_entry
* tep
;
7131 Elf_Internal_Shdr
* relsec
;
7132 Elf_Internal_Rela
* rela
;
7133 Elf_Internal_Rela
* rp
;
7134 unsigned char * table
;
7136 Elf_Internal_Sym
* sym
;
7137 const char * relname
;
7141 /* First, find the starting address of the segment that includes
7144 if (elf_header
.e_phnum
)
7146 if (! get_program_headers (file
))
7149 for (seg
= program_headers
;
7150 seg
< program_headers
+ elf_header
.e_phnum
;
7153 if (seg
->p_type
!= PT_LOAD
)
7156 if (sec
->sh_addr
>= seg
->p_vaddr
7157 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7159 aux
->seg_base
= seg
->p_vaddr
;
7165 /* Second, build the unwind table from the contents of the unwind section: */
7166 size
= sec
->sh_size
;
7167 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7172 aux
->table_len
= size
/ (3 * eh_addr_size
);
7173 aux
->table
= (struct ia64_unw_table_entry
*)
7174 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7177 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7179 tep
->start
.section
= SHN_UNDEF
;
7180 tep
->end
.section
= SHN_UNDEF
;
7181 tep
->info
.section
= SHN_UNDEF
;
7182 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7183 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7184 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7185 tep
->start
.offset
+= aux
->seg_base
;
7186 tep
->end
.offset
+= aux
->seg_base
;
7187 tep
->info
.offset
+= aux
->seg_base
;
7191 /* Third, apply any relocations to the unwind table: */
7192 for (relsec
= section_headers
;
7193 relsec
< section_headers
+ elf_header
.e_shnum
;
7196 if (relsec
->sh_type
!= SHT_RELA
7197 || relsec
->sh_info
>= elf_header
.e_shnum
7198 || section_headers
+ relsec
->sh_info
!= sec
)
7201 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7210 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7212 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7213 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7215 /* PR 17531: file: 9fa67536. */
7216 if (relname
== NULL
)
7218 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7222 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7224 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7228 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7230 /* PR 17531: file: 5bc8d9bf. */
7231 if (i
>= aux
->table_len
)
7233 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7237 switch (rp
->r_offset
/ eh_addr_size
% 3)
7240 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7241 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7244 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7245 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7248 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7249 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7263 ia64_process_unwind (FILE * file
)
7265 Elf_Internal_Shdr
* sec
;
7266 Elf_Internal_Shdr
* unwsec
= NULL
;
7267 Elf_Internal_Shdr
* strsec
;
7268 unsigned long i
, unwcount
= 0, unwstart
= 0;
7269 struct ia64_unw_aux_info aux
;
7271 memset (& aux
, 0, sizeof (aux
));
7273 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7275 if (sec
->sh_type
== SHT_SYMTAB
7276 && sec
->sh_link
< elf_header
.e_shnum
)
7278 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7280 strsec
= section_headers
+ sec
->sh_link
;
7281 if (aux
.strtab
!= NULL
)
7283 error (_("Multiple auxillary string tables encountered\n"));
7286 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7289 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7291 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7296 printf (_("\nThere are no unwind sections in this file.\n"));
7298 while (unwcount
-- > 0)
7303 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7304 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7305 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7310 /* We have already counted the number of SHT_IA64_UNWIND
7311 sections so the loop above should never fail. */
7312 assert (unwsec
!= NULL
);
7315 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7317 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7319 /* We need to find which section group it is in. */
7320 struct group_list
* g
;
7322 if (section_headers_groups
== NULL
7323 || section_headers_groups
[i
] == NULL
)
7324 i
= elf_header
.e_shnum
;
7327 g
= section_headers_groups
[i
]->root
;
7329 for (; g
!= NULL
; g
= g
->next
)
7331 sec
= section_headers
+ g
->section_index
;
7333 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7338 i
= elf_header
.e_shnum
;
7341 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7343 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7344 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7345 suffix
= SECTION_NAME (unwsec
) + len
;
7346 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7348 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7349 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7354 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7355 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7356 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7357 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7359 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7360 suffix
= SECTION_NAME (unwsec
) + len
;
7361 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7363 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7364 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7368 if (i
== elf_header
.e_shnum
)
7370 printf (_("\nCould not find unwind info section for "));
7372 if (string_table
== NULL
)
7373 printf ("%d", unwsec
->sh_name
);
7375 printf ("'%s'", printable_section_name (unwsec
));
7379 aux
.info_addr
= sec
->sh_addr
;
7380 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7383 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7385 printf (_("\nUnwind section "));
7387 if (string_table
== NULL
)
7388 printf ("%d", unwsec
->sh_name
);
7390 printf ("'%s'", printable_section_name (unwsec
));
7392 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7393 (unsigned long) unwsec
->sh_offset
,
7394 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7396 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7397 && aux
.table_len
> 0)
7398 dump_ia64_unwind (& aux
);
7401 free ((char *) aux
.table
);
7403 free ((char *) aux
.info
);
7412 free ((char *) aux
.strtab
);
7415 struct hppa_unw_table_entry
7417 struct absaddr start
;
7419 unsigned int Cannot_unwind
:1; /* 0 */
7420 unsigned int Millicode
:1; /* 1 */
7421 unsigned int Millicode_save_sr0
:1; /* 2 */
7422 unsigned int Region_description
:2; /* 3..4 */
7423 unsigned int reserved1
:1; /* 5 */
7424 unsigned int Entry_SR
:1; /* 6 */
7425 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7426 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7427 unsigned int Args_stored
:1; /* 16 */
7428 unsigned int Variable_Frame
:1; /* 17 */
7429 unsigned int Separate_Package_Body
:1; /* 18 */
7430 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7431 unsigned int Stack_Overflow_Check
:1; /* 20 */
7432 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7433 unsigned int Ada_Region
:1; /* 22 */
7434 unsigned int cxx_info
:1; /* 23 */
7435 unsigned int cxx_try_catch
:1; /* 24 */
7436 unsigned int sched_entry_seq
:1; /* 25 */
7437 unsigned int reserved2
:1; /* 26 */
7438 unsigned int Save_SP
:1; /* 27 */
7439 unsigned int Save_RP
:1; /* 28 */
7440 unsigned int Save_MRP_in_frame
:1; /* 29 */
7441 unsigned int extn_ptr_defined
:1; /* 30 */
7442 unsigned int Cleanup_defined
:1; /* 31 */
7444 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7445 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7446 unsigned int Large_frame
:1; /* 2 */
7447 unsigned int Pseudo_SP_Set
:1; /* 3 */
7448 unsigned int reserved4
:1; /* 4 */
7449 unsigned int Total_frame_size
:27; /* 5..31 */
7452 struct hppa_unw_aux_info
7454 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7455 unsigned long table_len
; /* Length of unwind table. */
7456 bfd_vma seg_base
; /* Starting address of segment. */
7457 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7458 unsigned long nsyms
; /* Number of symbols. */
7459 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7460 unsigned long nfuns
; /* Number of entries in funtab. */
7461 char * strtab
; /* The string table. */
7462 unsigned long strtab_size
; /* Size of string table. */
7466 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7468 struct hppa_unw_table_entry
* tp
;
7469 unsigned long j
, nfuns
;
7471 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7472 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7473 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7474 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7476 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7478 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7481 const char * procname
;
7483 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7484 aux
->strtab_size
, tp
->start
, &procname
,
7487 fputs ("\n<", stdout
);
7491 fputs (procname
, stdout
);
7494 printf ("+%lx", (unsigned long) offset
);
7497 fputs (">: [", stdout
);
7498 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7499 fputc ('-', stdout
);
7500 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7503 #define PF(_m) if (tp->_m) printf (#_m " ");
7504 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7507 PF(Millicode_save_sr0
);
7508 /* PV(Region_description); */
7514 PF(Separate_Package_Body
);
7515 PF(Frame_Extension_Millicode
);
7516 PF(Stack_Overflow_Check
);
7517 PF(Two_Instruction_SP_Increment
);
7521 PF(sched_entry_seq
);
7524 PF(Save_MRP_in_frame
);
7525 PF(extn_ptr_defined
);
7526 PF(Cleanup_defined
);
7527 PF(MPE_XL_interrupt_marker
);
7528 PF(HP_UX_interrupt_marker
);
7531 PV(Total_frame_size
);
7542 slurp_hppa_unwind_table (FILE * file
,
7543 struct hppa_unw_aux_info
* aux
,
7544 Elf_Internal_Shdr
* sec
)
7546 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7547 Elf_Internal_Phdr
* seg
;
7548 struct hppa_unw_table_entry
* tep
;
7549 Elf_Internal_Shdr
* relsec
;
7550 Elf_Internal_Rela
* rela
;
7551 Elf_Internal_Rela
* rp
;
7552 unsigned char * table
;
7554 Elf_Internal_Sym
* sym
;
7555 const char * relname
;
7557 /* First, find the starting address of the segment that includes
7560 if (elf_header
.e_phnum
)
7562 if (! get_program_headers (file
))
7565 for (seg
= program_headers
;
7566 seg
< program_headers
+ elf_header
.e_phnum
;
7569 if (seg
->p_type
!= PT_LOAD
)
7572 if (sec
->sh_addr
>= seg
->p_vaddr
7573 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7575 aux
->seg_base
= seg
->p_vaddr
;
7581 /* Second, build the unwind table from the contents of the unwind
7583 size
= sec
->sh_size
;
7584 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7590 nentries
= size
/ unw_ent_size
;
7591 size
= unw_ent_size
* nentries
;
7593 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7594 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7596 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7598 unsigned int tmp1
, tmp2
;
7600 tep
->start
.section
= SHN_UNDEF
;
7601 tep
->end
.section
= SHN_UNDEF
;
7603 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7604 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7605 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7606 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7608 tep
->start
.offset
+= aux
->seg_base
;
7609 tep
->end
.offset
+= aux
->seg_base
;
7611 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7612 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7613 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7614 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7615 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7616 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7617 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7618 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7619 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7620 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7621 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7622 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7623 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7624 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7625 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7626 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7627 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7628 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7629 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7630 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7631 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7632 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7633 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7634 tep
->Cleanup_defined
= tmp1
& 0x1;
7636 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7637 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7638 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7639 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7640 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7641 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7645 /* Third, apply any relocations to the unwind table. */
7646 for (relsec
= section_headers
;
7647 relsec
< section_headers
+ elf_header
.e_shnum
;
7650 if (relsec
->sh_type
!= SHT_RELA
7651 || relsec
->sh_info
>= elf_header
.e_shnum
7652 || section_headers
+ relsec
->sh_info
!= sec
)
7655 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7659 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7661 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7662 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7664 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7665 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7667 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7671 i
= rp
->r_offset
/ unw_ent_size
;
7673 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7676 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7677 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7680 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7681 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7691 aux
->table_len
= nentries
;
7697 hppa_process_unwind (FILE * file
)
7699 struct hppa_unw_aux_info aux
;
7700 Elf_Internal_Shdr
* unwsec
= NULL
;
7701 Elf_Internal_Shdr
* strsec
;
7702 Elf_Internal_Shdr
* sec
;
7705 if (string_table
== NULL
)
7708 memset (& aux
, 0, sizeof (aux
));
7710 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7712 if (sec
->sh_type
== SHT_SYMTAB
7713 && sec
->sh_link
< elf_header
.e_shnum
)
7715 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7717 strsec
= section_headers
+ sec
->sh_link
;
7718 if (aux
.strtab
!= NULL
)
7720 error (_("Multiple auxillary string tables encountered\n"));
7723 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7726 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7728 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7733 printf (_("\nThere are no unwind sections in this file.\n"));
7735 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7737 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7739 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7740 printable_section_name (sec
),
7741 (unsigned long) sec
->sh_offset
,
7742 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7744 slurp_hppa_unwind_table (file
, &aux
, sec
);
7745 if (aux
.table_len
> 0)
7746 dump_hppa_unwind (&aux
);
7749 free ((char *) aux
.table
);
7757 free ((char *) aux
.strtab
);
7762 unsigned char * data
; /* The unwind data. */
7763 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7764 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7765 unsigned long nrelas
; /* The number of relocations. */
7766 unsigned int rel_type
; /* REL or RELA ? */
7767 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7770 struct arm_unw_aux_info
7772 FILE * file
; /* The file containing the unwind sections. */
7773 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7774 unsigned long nsyms
; /* Number of symbols. */
7775 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7776 unsigned long nfuns
; /* Number of these symbols. */
7777 char * strtab
; /* The file's string table. */
7778 unsigned long strtab_size
; /* Size of string table. */
7782 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7783 bfd_vma fn
, struct absaddr addr
)
7785 const char *procname
;
7788 if (addr
.section
== SHN_UNDEF
)
7791 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7792 aux
->strtab_size
, addr
, &procname
,
7795 print_vma (fn
, PREFIX_HEX
);
7799 fputs (" <", stdout
);
7800 fputs (procname
, stdout
);
7803 printf ("+0x%lx", (unsigned long) sym_offset
);
7804 fputc ('>', stdout
);
7811 arm_free_section (struct arm_section
*arm_sec
)
7813 if (arm_sec
->data
!= NULL
)
7814 free (arm_sec
->data
);
7816 if (arm_sec
->rela
!= NULL
)
7817 free (arm_sec
->rela
);
7820 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7821 cached section and install SEC instead.
7822 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7823 and return its valued in * WORDP, relocating if necessary.
7824 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7825 relocation's offset in ADDR.
7826 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7827 into the string table of the symbol associated with the reloc. If no
7828 reloc was applied store -1 there.
7829 5) Return TRUE upon success, FALSE otherwise. */
7832 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7833 struct arm_section
* arm_sec
,
7834 Elf_Internal_Shdr
* sec
,
7835 bfd_vma word_offset
,
7836 unsigned int * wordp
,
7837 struct absaddr
* addr
,
7840 Elf_Internal_Rela
*rp
;
7841 Elf_Internal_Sym
*sym
;
7842 const char * relname
;
7844 bfd_boolean wrapped
;
7846 if (sec
== NULL
|| arm_sec
== NULL
)
7849 addr
->section
= SHN_UNDEF
;
7852 if (sym_name
!= NULL
)
7853 *sym_name
= (bfd_vma
) -1;
7855 /* If necessary, update the section cache. */
7856 if (sec
!= arm_sec
->sec
)
7858 Elf_Internal_Shdr
*relsec
;
7860 arm_free_section (arm_sec
);
7863 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7864 sec
->sh_size
, _("unwind data"));
7865 arm_sec
->rela
= NULL
;
7866 arm_sec
->nrelas
= 0;
7868 for (relsec
= section_headers
;
7869 relsec
< section_headers
+ elf_header
.e_shnum
;
7872 if (relsec
->sh_info
>= elf_header
.e_shnum
7873 || section_headers
+ relsec
->sh_info
!= sec
7874 /* PR 15745: Check the section type as well. */
7875 || (relsec
->sh_type
!= SHT_REL
7876 && relsec
->sh_type
!= SHT_RELA
))
7879 arm_sec
->rel_type
= relsec
->sh_type
;
7880 if (relsec
->sh_type
== SHT_REL
)
7882 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7884 & arm_sec
->rela
, & arm_sec
->nrelas
))
7887 else /* relsec->sh_type == SHT_RELA */
7889 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7891 & arm_sec
->rela
, & arm_sec
->nrelas
))
7897 arm_sec
->next_rela
= arm_sec
->rela
;
7900 /* If there is no unwind data we can do nothing. */
7901 if (arm_sec
->data
== NULL
)
7904 /* If the offset is invalid then fail. */
7905 if (word_offset
> (sec
->sh_size
- 4)
7907 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7908 || ((bfd_signed_vma
) word_offset
) < 0)
7911 /* Get the word at the required offset. */
7912 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7914 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7915 if (arm_sec
->rela
== NULL
)
7921 /* Look through the relocs to find the one that applies to the provided offset. */
7923 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7925 bfd_vma prelval
, offset
;
7927 if (rp
->r_offset
> word_offset
&& !wrapped
)
7932 if (rp
->r_offset
> word_offset
)
7935 if (rp
->r_offset
& 3)
7937 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7938 (unsigned long) rp
->r_offset
);
7942 if (rp
->r_offset
< word_offset
)
7945 /* PR 17531: file: 027-161405-0.004 */
7946 if (aux
->symtab
== NULL
)
7949 if (arm_sec
->rel_type
== SHT_REL
)
7951 offset
= word
& 0x7fffffff;
7952 if (offset
& 0x40000000)
7953 offset
|= ~ (bfd_vma
) 0x7fffffff;
7955 else if (arm_sec
->rel_type
== SHT_RELA
)
7956 offset
= rp
->r_addend
;
7959 error (_("Unknown section relocation type %d encountered\n"),
7964 /* PR 17531 file: 027-1241568-0.004. */
7965 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7967 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7968 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7972 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7973 offset
+= sym
->st_value
;
7974 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7976 /* Check that we are processing the expected reloc type. */
7977 if (elf_header
.e_machine
== EM_ARM
)
7979 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7980 if (relname
== NULL
)
7982 warn (_("Skipping unknown ARM relocation type: %d\n"),
7983 (int) ELF32_R_TYPE (rp
->r_info
));
7987 if (streq (relname
, "R_ARM_NONE"))
7990 if (! streq (relname
, "R_ARM_PREL31"))
7992 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7996 else if (elf_header
.e_machine
== EM_TI_C6000
)
7998 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7999 if (relname
== NULL
)
8001 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8002 (int) ELF32_R_TYPE (rp
->r_info
));
8006 if (streq (relname
, "R_C6000_NONE"))
8009 if (! streq (relname
, "R_C6000_PREL31"))
8011 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8019 /* This function currently only supports ARM and TI unwinders. */
8020 warn (_("Only TI and ARM unwinders are currently supported\n"));
8024 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8025 addr
->section
= sym
->st_shndx
;
8026 addr
->offset
= offset
;
8029 * sym_name
= sym
->st_name
;
8034 arm_sec
->next_rela
= rp
;
8039 static const char *tic6x_unwind_regnames
[16] =
8041 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8042 "A14", "A13", "A12", "A11", "A10",
8043 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8047 decode_tic6x_unwind_regmask (unsigned int mask
)
8051 for (i
= 12; mask
; mask
>>= 1, i
--)
8055 fputs (tic6x_unwind_regnames
[i
], stdout
);
8057 fputs (", ", stdout
);
8063 if (remaining == 0 && more_words) \
8066 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8067 data_offset, & word, & addr, NULL)) \
8073 #define GET_OP(OP) \
8078 (OP) = word >> 24; \
8083 printf (_("[Truncated opcode]\n")); \
8086 printf ("0x%02x ", OP)
8089 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8091 unsigned int remaining
,
8092 unsigned int more_words
,
8093 bfd_vma data_offset
,
8094 Elf_Internal_Shdr
* data_sec
,
8095 struct arm_section
* data_arm_sec
)
8097 struct absaddr addr
;
8099 /* Decode the unwinding instructions. */
8102 unsigned int op
, op2
;
8111 printf (" 0x%02x ", op
);
8113 if ((op
& 0xc0) == 0x00)
8115 int offset
= ((op
& 0x3f) << 2) + 4;
8117 printf (" vsp = vsp + %d", offset
);
8119 else if ((op
& 0xc0) == 0x40)
8121 int offset
= ((op
& 0x3f) << 2) + 4;
8123 printf (" vsp = vsp - %d", offset
);
8125 else if ((op
& 0xf0) == 0x80)
8128 if (op
== 0x80 && op2
== 0)
8129 printf (_("Refuse to unwind"));
8132 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8137 for (i
= 0; i
< 12; i
++)
8138 if (mask
& (1 << i
))
8144 printf ("r%d", 4 + i
);
8149 else if ((op
& 0xf0) == 0x90)
8151 if (op
== 0x9d || op
== 0x9f)
8152 printf (_(" [Reserved]"));
8154 printf (" vsp = r%d", op
& 0x0f);
8156 else if ((op
& 0xf0) == 0xa0)
8158 int end
= 4 + (op
& 0x07);
8163 for (i
= 4; i
<= end
; i
++)
8179 else if (op
== 0xb0)
8180 printf (_(" finish"));
8181 else if (op
== 0xb1)
8184 if (op2
== 0 || (op2
& 0xf0) != 0)
8185 printf (_("[Spare]"));
8188 unsigned int mask
= op2
& 0x0f;
8193 for (i
= 0; i
< 12; i
++)
8194 if (mask
& (1 << i
))
8205 else if (op
== 0xb2)
8207 unsigned char buf
[9];
8208 unsigned int i
, len
;
8209 unsigned long offset
;
8211 for (i
= 0; i
< sizeof (buf
); i
++)
8214 if ((buf
[i
] & 0x80) == 0)
8217 if (i
== sizeof (buf
))
8218 printf (_("corrupt change to vsp"));
8221 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8222 assert (len
== i
+ 1);
8223 offset
= offset
* 4 + 0x204;
8224 printf ("vsp = vsp + %ld", offset
);
8227 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8229 unsigned int first
, last
;
8236 printf ("pop {D%d", first
);
8238 printf ("-D%d", first
+ last
);
8241 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8243 unsigned int count
= op
& 0x07;
8247 printf ("-D%d", 8 + count
);
8250 else if (op
>= 0xc0 && op
<= 0xc5)
8252 unsigned int count
= op
& 0x07;
8254 printf (" pop {wR10");
8256 printf ("-wR%d", 10 + count
);
8259 else if (op
== 0xc6)
8261 unsigned int first
, last
;
8266 printf ("pop {wR%d", first
);
8268 printf ("-wR%d", first
+ last
);
8271 else if (op
== 0xc7)
8274 if (op2
== 0 || (op2
& 0xf0) != 0)
8275 printf (_("[Spare]"));
8278 unsigned int mask
= op2
& 0x0f;
8283 for (i
= 0; i
< 4; i
++)
8284 if (mask
& (1 << i
))
8290 printf ("wCGR%d", i
);
8296 printf (_(" [unsupported opcode]"));
8302 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8304 unsigned int remaining
,
8305 unsigned int more_words
,
8306 bfd_vma data_offset
,
8307 Elf_Internal_Shdr
* data_sec
,
8308 struct arm_section
* data_arm_sec
)
8310 struct absaddr addr
;
8312 /* Decode the unwinding instructions. */
8315 unsigned int op
, op2
;
8324 printf (" 0x%02x ", op
);
8326 if ((op
& 0xc0) == 0x00)
8328 int offset
= ((op
& 0x3f) << 3) + 8;
8329 printf (" sp = sp + %d", offset
);
8331 else if ((op
& 0xc0) == 0x80)
8334 if (op
== 0x80 && op2
== 0)
8335 printf (_("Refuse to unwind"));
8338 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8340 printf ("pop compact {");
8344 decode_tic6x_unwind_regmask (mask
);
8348 else if ((op
& 0xf0) == 0xc0)
8356 unsigned int offset
;
8360 /* Scan entire instruction first so that GET_OP output is not
8361 interleaved with disassembly. */
8363 for (i
= 0; nregs
< (op
& 0xf); i
++)
8369 regpos
[nregs
].offset
= i
* 2;
8370 regpos
[nregs
].reg
= reg
;
8377 regpos
[nregs
].offset
= i
* 2 + 1;
8378 regpos
[nregs
].reg
= reg
;
8383 printf (_("pop frame {"));
8385 for (i
= i
* 2; i
> 0; i
--)
8387 if (regpos
[reg
].offset
== i
- 1)
8389 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8396 fputs (name
, stdout
);
8403 else if (op
== 0xd0)
8404 printf (" MOV FP, SP");
8405 else if (op
== 0xd1)
8406 printf (" __c6xabi_pop_rts");
8407 else if (op
== 0xd2)
8409 unsigned char buf
[9];
8410 unsigned int i
, len
;
8411 unsigned long offset
;
8413 for (i
= 0; i
< sizeof (buf
); i
++)
8416 if ((buf
[i
] & 0x80) == 0)
8419 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8420 if (i
== sizeof (buf
))
8422 printf ("<corrupt sp adjust>\n");
8423 warn (_("Corrupt stack pointer adjustment detected\n"));
8427 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8428 assert (len
== i
+ 1);
8429 offset
= offset
* 8 + 0x408;
8430 printf (_("sp = sp + %ld"), offset
);
8432 else if ((op
& 0xf0) == 0xe0)
8434 if ((op
& 0x0f) == 7)
8437 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8441 printf (_(" [unsupported opcode]"));
8448 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8452 offset
= word
& 0x7fffffff;
8453 if (offset
& 0x40000000)
8454 offset
|= ~ (bfd_vma
) 0x7fffffff;
8456 if (elf_header
.e_machine
== EM_TI_C6000
)
8459 return offset
+ where
;
8463 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8465 unsigned int remaining
,
8466 bfd_vma data_offset
,
8467 Elf_Internal_Shdr
* data_sec
,
8468 struct arm_section
* data_arm_sec
)
8471 unsigned int more_words
= 0;
8472 struct absaddr addr
;
8473 bfd_vma sym_name
= (bfd_vma
) -1;
8477 /* Fetch the first word.
8478 Note - when decoding an object file the address extracted
8479 here will always be 0. So we also pass in the sym_name
8480 parameter so that we can find the symbol associated with
8481 the personality routine. */
8482 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8483 & word
, & addr
, & sym_name
))
8489 if ((word
& 0x80000000) == 0)
8491 /* Expand prel31 for personality routine. */
8493 const char *procname
;
8495 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8496 printf (_(" Personality routine: "));
8498 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8499 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8501 procname
= aux
->strtab
+ sym_name
;
8502 print_vma (fn
, PREFIX_HEX
);
8505 fputs (" <", stdout
);
8506 fputs (procname
, stdout
);
8507 fputc ('>', stdout
);
8511 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8512 fputc ('\n', stdout
);
8514 /* The GCC personality routines use the standard compact
8515 encoding, starting with one byte giving the number of
8517 if (procname
!= NULL
8518 && (const_strneq (procname
, "__gcc_personality_v0")
8519 || const_strneq (procname
, "__gxx_personality_v0")
8520 || const_strneq (procname
, "__gcj_personality_v0")
8521 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8528 printf (_(" [Truncated data]\n"));
8531 more_words
= word
>> 24;
8541 /* ARM EHABI Section 6.3:
8543 An exception-handling table entry for the compact model looks like:
8547 1 0 index Data for personalityRoutine[index] */
8549 if (elf_header
.e_machine
== EM_ARM
8550 && (word
& 0x70000000))
8551 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8553 per_index
= (word
>> 24) & 0x7f;
8554 printf (_(" Compact model index: %d\n"), per_index
);
8561 else if (per_index
< 3)
8563 more_words
= (word
>> 16) & 0xff;
8569 switch (elf_header
.e_machine
)
8574 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8575 data_offset
, data_sec
, data_arm_sec
);
8579 warn (_("Unknown ARM compact model index encountered\n"));
8580 printf (_(" [reserved]\n"));
8587 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8588 data_offset
, data_sec
, data_arm_sec
);
8590 else if (per_index
< 5)
8592 if (((word
>> 17) & 0x7f) == 0x7f)
8593 printf (_(" Restore stack from frame pointer\n"));
8595 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8596 printf (_(" Registers restored: "));
8598 printf (" (compact) ");
8599 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8601 printf (_(" Return register: %s\n"),
8602 tic6x_unwind_regnames
[word
& 0xf]);
8605 printf (_(" [reserved (%d)]\n"), per_index
);
8609 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8610 elf_header
.e_machine
);
8613 /* Decode the descriptors. Not implemented. */
8617 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8619 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8620 unsigned int i
, exidx_len
;
8621 unsigned long j
, nfuns
;
8623 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8624 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8625 exidx_len
= exidx_sec
->sh_size
/ 8;
8627 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8628 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8629 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8630 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8632 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8634 for (i
= 0; i
< exidx_len
; i
++)
8636 unsigned int exidx_fn
, exidx_entry
;
8637 struct absaddr fn_addr
, entry_addr
;
8640 fputc ('\n', stdout
);
8642 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8643 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8644 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8645 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8648 arm_free_section (& exidx_arm_sec
);
8649 arm_free_section (& extab_arm_sec
);
8653 /* ARM EHABI, Section 5:
8654 An index table entry consists of 2 words.
8655 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8656 if (exidx_fn
& 0x80000000)
8657 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8659 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8661 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8662 fputs (": ", stdout
);
8664 if (exidx_entry
== 1)
8666 print_vma (exidx_entry
, PREFIX_HEX
);
8667 fputs (" [cantunwind]\n", stdout
);
8669 else if (exidx_entry
& 0x80000000)
8671 print_vma (exidx_entry
, PREFIX_HEX
);
8672 fputc ('\n', stdout
);
8673 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8677 bfd_vma table
, table_offset
= 0;
8678 Elf_Internal_Shdr
*table_sec
;
8680 fputs ("@", stdout
);
8681 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8682 print_vma (table
, PREFIX_HEX
);
8685 /* Locate the matching .ARM.extab. */
8686 if (entry_addr
.section
!= SHN_UNDEF
8687 && entry_addr
.section
< elf_header
.e_shnum
)
8689 table_sec
= section_headers
+ entry_addr
.section
;
8690 table_offset
= entry_addr
.offset
;
8692 if (table_offset
> table_sec
->sh_size
8693 || ((bfd_signed_vma
) table_offset
) < 0)
8695 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8696 (unsigned long) table_offset
,
8697 printable_section_name (table_sec
));
8703 table_sec
= find_section_by_address (table
);
8704 if (table_sec
!= NULL
)
8705 table_offset
= table
- table_sec
->sh_addr
;
8707 if (table_sec
== NULL
)
8709 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8710 (unsigned long) table
);
8713 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8721 arm_free_section (&exidx_arm_sec
);
8722 arm_free_section (&extab_arm_sec
);
8725 /* Used for both ARM and C6X unwinding tables. */
8728 arm_process_unwind (FILE *file
)
8730 struct arm_unw_aux_info aux
;
8731 Elf_Internal_Shdr
*unwsec
= NULL
;
8732 Elf_Internal_Shdr
*strsec
;
8733 Elf_Internal_Shdr
*sec
;
8735 unsigned int sec_type
;
8737 switch (elf_header
.e_machine
)
8740 sec_type
= SHT_ARM_EXIDX
;
8744 sec_type
= SHT_C6000_UNWIND
;
8748 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8749 elf_header
.e_machine
);
8753 if (string_table
== NULL
)
8756 memset (& aux
, 0, sizeof (aux
));
8759 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8761 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8763 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8765 strsec
= section_headers
+ sec
->sh_link
;
8767 /* PR binutils/17531 file: 011-12666-0.004. */
8768 if (aux
.strtab
!= NULL
)
8770 error (_("Multiple string tables found in file.\n"));
8773 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8774 1, strsec
->sh_size
, _("string table"));
8775 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8777 else if (sec
->sh_type
== sec_type
)
8782 printf (_("\nThere are no unwind sections in this file.\n"));
8784 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8786 if (sec
->sh_type
== sec_type
)
8788 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8789 printable_section_name (sec
),
8790 (unsigned long) sec
->sh_offset
,
8791 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8793 dump_arm_unwind (&aux
, sec
);
8800 free ((char *) aux
.strtab
);
8804 process_unwind (FILE * file
)
8806 struct unwind_handler
8809 void (* handler
)(FILE *);
8812 { EM_ARM
, arm_process_unwind
},
8813 { EM_IA_64
, ia64_process_unwind
},
8814 { EM_PARISC
, hppa_process_unwind
},
8815 { EM_TI_C6000
, arm_process_unwind
},
8823 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8824 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8826 handlers
[i
].handler (file
);
8830 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8831 get_machine_name (elf_header
.e_machine
));
8835 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8837 switch (entry
->d_tag
)
8840 if (entry
->d_un
.d_val
== 0)
8844 static const char * opts
[] =
8846 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8847 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8848 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8849 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8855 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8856 if (entry
->d_un
.d_val
& (1 << cnt
))
8858 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8864 case DT_MIPS_IVERSION
:
8865 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8866 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8870 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8871 /* Note: coded this way so that there is a single string for translation. */
8872 printf (_("<corrupt: %s>"), buf
);
8876 case DT_MIPS_TIME_STAMP
:
8880 time_t atime
= entry
->d_un
.d_val
;
8882 tmp
= gmtime (&atime
);
8883 /* PR 17531: file: 6accc532. */
8885 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8887 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8888 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8889 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8890 printf (_("Time Stamp: %s"), timebuf
);
8894 case DT_MIPS_RLD_VERSION
:
8895 case DT_MIPS_LOCAL_GOTNO
:
8896 case DT_MIPS_CONFLICTNO
:
8897 case DT_MIPS_LIBLISTNO
:
8898 case DT_MIPS_SYMTABNO
:
8899 case DT_MIPS_UNREFEXTNO
:
8900 case DT_MIPS_HIPAGENO
:
8901 case DT_MIPS_DELTA_CLASS_NO
:
8902 case DT_MIPS_DELTA_INSTANCE_NO
:
8903 case DT_MIPS_DELTA_RELOC_NO
:
8904 case DT_MIPS_DELTA_SYM_NO
:
8905 case DT_MIPS_DELTA_CLASSSYM_NO
:
8906 case DT_MIPS_COMPACT_SIZE
:
8907 print_vma (entry
->d_un
.d_val
, DEC
);
8911 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8917 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8919 switch (entry
->d_tag
)
8921 case DT_HP_DLD_FLAGS
:
8930 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8931 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8932 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8933 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8934 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8935 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8936 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8937 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8938 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8939 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8940 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8941 { DT_HP_GST
, "HP_GST" },
8942 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8943 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8944 { DT_HP_NODELETE
, "HP_NODELETE" },
8945 { DT_HP_GROUP
, "HP_GROUP" },
8946 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8950 bfd_vma val
= entry
->d_un
.d_val
;
8952 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8953 if (val
& flags
[cnt
].bit
)
8957 fputs (flags
[cnt
].str
, stdout
);
8959 val
^= flags
[cnt
].bit
;
8962 if (val
!= 0 || first
)
8966 print_vma (val
, HEX
);
8972 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8980 /* VMS vs Unix time offset and factor. */
8982 #define VMS_EPOCH_OFFSET 35067168000000000LL
8983 #define VMS_GRANULARITY_FACTOR 10000000
8985 /* Display a VMS time in a human readable format. */
8988 print_vms_time (bfd_int64_t vmstime
)
8993 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8994 tm
= gmtime (&unxtime
);
8995 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8996 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8997 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9002 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9004 switch (entry
->d_tag
)
9006 case DT_IA_64_PLT_RESERVE
:
9007 /* First 3 slots reserved. */
9008 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9010 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9013 case DT_IA_64_VMS_LINKTIME
:
9015 print_vms_time (entry
->d_un
.d_val
);
9019 case DT_IA_64_VMS_LNKFLAGS
:
9020 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9021 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9022 printf (" CALL_DEBUG");
9023 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9024 printf (" NOP0BUFS");
9025 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9026 printf (" P0IMAGE");
9027 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9028 printf (" MKTHREADS");
9029 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9030 printf (" UPCALLS");
9031 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9033 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9034 printf (" INITIALIZE");
9035 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9037 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9038 printf (" EXE_INIT");
9039 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9040 printf (" TBK_IN_IMG");
9041 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9042 printf (" DBG_IN_IMG");
9043 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9044 printf (" TBK_IN_DSF");
9045 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9046 printf (" DBG_IN_DSF");
9047 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9048 printf (" SIGNATURES");
9049 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9050 printf (" REL_SEG_OFF");
9054 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9061 get_32bit_dynamic_section (FILE * file
)
9063 Elf32_External_Dyn
* edyn
;
9064 Elf32_External_Dyn
* ext
;
9065 Elf_Internal_Dyn
* entry
;
9067 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9068 dynamic_size
, _("dynamic section"));
9072 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9073 might not have the luxury of section headers. Look for the DT_NULL
9074 terminator to determine the number of entries. */
9075 for (ext
= edyn
, dynamic_nent
= 0;
9076 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9080 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9084 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9086 if (dynamic_section
== NULL
)
9088 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9089 (unsigned long) dynamic_nent
);
9094 for (ext
= edyn
, entry
= dynamic_section
;
9095 entry
< dynamic_section
+ dynamic_nent
;
9098 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9099 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9108 get_64bit_dynamic_section (FILE * file
)
9110 Elf64_External_Dyn
* edyn
;
9111 Elf64_External_Dyn
* ext
;
9112 Elf_Internal_Dyn
* entry
;
9114 /* Read in the data. */
9115 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9116 dynamic_size
, _("dynamic section"));
9120 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9121 might not have the luxury of section headers. Look for the DT_NULL
9122 terminator to determine the number of entries. */
9123 for (ext
= edyn
, dynamic_nent
= 0;
9124 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9125 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9129 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9133 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9135 if (dynamic_section
== NULL
)
9137 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9138 (unsigned long) dynamic_nent
);
9143 /* Convert from external to internal formats. */
9144 for (ext
= edyn
, entry
= dynamic_section
;
9145 entry
< dynamic_section
+ dynamic_nent
;
9148 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9149 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9158 print_dynamic_flags (bfd_vma flags
)
9166 flag
= flags
& - flags
;
9176 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9177 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9178 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9179 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9180 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9181 default: fputs (_("unknown"), stdout
); break;
9187 /* Parse and display the contents of the dynamic section. */
9190 process_dynamic_section (FILE * file
)
9192 Elf_Internal_Dyn
* entry
;
9194 if (dynamic_size
== 0)
9197 printf (_("\nThere is no dynamic section in this file.\n"));
9204 if (! get_32bit_dynamic_section (file
))
9207 else if (! get_64bit_dynamic_section (file
))
9210 /* Find the appropriate symbol table. */
9211 if (dynamic_symbols
== NULL
)
9213 for (entry
= dynamic_section
;
9214 entry
< dynamic_section
+ dynamic_nent
;
9217 Elf_Internal_Shdr section
;
9219 if (entry
->d_tag
!= DT_SYMTAB
)
9222 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9224 /* Since we do not know how big the symbol table is,
9225 we default to reading in the entire file (!) and
9226 processing that. This is overkill, I know, but it
9228 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9230 if (archive_file_offset
!= 0)
9231 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9234 if (fseek (file
, 0, SEEK_END
))
9235 error (_("Unable to seek to end of file!\n"));
9237 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9241 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9243 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9244 section
.sh_name
= string_table_length
;
9246 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9247 if (num_dynamic_syms
< 1)
9249 error (_("Unable to determine the number of symbols to load\n"));
9255 /* Similarly find a string table. */
9256 if (dynamic_strings
== NULL
)
9258 for (entry
= dynamic_section
;
9259 entry
< dynamic_section
+ dynamic_nent
;
9262 unsigned long offset
;
9265 if (entry
->d_tag
!= DT_STRTAB
)
9268 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9270 /* Since we do not know how big the string table is,
9271 we default to reading in the entire file (!) and
9272 processing that. This is overkill, I know, but it
9275 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9277 if (archive_file_offset
!= 0)
9278 str_tab_len
= archive_file_size
- offset
;
9281 if (fseek (file
, 0, SEEK_END
))
9282 error (_("Unable to seek to end of file\n"));
9283 str_tab_len
= ftell (file
) - offset
;
9286 if (str_tab_len
< 1)
9289 (_("Unable to determine the length of the dynamic string table\n"));
9293 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9295 _("dynamic string table"));
9296 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9301 /* And find the syminfo section if available. */
9302 if (dynamic_syminfo
== NULL
)
9304 unsigned long syminsz
= 0;
9306 for (entry
= dynamic_section
;
9307 entry
< dynamic_section
+ dynamic_nent
;
9310 if (entry
->d_tag
== DT_SYMINENT
)
9312 /* Note: these braces are necessary to avoid a syntax
9313 error from the SunOS4 C compiler. */
9314 /* PR binutils/17531: A corrupt file can trigger this test.
9315 So do not use an assert, instead generate an error message. */
9316 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9317 error (_("Bad value (%d) for SYMINENT entry\n"),
9318 (int) entry
->d_un
.d_val
);
9320 else if (entry
->d_tag
== DT_SYMINSZ
)
9321 syminsz
= entry
->d_un
.d_val
;
9322 else if (entry
->d_tag
== DT_SYMINFO
)
9323 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9327 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9329 Elf_External_Syminfo
* extsyminfo
;
9330 Elf_External_Syminfo
* extsym
;
9331 Elf_Internal_Syminfo
* syminfo
;
9333 /* There is a syminfo section. Read the data. */
9334 extsyminfo
= (Elf_External_Syminfo
*)
9335 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9336 _("symbol information"));
9340 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9341 if (dynamic_syminfo
== NULL
)
9343 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9344 (unsigned long) syminsz
);
9348 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9349 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9350 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9351 ++syminfo
, ++extsym
)
9353 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9354 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9361 if (do_dynamic
&& dynamic_addr
)
9362 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9363 dynamic_addr
, (unsigned long) dynamic_nent
);
9365 printf (_(" Tag Type Name/Value\n"));
9367 for (entry
= dynamic_section
;
9368 entry
< dynamic_section
+ dynamic_nent
;
9376 print_vma (entry
->d_tag
, FULL_HEX
);
9377 dtype
= get_dynamic_type (entry
->d_tag
);
9378 printf (" (%s)%*s", dtype
,
9379 ((is_32bit_elf
? 27 : 19)
9380 - (int) strlen (dtype
)),
9384 switch (entry
->d_tag
)
9388 print_dynamic_flags (entry
->d_un
.d_val
);
9398 switch (entry
->d_tag
)
9401 printf (_("Auxiliary library"));
9405 printf (_("Filter library"));
9409 printf (_("Configuration file"));
9413 printf (_("Dependency audit library"));
9417 printf (_("Audit library"));
9421 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9422 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9426 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9435 printf (_("Flags:"));
9437 if (entry
->d_un
.d_val
== 0)
9438 printf (_(" None\n"));
9441 unsigned long int val
= entry
->d_un
.d_val
;
9443 if (val
& DTF_1_PARINIT
)
9445 printf (" PARINIT");
9446 val
^= DTF_1_PARINIT
;
9448 if (val
& DTF_1_CONFEXP
)
9450 printf (" CONFEXP");
9451 val
^= DTF_1_CONFEXP
;
9454 printf (" %lx", val
);
9463 printf (_("Flags:"));
9465 if (entry
->d_un
.d_val
== 0)
9466 printf (_(" None\n"));
9469 unsigned long int val
= entry
->d_un
.d_val
;
9471 if (val
& DF_P1_LAZYLOAD
)
9473 printf (" LAZYLOAD");
9474 val
^= DF_P1_LAZYLOAD
;
9476 if (val
& DF_P1_GROUPPERM
)
9478 printf (" GROUPPERM");
9479 val
^= DF_P1_GROUPPERM
;
9482 printf (" %lx", val
);
9491 printf (_("Flags:"));
9492 if (entry
->d_un
.d_val
== 0)
9493 printf (_(" None\n"));
9496 unsigned long int val
= entry
->d_un
.d_val
;
9503 if (val
& DF_1_GLOBAL
)
9508 if (val
& DF_1_GROUP
)
9513 if (val
& DF_1_NODELETE
)
9515 printf (" NODELETE");
9516 val
^= DF_1_NODELETE
;
9518 if (val
& DF_1_LOADFLTR
)
9520 printf (" LOADFLTR");
9521 val
^= DF_1_LOADFLTR
;
9523 if (val
& DF_1_INITFIRST
)
9525 printf (" INITFIRST");
9526 val
^= DF_1_INITFIRST
;
9528 if (val
& DF_1_NOOPEN
)
9533 if (val
& DF_1_ORIGIN
)
9538 if (val
& DF_1_DIRECT
)
9543 if (val
& DF_1_TRANS
)
9548 if (val
& DF_1_INTERPOSE
)
9550 printf (" INTERPOSE");
9551 val
^= DF_1_INTERPOSE
;
9553 if (val
& DF_1_NODEFLIB
)
9555 printf (" NODEFLIB");
9556 val
^= DF_1_NODEFLIB
;
9558 if (val
& DF_1_NODUMP
)
9563 if (val
& DF_1_CONFALT
)
9565 printf (" CONFALT");
9566 val
^= DF_1_CONFALT
;
9568 if (val
& DF_1_ENDFILTEE
)
9570 printf (" ENDFILTEE");
9571 val
^= DF_1_ENDFILTEE
;
9573 if (val
& DF_1_DISPRELDNE
)
9575 printf (" DISPRELDNE");
9576 val
^= DF_1_DISPRELDNE
;
9578 if (val
& DF_1_DISPRELPND
)
9580 printf (" DISPRELPND");
9581 val
^= DF_1_DISPRELPND
;
9583 if (val
& DF_1_NODIRECT
)
9585 printf (" NODIRECT");
9586 val
^= DF_1_NODIRECT
;
9588 if (val
& DF_1_IGNMULDEF
)
9590 printf (" IGNMULDEF");
9591 val
^= DF_1_IGNMULDEF
;
9593 if (val
& DF_1_NOKSYMS
)
9595 printf (" NOKSYMS");
9596 val
^= DF_1_NOKSYMS
;
9598 if (val
& DF_1_NOHDR
)
9603 if (val
& DF_1_EDITED
)
9608 if (val
& DF_1_NORELOC
)
9610 printf (" NORELOC");
9611 val
^= DF_1_NORELOC
;
9613 if (val
& DF_1_SYMINTPOSE
)
9615 printf (" SYMINTPOSE");
9616 val
^= DF_1_SYMINTPOSE
;
9618 if (val
& DF_1_GLOBAUDIT
)
9620 printf (" GLOBAUDIT");
9621 val
^= DF_1_GLOBAUDIT
;
9623 if (val
& DF_1_SINGLETON
)
9625 printf (" SINGLETON");
9626 val
^= DF_1_SINGLETON
;
9628 if (val
& DF_1_STUB
)
9639 printf (" %lx", val
);
9646 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9648 puts (get_dynamic_type (entry
->d_un
.d_val
));
9668 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9674 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9675 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9681 switch (entry
->d_tag
)
9684 printf (_("Shared library: [%s]"), name
);
9686 if (streq (name
, program_interpreter
))
9687 printf (_(" program interpreter"));
9691 printf (_("Library soname: [%s]"), name
);
9695 printf (_("Library rpath: [%s]"), name
);
9699 printf (_("Library runpath: [%s]"), name
);
9703 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9708 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9721 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9726 case DT_INIT_ARRAYSZ
:
9727 case DT_FINI_ARRAYSZ
:
9728 case DT_GNU_CONFLICTSZ
:
9729 case DT_GNU_LIBLISTSZ
:
9732 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9733 printf (_(" (bytes)\n"));
9743 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9756 if (entry
->d_tag
== DT_USED
9757 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9759 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9763 printf (_("Not needed object: [%s]\n"), name
);
9768 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9774 /* The value of this entry is ignored. */
9779 case DT_GNU_PRELINKED
:
9783 time_t atime
= entry
->d_un
.d_val
;
9785 tmp
= gmtime (&atime
);
9786 /* PR 17533 file: 041-1244816-0.004. */
9788 printf (_("<corrupt time val: %lx"),
9789 (unsigned long) atime
);
9791 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9792 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9793 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9799 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9802 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9808 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9809 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9814 switch (elf_header
.e_machine
)
9817 case EM_MIPS_RS3_LE
:
9818 dynamic_section_mips_val (entry
);
9821 dynamic_section_parisc_val (entry
);
9824 dynamic_section_ia64_val (entry
);
9827 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9839 get_ver_flags (unsigned int flags
)
9841 static char buff
[32];
9848 if (flags
& VER_FLG_BASE
)
9849 strcat (buff
, "BASE ");
9851 if (flags
& VER_FLG_WEAK
)
9853 if (flags
& VER_FLG_BASE
)
9854 strcat (buff
, "| ");
9856 strcat (buff
, "WEAK ");
9859 if (flags
& VER_FLG_INFO
)
9861 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9862 strcat (buff
, "| ");
9864 strcat (buff
, "INFO ");
9867 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9868 strcat (buff
, _("| <unknown>"));
9873 /* Display the contents of the version sections. */
9876 process_version_sections (FILE * file
)
9878 Elf_Internal_Shdr
* section
;
9885 for (i
= 0, section
= section_headers
;
9886 i
< elf_header
.e_shnum
;
9889 switch (section
->sh_type
)
9891 case SHT_GNU_verdef
:
9893 Elf_External_Verdef
* edefs
;
9900 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9901 printable_section_name (section
),
9904 printf (_(" Addr: 0x"));
9905 printf_vma (section
->sh_addr
);
9906 printf (_(" Offset: %#08lx Link: %u (%s)"),
9907 (unsigned long) section
->sh_offset
, section
->sh_link
,
9908 printable_section_name_from_index (section
->sh_link
));
9910 edefs
= (Elf_External_Verdef
*)
9911 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9912 _("version definition section"));
9915 endbuf
= (char *) edefs
+ section
->sh_size
;
9917 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9920 Elf_External_Verdef
* edef
;
9921 Elf_Internal_Verdef ent
;
9922 Elf_External_Verdaux
* eaux
;
9923 Elf_Internal_Verdaux aux
;
9927 /* Check for very large indicies. */
9928 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9931 vstart
= ((char *) edefs
) + idx
;
9932 if (vstart
+ sizeof (*edef
) > endbuf
)
9935 edef
= (Elf_External_Verdef
*) vstart
;
9937 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9938 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9939 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9940 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9941 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9942 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9943 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9945 printf (_(" %#06x: Rev: %d Flags: %s"),
9946 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9948 printf (_(" Index: %d Cnt: %d "),
9949 ent
.vd_ndx
, ent
.vd_cnt
);
9951 /* Check for overflow. */
9952 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9955 vstart
+= ent
.vd_aux
;
9957 eaux
= (Elf_External_Verdaux
*) vstart
;
9959 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9960 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9962 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9963 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9965 printf (_("Name index: %ld\n"), aux
.vda_name
);
9967 isum
= idx
+ ent
.vd_aux
;
9969 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9971 /* Check for overflow. */
9972 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9975 isum
+= aux
.vda_next
;
9976 vstart
+= aux
.vda_next
;
9978 eaux
= (Elf_External_Verdaux
*) vstart
;
9979 if (vstart
+ sizeof (*eaux
) > endbuf
)
9982 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9983 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9985 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9986 printf (_(" %#06x: Parent %d: %s\n"),
9987 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9989 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9990 isum
, j
, aux
.vda_name
);
9994 printf (_(" Version def aux past end of section\n"));
9996 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9997 if (idx
+ ent
.vd_next
<= idx
)
10000 idx
+= ent
.vd_next
;
10003 if (cnt
< section
->sh_info
)
10004 printf (_(" Version definition past end of section\n"));
10010 case SHT_GNU_verneed
:
10012 Elf_External_Verneed
* eneed
;
10019 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10020 printable_section_name (section
), section
->sh_info
);
10022 printf (_(" Addr: 0x"));
10023 printf_vma (section
->sh_addr
);
10024 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10025 (unsigned long) section
->sh_offset
, section
->sh_link
,
10026 printable_section_name_from_index (section
->sh_link
));
10028 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10029 section
->sh_offset
, 1,
10031 _("Version Needs section"));
10034 endbuf
= (char *) eneed
+ section
->sh_size
;
10036 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10038 Elf_External_Verneed
* entry
;
10039 Elf_Internal_Verneed ent
;
10044 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10047 vstart
= ((char *) eneed
) + idx
;
10048 if (vstart
+ sizeof (*entry
) > endbuf
)
10051 entry
= (Elf_External_Verneed
*) vstart
;
10053 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10054 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10055 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10056 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10057 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10059 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10061 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10062 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10064 printf (_(" File: %lx"), ent
.vn_file
);
10066 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10068 /* Check for overflow. */
10069 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10071 vstart
+= ent
.vn_aux
;
10073 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10075 Elf_External_Vernaux
* eaux
;
10076 Elf_Internal_Vernaux aux
;
10078 if (vstart
+ sizeof (*eaux
) > endbuf
)
10080 eaux
= (Elf_External_Vernaux
*) vstart
;
10082 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10083 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10084 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10085 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10086 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10088 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10089 printf (_(" %#06x: Name: %s"),
10090 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10092 printf (_(" %#06x: Name index: %lx"),
10093 isum
, aux
.vna_name
);
10095 printf (_(" Flags: %s Version: %d\n"),
10096 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10098 /* Check for overflow. */
10099 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10100 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10102 warn (_("Invalid vna_next field of %lx\n"),
10107 isum
+= aux
.vna_next
;
10108 vstart
+= aux
.vna_next
;
10111 if (j
< ent
.vn_cnt
)
10112 warn (_("Missing Version Needs auxillary information\n"));
10114 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10116 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10117 cnt
= section
->sh_info
;
10120 idx
+= ent
.vn_next
;
10123 if (cnt
< section
->sh_info
)
10124 warn (_("Missing Version Needs information\n"));
10130 case SHT_GNU_versym
:
10132 Elf_Internal_Shdr
* link_section
;
10135 unsigned char * edata
;
10136 unsigned short * data
;
10138 Elf_Internal_Sym
* symbols
;
10139 Elf_Internal_Shdr
* string_sec
;
10140 unsigned long num_syms
;
10143 if (section
->sh_link
>= elf_header
.e_shnum
)
10146 link_section
= section_headers
+ section
->sh_link
;
10147 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10149 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10154 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10155 if (symbols
== NULL
)
10158 string_sec
= section_headers
+ link_section
->sh_link
;
10160 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10161 string_sec
->sh_size
,
10162 _("version string table"));
10169 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10170 printable_section_name (section
), (unsigned long) total
);
10172 printf (_(" Addr: "));
10173 printf_vma (section
->sh_addr
);
10174 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10175 (unsigned long) section
->sh_offset
, section
->sh_link
,
10176 printable_section_name (link_section
));
10178 off
= offset_from_vma (file
,
10179 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10180 total
* sizeof (short));
10181 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10183 _("version symbol data"));
10191 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10193 for (cnt
= total
; cnt
--;)
10194 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10199 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10203 char *invalid
= _("*invalid*");
10205 printf (" %03x:", cnt
);
10207 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10208 switch (data
[cnt
+ j
])
10211 fputs (_(" 0 (*local*) "), stdout
);
10215 fputs (_(" 1 (*global*) "), stdout
);
10219 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10220 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10222 /* If this index value is greater than the size of the symbols
10223 array, break to avoid an out-of-bounds read. */
10224 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10226 warn (_("invalid index into symbol array\n"));
10231 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10233 Elf_Internal_Verneed ivn
;
10234 unsigned long offset
;
10236 offset
= offset_from_vma
10237 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10238 sizeof (Elf_External_Verneed
));
10242 Elf_Internal_Vernaux ivna
;
10243 Elf_External_Verneed evn
;
10244 Elf_External_Vernaux evna
;
10245 unsigned long a_off
;
10247 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10248 _("version need")) == NULL
)
10251 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10252 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10254 a_off
= offset
+ ivn
.vn_aux
;
10258 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10259 1, _("version need aux (2)")) == NULL
)
10262 ivna
.vna_other
= 0;
10266 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10267 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10270 a_off
+= ivna
.vna_next
;
10272 while (ivna
.vna_other
!= data
[cnt
+ j
]
10273 && ivna
.vna_next
!= 0);
10275 if (ivna
.vna_other
== data
[cnt
+ j
])
10277 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10279 if (ivna
.vna_name
>= string_sec
->sh_size
)
10282 name
= strtab
+ ivna
.vna_name
;
10286 offset
+= ivn
.vn_next
;
10288 while (ivn
.vn_next
);
10291 if (data
[cnt
+ j
] != 0x8001
10292 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10294 Elf_Internal_Verdef ivd
;
10295 Elf_External_Verdef evd
;
10296 unsigned long offset
;
10298 offset
= offset_from_vma
10299 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10304 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10305 _("version def")) == NULL
)
10308 /* PR 17531: file: 046-1082287-0.004. */
10309 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10314 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10315 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10318 offset
+= ivd
.vd_next
;
10320 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10321 && ivd
.vd_next
!= 0);
10323 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10325 Elf_External_Verdaux evda
;
10326 Elf_Internal_Verdaux ivda
;
10328 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10330 if (get_data (&evda
, file
,
10331 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10333 _("version def aux")) == NULL
)
10336 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10338 if (ivda
.vda_name
>= string_sec
->sh_size
)
10340 else if (name
!= NULL
&& name
!= invalid
)
10341 name
= _("*both*");
10343 name
= strtab
+ ivda
.vda_name
;
10347 nn
+= printf ("(%s%-*s",
10349 12 - (int) strlen (name
),
10353 printf ("%*c", 18 - nn
, ' ');
10371 printf (_("\nNo version information found in this file.\n"));
10376 static const char *
10377 get_symbol_binding (unsigned int binding
)
10379 static char buff
[32];
10383 case STB_LOCAL
: return "LOCAL";
10384 case STB_GLOBAL
: return "GLOBAL";
10385 case STB_WEAK
: return "WEAK";
10387 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10388 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10390 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10392 if (binding
== STB_GNU_UNIQUE
10393 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10394 /* GNU is still using the default value 0. */
10395 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10397 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10400 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10405 static const char *
10406 get_symbol_type (unsigned int type
)
10408 static char buff
[32];
10412 case STT_NOTYPE
: return "NOTYPE";
10413 case STT_OBJECT
: return "OBJECT";
10414 case STT_FUNC
: return "FUNC";
10415 case STT_SECTION
: return "SECTION";
10416 case STT_FILE
: return "FILE";
10417 case STT_COMMON
: return "COMMON";
10418 case STT_TLS
: return "TLS";
10419 case STT_RELC
: return "RELC";
10420 case STT_SRELC
: return "SRELC";
10422 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10424 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10425 return "THUMB_FUNC";
10427 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10430 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10431 return "PARISC_MILLI";
10433 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10435 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10437 if (elf_header
.e_machine
== EM_PARISC
)
10439 if (type
== STT_HP_OPAQUE
)
10440 return "HP_OPAQUE";
10441 if (type
== STT_HP_STUB
)
10445 if (type
== STT_GNU_IFUNC
10446 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10447 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10448 /* GNU is still using the default value 0. */
10449 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10452 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10455 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10460 static const char *
10461 get_symbol_visibility (unsigned int visibility
)
10463 switch (visibility
)
10465 case STV_DEFAULT
: return "DEFAULT";
10466 case STV_INTERNAL
: return "INTERNAL";
10467 case STV_HIDDEN
: return "HIDDEN";
10468 case STV_PROTECTED
: return "PROTECTED";
10470 error (_("Unrecognized visibility value: %u"), visibility
);
10471 return _("<unknown>");
10475 static const char *
10476 get_solaris_symbol_visibility (unsigned int visibility
)
10478 switch (visibility
)
10480 case 4: return "EXPORTED";
10481 case 5: return "SINGLETON";
10482 case 6: return "ELIMINATE";
10483 default: return get_symbol_visibility (visibility
);
10487 static const char *
10488 get_mips_symbol_other (unsigned int other
)
10498 case STO_MICROMIPS
:
10499 return "MICROMIPS";
10500 case STO_MICROMIPS
| STO_MIPS_PIC
:
10501 return "MICROMIPS, MIPS PIC";
10509 static const char *
10510 get_ia64_symbol_other (unsigned int other
)
10512 if (is_ia64_vms ())
10514 static char res
[32];
10518 /* Function types is for images and .STB files only. */
10519 switch (elf_header
.e_type
)
10523 switch (VMS_ST_FUNC_TYPE (other
))
10525 case VMS_SFT_CODE_ADDR
:
10526 strcat (res
, " CA");
10528 case VMS_SFT_SYMV_IDX
:
10529 strcat (res
, " VEC");
10532 strcat (res
, " FD");
10534 case VMS_SFT_RESERVE
:
10535 strcat (res
, " RSV");
10538 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10539 VMS_ST_FUNC_TYPE (other
));
10540 strcat (res
, " <unknown>");
10547 switch (VMS_ST_LINKAGE (other
))
10549 case VMS_STL_IGNORE
:
10550 strcat (res
, " IGN");
10552 case VMS_STL_RESERVE
:
10553 strcat (res
, " RSV");
10556 strcat (res
, " STD");
10559 strcat (res
, " LNK");
10562 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10563 VMS_ST_LINKAGE (other
));
10564 strcat (res
, " <unknown>");
10576 static const char *
10577 get_ppc64_symbol_other (unsigned int other
)
10579 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10581 static char buf
[32];
10582 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10583 PPC64_LOCAL_ENTRY_OFFSET (other
));
10589 static const char *
10590 get_symbol_other (unsigned int other
)
10592 const char * result
= NULL
;
10593 static char buff
[32];
10598 switch (elf_header
.e_machine
)
10601 result
= get_mips_symbol_other (other
);
10604 result
= get_ia64_symbol_other (other
);
10607 result
= get_ppc64_symbol_other (other
);
10617 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10621 static const char *
10622 get_symbol_index_type (unsigned int type
)
10624 static char buff
[32];
10628 case SHN_UNDEF
: return "UND";
10629 case SHN_ABS
: return "ABS";
10630 case SHN_COMMON
: return "COM";
10632 if (type
== SHN_IA_64_ANSI_COMMON
10633 && elf_header
.e_machine
== EM_IA_64
10634 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10636 else if ((elf_header
.e_machine
== EM_X86_64
10637 || elf_header
.e_machine
== EM_L1OM
10638 || elf_header
.e_machine
== EM_K1OM
)
10639 && type
== SHN_X86_64_LCOMMON
)
10640 return "LARGE_COM";
10641 else if ((type
== SHN_MIPS_SCOMMON
10642 && elf_header
.e_machine
== EM_MIPS
)
10643 || (type
== SHN_TIC6X_SCOMMON
10644 && elf_header
.e_machine
== EM_TI_C6000
))
10646 else if (type
== SHN_MIPS_SUNDEFINED
10647 && elf_header
.e_machine
== EM_MIPS
)
10649 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10650 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10651 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10652 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10653 else if (type
>= SHN_LORESERVE
)
10654 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10655 else if (type
>= elf_header
.e_shnum
)
10656 sprintf (buff
, _("bad section index[%3d]"), type
);
10658 sprintf (buff
, "%3d", type
);
10666 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10668 unsigned char * e_data
;
10671 /* If the size_t type is smaller than the bfd_size_type, eg because
10672 you are building a 32-bit tool on a 64-bit host, then make sure
10673 that when (number) is cast to (size_t) no information is lost. */
10674 if (sizeof (size_t) < sizeof (bfd_size_type
)
10675 && (bfd_size_type
) ((size_t) number
) != number
)
10677 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10678 " elements of size %u\n"),
10683 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10684 attempting to allocate memory when the read is bound to fail. */
10685 if (ent_size
* number
> current_file_size
)
10687 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10692 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10693 if (e_data
== NULL
)
10695 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10700 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10702 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10703 number
* ent_size
);
10708 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10709 if (i_data
== NULL
)
10711 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10712 " dynamic entries\n"),
10719 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10727 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10729 Elf_Internal_Sym
* psym
;
10732 n
= print_vma (si
, DEC_5
);
10734 fputs (&" "[n
], stdout
);
10735 printf (" %3lu: ", hn
);
10737 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10739 printf (_("<No info available for dynamic symbol number %lu>\n"),
10740 (unsigned long) si
);
10744 psym
= dynamic_symbols
+ si
;
10745 print_vma (psym
->st_value
, LONG_HEX
);
10747 print_vma (psym
->st_size
, DEC_5
);
10749 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10750 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10752 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10753 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10756 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10758 printf (" %-7s", get_symbol_visibility (vis
));
10759 /* Check to see if any other bits in the st_other field are set.
10760 Note - displaying this information disrupts the layout of the
10761 table being generated, but for the moment this case is very
10763 if (psym
->st_other
^ vis
)
10764 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10767 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10768 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10769 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10771 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10775 static const char *
10776 get_symbol_version_string (FILE *file
, int is_dynsym
,
10777 const char *strtab
,
10778 unsigned long int strtab_size
,
10779 unsigned int si
, Elf_Internal_Sym
*psym
,
10780 enum versioned_symbol_info
*sym_info
,
10781 unsigned short *vna_other
)
10783 unsigned char data
[2];
10784 unsigned short vers_data
;
10785 unsigned long offset
;
10788 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10791 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10792 sizeof data
+ si
* sizeof (vers_data
));
10794 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10795 sizeof (data
), 1, _("version data")) == NULL
)
10798 vers_data
= byte_get (data
, 2);
10800 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10803 /* Usually we'd only see verdef for defined symbols, and verneed for
10804 undefined symbols. However, symbols defined by the linker in
10805 .dynbss for variables copied from a shared library in order to
10806 avoid text relocations are defined yet have verneed. We could
10807 use a heuristic to detect the special case, for example, check
10808 for verneed first on symbols defined in SHT_NOBITS sections, but
10809 it is simpler and more reliable to just look for both verdef and
10810 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10812 if (psym
->st_shndx
!= SHN_UNDEF
10813 && vers_data
!= 0x8001
10814 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10816 Elf_Internal_Verdef ivd
;
10817 Elf_Internal_Verdaux ivda
;
10818 Elf_External_Verdaux evda
;
10821 off
= offset_from_vma (file
,
10822 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10823 sizeof (Elf_External_Verdef
));
10827 Elf_External_Verdef evd
;
10829 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10830 _("version def")) == NULL
)
10838 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10839 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10840 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10843 off
+= ivd
.vd_next
;
10845 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10847 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10849 off
-= ivd
.vd_next
;
10852 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10853 _("version def aux")) != NULL
)
10855 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10857 if (psym
->st_name
!= ivda
.vda_name
)
10859 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10860 ? symbol_hidden
: symbol_public
);
10861 return (ivda
.vda_name
< strtab_size
10862 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10868 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10870 Elf_External_Verneed evn
;
10871 Elf_Internal_Verneed ivn
;
10872 Elf_Internal_Vernaux ivna
;
10874 offset
= offset_from_vma (file
,
10875 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10879 unsigned long vna_off
;
10881 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10882 _("version need")) == NULL
)
10885 ivna
.vna_other
= 0;
10890 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10891 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10893 vna_off
= offset
+ ivn
.vn_aux
;
10897 Elf_External_Vernaux evna
;
10899 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10900 _("version need aux (3)")) == NULL
)
10903 ivna
.vna_other
= 0;
10908 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10909 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10910 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10913 vna_off
+= ivna
.vna_next
;
10915 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10917 if (ivna
.vna_other
== vers_data
)
10920 offset
+= ivn
.vn_next
;
10922 while (ivn
.vn_next
!= 0);
10924 if (ivna
.vna_other
== vers_data
)
10926 *sym_info
= symbol_undefined
;
10927 *vna_other
= ivna
.vna_other
;
10928 return (ivna
.vna_name
< strtab_size
10929 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10935 /* Dump the symbol table. */
10937 process_symbol_table (FILE * file
)
10939 Elf_Internal_Shdr
* section
;
10940 bfd_size_type nbuckets
= 0;
10941 bfd_size_type nchains
= 0;
10942 bfd_vma
* buckets
= NULL
;
10943 bfd_vma
* chains
= NULL
;
10944 bfd_vma ngnubuckets
= 0;
10945 bfd_vma
* gnubuckets
= NULL
;
10946 bfd_vma
* gnuchains
= NULL
;
10947 bfd_vma gnusymidx
= 0;
10948 bfd_size_type ngnuchains
= 0;
10950 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10953 if (dynamic_info
[DT_HASH
]
10955 || (do_using_dynamic
10957 && dynamic_strings
!= NULL
)))
10959 unsigned char nb
[8];
10960 unsigned char nc
[8];
10961 unsigned int hash_ent_size
= 4;
10963 if ((elf_header
.e_machine
== EM_ALPHA
10964 || elf_header
.e_machine
== EM_S390
10965 || elf_header
.e_machine
== EM_S390_OLD
)
10966 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10970 (archive_file_offset
10971 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10972 sizeof nb
+ sizeof nc
)),
10975 error (_("Unable to seek to start of dynamic information\n"));
10979 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10981 error (_("Failed to read in number of buckets\n"));
10985 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10987 error (_("Failed to read in number of chains\n"));
10991 nbuckets
= byte_get (nb
, hash_ent_size
);
10992 nchains
= byte_get (nc
, hash_ent_size
);
10994 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10995 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10998 if (buckets
== NULL
|| chains
== NULL
)
11000 if (do_using_dynamic
)
11011 if (dynamic_info_DT_GNU_HASH
11013 || (do_using_dynamic
11015 && dynamic_strings
!= NULL
)))
11017 unsigned char nb
[16];
11018 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11019 bfd_vma buckets_vma
;
11022 (archive_file_offset
11023 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11027 error (_("Unable to seek to start of dynamic information\n"));
11031 if (fread (nb
, 16, 1, file
) != 1)
11033 error (_("Failed to read in number of buckets\n"));
11037 ngnubuckets
= byte_get (nb
, 4);
11038 gnusymidx
= byte_get (nb
+ 4, 4);
11039 bitmaskwords
= byte_get (nb
+ 8, 4);
11040 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11042 buckets_vma
+= bitmaskwords
* 4;
11044 buckets_vma
+= bitmaskwords
* 8;
11047 (archive_file_offset
11048 + offset_from_vma (file
, buckets_vma
, 4)),
11051 error (_("Unable to seek to start of dynamic information\n"));
11055 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11057 if (gnubuckets
== NULL
)
11060 for (i
= 0; i
< ngnubuckets
; i
++)
11061 if (gnubuckets
[i
] != 0)
11063 if (gnubuckets
[i
] < gnusymidx
)
11066 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11067 maxchain
= gnubuckets
[i
];
11070 if (maxchain
== 0xffffffff)
11073 maxchain
-= gnusymidx
;
11076 (archive_file_offset
11077 + offset_from_vma (file
, buckets_vma
11078 + 4 * (ngnubuckets
+ maxchain
), 4)),
11081 error (_("Unable to seek to start of dynamic information\n"));
11087 if (fread (nb
, 4, 1, file
) != 1)
11089 error (_("Failed to determine last chain length\n"));
11093 if (maxchain
+ 1 == 0)
11098 while ((byte_get (nb
, 4) & 1) == 0);
11101 (archive_file_offset
11102 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11105 error (_("Unable to seek to start of dynamic information\n"));
11109 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11110 ngnuchains
= maxchain
;
11113 if (gnuchains
== NULL
)
11118 if (do_using_dynamic
)
11123 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11125 && do_using_dynamic
11126 && dynamic_strings
!= NULL
11127 && dynamic_symbols
!= NULL
)
11131 if (dynamic_info
[DT_HASH
])
11135 printf (_("\nSymbol table for image:\n"));
11137 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11139 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11141 for (hn
= 0; hn
< nbuckets
; hn
++)
11146 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11147 print_dynamic_symbol (si
, hn
);
11151 if (dynamic_info_DT_GNU_HASH
)
11153 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11155 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11157 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11159 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11160 if (gnubuckets
[hn
] != 0)
11162 bfd_vma si
= gnubuckets
[hn
];
11163 bfd_vma off
= si
- gnusymidx
;
11167 print_dynamic_symbol (si
, hn
);
11170 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11174 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11175 && section_headers
!= NULL
)
11179 for (i
= 0, section
= section_headers
;
11180 i
< elf_header
.e_shnum
;
11184 char * strtab
= NULL
;
11185 unsigned long int strtab_size
= 0;
11186 Elf_Internal_Sym
* symtab
;
11187 Elf_Internal_Sym
* psym
;
11188 unsigned long num_syms
;
11190 if ((section
->sh_type
!= SHT_SYMTAB
11191 && section
->sh_type
!= SHT_DYNSYM
)
11193 && section
->sh_type
== SHT_SYMTAB
))
11196 if (section
->sh_entsize
== 0)
11198 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11199 printable_section_name (section
));
11203 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11204 printable_section_name (section
),
11205 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11208 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11210 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11212 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11213 if (symtab
== NULL
)
11216 if (section
->sh_link
== elf_header
.e_shstrndx
)
11218 strtab
= string_table
;
11219 strtab_size
= string_table_length
;
11221 else if (section
->sh_link
< elf_header
.e_shnum
)
11223 Elf_Internal_Shdr
* string_sec
;
11225 string_sec
= section_headers
+ section
->sh_link
;
11227 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11228 1, string_sec
->sh_size
,
11229 _("string table"));
11230 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11233 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11235 const char *version_string
;
11236 enum versioned_symbol_info sym_info
;
11237 unsigned short vna_other
;
11239 printf ("%6d: ", si
);
11240 print_vma (psym
->st_value
, LONG_HEX
);
11242 print_vma (psym
->st_size
, DEC_5
);
11243 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11244 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11245 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11246 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11249 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11251 printf (" %-7s", get_symbol_visibility (vis
));
11252 /* Check to see if any other bits in the st_other field are set.
11253 Note - displaying this information disrupts the layout of the
11254 table being generated, but for the moment this case is very rare. */
11255 if (psym
->st_other
^ vis
)
11256 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11258 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11259 print_symbol (25, psym
->st_name
< strtab_size
11260 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11263 = get_symbol_version_string (file
,
11264 section
->sh_type
== SHT_DYNSYM
,
11265 strtab
, strtab_size
, si
,
11266 psym
, &sym_info
, &vna_other
);
11267 if (version_string
)
11269 if (sym_info
== symbol_undefined
)
11270 printf ("@%s (%d)", version_string
, vna_other
);
11272 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11278 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11279 && si
>= section
->sh_info
11280 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11281 && elf_header
.e_machine
!= EM_MIPS
11282 /* Solaris binaries have been found to violate this requirement as
11283 well. Not sure if this is a bug or an ABI requirement. */
11284 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11285 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11286 si
, printable_section_name (section
), section
->sh_info
);
11290 if (strtab
!= string_table
)
11296 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11298 if (do_histogram
&& buckets
!= NULL
)
11300 unsigned long * lengths
;
11301 unsigned long * counts
;
11304 unsigned long maxlength
= 0;
11305 unsigned long nzero_counts
= 0;
11306 unsigned long nsyms
= 0;
11307 unsigned long chained
;
11309 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11310 (unsigned long) nbuckets
);
11312 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11313 if (lengths
== NULL
)
11315 error (_("Out of memory allocating space for histogram buckets\n"));
11319 printf (_(" Length Number %% of total Coverage\n"));
11320 for (hn
= 0; hn
< nbuckets
; ++hn
)
11322 for (si
= buckets
[hn
], chained
= 0;
11323 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11324 si
= chains
[si
], ++chained
)
11327 if (maxlength
< ++lengths
[hn
])
11331 /* PR binutils/17531: A corrupt binary could contain broken
11332 histogram data. Do not go into an infinite loop trying
11334 if (chained
> nchains
)
11336 error (_("histogram chain is corrupt\n"));
11341 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11342 if (counts
== NULL
)
11345 error (_("Out of memory allocating space for histogram counts\n"));
11349 for (hn
= 0; hn
< nbuckets
; ++hn
)
11350 ++counts
[lengths
[hn
]];
11355 printf (" 0 %-10lu (%5.1f%%)\n",
11356 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11357 for (i
= 1; i
<= maxlength
; ++i
)
11359 nzero_counts
+= counts
[i
] * i
;
11360 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11361 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11362 (nzero_counts
* 100.0) / nsyms
);
11370 if (buckets
!= NULL
)
11376 if (do_histogram
&& gnubuckets
!= NULL
)
11378 unsigned long * lengths
;
11379 unsigned long * counts
;
11381 unsigned long maxlength
= 0;
11382 unsigned long nzero_counts
= 0;
11383 unsigned long nsyms
= 0;
11385 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11386 (unsigned long) ngnubuckets
);
11388 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11389 if (lengths
== NULL
)
11391 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11395 printf (_(" Length Number %% of total Coverage\n"));
11397 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11398 if (gnubuckets
[hn
] != 0)
11400 bfd_vma off
, length
= 1;
11402 for (off
= gnubuckets
[hn
] - gnusymidx
;
11403 /* PR 17531 file: 010-77222-0.004. */
11404 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11407 lengths
[hn
] = length
;
11408 if (length
> maxlength
)
11409 maxlength
= length
;
11413 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11414 if (counts
== NULL
)
11417 error (_("Out of memory allocating space for gnu histogram counts\n"));
11421 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11422 ++counts
[lengths
[hn
]];
11424 if (ngnubuckets
> 0)
11427 printf (" 0 %-10lu (%5.1f%%)\n",
11428 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11429 for (j
= 1; j
<= maxlength
; ++j
)
11431 nzero_counts
+= counts
[j
] * j
;
11432 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11433 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11434 (nzero_counts
* 100.0) / nsyms
);
11448 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11452 if (dynamic_syminfo
== NULL
11454 /* No syminfo, this is ok. */
11457 /* There better should be a dynamic symbol section. */
11458 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11462 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11463 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11465 printf (_(" Num: Name BoundTo Flags\n"));
11466 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11468 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11470 printf ("%4d: ", i
);
11471 if (i
>= num_dynamic_syms
)
11472 printf (_("<corrupt index>"));
11473 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11474 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11476 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11479 switch (dynamic_syminfo
[i
].si_boundto
)
11481 case SYMINFO_BT_SELF
:
11482 fputs ("SELF ", stdout
);
11484 case SYMINFO_BT_PARENT
:
11485 fputs ("PARENT ", stdout
);
11488 if (dynamic_syminfo
[i
].si_boundto
> 0
11489 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11490 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11492 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11496 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11500 if (flags
& SYMINFO_FLG_DIRECT
)
11501 printf (" DIRECT");
11502 if (flags
& SYMINFO_FLG_PASSTHRU
)
11503 printf (" PASSTHRU");
11504 if (flags
& SYMINFO_FLG_COPY
)
11506 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11507 printf (" LAZYLOAD");
11515 /* Check to see if the given reloc needs to be handled in a target specific
11516 manner. If so then process the reloc and return TRUE otherwise return
11520 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11521 unsigned char * start
,
11522 Elf_Internal_Sym
* symtab
)
11524 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11526 switch (elf_header
.e_machine
)
11529 case EM_MSP430_OLD
:
11531 static Elf_Internal_Sym
* saved_sym
= NULL
;
11533 switch (reloc_type
)
11535 case 10: /* R_MSP430_SYM_DIFF */
11536 if (uses_msp430x_relocs ())
11538 /* Fall through. */
11539 case 21: /* R_MSP430X_SYM_DIFF */
11540 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11543 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11544 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11545 goto handle_sym_diff
;
11547 case 5: /* R_MSP430_16_BYTE */
11548 case 9: /* R_MSP430_8 */
11549 if (uses_msp430x_relocs ())
11551 goto handle_sym_diff
;
11553 case 2: /* R_MSP430_ABS16 */
11554 case 15: /* R_MSP430X_ABS16 */
11555 if (! uses_msp430x_relocs ())
11557 goto handle_sym_diff
;
11560 if (saved_sym
!= NULL
)
11564 value
= reloc
->r_addend
11565 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11566 - saved_sym
->st_value
);
11568 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11576 if (saved_sym
!= NULL
)
11577 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11584 case EM_CYGNUS_MN10300
:
11586 static Elf_Internal_Sym
* saved_sym
= NULL
;
11588 switch (reloc_type
)
11590 case 34: /* R_MN10300_ALIGN */
11592 case 33: /* R_MN10300_SYM_DIFF */
11593 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11595 case 1: /* R_MN10300_32 */
11596 case 2: /* R_MN10300_16 */
11597 if (saved_sym
!= NULL
)
11601 value
= reloc
->r_addend
11602 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11603 - saved_sym
->st_value
);
11605 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11612 if (saved_sym
!= NULL
)
11613 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11621 static bfd_vma saved_sym1
= 0;
11622 static bfd_vma saved_sym2
= 0;
11623 static bfd_vma value
;
11625 switch (reloc_type
)
11627 case 0x80: /* R_RL78_SYM. */
11628 saved_sym1
= saved_sym2
;
11629 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11630 saved_sym2
+= reloc
->r_addend
;
11633 case 0x83: /* R_RL78_OPsub. */
11634 value
= saved_sym1
- saved_sym2
;
11635 saved_sym2
= saved_sym1
= 0;
11639 case 0x41: /* R_RL78_ABS32. */
11640 byte_put (start
+ reloc
->r_offset
, value
, 4);
11644 case 0x43: /* R_RL78_ABS16. */
11645 byte_put (start
+ reloc
->r_offset
, value
, 2);
11659 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11660 DWARF debug sections. This is a target specific test. Note - we do not
11661 go through the whole including-target-headers-multiple-times route, (as
11662 we have already done with <elf/h8.h>) because this would become very
11663 messy and even then this function would have to contain target specific
11664 information (the names of the relocs instead of their numeric values).
11665 FIXME: This is not the correct way to solve this problem. The proper way
11666 is to have target specific reloc sizing and typing functions created by
11667 the reloc-macros.h header, in the same way that it already creates the
11668 reloc naming functions. */
11671 is_32bit_abs_reloc (unsigned int reloc_type
)
11673 /* Please keep this table alpha-sorted for ease of visual lookup. */
11674 switch (elf_header
.e_machine
)
11678 return reloc_type
== 1; /* R_386_32. */
11680 return reloc_type
== 1; /* R_68K_32. */
11682 return reloc_type
== 1; /* R_860_32. */
11684 return reloc_type
== 2; /* R_960_32. */
11686 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11687 case EM_ADAPTEVA_EPIPHANY
:
11688 return reloc_type
== 3;
11690 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11692 return reloc_type
== 1; /* R_ARC_32. */
11693 case EM_ARC_COMPACT
:
11694 case EM_ARC_COMPACT2
:
11695 return reloc_type
== 4; /* R_ARC_32. */
11697 return reloc_type
== 2; /* R_ARM_ABS32 */
11700 return reloc_type
== 1;
11702 return reloc_type
== 0x12; /* R_byte4_data. */
11704 return reloc_type
== 3; /* R_CRIS_32. */
11706 return reloc_type
== 3; /* R_CR16_NUM32. */
11708 return reloc_type
== 15; /* R_CRX_NUM32. */
11709 case EM_CYGNUS_FRV
:
11710 return reloc_type
== 1;
11711 case EM_CYGNUS_D10V
:
11713 return reloc_type
== 6; /* R_D10V_32. */
11714 case EM_CYGNUS_D30V
:
11716 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11718 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11719 case EM_CYGNUS_FR30
:
11721 return reloc_type
== 3; /* R_FR30_32. */
11723 return reloc_type
== 1; /* R_FT32_32. */
11727 return reloc_type
== 1; /* R_H8_DIR32. */
11729 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11730 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11733 return reloc_type
== 2; /* R_IP2K_32. */
11735 return reloc_type
== 2; /* R_IQ2000_32. */
11736 case EM_LATTICEMICO32
:
11737 return reloc_type
== 3; /* R_LM32_32. */
11740 return reloc_type
== 3; /* R_M32C_32. */
11742 return reloc_type
== 34; /* R_M32R_32_RELA. */
11745 return reloc_type
== 6; /* R_M68HC11_32. */
11747 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11748 case EM_CYGNUS_MEP
:
11749 return reloc_type
== 4; /* R_MEP_32. */
11751 return reloc_type
== 2; /* R_METAG_ADDR32. */
11752 case EM_MICROBLAZE
:
11753 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11755 return reloc_type
== 2; /* R_MIPS_32. */
11757 return reloc_type
== 4; /* R_MMIX_32. */
11758 case EM_CYGNUS_MN10200
:
11760 return reloc_type
== 1; /* R_MN10200_32. */
11761 case EM_CYGNUS_MN10300
:
11763 return reloc_type
== 1; /* R_MN10300_32. */
11765 return reloc_type
== 1; /* R_MOXIE_32. */
11766 case EM_MSP430_OLD
:
11768 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11770 return reloc_type
== 2; /* R_MT_32. */
11772 return reloc_type
== 20; /* R_NDS32_RELA. */
11773 case EM_ALTERA_NIOS2
:
11774 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11776 return reloc_type
== 1; /* R_NIOS_32. */
11778 return reloc_type
== 1; /* R_OR1K_32. */
11780 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11781 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11784 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11786 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11788 return reloc_type
== 1; /* R_PPC_ADDR32. */
11790 return reloc_type
== 1; /* R_RL78_DIR32. */
11792 return reloc_type
== 1; /* R_RX_DIR32. */
11794 return reloc_type
== 1; /* R_I370_ADDR31. */
11797 return reloc_type
== 4; /* R_S390_32. */
11799 return reloc_type
== 8; /* R_SCORE_ABS32. */
11801 return reloc_type
== 1; /* R_SH_DIR32. */
11802 case EM_SPARC32PLUS
:
11805 return reloc_type
== 3 /* R_SPARC_32. */
11806 || reloc_type
== 23; /* R_SPARC_UA32. */
11808 return reloc_type
== 6; /* R_SPU_ADDR32 */
11810 return reloc_type
== 1; /* R_C6000_ABS32. */
11812 return reloc_type
== 2; /* R_TILEGX_32. */
11814 return reloc_type
== 1; /* R_TILEPRO_32. */
11815 case EM_CYGNUS_V850
:
11817 return reloc_type
== 6; /* R_V850_ABS32. */
11819 return reloc_type
== 0x33; /* R_V810_WORD. */
11821 return reloc_type
== 1; /* R_VAX_32. */
11823 return reloc_type
== 3; /* R_VISIUM_32. */
11827 return reloc_type
== 10; /* R_X86_64_32. */
11830 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11832 return reloc_type
== 4; /* R_XGATE_32. */
11834 return reloc_type
== 1; /* R_XSTROMY16_32. */
11835 case EM_XTENSA_OLD
:
11837 return reloc_type
== 1; /* R_XTENSA_32. */
11840 static unsigned int prev_warn
= 0;
11842 /* Avoid repeating the same warning multiple times. */
11843 if (prev_warn
!= elf_header
.e_machine
)
11844 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11845 elf_header
.e_machine
);
11846 prev_warn
= elf_header
.e_machine
;
11852 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11853 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11856 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11858 switch (elf_header
.e_machine
)
11859 /* Please keep this table alpha-sorted for ease of visual lookup. */
11863 return reloc_type
== 2; /* R_386_PC32. */
11865 return reloc_type
== 4; /* R_68K_PC32. */
11867 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11868 case EM_ADAPTEVA_EPIPHANY
:
11869 return reloc_type
== 6;
11871 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11872 case EM_ARC_COMPACT
:
11873 case EM_ARC_COMPACT2
:
11874 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11876 return reloc_type
== 3; /* R_ARM_REL32 */
11879 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11880 case EM_MICROBLAZE
:
11881 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11883 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11885 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11887 return reloc_type
== 26; /* R_PPC_REL32. */
11889 return reloc_type
== 26; /* R_PPC64_REL32. */
11892 return reloc_type
== 5; /* R_390_PC32. */
11894 return reloc_type
== 2; /* R_SH_REL32. */
11895 case EM_SPARC32PLUS
:
11898 return reloc_type
== 6; /* R_SPARC_DISP32. */
11900 return reloc_type
== 13; /* R_SPU_REL32. */
11902 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11904 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11906 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11910 return reloc_type
== 2; /* R_X86_64_PC32. */
11911 case EM_XTENSA_OLD
:
11913 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11915 /* Do not abort or issue an error message here. Not all targets use
11916 pc-relative 32-bit relocs in their DWARF debug information and we
11917 have already tested for target coverage in is_32bit_abs_reloc. A
11918 more helpful warning message will be generated by apply_relocations
11919 anyway, so just return. */
11924 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11925 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11928 is_64bit_abs_reloc (unsigned int reloc_type
)
11930 switch (elf_header
.e_machine
)
11933 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11935 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11937 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11939 return reloc_type
== 80; /* R_PARISC_DIR64. */
11941 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11942 case EM_SPARC32PLUS
:
11945 return reloc_type
== 54; /* R_SPARC_UA64. */
11949 return reloc_type
== 1; /* R_X86_64_64. */
11952 return reloc_type
== 22; /* R_S390_64. */
11954 return reloc_type
== 1; /* R_TILEGX_64. */
11956 return reloc_type
== 18; /* R_MIPS_64. */
11962 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11963 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11966 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11968 switch (elf_header
.e_machine
)
11971 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11973 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11975 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11977 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11979 return reloc_type
== 44; /* R_PPC64_REL64. */
11980 case EM_SPARC32PLUS
:
11983 return reloc_type
== 46; /* R_SPARC_DISP64. */
11987 return reloc_type
== 24; /* R_X86_64_PC64. */
11990 return reloc_type
== 23; /* R_S390_PC64. */
11992 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11998 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11999 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12002 is_24bit_abs_reloc (unsigned int reloc_type
)
12004 switch (elf_header
.e_machine
)
12006 case EM_CYGNUS_MN10200
:
12008 return reloc_type
== 4; /* R_MN10200_24. */
12010 return reloc_type
== 5; /* R_FT32_20. */
12016 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12017 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12020 is_16bit_abs_reloc (unsigned int reloc_type
)
12022 /* Please keep this table alpha-sorted for ease of visual lookup. */
12023 switch (elf_header
.e_machine
)
12026 case EM_ARC_COMPACT
:
12027 case EM_ARC_COMPACT2
:
12028 return reloc_type
== 2; /* R_ARC_16. */
12029 case EM_ADAPTEVA_EPIPHANY
:
12030 return reloc_type
== 5;
12033 return reloc_type
== 4; /* R_AVR_16. */
12034 case EM_CYGNUS_D10V
:
12036 return reloc_type
== 3; /* R_D10V_16. */
12040 return reloc_type
== R_H8_DIR16
;
12043 return reloc_type
== 1; /* R_IP2K_16. */
12046 return reloc_type
== 1; /* R_M32C_16 */
12047 case EM_CYGNUS_MN10200
:
12049 return reloc_type
== 2; /* R_MN10200_16. */
12050 case EM_CYGNUS_MN10300
:
12052 return reloc_type
== 2; /* R_MN10300_16. */
12054 if (uses_msp430x_relocs ())
12055 return reloc_type
== 2; /* R_MSP430_ABS16. */
12056 /* Fall through. */
12057 case EM_MSP430_OLD
:
12058 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12060 return reloc_type
== 19; /* R_NDS32_RELA. */
12061 case EM_ALTERA_NIOS2
:
12062 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12064 return reloc_type
== 9; /* R_NIOS_16. */
12066 return reloc_type
== 2; /* R_OR1K_16. */
12068 return reloc_type
== 2; /* R_C6000_ABS16. */
12070 return reloc_type
== 2; /* R_VISIUM_16. */
12073 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12075 return reloc_type
== 3; /* R_XGATE_16. */
12081 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12082 relocation entries (possibly formerly used for SHT_GROUP sections). */
12085 is_none_reloc (unsigned int reloc_type
)
12087 switch (elf_header
.e_machine
)
12089 case EM_386
: /* R_386_NONE. */
12090 case EM_68K
: /* R_68K_NONE. */
12091 case EM_ADAPTEVA_EPIPHANY
:
12092 case EM_ALPHA
: /* R_ALPHA_NONE. */
12093 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12094 case EM_ARC
: /* R_ARC_NONE. */
12095 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12096 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12097 case EM_ARM
: /* R_ARM_NONE. */
12098 case EM_C166
: /* R_XC16X_NONE. */
12099 case EM_CRIS
: /* R_CRIS_NONE. */
12100 case EM_FT32
: /* R_FT32_NONE. */
12101 case EM_IA_64
: /* R_IA64_NONE. */
12102 case EM_K1OM
: /* R_X86_64_NONE. */
12103 case EM_L1OM
: /* R_X86_64_NONE. */
12104 case EM_M32R
: /* R_M32R_NONE. */
12105 case EM_MIPS
: /* R_MIPS_NONE. */
12106 case EM_MN10300
: /* R_MN10300_NONE. */
12107 case EM_MOXIE
: /* R_MOXIE_NONE. */
12108 case EM_NIOS32
: /* R_NIOS_NONE. */
12109 case EM_OR1K
: /* R_OR1K_NONE. */
12110 case EM_PARISC
: /* R_PARISC_NONE. */
12111 case EM_PPC64
: /* R_PPC64_NONE. */
12112 case EM_PPC
: /* R_PPC_NONE. */
12113 case EM_S390
: /* R_390_NONE. */
12115 case EM_SH
: /* R_SH_NONE. */
12116 case EM_SPARC32PLUS
:
12117 case EM_SPARC
: /* R_SPARC_NONE. */
12119 case EM_TILEGX
: /* R_TILEGX_NONE. */
12120 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12121 case EM_TI_C6000
:/* R_C6000_NONE. */
12122 case EM_X86_64
: /* R_X86_64_NONE. */
12124 return reloc_type
== 0;
12127 return reloc_type
== 0 || reloc_type
== 256;
12130 return (reloc_type
== 0 /* R_AVR_NONE. */
12131 || reloc_type
== 30 /* R_AVR_DIFF8. */
12132 || reloc_type
== 31 /* R_AVR_DIFF16. */
12133 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12135 return reloc_type
== 3; /* R_METAG_NONE. */
12137 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12138 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12139 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12140 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12141 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12142 case EM_XTENSA_OLD
:
12144 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12145 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12146 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12147 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12152 /* Returns TRUE if there is a relocation against
12153 section NAME at OFFSET bytes. */
12156 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12158 Elf_Internal_Rela
* relocs
;
12159 Elf_Internal_Rela
* rp
;
12161 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12164 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12166 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12167 if (rp
->r_offset
== offset
)
12173 /* Apply relocations to a section.
12174 Note: So far support has been added only for those relocations
12175 which can be found in debug sections.
12176 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12177 loaded relocs. It is then the caller's responsibility to free them.
12178 FIXME: Add support for more relocations ? */
12181 apply_relocations (void * file
,
12182 const Elf_Internal_Shdr
* section
,
12183 unsigned char * start
,
12184 bfd_size_type size
,
12185 void ** relocs_return
,
12186 unsigned long * num_relocs_return
)
12188 Elf_Internal_Shdr
* relsec
;
12189 unsigned char * end
= start
+ size
;
12191 if (relocs_return
!= NULL
)
12193 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12194 * num_relocs_return
= 0;
12197 if (elf_header
.e_type
!= ET_REL
)
12200 /* Find the reloc section associated with the section. */
12201 for (relsec
= section_headers
;
12202 relsec
< section_headers
+ elf_header
.e_shnum
;
12205 bfd_boolean is_rela
;
12206 unsigned long num_relocs
;
12207 Elf_Internal_Rela
* relocs
;
12208 Elf_Internal_Rela
* rp
;
12209 Elf_Internal_Shdr
* symsec
;
12210 Elf_Internal_Sym
* symtab
;
12211 unsigned long num_syms
;
12212 Elf_Internal_Sym
* sym
;
12214 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12215 || relsec
->sh_info
>= elf_header
.e_shnum
12216 || section_headers
+ relsec
->sh_info
!= section
12217 || relsec
->sh_size
== 0
12218 || relsec
->sh_link
>= elf_header
.e_shnum
)
12221 is_rela
= relsec
->sh_type
== SHT_RELA
;
12225 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12226 relsec
->sh_size
, & relocs
, & num_relocs
))
12231 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12232 relsec
->sh_size
, & relocs
, & num_relocs
))
12236 /* SH uses RELA but uses in place value instead of the addend field. */
12237 if (elf_header
.e_machine
== EM_SH
)
12240 symsec
= section_headers
+ relsec
->sh_link
;
12241 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12243 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12246 unsigned int reloc_type
;
12247 unsigned int reloc_size
;
12248 unsigned char * rloc
;
12249 unsigned long sym_index
;
12251 reloc_type
= get_reloc_type (rp
->r_info
);
12253 if (target_specific_reloc_handling (rp
, start
, symtab
))
12255 else if (is_none_reloc (reloc_type
))
12257 else if (is_32bit_abs_reloc (reloc_type
)
12258 || is_32bit_pcrel_reloc (reloc_type
))
12260 else if (is_64bit_abs_reloc (reloc_type
)
12261 || is_64bit_pcrel_reloc (reloc_type
))
12263 else if (is_24bit_abs_reloc (reloc_type
))
12265 else if (is_16bit_abs_reloc (reloc_type
))
12269 static unsigned int prev_reloc
= 0;
12270 if (reloc_type
!= prev_reloc
)
12271 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12272 reloc_type
, printable_section_name (section
));
12273 prev_reloc
= reloc_type
;
12277 rloc
= start
+ rp
->r_offset
;
12278 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12280 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12281 (unsigned long) rp
->r_offset
,
12282 printable_section_name (section
));
12286 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12287 if (sym_index
>= num_syms
)
12289 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12290 sym_index
, printable_section_name (section
));
12293 sym
= symtab
+ sym_index
;
12295 /* If the reloc has a symbol associated with it,
12296 make sure that it is of an appropriate type.
12298 Relocations against symbols without type can happen.
12299 Gcc -feliminate-dwarf2-dups may generate symbols
12300 without type for debug info.
12302 Icc generates relocations against function symbols
12303 instead of local labels.
12305 Relocations against object symbols can happen, eg when
12306 referencing a global array. For an example of this see
12307 the _clz.o binary in libgcc.a. */
12309 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12310 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12312 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12313 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12314 (long int)(rp
- relocs
),
12315 printable_section_name (relsec
));
12321 addend
+= rp
->r_addend
;
12322 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12323 partial_inplace. */
12325 || (elf_header
.e_machine
== EM_XTENSA
12326 && reloc_type
== 1)
12327 || ((elf_header
.e_machine
== EM_PJ
12328 || elf_header
.e_machine
== EM_PJ_OLD
)
12329 && reloc_type
== 1)
12330 || ((elf_header
.e_machine
== EM_D30V
12331 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12332 && reloc_type
== 12))
12333 addend
+= byte_get (rloc
, reloc_size
);
12335 if (is_32bit_pcrel_reloc (reloc_type
)
12336 || is_64bit_pcrel_reloc (reloc_type
))
12338 /* On HPPA, all pc-relative relocations are biased by 8. */
12339 if (elf_header
.e_machine
== EM_PARISC
)
12341 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12345 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12352 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12353 * num_relocs_return
= num_relocs
;
12362 #ifdef SUPPORT_DISASSEMBLY
12364 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12366 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12368 /* FIXME: XXX -- to be done --- XXX */
12374 /* Reads in the contents of SECTION from FILE, returning a pointer
12375 to a malloc'ed buffer or NULL if something went wrong. */
12378 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12380 bfd_size_type num_bytes
;
12382 num_bytes
= section
->sh_size
;
12384 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12386 printf (_("\nSection '%s' has no data to dump.\n"),
12387 printable_section_name (section
));
12391 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12392 _("section contents"));
12395 /* Uncompresses a section that was compressed using zlib, in place. */
12398 uncompress_section_contents (unsigned char **buffer
,
12399 dwarf_size_type uncompressed_size
,
12400 dwarf_size_type
*size
)
12402 dwarf_size_type compressed_size
= *size
;
12403 unsigned char * compressed_buffer
= *buffer
;
12404 unsigned char * uncompressed_buffer
;
12408 /* It is possible the section consists of several compressed
12409 buffers concatenated together, so we uncompress in a loop. */
12410 /* PR 18313: The state field in the z_stream structure is supposed
12411 to be invisible to the user (ie us), but some compilers will
12412 still complain about it being used without initialisation. So
12413 we first zero the entire z_stream structure and then set the fields
12415 memset (& strm
, 0, sizeof strm
);
12416 strm
.avail_in
= compressed_size
;
12417 strm
.next_in
= (Bytef
*) compressed_buffer
;
12418 strm
.avail_out
= uncompressed_size
;
12419 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12421 rc
= inflateInit (& strm
);
12422 while (strm
.avail_in
> 0)
12426 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12427 + (uncompressed_size
- strm
.avail_out
));
12428 rc
= inflate (&strm
, Z_FINISH
);
12429 if (rc
!= Z_STREAM_END
)
12431 rc
= inflateReset (& strm
);
12433 rc
= inflateEnd (& strm
);
12435 || strm
.avail_out
!= 0)
12438 *buffer
= uncompressed_buffer
;
12439 *size
= uncompressed_size
;
12443 free (uncompressed_buffer
);
12444 /* Indicate decompression failure. */
12450 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12452 Elf_Internal_Shdr
* relsec
;
12453 bfd_size_type num_bytes
;
12454 unsigned char * data
;
12455 unsigned char * end
;
12456 unsigned char * real_start
;
12457 unsigned char * start
;
12458 bfd_boolean some_strings_shown
;
12460 real_start
= start
= (unsigned char *) get_section_contents (section
,
12464 num_bytes
= section
->sh_size
;
12466 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12468 if (decompress_dumps
)
12470 dwarf_size_type new_size
= num_bytes
;
12471 dwarf_size_type uncompressed_size
= 0;
12473 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12475 Elf_Internal_Chdr chdr
;
12476 unsigned int compression_header_size
12477 = get_compression_header (& chdr
, (unsigned char *) start
);
12479 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12481 warn (_("section '%s' has unsupported compress type: %d\n"),
12482 printable_section_name (section
), chdr
.ch_type
);
12485 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12487 warn (_("compressed section '%s' is corrupted\n"),
12488 printable_section_name (section
));
12491 uncompressed_size
= chdr
.ch_size
;
12492 start
+= compression_header_size
;
12493 new_size
-= compression_header_size
;
12495 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12497 /* Read the zlib header. In this case, it should be "ZLIB"
12498 followed by the uncompressed section size, 8 bytes in
12499 big-endian order. */
12500 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12501 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12502 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12503 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12504 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12505 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12506 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12507 uncompressed_size
+= start
[11];
12512 if (uncompressed_size
12513 && uncompress_section_contents (& start
,
12514 uncompressed_size
, & new_size
))
12515 num_bytes
= new_size
;
12518 /* If the section being dumped has relocations against it the user might
12519 be expecting these relocations to have been applied. Check for this
12520 case and issue a warning message in order to avoid confusion.
12521 FIXME: Maybe we ought to have an option that dumps a section with
12522 relocs applied ? */
12523 for (relsec
= section_headers
;
12524 relsec
< section_headers
+ elf_header
.e_shnum
;
12527 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12528 || relsec
->sh_info
>= elf_header
.e_shnum
12529 || section_headers
+ relsec
->sh_info
!= section
12530 || relsec
->sh_size
== 0
12531 || relsec
->sh_link
>= elf_header
.e_shnum
)
12534 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12539 end
= start
+ num_bytes
;
12540 some_strings_shown
= FALSE
;
12544 while (!ISPRINT (* data
))
12545 if (++ data
>= end
)
12550 size_t maxlen
= end
- data
;
12553 /* PR 11128: Use two separate invocations in order to work
12554 around bugs in the Solaris 8 implementation of printf. */
12555 printf (" [%6tx] ", data
- start
);
12557 printf (" [%6Ix] ", (size_t) (data
- start
));
12561 print_symbol ((int) maxlen
, (const char *) data
);
12563 data
+= strnlen ((const char *) data
, maxlen
);
12567 printf (_("<corrupt>\n"));
12570 some_strings_shown
= TRUE
;
12574 if (! some_strings_shown
)
12575 printf (_(" No strings found in this section."));
12583 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12585 bfd_boolean relocate
)
12587 Elf_Internal_Shdr
* relsec
;
12588 bfd_size_type bytes
;
12589 bfd_size_type section_size
;
12591 unsigned char * data
;
12592 unsigned char * real_start
;
12593 unsigned char * start
;
12595 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12598 section_size
= section
->sh_size
;
12600 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12602 if (decompress_dumps
)
12604 dwarf_size_type new_size
= section_size
;
12605 dwarf_size_type uncompressed_size
= 0;
12607 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12609 Elf_Internal_Chdr chdr
;
12610 unsigned int compression_header_size
12611 = get_compression_header (& chdr
, start
);
12613 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12615 warn (_("section '%s' has unsupported compress type: %d\n"),
12616 printable_section_name (section
), chdr
.ch_type
);
12619 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12621 warn (_("compressed section '%s' is corrupted\n"),
12622 printable_section_name (section
));
12625 uncompressed_size
= chdr
.ch_size
;
12626 start
+= compression_header_size
;
12627 new_size
-= compression_header_size
;
12629 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12631 /* Read the zlib header. In this case, it should be "ZLIB"
12632 followed by the uncompressed section size, 8 bytes in
12633 big-endian order. */
12634 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12635 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12636 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12637 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12638 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12639 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12640 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12641 uncompressed_size
+= start
[11];
12646 if (uncompressed_size
12647 && uncompress_section_contents (& start
, uncompressed_size
,
12649 section_size
= new_size
;
12654 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12658 /* If the section being dumped has relocations against it the user might
12659 be expecting these relocations to have been applied. Check for this
12660 case and issue a warning message in order to avoid confusion.
12661 FIXME: Maybe we ought to have an option that dumps a section with
12662 relocs applied ? */
12663 for (relsec
= section_headers
;
12664 relsec
< section_headers
+ elf_header
.e_shnum
;
12667 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12668 || relsec
->sh_info
>= elf_header
.e_shnum
12669 || section_headers
+ relsec
->sh_info
!= section
12670 || relsec
->sh_size
== 0
12671 || relsec
->sh_link
>= elf_header
.e_shnum
)
12674 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12679 addr
= section
->sh_addr
;
12680 bytes
= section_size
;
12689 lbytes
= (bytes
> 16 ? 16 : bytes
);
12691 printf (" 0x%8.8lx ", (unsigned long) addr
);
12693 for (j
= 0; j
< 16; j
++)
12696 printf ("%2.2x", data
[j
]);
12704 for (j
= 0; j
< lbytes
; j
++)
12707 if (k
>= ' ' && k
< 0x7f)
12726 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12727 const Elf_Internal_Shdr
* sec
, void * file
)
12729 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12732 /* If it is already loaded, do nothing. */
12733 if (section
->start
!= NULL
)
12736 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12737 section
->address
= sec
->sh_addr
;
12738 section
->user_data
= NULL
;
12739 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12741 sec
->sh_size
, buf
);
12742 if (section
->start
== NULL
)
12746 unsigned char *start
= section
->start
;
12747 dwarf_size_type size
= sec
->sh_size
;
12748 dwarf_size_type uncompressed_size
= 0;
12750 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12752 Elf_Internal_Chdr chdr
;
12753 unsigned int compression_header_size
;
12755 if (size
< (is_32bit_elf
12756 ? sizeof (Elf32_External_Chdr
)
12757 : sizeof (Elf64_External_Chdr
)))
12759 warn (_("compressed section %s is too small to contain a compression header"),
12764 compression_header_size
= get_compression_header (&chdr
, start
);
12766 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12768 warn (_("section '%s' has unsupported compress type: %d\n"),
12769 section
->name
, chdr
.ch_type
);
12772 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12774 warn (_("compressed section '%s' is corrupted\n"),
12778 uncompressed_size
= chdr
.ch_size
;
12779 start
+= compression_header_size
;
12780 size
-= compression_header_size
;
12782 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12784 /* Read the zlib header. In this case, it should be "ZLIB"
12785 followed by the uncompressed section size, 8 bytes in
12786 big-endian order. */
12787 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12788 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12789 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12790 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12791 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12792 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12793 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12794 uncompressed_size
+= start
[11];
12799 if (uncompressed_size
12800 && uncompress_section_contents (&start
, uncompressed_size
,
12803 /* Free the compressed buffer, update the section buffer
12804 and the section size if uncompress is successful. */
12805 free (section
->start
);
12806 section
->start
= start
;
12808 section
->size
= size
;
12811 if (section
->start
== NULL
)
12814 if (debug_displays
[debug
].relocate
)
12815 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12816 & section
->reloc_info
, & section
->num_relocs
);
12819 section
->reloc_info
= NULL
;
12820 section
->num_relocs
= 0;
12826 /* If this is not NULL, load_debug_section will only look for sections
12827 within the list of sections given here. */
12828 unsigned int *section_subset
= NULL
;
12831 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12833 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12834 Elf_Internal_Shdr
* sec
;
12836 /* Locate the debug section. */
12837 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12839 section
->name
= section
->uncompressed_name
;
12842 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12844 section
->name
= section
->compressed_name
;
12849 /* If we're loading from a subset of sections, and we've loaded
12850 a section matching this name before, it's likely that it's a
12852 if (section_subset
!= NULL
)
12853 free_debug_section (debug
);
12855 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12859 free_debug_section (enum dwarf_section_display_enum debug
)
12861 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12863 if (section
->start
== NULL
)
12866 free ((char *) section
->start
);
12867 section
->start
= NULL
;
12868 section
->address
= 0;
12873 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12875 char * name
= SECTION_NAME (section
);
12876 const char * print_name
= printable_section_name (section
);
12877 bfd_size_type length
;
12881 length
= section
->sh_size
;
12884 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12887 if (section
->sh_type
== SHT_NOBITS
)
12889 /* There is no point in dumping the contents of a debugging section
12890 which has the NOBITS type - the bits in the file will be random.
12891 This can happen when a file containing a .eh_frame section is
12892 stripped with the --only-keep-debug command line option. */
12893 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12898 if (const_strneq (name
, ".gnu.linkonce.wi."))
12899 name
= ".debug_info";
12901 /* See if we know how to display the contents of this section. */
12902 for (i
= 0; i
< max
; i
++)
12903 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12904 || (i
== line
&& const_strneq (name
, ".debug_line."))
12905 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12907 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12908 int secondary
= (section
!= find_section (name
));
12911 free_debug_section ((enum dwarf_section_display_enum
) i
);
12913 if (i
== line
&& const_strneq (name
, ".debug_line."))
12915 else if (streq (sec
->uncompressed_name
, name
))
12916 sec
->name
= sec
->uncompressed_name
;
12918 sec
->name
= sec
->compressed_name
;
12919 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12922 /* If this debug section is part of a CU/TU set in a .dwp file,
12923 restrict load_debug_section to the sections in that set. */
12924 section_subset
= find_cu_tu_set (file
, shndx
);
12926 result
&= debug_displays
[i
].display (sec
, file
);
12928 section_subset
= NULL
;
12930 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12931 free_debug_section ((enum dwarf_section_display_enum
) i
);
12939 printf (_("Unrecognized debug section: %s\n"), print_name
);
12946 /* Set DUMP_SECTS for all sections where dumps were requested
12947 based on section name. */
12950 initialise_dumps_byname (void)
12952 struct dump_list_entry
* cur
;
12954 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12959 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12960 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12962 request_dump_bynumber (i
, cur
->type
);
12967 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12973 process_section_contents (FILE * file
)
12975 Elf_Internal_Shdr
* section
;
12981 initialise_dumps_byname ();
12983 for (i
= 0, section
= section_headers
;
12984 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12987 #ifdef SUPPORT_DISASSEMBLY
12988 if (dump_sects
[i
] & DISASS_DUMP
)
12989 disassemble_section (section
, file
);
12991 if (dump_sects
[i
] & HEX_DUMP
)
12992 dump_section_as_bytes (section
, file
, FALSE
);
12994 if (dump_sects
[i
] & RELOC_DUMP
)
12995 dump_section_as_bytes (section
, file
, TRUE
);
12997 if (dump_sects
[i
] & STRING_DUMP
)
12998 dump_section_as_strings (section
, file
);
13000 if (dump_sects
[i
] & DEBUG_DUMP
)
13001 display_debug_section (i
, section
, file
);
13004 /* Check to see if the user requested a
13005 dump of a section that does not exist. */
13006 while (i
++ < num_dump_sects
)
13008 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13012 process_mips_fpe_exception (int mask
)
13017 if (mask
& OEX_FPU_INEX
)
13018 fputs ("INEX", stdout
), first
= 0;
13019 if (mask
& OEX_FPU_UFLO
)
13020 printf ("%sUFLO", first
? "" : "|"), first
= 0;
13021 if (mask
& OEX_FPU_OFLO
)
13022 printf ("%sOFLO", first
? "" : "|"), first
= 0;
13023 if (mask
& OEX_FPU_DIV0
)
13024 printf ("%sDIV0", first
? "" : "|"), first
= 0;
13025 if (mask
& OEX_FPU_INVAL
)
13026 printf ("%sINVAL", first
? "" : "|");
13029 fputs ("0", stdout
);
13032 /* Display's the value of TAG at location P. If TAG is
13033 greater than 0 it is assumed to be an unknown tag, and
13034 a message is printed to this effect. Otherwise it is
13035 assumed that a message has already been printed.
13037 If the bottom bit of TAG is set it assumed to have a
13038 string value, otherwise it is assumed to have an integer
13041 Returns an updated P pointing to the first unread byte
13042 beyond the end of TAG's value.
13044 Reads at or beyond END will not be made. */
13046 static unsigned char *
13047 display_tag_value (int tag
,
13049 const unsigned char * const end
)
13054 printf (" Tag_unknown_%d: ", tag
);
13058 warn (_("<corrupt tag>\n"));
13062 /* PR 17531 file: 027-19978-0.004. */
13063 size_t maxlen
= (end
- p
) - 1;
13068 print_symbol ((int) maxlen
, (const char *) p
);
13069 p
+= strnlen ((char *) p
, maxlen
) + 1;
13073 printf (_("<corrupt string tag>"));
13074 p
= (unsigned char *) end
;
13082 val
= read_uleb128 (p
, &len
, end
);
13084 printf ("%ld (0x%lx)\n", val
, val
);
13091 /* ARM EABI attributes section. */
13096 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13098 const char ** table
;
13099 } arm_attr_public_tag
;
13101 static const char * arm_attr_tag_CPU_arch
[] =
13102 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13103 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13105 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13106 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13107 {"No", "Thumb-1", "Thumb-2", "Yes"};
13108 static const char * arm_attr_tag_FP_arch
[] =
13109 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13110 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13111 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13112 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13113 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13114 "NEON for ARMv8.1"};
13115 static const char * arm_attr_tag_PCS_config
[] =
13116 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13117 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13118 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13119 {"V6", "SB", "TLS", "Unused"};
13120 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13121 {"Absolute", "PC-relative", "SB-relative", "None"};
13122 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13123 {"Absolute", "PC-relative", "None"};
13124 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13125 {"None", "direct", "GOT-indirect"};
13126 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13127 {"None", "??? 1", "2", "??? 3", "4"};
13128 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13129 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13130 {"Unused", "Needed", "Sign only"};
13131 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13132 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13133 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13134 {"Unused", "Finite", "RTABI", "IEEE 754"};
13135 static const char * arm_attr_tag_ABI_enum_size
[] =
13136 {"Unused", "small", "int", "forced to int"};
13137 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13138 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13139 static const char * arm_attr_tag_ABI_VFP_args
[] =
13140 {"AAPCS", "VFP registers", "custom", "compatible"};
13141 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13142 {"AAPCS", "WMMX registers", "custom"};
13143 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13144 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13145 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13146 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13147 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13148 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13149 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13150 static const char * arm_attr_tag_FP_HP_extension
[] =
13151 {"Not Allowed", "Allowed"};
13152 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13153 {"None", "IEEE 754", "Alternative Format"};
13154 static const char * arm_attr_tag_DSP_extension
[] =
13155 {"Follow architecture", "Allowed"};
13156 static const char * arm_attr_tag_MPextension_use
[] =
13157 {"Not Allowed", "Allowed"};
13158 static const char * arm_attr_tag_DIV_use
[] =
13159 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13160 "Allowed in v7-A with integer division extension"};
13161 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13162 static const char * arm_attr_tag_Virtualization_use
[] =
13163 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13164 "TrustZone and Virtualization Extensions"};
13165 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13166 {"Not Allowed", "Allowed"};
13168 #define LOOKUP(id, name) \
13169 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13170 static arm_attr_public_tag arm_attr_public_tags
[] =
13172 {4, "CPU_raw_name", 1, NULL
},
13173 {5, "CPU_name", 1, NULL
},
13174 LOOKUP(6, CPU_arch
),
13175 {7, "CPU_arch_profile", 0, NULL
},
13176 LOOKUP(8, ARM_ISA_use
),
13177 LOOKUP(9, THUMB_ISA_use
),
13178 LOOKUP(10, FP_arch
),
13179 LOOKUP(11, WMMX_arch
),
13180 LOOKUP(12, Advanced_SIMD_arch
),
13181 LOOKUP(13, PCS_config
),
13182 LOOKUP(14, ABI_PCS_R9_use
),
13183 LOOKUP(15, ABI_PCS_RW_data
),
13184 LOOKUP(16, ABI_PCS_RO_data
),
13185 LOOKUP(17, ABI_PCS_GOT_use
),
13186 LOOKUP(18, ABI_PCS_wchar_t
),
13187 LOOKUP(19, ABI_FP_rounding
),
13188 LOOKUP(20, ABI_FP_denormal
),
13189 LOOKUP(21, ABI_FP_exceptions
),
13190 LOOKUP(22, ABI_FP_user_exceptions
),
13191 LOOKUP(23, ABI_FP_number_model
),
13192 {24, "ABI_align_needed", 0, NULL
},
13193 {25, "ABI_align_preserved", 0, NULL
},
13194 LOOKUP(26, ABI_enum_size
),
13195 LOOKUP(27, ABI_HardFP_use
),
13196 LOOKUP(28, ABI_VFP_args
),
13197 LOOKUP(29, ABI_WMMX_args
),
13198 LOOKUP(30, ABI_optimization_goals
),
13199 LOOKUP(31, ABI_FP_optimization_goals
),
13200 {32, "compatibility", 0, NULL
},
13201 LOOKUP(34, CPU_unaligned_access
),
13202 LOOKUP(36, FP_HP_extension
),
13203 LOOKUP(38, ABI_FP_16bit_format
),
13204 LOOKUP(42, MPextension_use
),
13205 LOOKUP(44, DIV_use
),
13206 LOOKUP(46, DSP_extension
),
13207 {64, "nodefaults", 0, NULL
},
13208 {65, "also_compatible_with", 0, NULL
},
13209 LOOKUP(66, T2EE_use
),
13210 {67, "conformance", 1, NULL
},
13211 LOOKUP(68, Virtualization_use
),
13212 LOOKUP(70, MPextension_use_legacy
)
13216 static unsigned char *
13217 display_arm_attribute (unsigned char * p
,
13218 const unsigned char * const end
)
13223 arm_attr_public_tag
* attr
;
13227 tag
= read_uleb128 (p
, &len
, end
);
13230 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13232 if (arm_attr_public_tags
[i
].tag
== tag
)
13234 attr
= &arm_attr_public_tags
[i
];
13241 printf (" Tag_%s: ", attr
->name
);
13242 switch (attr
->type
)
13247 case 7: /* Tag_CPU_arch_profile. */
13248 val
= read_uleb128 (p
, &len
, end
);
13252 case 0: printf (_("None\n")); break;
13253 case 'A': printf (_("Application\n")); break;
13254 case 'R': printf (_("Realtime\n")); break;
13255 case 'M': printf (_("Microcontroller\n")); break;
13256 case 'S': printf (_("Application or Realtime\n")); break;
13257 default: printf ("??? (%d)\n", val
); break;
13261 case 24: /* Tag_align_needed. */
13262 val
= read_uleb128 (p
, &len
, end
);
13266 case 0: printf (_("None\n")); break;
13267 case 1: printf (_("8-byte\n")); break;
13268 case 2: printf (_("4-byte\n")); break;
13269 case 3: printf ("??? 3\n"); break;
13272 printf (_("8-byte and up to %d-byte extended\n"),
13275 printf ("??? (%d)\n", val
);
13280 case 25: /* Tag_align_preserved. */
13281 val
= read_uleb128 (p
, &len
, end
);
13285 case 0: printf (_("None\n")); break;
13286 case 1: printf (_("8-byte, except leaf SP\n")); break;
13287 case 2: printf (_("8-byte\n")); break;
13288 case 3: printf ("??? 3\n"); break;
13291 printf (_("8-byte and up to %d-byte extended\n"),
13294 printf ("??? (%d)\n", val
);
13299 case 32: /* Tag_compatibility. */
13301 val
= read_uleb128 (p
, &len
, end
);
13303 printf (_("flag = %d, vendor = "), val
);
13306 size_t maxlen
= (end
- p
) - 1;
13308 print_symbol ((int) maxlen
, (const char *) p
);
13309 p
+= strnlen ((char *) p
, maxlen
) + 1;
13313 printf (_("<corrupt>"));
13314 p
= (unsigned char *) end
;
13320 case 64: /* Tag_nodefaults. */
13321 /* PR 17531: file: 001-505008-0.01. */
13324 printf (_("True\n"));
13327 case 65: /* Tag_also_compatible_with. */
13328 val
= read_uleb128 (p
, &len
, end
);
13330 if (val
== 6 /* Tag_CPU_arch. */)
13332 val
= read_uleb128 (p
, &len
, end
);
13334 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13335 printf ("??? (%d)\n", val
);
13337 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13341 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13346 printf (_("<unknown: %d>\n"), tag
);
13352 return display_tag_value (-1, p
, end
);
13354 return display_tag_value (0, p
, end
);
13357 assert (attr
->type
& 0x80);
13358 val
= read_uleb128 (p
, &len
, end
);
13360 type
= attr
->type
& 0x7f;
13362 printf ("??? (%d)\n", val
);
13364 printf ("%s\n", attr
->table
[val
]);
13369 return display_tag_value (tag
, p
, end
);
13372 static unsigned char *
13373 display_gnu_attribute (unsigned char * p
,
13374 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13375 const unsigned char * const end
)
13381 tag
= read_uleb128 (p
, &len
, end
);
13384 /* Tag_compatibility is the only generic GNU attribute defined at
13388 val
= read_uleb128 (p
, &len
, end
);
13391 printf (_("flag = %d, vendor = "), val
);
13394 printf (_("<corrupt>\n"));
13395 warn (_("corrupt vendor attribute\n"));
13401 size_t maxlen
= (end
- p
) - 1;
13403 print_symbol ((int) maxlen
, (const char *) p
);
13404 p
+= strnlen ((char *) p
, maxlen
) + 1;
13408 printf (_("<corrupt>"));
13409 p
= (unsigned char *) end
;
13416 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13417 return display_proc_gnu_attribute (p
, tag
, end
);
13419 return display_tag_value (tag
, p
, end
);
13422 static unsigned char *
13423 display_power_gnu_attribute (unsigned char * p
,
13425 const unsigned char * const end
)
13430 if (tag
== Tag_GNU_Power_ABI_FP
)
13432 val
= read_uleb128 (p
, &len
, end
);
13434 printf (" Tag_GNU_Power_ABI_FP: ");
13437 printf (_("<corrupt>\n"));
13442 printf ("(%#x), ", val
);
13447 printf (_("unspecified hard/soft float, "));
13450 printf (_("hard float, "));
13453 printf (_("soft float, "));
13456 printf (_("single-precision hard float, "));
13463 printf (_("unspecified long double\n"));
13466 printf (_("128-bit IBM long double\n"));
13469 printf (_("64-bit long double\n"));
13472 printf (_("128-bit IEEE long double\n"));
13478 if (tag
== Tag_GNU_Power_ABI_Vector
)
13480 val
= read_uleb128 (p
, &len
, end
);
13482 printf (" Tag_GNU_Power_ABI_Vector: ");
13485 printf (_("<corrupt>\n"));
13490 printf ("(%#x), ", val
);
13495 printf (_("unspecified\n"));
13498 printf (_("generic\n"));
13501 printf ("AltiVec\n");
13510 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13512 val
= read_uleb128 (p
, &len
, end
);
13514 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13517 printf (_("<corrupt>\n"));
13522 printf ("(%#x), ", val
);
13527 printf (_("unspecified\n"));
13530 printf ("r3/r4\n");
13533 printf (_("memory\n"));
13542 return display_tag_value (tag
& 1, p
, end
);
13545 static unsigned char *
13546 display_s390_gnu_attribute (unsigned char * p
,
13548 const unsigned char * const end
)
13553 if (tag
== Tag_GNU_S390_ABI_Vector
)
13555 val
= read_uleb128 (p
, &len
, end
);
13557 printf (" Tag_GNU_S390_ABI_Vector: ");
13562 printf (_("any\n"));
13565 printf (_("software\n"));
13568 printf (_("hardware\n"));
13571 printf ("??? (%d)\n", val
);
13577 return display_tag_value (tag
& 1, p
, end
);
13581 display_sparc_hwcaps (int mask
)
13587 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13588 fputs ("mul32", stdout
), first
= 0;
13589 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13590 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13591 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13592 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13593 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13594 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13595 if (mask
& ELF_SPARC_HWCAP_POPC
)
13596 printf ("%spopc", first
? "" : "|"), first
= 0;
13597 if (mask
& ELF_SPARC_HWCAP_VIS
)
13598 printf ("%svis", first
? "" : "|"), first
= 0;
13599 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13600 printf ("%svis2", first
? "" : "|"), first
= 0;
13601 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13602 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13603 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13604 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13605 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13606 printf ("%svis3", first
? "" : "|"), first
= 0;
13607 if (mask
& ELF_SPARC_HWCAP_HPC
)
13608 printf ("%shpc", first
? "" : "|"), first
= 0;
13609 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13610 printf ("%srandom", first
? "" : "|"), first
= 0;
13611 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13612 printf ("%strans", first
? "" : "|"), first
= 0;
13613 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13614 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13615 if (mask
& ELF_SPARC_HWCAP_IMA
)
13616 printf ("%sima", first
? "" : "|"), first
= 0;
13617 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13618 printf ("%scspare", first
? "" : "|"), first
= 0;
13621 fputc ('0', stdout
);
13622 fputc ('\n', stdout
);
13626 display_sparc_hwcaps2 (int mask
)
13632 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13633 fputs ("fjathplus", stdout
), first
= 0;
13634 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13635 printf ("%svis3b", first
? "" : "|"), first
= 0;
13636 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13637 printf ("%sadp", first
? "" : "|"), first
= 0;
13638 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13639 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13640 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13641 printf ("%smwait", first
? "" : "|"), first
= 0;
13642 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13643 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13644 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13645 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13646 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13647 printf ("%snsec", first
? "" : "|"), first
= 0;
13648 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13649 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13650 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13651 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13652 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13653 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13656 fputc ('0', stdout
);
13657 fputc ('\n', stdout
);
13660 static unsigned char *
13661 display_sparc_gnu_attribute (unsigned char * p
,
13663 const unsigned char * const end
)
13668 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13670 val
= read_uleb128 (p
, &len
, end
);
13672 printf (" Tag_GNU_Sparc_HWCAPS: ");
13673 display_sparc_hwcaps (val
);
13676 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13678 val
= read_uleb128 (p
, &len
, end
);
13680 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13681 display_sparc_hwcaps2 (val
);
13685 return display_tag_value (tag
, p
, end
);
13689 print_mips_fp_abi_value (int val
)
13693 case Val_GNU_MIPS_ABI_FP_ANY
:
13694 printf (_("Hard or soft float\n"));
13696 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13697 printf (_("Hard float (double precision)\n"));
13699 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13700 printf (_("Hard float (single precision)\n"));
13702 case Val_GNU_MIPS_ABI_FP_SOFT
:
13703 printf (_("Soft float\n"));
13705 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13706 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13708 case Val_GNU_MIPS_ABI_FP_XX
:
13709 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13711 case Val_GNU_MIPS_ABI_FP_64
:
13712 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13714 case Val_GNU_MIPS_ABI_FP_64A
:
13715 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13717 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13718 printf (_("NaN 2008 compatibility\n"));
13721 printf ("??? (%d)\n", val
);
13726 static unsigned char *
13727 display_mips_gnu_attribute (unsigned char * p
,
13729 const unsigned char * const end
)
13731 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13736 val
= read_uleb128 (p
, &len
, end
);
13738 printf (" Tag_GNU_MIPS_ABI_FP: ");
13740 print_mips_fp_abi_value (val
);
13745 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13750 val
= read_uleb128 (p
, &len
, end
);
13752 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13756 case Val_GNU_MIPS_ABI_MSA_ANY
:
13757 printf (_("Any MSA or not\n"));
13759 case Val_GNU_MIPS_ABI_MSA_128
:
13760 printf (_("128-bit MSA\n"));
13763 printf ("??? (%d)\n", val
);
13769 return display_tag_value (tag
& 1, p
, end
);
13772 static unsigned char *
13773 display_tic6x_attribute (unsigned char * p
,
13774 const unsigned char * const end
)
13780 tag
= read_uleb128 (p
, &len
, end
);
13786 val
= read_uleb128 (p
, &len
, end
);
13788 printf (" Tag_ISA: ");
13792 case C6XABI_Tag_ISA_none
:
13793 printf (_("None\n"));
13795 case C6XABI_Tag_ISA_C62X
:
13798 case C6XABI_Tag_ISA_C67X
:
13801 case C6XABI_Tag_ISA_C67XP
:
13802 printf ("C67x+\n");
13804 case C6XABI_Tag_ISA_C64X
:
13807 case C6XABI_Tag_ISA_C64XP
:
13808 printf ("C64x+\n");
13810 case C6XABI_Tag_ISA_C674X
:
13811 printf ("C674x\n");
13814 printf ("??? (%d)\n", val
);
13819 case Tag_ABI_wchar_t
:
13820 val
= read_uleb128 (p
, &len
, end
);
13822 printf (" Tag_ABI_wchar_t: ");
13826 printf (_("Not used\n"));
13829 printf (_("2 bytes\n"));
13832 printf (_("4 bytes\n"));
13835 printf ("??? (%d)\n", val
);
13840 case Tag_ABI_stack_align_needed
:
13841 val
= read_uleb128 (p
, &len
, end
);
13843 printf (" Tag_ABI_stack_align_needed: ");
13847 printf (_("8-byte\n"));
13850 printf (_("16-byte\n"));
13853 printf ("??? (%d)\n", val
);
13858 case Tag_ABI_stack_align_preserved
:
13859 val
= read_uleb128 (p
, &len
, end
);
13861 printf (" Tag_ABI_stack_align_preserved: ");
13865 printf (_("8-byte\n"));
13868 printf (_("16-byte\n"));
13871 printf ("??? (%d)\n", val
);
13877 val
= read_uleb128 (p
, &len
, end
);
13879 printf (" Tag_ABI_DSBT: ");
13883 printf (_("DSBT addressing not used\n"));
13886 printf (_("DSBT addressing used\n"));
13889 printf ("??? (%d)\n", val
);
13895 val
= read_uleb128 (p
, &len
, end
);
13897 printf (" Tag_ABI_PID: ");
13901 printf (_("Data addressing position-dependent\n"));
13904 printf (_("Data addressing position-independent, GOT near DP\n"));
13907 printf (_("Data addressing position-independent, GOT far from DP\n"));
13910 printf ("??? (%d)\n", val
);
13916 val
= read_uleb128 (p
, &len
, end
);
13918 printf (" Tag_ABI_PIC: ");
13922 printf (_("Code addressing position-dependent\n"));
13925 printf (_("Code addressing position-independent\n"));
13928 printf ("??? (%d)\n", val
);
13933 case Tag_ABI_array_object_alignment
:
13934 val
= read_uleb128 (p
, &len
, end
);
13936 printf (" Tag_ABI_array_object_alignment: ");
13940 printf (_("8-byte\n"));
13943 printf (_("4-byte\n"));
13946 printf (_("16-byte\n"));
13949 printf ("??? (%d)\n", val
);
13954 case Tag_ABI_array_object_align_expected
:
13955 val
= read_uleb128 (p
, &len
, end
);
13957 printf (" Tag_ABI_array_object_align_expected: ");
13961 printf (_("8-byte\n"));
13964 printf (_("4-byte\n"));
13967 printf (_("16-byte\n"));
13970 printf ("??? (%d)\n", val
);
13975 case Tag_ABI_compatibility
:
13977 val
= read_uleb128 (p
, &len
, end
);
13979 printf (" Tag_ABI_compatibility: ");
13980 printf (_("flag = %d, vendor = "), val
);
13983 size_t maxlen
= (end
- p
) - 1;
13985 print_symbol ((int) maxlen
, (const char *) p
);
13986 p
+= strnlen ((char *) p
, maxlen
) + 1;
13990 printf (_("<corrupt>"));
13991 p
= (unsigned char *) end
;
13997 case Tag_ABI_conformance
:
13999 printf (" Tag_ABI_conformance: \"");
14002 size_t maxlen
= (end
- p
) - 1;
14004 print_symbol ((int) maxlen
, (const char *) p
);
14005 p
+= strnlen ((char *) p
, maxlen
) + 1;
14009 printf (_("<corrupt>"));
14010 p
= (unsigned char *) end
;
14017 return display_tag_value (tag
, p
, end
);
14021 display_raw_attribute (unsigned char * p
, unsigned char * end
)
14023 unsigned long addr
= 0;
14024 size_t bytes
= end
- p
;
14031 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14033 printf (" 0x%8.8lx ", addr
);
14035 for (j
= 0; j
< 16; j
++)
14038 printf ("%2.2x", p
[j
]);
14046 for (j
= 0; j
< lbytes
; j
++)
14049 if (k
>= ' ' && k
< 0x7f)
14065 static unsigned char *
14066 display_msp430x_attribute (unsigned char * p
,
14067 const unsigned char * const end
)
14073 tag
= read_uleb128 (p
, & len
, end
);
14078 case OFBA_MSPABI_Tag_ISA
:
14079 val
= read_uleb128 (p
, &len
, end
);
14081 printf (" Tag_ISA: ");
14084 case 0: printf (_("None\n")); break;
14085 case 1: printf (_("MSP430\n")); break;
14086 case 2: printf (_("MSP430X\n")); break;
14087 default: printf ("??? (%d)\n", val
); break;
14091 case OFBA_MSPABI_Tag_Code_Model
:
14092 val
= read_uleb128 (p
, &len
, end
);
14094 printf (" Tag_Code_Model: ");
14097 case 0: printf (_("None\n")); break;
14098 case 1: printf (_("Small\n")); break;
14099 case 2: printf (_("Large\n")); break;
14100 default: printf ("??? (%d)\n", val
); break;
14104 case OFBA_MSPABI_Tag_Data_Model
:
14105 val
= read_uleb128 (p
, &len
, end
);
14107 printf (" Tag_Data_Model: ");
14110 case 0: printf (_("None\n")); break;
14111 case 1: printf (_("Small\n")); break;
14112 case 2: printf (_("Large\n")); break;
14113 case 3: printf (_("Restricted Large\n")); break;
14114 default: printf ("??? (%d)\n", val
); break;
14119 printf (_(" <unknown tag %d>: "), tag
);
14126 size_t maxlen
= (end
- p
) - 1;
14128 print_symbol ((int) maxlen
, (const char *) p
);
14129 p
+= strnlen ((char *) p
, maxlen
) + 1;
14133 printf (_("<corrupt>"));
14134 p
= (unsigned char *) end
;
14140 val
= read_uleb128 (p
, &len
, end
);
14142 printf ("%d (0x%x)\n", val
, val
);
14152 process_attributes (FILE * file
,
14153 const char * public_name
,
14154 unsigned int proc_type
,
14155 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14156 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14158 Elf_Internal_Shdr
* sect
;
14161 /* Find the section header so that we get the size. */
14162 for (i
= 0, sect
= section_headers
;
14163 i
< elf_header
.e_shnum
;
14166 unsigned char * contents
;
14169 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14172 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14173 sect
->sh_size
, _("attributes"));
14174 if (contents
== NULL
)
14180 bfd_vma section_len
;
14182 section_len
= sect
->sh_size
- 1;
14185 while (section_len
> 0)
14188 unsigned int namelen
;
14189 bfd_boolean public_section
;
14190 bfd_boolean gnu_section
;
14192 if (section_len
<= 4)
14194 error (_("Tag section ends prematurely\n"));
14197 attr_len
= byte_get (p
, 4);
14200 if (attr_len
> section_len
)
14202 error (_("Bad attribute length (%u > %u)\n"),
14203 (unsigned) attr_len
, (unsigned) section_len
);
14204 attr_len
= section_len
;
14206 /* PR 17531: file: 001-101425-0.004 */
14207 else if (attr_len
< 5)
14209 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14213 section_len
-= attr_len
;
14216 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14217 if (namelen
== 0 || namelen
>= attr_len
)
14219 error (_("Corrupt attribute section name\n"));
14223 printf (_("Attribute Section: "));
14224 print_symbol (INT_MAX
, (const char *) p
);
14227 if (public_name
&& streq ((char *) p
, public_name
))
14228 public_section
= TRUE
;
14230 public_section
= FALSE
;
14232 if (streq ((char *) p
, "gnu"))
14233 gnu_section
= TRUE
;
14235 gnu_section
= FALSE
;
14238 attr_len
-= namelen
;
14240 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14245 unsigned char * end
;
14247 /* PR binutils/17531: Safe handling of corrupt files. */
14250 error (_("Unused bytes at end of section\n"));
14256 size
= byte_get (p
, 4);
14257 if (size
> attr_len
)
14259 error (_("Bad subsection length (%u > %u)\n"),
14260 (unsigned) size
, (unsigned) attr_len
);
14263 /* PR binutils/17531: Safe handling of corrupt files. */
14266 error (_("Bad subsection length (%u < 6)\n"),
14273 end
= p
+ size
- 1;
14274 assert (end
<= contents
+ sect
->sh_size
);
14280 printf (_("File Attributes\n"));
14283 printf (_("Section Attributes:"));
14286 printf (_("Symbol Attributes:"));
14287 /* Fall through. */
14293 val
= read_uleb128 (p
, &j
, end
);
14297 printf (" %d", val
);
14302 printf (_("Unknown tag: %d\n"), tag
);
14303 public_section
= FALSE
;
14307 if (public_section
&& display_pub_attribute
!= NULL
)
14310 p
= display_pub_attribute (p
, end
);
14313 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14316 p
= display_gnu_attribute (p
,
14317 display_proc_gnu_attribute
,
14323 printf (_(" Unknown attribute:\n"));
14324 display_raw_attribute (p
, end
);
14333 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14341 process_arm_specific (FILE * file
)
14343 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14344 display_arm_attribute
, NULL
);
14348 process_power_specific (FILE * file
)
14350 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14351 display_power_gnu_attribute
);
14355 process_s390_specific (FILE * file
)
14357 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14358 display_s390_gnu_attribute
);
14362 process_sparc_specific (FILE * file
)
14364 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14365 display_sparc_gnu_attribute
);
14369 process_tic6x_specific (FILE * file
)
14371 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14372 display_tic6x_attribute
, NULL
);
14376 process_msp430x_specific (FILE * file
)
14378 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14379 display_msp430x_attribute
, NULL
);
14382 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14383 Print the Address, Access and Initial fields of an entry at VMA ADDR
14384 and return the VMA of the next entry, or -1 if there was a problem.
14385 Does not read from DATA_END or beyond. */
14388 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14389 unsigned char * data_end
)
14392 print_vma (addr
, LONG_HEX
);
14394 if (addr
< pltgot
+ 0xfff0)
14395 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14397 printf ("%10s", "");
14400 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14404 unsigned char * from
= data
+ addr
- pltgot
;
14406 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14408 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14409 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14410 return (bfd_vma
) -1;
14414 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14415 print_vma (entry
, LONG_HEX
);
14418 return addr
+ (is_32bit_elf
? 4 : 8);
14421 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14422 PLTGOT. Print the Address and Initial fields of an entry at VMA
14423 ADDR and return the VMA of the next entry. */
14426 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14429 print_vma (addr
, LONG_HEX
);
14432 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14437 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14438 print_vma (entry
, LONG_HEX
);
14440 return addr
+ (is_32bit_elf
? 4 : 8);
14444 print_mips_ases (unsigned int mask
)
14446 if (mask
& AFL_ASE_DSP
)
14447 fputs ("\n\tDSP ASE", stdout
);
14448 if (mask
& AFL_ASE_DSPR2
)
14449 fputs ("\n\tDSP R2 ASE", stdout
);
14450 if (mask
& AFL_ASE_DSPR3
)
14451 fputs ("\n\tDSP R3 ASE", stdout
);
14452 if (mask
& AFL_ASE_EVA
)
14453 fputs ("\n\tEnhanced VA Scheme", stdout
);
14454 if (mask
& AFL_ASE_MCU
)
14455 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14456 if (mask
& AFL_ASE_MDMX
)
14457 fputs ("\n\tMDMX ASE", stdout
);
14458 if (mask
& AFL_ASE_MIPS3D
)
14459 fputs ("\n\tMIPS-3D ASE", stdout
);
14460 if (mask
& AFL_ASE_MT
)
14461 fputs ("\n\tMT ASE", stdout
);
14462 if (mask
& AFL_ASE_SMARTMIPS
)
14463 fputs ("\n\tSmartMIPS ASE", stdout
);
14464 if (mask
& AFL_ASE_VIRT
)
14465 fputs ("\n\tVZ ASE", stdout
);
14466 if (mask
& AFL_ASE_MSA
)
14467 fputs ("\n\tMSA ASE", stdout
);
14468 if (mask
& AFL_ASE_MIPS16
)
14469 fputs ("\n\tMIPS16 ASE", stdout
);
14470 if (mask
& AFL_ASE_MICROMIPS
)
14471 fputs ("\n\tMICROMIPS ASE", stdout
);
14472 if (mask
& AFL_ASE_XPA
)
14473 fputs ("\n\tXPA ASE", stdout
);
14475 fprintf (stdout
, "\n\t%s", _("None"));
14476 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14477 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14481 print_mips_isa_ext (unsigned int isa_ext
)
14486 fputs (_("None"), stdout
);
14489 fputs ("RMI XLR", stdout
);
14491 case AFL_EXT_OCTEON3
:
14492 fputs ("Cavium Networks Octeon3", stdout
);
14494 case AFL_EXT_OCTEON2
:
14495 fputs ("Cavium Networks Octeon2", stdout
);
14497 case AFL_EXT_OCTEONP
:
14498 fputs ("Cavium Networks OcteonP", stdout
);
14500 case AFL_EXT_LOONGSON_3A
:
14501 fputs ("Loongson 3A", stdout
);
14503 case AFL_EXT_OCTEON
:
14504 fputs ("Cavium Networks Octeon", stdout
);
14507 fputs ("Toshiba R5900", stdout
);
14510 fputs ("MIPS R4650", stdout
);
14513 fputs ("LSI R4010", stdout
);
14516 fputs ("NEC VR4100", stdout
);
14519 fputs ("Toshiba R3900", stdout
);
14521 case AFL_EXT_10000
:
14522 fputs ("MIPS R10000", stdout
);
14525 fputs ("Broadcom SB-1", stdout
);
14528 fputs ("NEC VR4111/VR4181", stdout
);
14531 fputs ("NEC VR4120", stdout
);
14534 fputs ("NEC VR5400", stdout
);
14537 fputs ("NEC VR5500", stdout
);
14539 case AFL_EXT_LOONGSON_2E
:
14540 fputs ("ST Microelectronics Loongson 2E", stdout
);
14542 case AFL_EXT_LOONGSON_2F
:
14543 fputs ("ST Microelectronics Loongson 2F", stdout
);
14546 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14551 get_mips_reg_size (int reg_size
)
14553 return (reg_size
== AFL_REG_NONE
) ? 0
14554 : (reg_size
== AFL_REG_32
) ? 32
14555 : (reg_size
== AFL_REG_64
) ? 64
14556 : (reg_size
== AFL_REG_128
) ? 128
14561 process_mips_specific (FILE * file
)
14563 Elf_Internal_Dyn
* entry
;
14564 Elf_Internal_Shdr
*sect
= NULL
;
14565 size_t liblist_offset
= 0;
14566 size_t liblistno
= 0;
14567 size_t conflictsno
= 0;
14568 size_t options_offset
= 0;
14569 size_t conflicts_offset
= 0;
14570 size_t pltrelsz
= 0;
14572 bfd_vma pltgot
= 0;
14573 bfd_vma mips_pltgot
= 0;
14574 bfd_vma jmprel
= 0;
14575 bfd_vma local_gotno
= 0;
14576 bfd_vma gotsym
= 0;
14577 bfd_vma symtabno
= 0;
14579 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14580 display_mips_gnu_attribute
);
14582 sect
= find_section (".MIPS.abiflags");
14586 Elf_External_ABIFlags_v0
*abiflags_ext
;
14587 Elf_Internal_ABIFlags_v0 abiflags_in
;
14589 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14590 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14593 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14594 sect
->sh_size
, _("MIPS ABI Flags section"));
14597 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14598 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14599 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14600 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14601 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14602 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14603 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14604 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14605 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14606 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14607 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14609 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14610 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14611 if (abiflags_in
.isa_rev
> 1)
14612 printf ("r%d", abiflags_in
.isa_rev
);
14613 printf ("\nGPR size: %d",
14614 get_mips_reg_size (abiflags_in
.gpr_size
));
14615 printf ("\nCPR1 size: %d",
14616 get_mips_reg_size (abiflags_in
.cpr1_size
));
14617 printf ("\nCPR2 size: %d",
14618 get_mips_reg_size (abiflags_in
.cpr2_size
));
14619 fputs ("\nFP ABI: ", stdout
);
14620 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14621 fputs ("ISA Extension: ", stdout
);
14622 print_mips_isa_ext (abiflags_in
.isa_ext
);
14623 fputs ("\nASEs:", stdout
);
14624 print_mips_ases (abiflags_in
.ases
);
14625 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14626 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14627 fputc ('\n', stdout
);
14628 free (abiflags_ext
);
14633 /* We have a lot of special sections. Thanks SGI! */
14634 if (dynamic_section
== NULL
)
14635 /* No information available. */
14638 for (entry
= dynamic_section
;
14639 /* PR 17531 file: 012-50589-0.004. */
14640 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14642 switch (entry
->d_tag
)
14644 case DT_MIPS_LIBLIST
:
14646 = offset_from_vma (file
, entry
->d_un
.d_val
,
14647 liblistno
* sizeof (Elf32_External_Lib
));
14649 case DT_MIPS_LIBLISTNO
:
14650 liblistno
= entry
->d_un
.d_val
;
14652 case DT_MIPS_OPTIONS
:
14653 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14655 case DT_MIPS_CONFLICT
:
14657 = offset_from_vma (file
, entry
->d_un
.d_val
,
14658 conflictsno
* sizeof (Elf32_External_Conflict
));
14660 case DT_MIPS_CONFLICTNO
:
14661 conflictsno
= entry
->d_un
.d_val
;
14664 pltgot
= entry
->d_un
.d_ptr
;
14666 case DT_MIPS_LOCAL_GOTNO
:
14667 local_gotno
= entry
->d_un
.d_val
;
14669 case DT_MIPS_GOTSYM
:
14670 gotsym
= entry
->d_un
.d_val
;
14672 case DT_MIPS_SYMTABNO
:
14673 symtabno
= entry
->d_un
.d_val
;
14675 case DT_MIPS_PLTGOT
:
14676 mips_pltgot
= entry
->d_un
.d_ptr
;
14679 pltrel
= entry
->d_un
.d_val
;
14682 pltrelsz
= entry
->d_un
.d_val
;
14685 jmprel
= entry
->d_un
.d_ptr
;
14691 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14693 Elf32_External_Lib
* elib
;
14696 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14698 sizeof (Elf32_External_Lib
),
14699 _("liblist section data"));
14702 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14703 (unsigned long) liblistno
);
14704 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14707 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14714 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14715 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14716 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14717 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14718 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14720 tmp
= gmtime (&atime
);
14721 snprintf (timebuf
, sizeof (timebuf
),
14722 "%04u-%02u-%02uT%02u:%02u:%02u",
14723 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14724 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14726 printf ("%3lu: ", (unsigned long) cnt
);
14727 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14728 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14730 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14731 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14732 liblist
.l_version
);
14734 if (liblist
.l_flags
== 0)
14738 static const struct
14745 { " EXACT_MATCH", LL_EXACT_MATCH
},
14746 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14747 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14748 { " EXPORTS", LL_EXPORTS
},
14749 { " DELAY_LOAD", LL_DELAY_LOAD
},
14750 { " DELTA", LL_DELTA
}
14752 int flags
= liblist
.l_flags
;
14755 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14756 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14758 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14759 flags
^= l_flags_vals
[fcnt
].bit
;
14762 printf (" %#x", (unsigned int) flags
);
14772 if (options_offset
!= 0)
14774 Elf_External_Options
* eopt
;
14775 Elf_Internal_Options
* iopt
;
14776 Elf_Internal_Options
* option
;
14779 sect
= section_headers
;
14781 /* Find the section header so that we get the size. */
14782 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14783 /* PR 17533 file: 012-277276-0.004. */
14786 error (_("No MIPS_OPTIONS header found\n"));
14790 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14791 sect
->sh_size
, _("options"));
14794 iopt
= (Elf_Internal_Options
*)
14795 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14798 error (_("Out of memory allocating space for MIPS options\n"));
14805 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14807 Elf_External_Options
* eoption
;
14809 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14811 option
->kind
= BYTE_GET (eoption
->kind
);
14812 option
->size
= BYTE_GET (eoption
->size
);
14813 option
->section
= BYTE_GET (eoption
->section
);
14814 option
->info
= BYTE_GET (eoption
->info
);
14816 /* PR 17531: file: ffa0fa3b. */
14817 if (option
->size
< sizeof (* eopt
)
14818 || offset
+ option
->size
> sect
->sh_size
)
14820 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14823 offset
+= option
->size
;
14829 printf (_("\nSection '%s' contains %d entries:\n"),
14830 printable_section_name (sect
), cnt
);
14839 switch (option
->kind
)
14842 /* This shouldn't happen. */
14843 printf (" NULL %d %lx", option
->section
, option
->info
);
14846 printf (" REGINFO ");
14847 if (elf_header
.e_machine
== EM_MIPS
)
14850 Elf32_External_RegInfo
* ereg
;
14851 Elf32_RegInfo reginfo
;
14853 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14854 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14855 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14856 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14857 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14858 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14859 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14861 printf ("GPR %08lx GP 0x%lx\n",
14862 reginfo
.ri_gprmask
,
14863 (unsigned long) reginfo
.ri_gp_value
);
14864 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14865 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14866 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14871 Elf64_External_RegInfo
* ereg
;
14872 Elf64_Internal_RegInfo reginfo
;
14874 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14875 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14876 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14877 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14878 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14879 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14880 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14882 printf ("GPR %08lx GP 0x",
14883 reginfo
.ri_gprmask
);
14884 printf_vma (reginfo
.ri_gp_value
);
14887 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14888 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14889 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14893 case ODK_EXCEPTIONS
:
14894 fputs (" EXCEPTIONS fpe_min(", stdout
);
14895 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14896 fputs (") fpe_max(", stdout
);
14897 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14898 fputs (")", stdout
);
14900 if (option
->info
& OEX_PAGE0
)
14901 fputs (" PAGE0", stdout
);
14902 if (option
->info
& OEX_SMM
)
14903 fputs (" SMM", stdout
);
14904 if (option
->info
& OEX_FPDBUG
)
14905 fputs (" FPDBUG", stdout
);
14906 if (option
->info
& OEX_DISMISS
)
14907 fputs (" DISMISS", stdout
);
14910 fputs (" PAD ", stdout
);
14911 if (option
->info
& OPAD_PREFIX
)
14912 fputs (" PREFIX", stdout
);
14913 if (option
->info
& OPAD_POSTFIX
)
14914 fputs (" POSTFIX", stdout
);
14915 if (option
->info
& OPAD_SYMBOL
)
14916 fputs (" SYMBOL", stdout
);
14919 fputs (" HWPATCH ", stdout
);
14920 if (option
->info
& OHW_R4KEOP
)
14921 fputs (" R4KEOP", stdout
);
14922 if (option
->info
& OHW_R8KPFETCH
)
14923 fputs (" R8KPFETCH", stdout
);
14924 if (option
->info
& OHW_R5KEOP
)
14925 fputs (" R5KEOP", stdout
);
14926 if (option
->info
& OHW_R5KCVTL
)
14927 fputs (" R5KCVTL", stdout
);
14930 fputs (" FILL ", stdout
);
14931 /* XXX Print content of info word? */
14934 fputs (" TAGS ", stdout
);
14935 /* XXX Print content of info word? */
14938 fputs (" HWAND ", stdout
);
14939 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14940 fputs (" R4KEOP_CHECKED", stdout
);
14941 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14942 fputs (" R4KEOP_CLEAN", stdout
);
14945 fputs (" HWOR ", stdout
);
14946 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14947 fputs (" R4KEOP_CHECKED", stdout
);
14948 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14949 fputs (" R4KEOP_CLEAN", stdout
);
14952 printf (" GP_GROUP %#06lx self-contained %#06lx",
14953 option
->info
& OGP_GROUP
,
14954 (option
->info
& OGP_SELF
) >> 16);
14957 printf (" IDENT %#06lx self-contained %#06lx",
14958 option
->info
& OGP_GROUP
,
14959 (option
->info
& OGP_SELF
) >> 16);
14962 /* This shouldn't happen. */
14963 printf (" %3d ??? %d %lx",
14964 option
->kind
, option
->section
, option
->info
);
14968 len
= sizeof (* eopt
);
14969 while (len
< option
->size
)
14971 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14973 if (ISPRINT (datum
))
14974 printf ("%c", datum
);
14976 printf ("\\%03o", datum
);
14979 fputs ("\n", stdout
);
14981 offset
+= option
->size
;
14989 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14991 Elf32_Conflict
* iconf
;
14994 if (dynamic_symbols
== NULL
)
14996 error (_("conflict list found without a dynamic symbol table\n"));
15000 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15003 error (_("Out of memory allocating space for dynamic conflicts\n"));
15009 Elf32_External_Conflict
* econf32
;
15011 econf32
= (Elf32_External_Conflict
*)
15012 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15013 sizeof (* econf32
), _("conflict"));
15017 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15018 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15024 Elf64_External_Conflict
* econf64
;
15026 econf64
= (Elf64_External_Conflict
*)
15027 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15028 sizeof (* econf64
), _("conflict"));
15032 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15033 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15038 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15039 (unsigned long) conflictsno
);
15040 puts (_(" Num: Index Value Name"));
15042 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15044 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15046 if (iconf
[cnt
] >= num_dynamic_syms
)
15047 printf (_("<corrupt symbol index>"));
15050 Elf_Internal_Sym
* psym
;
15052 psym
= & dynamic_symbols
[iconf
[cnt
]];
15053 print_vma (psym
->st_value
, FULL_HEX
);
15055 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15056 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15058 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15066 if (pltgot
!= 0 && local_gotno
!= 0)
15068 bfd_vma ent
, local_end
, global_end
;
15070 unsigned char * data
;
15071 unsigned char * data_end
;
15075 addr_size
= (is_32bit_elf
? 4 : 8);
15076 local_end
= pltgot
+ local_gotno
* addr_size
;
15078 /* PR binutils/17533 file: 012-111227-0.004 */
15079 if (symtabno
< gotsym
)
15081 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15082 (unsigned long) gotsym
, (unsigned long) symtabno
);
15086 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15087 /* PR 17531: file: 54c91a34. */
15088 if (global_end
< local_end
)
15090 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15094 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15095 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15096 global_end
- pltgot
, 1,
15097 _("Global Offset Table data"));
15100 data_end
= data
+ (global_end
- pltgot
);
15102 printf (_("\nPrimary GOT:\n"));
15103 printf (_(" Canonical gp value: "));
15104 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15107 printf (_(" Reserved entries:\n"));
15108 printf (_(" %*s %10s %*s Purpose\n"),
15109 addr_size
* 2, _("Address"), _("Access"),
15110 addr_size
* 2, _("Initial"));
15111 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15112 printf (_(" Lazy resolver\n"));
15113 if (ent
== (bfd_vma
) -1)
15114 goto got_print_fail
;
15116 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15117 >> (addr_size
* 8 - 1)) != 0)
15119 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15120 printf (_(" Module pointer (GNU extension)\n"));
15121 if (ent
== (bfd_vma
) -1)
15122 goto got_print_fail
;
15126 if (ent
< local_end
)
15128 printf (_(" Local entries:\n"));
15129 printf (" %*s %10s %*s\n",
15130 addr_size
* 2, _("Address"), _("Access"),
15131 addr_size
* 2, _("Initial"));
15132 while (ent
< local_end
)
15134 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15136 if (ent
== (bfd_vma
) -1)
15137 goto got_print_fail
;
15142 if (gotsym
< symtabno
)
15146 printf (_(" Global entries:\n"));
15147 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15148 addr_size
* 2, _("Address"),
15150 addr_size
* 2, _("Initial"),
15151 addr_size
* 2, _("Sym.Val."),
15153 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15154 _("Ndx"), _("Name"));
15156 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15158 for (i
= gotsym
; i
< symtabno
; i
++)
15160 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15163 if (dynamic_symbols
== NULL
)
15164 printf (_("<no dynamic symbols>"));
15165 else if (i
< num_dynamic_syms
)
15167 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15169 print_vma (psym
->st_value
, LONG_HEX
);
15170 printf (" %-7s %3s ",
15171 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15172 get_symbol_index_type (psym
->st_shndx
));
15174 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15175 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15177 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15180 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15181 (unsigned long) i
);
15184 if (ent
== (bfd_vma
) -1)
15195 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15198 size_t offset
, rel_offset
;
15199 unsigned long count
, i
;
15200 unsigned char * data
;
15201 int addr_size
, sym_width
;
15202 Elf_Internal_Rela
* rels
;
15204 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15205 if (pltrel
== DT_RELA
)
15207 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15212 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15217 addr_size
= (is_32bit_elf
? 4 : 8);
15218 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15220 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15221 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15222 1, _("Procedure Linkage Table data"));
15226 printf ("\nPLT GOT:\n\n");
15227 printf (_(" Reserved entries:\n"));
15228 printf (_(" %*s %*s Purpose\n"),
15229 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15230 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15231 printf (_(" PLT lazy resolver\n"));
15232 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15233 printf (_(" Module pointer\n"));
15236 printf (_(" Entries:\n"));
15237 printf (" %*s %*s %*s %-7s %3s %s\n",
15238 addr_size
* 2, _("Address"),
15239 addr_size
* 2, _("Initial"),
15240 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15241 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15242 for (i
= 0; i
< count
; i
++)
15244 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15246 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15249 if (idx
>= num_dynamic_syms
)
15250 printf (_("<corrupt symbol index: %lu>"), idx
);
15253 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15255 print_vma (psym
->st_value
, LONG_HEX
);
15256 printf (" %-7s %3s ",
15257 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15258 get_symbol_index_type (psym
->st_shndx
));
15259 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15260 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15262 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15277 process_nds32_specific (FILE * file
)
15279 Elf_Internal_Shdr
*sect
= NULL
;
15281 sect
= find_section (".nds32_e_flags");
15284 unsigned int *flag
;
15286 printf ("\nNDS32 elf flags section:\n");
15287 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15288 sect
->sh_size
, _("NDS32 elf flags section"));
15290 switch ((*flag
) & 0x3)
15293 printf ("(VEC_SIZE):\tNo entry.\n");
15296 printf ("(VEC_SIZE):\t4 bytes\n");
15299 printf ("(VEC_SIZE):\t16 bytes\n");
15302 printf ("(VEC_SIZE):\treserved\n");
15311 process_gnu_liblist (FILE * file
)
15313 Elf_Internal_Shdr
* section
;
15314 Elf_Internal_Shdr
* string_sec
;
15315 Elf32_External_Lib
* elib
;
15317 size_t strtab_size
;
15324 for (i
= 0, section
= section_headers
;
15325 i
< elf_header
.e_shnum
;
15328 switch (section
->sh_type
)
15330 case SHT_GNU_LIBLIST
:
15331 if (section
->sh_link
>= elf_header
.e_shnum
)
15334 elib
= (Elf32_External_Lib
*)
15335 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15336 _("liblist section data"));
15340 string_sec
= section_headers
+ section
->sh_link
;
15342 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15343 string_sec
->sh_size
,
15344 _("liblist string table"));
15346 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15352 strtab_size
= string_sec
->sh_size
;
15354 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15355 printable_section_name (section
),
15356 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15358 puts (_(" Library Time Stamp Checksum Version Flags"));
15360 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15368 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15369 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15370 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15371 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15372 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15374 tmp
= gmtime (&atime
);
15375 snprintf (timebuf
, sizeof (timebuf
),
15376 "%04u-%02u-%02uT%02u:%02u:%02u",
15377 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15378 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15380 printf ("%3lu: ", (unsigned long) cnt
);
15382 printf ("%-20s", liblist
.l_name
< strtab_size
15383 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15385 printf ("%-20.20s", liblist
.l_name
< strtab_size
15386 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15387 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15388 liblist
.l_version
, liblist
.l_flags
);
15399 static const char *
15400 get_note_type (unsigned e_type
)
15402 static char buff
[64];
15404 if (elf_header
.e_type
== ET_CORE
)
15408 return _("NT_AUXV (auxiliary vector)");
15410 return _("NT_PRSTATUS (prstatus structure)");
15412 return _("NT_FPREGSET (floating point registers)");
15414 return _("NT_PRPSINFO (prpsinfo structure)");
15415 case NT_TASKSTRUCT
:
15416 return _("NT_TASKSTRUCT (task structure)");
15418 return _("NT_PRXFPREG (user_xfpregs structure)");
15420 return _("NT_PPC_VMX (ppc Altivec registers)");
15422 return _("NT_PPC_VSX (ppc VSX registers)");
15424 return _("NT_386_TLS (x86 TLS information)");
15425 case NT_386_IOPERM
:
15426 return _("NT_386_IOPERM (x86 I/O permissions)");
15427 case NT_X86_XSTATE
:
15428 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15429 case NT_S390_HIGH_GPRS
:
15430 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15431 case NT_S390_TIMER
:
15432 return _("NT_S390_TIMER (s390 timer register)");
15433 case NT_S390_TODCMP
:
15434 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15435 case NT_S390_TODPREG
:
15436 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15438 return _("NT_S390_CTRS (s390 control registers)");
15439 case NT_S390_PREFIX
:
15440 return _("NT_S390_PREFIX (s390 prefix register)");
15441 case NT_S390_LAST_BREAK
:
15442 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15443 case NT_S390_SYSTEM_CALL
:
15444 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15446 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15447 case NT_S390_VXRS_LOW
:
15448 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15449 case NT_S390_VXRS_HIGH
:
15450 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15452 return _("NT_ARM_VFP (arm VFP registers)");
15454 return _("NT_ARM_TLS (AArch TLS registers)");
15455 case NT_ARM_HW_BREAK
:
15456 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15457 case NT_ARM_HW_WATCH
:
15458 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15460 return _("NT_PSTATUS (pstatus structure)");
15462 return _("NT_FPREGS (floating point registers)");
15464 return _("NT_PSINFO (psinfo structure)");
15466 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15468 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15469 case NT_WIN32PSTATUS
:
15470 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15472 return _("NT_SIGINFO (siginfo_t data)");
15474 return _("NT_FILE (mapped files)");
15482 return _("NT_VERSION (version)");
15484 return _("NT_ARCH (architecture)");
15489 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15494 print_core_note (Elf_Internal_Note
*pnote
)
15496 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15497 bfd_vma count
, page_size
;
15498 unsigned char *descdata
, *filenames
, *descend
;
15500 if (pnote
->type
!= NT_FILE
)
15506 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15507 /* Still "successful". */
15512 if (pnote
->descsz
< 2 * addr_size
)
15514 printf (_(" Malformed note - too short for header\n"));
15518 descdata
= (unsigned char *) pnote
->descdata
;
15519 descend
= descdata
+ pnote
->descsz
;
15521 if (descdata
[pnote
->descsz
- 1] != '\0')
15523 printf (_(" Malformed note - does not end with \\0\n"));
15527 count
= byte_get (descdata
, addr_size
);
15528 descdata
+= addr_size
;
15530 page_size
= byte_get (descdata
, addr_size
);
15531 descdata
+= addr_size
;
15533 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15535 printf (_(" Malformed note - too short for supplied file count\n"));
15539 printf (_(" Page size: "));
15540 print_vma (page_size
, DEC
);
15543 printf (_(" %*s%*s%*s\n"),
15544 (int) (2 + 2 * addr_size
), _("Start"),
15545 (int) (4 + 2 * addr_size
), _("End"),
15546 (int) (4 + 2 * addr_size
), _("Page Offset"));
15547 filenames
= descdata
+ count
* 3 * addr_size
;
15548 while (count
-- > 0)
15550 bfd_vma start
, end
, file_ofs
;
15552 if (filenames
== descend
)
15554 printf (_(" Malformed note - filenames end too early\n"));
15558 start
= byte_get (descdata
, addr_size
);
15559 descdata
+= addr_size
;
15560 end
= byte_get (descdata
, addr_size
);
15561 descdata
+= addr_size
;
15562 file_ofs
= byte_get (descdata
, addr_size
);
15563 descdata
+= addr_size
;
15566 print_vma (start
, FULL_HEX
);
15568 print_vma (end
, FULL_HEX
);
15570 print_vma (file_ofs
, FULL_HEX
);
15571 printf ("\n %s\n", filenames
);
15573 filenames
+= 1 + strlen ((char *) filenames
);
15579 static const char *
15580 get_gnu_elf_note_type (unsigned e_type
)
15582 static char buff
[64];
15586 case NT_GNU_ABI_TAG
:
15587 return _("NT_GNU_ABI_TAG (ABI version tag)");
15589 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15590 case NT_GNU_BUILD_ID
:
15591 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15592 case NT_GNU_GOLD_VERSION
:
15593 return _("NT_GNU_GOLD_VERSION (gold version)");
15598 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15603 print_gnu_note (Elf_Internal_Note
*pnote
)
15605 switch (pnote
->type
)
15607 case NT_GNU_BUILD_ID
:
15611 printf (_(" Build ID: "));
15612 for (i
= 0; i
< pnote
->descsz
; ++i
)
15613 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15618 case NT_GNU_ABI_TAG
:
15620 unsigned long os
, major
, minor
, subminor
;
15621 const char *osname
;
15623 /* PR 17531: file: 030-599401-0.004. */
15624 if (pnote
->descsz
< 16)
15626 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15630 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15631 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15632 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15633 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15637 case GNU_ABI_TAG_LINUX
:
15640 case GNU_ABI_TAG_HURD
:
15643 case GNU_ABI_TAG_SOLARIS
:
15644 osname
= "Solaris";
15646 case GNU_ABI_TAG_FREEBSD
:
15647 osname
= "FreeBSD";
15649 case GNU_ABI_TAG_NETBSD
:
15652 case GNU_ABI_TAG_SYLLABLE
:
15653 osname
= "Syllable";
15655 case GNU_ABI_TAG_NACL
:
15659 osname
= "Unknown";
15663 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15664 major
, minor
, subminor
);
15668 case NT_GNU_GOLD_VERSION
:
15672 printf (_(" Version: "));
15673 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15674 printf ("%c", pnote
->descdata
[i
]);
15683 static const char *
15684 get_v850_elf_note_type (enum v850_notes n_type
)
15686 static char buff
[64];
15690 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15691 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15692 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15693 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15694 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15695 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15697 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15703 print_v850_note (Elf_Internal_Note
* pnote
)
15707 if (pnote
->descsz
!= 4)
15709 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15713 printf (_("not set\n"));
15717 switch (pnote
->type
)
15719 case V850_NOTE_ALIGNMENT
:
15722 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15723 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15727 case V850_NOTE_DATA_SIZE
:
15730 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15731 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15735 case V850_NOTE_FPU_INFO
:
15738 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15739 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15743 case V850_NOTE_MMU_INFO
:
15744 case V850_NOTE_CACHE_INFO
:
15745 case V850_NOTE_SIMD_INFO
:
15746 if (val
== EF_RH850_SIMD
)
15748 printf (_("yes\n"));
15754 /* An 'unknown note type' message will already have been displayed. */
15758 printf (_("unknown value: %x\n"), val
);
15763 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15765 unsigned int version
;
15767 switch (pnote
->type
)
15769 case NT_NETBSD_IDENT
:
15770 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15771 if ((version
/ 10000) % 100)
15772 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15773 version
, version
/ 100000000, (version
/ 1000000) % 100,
15774 (version
/ 10000) % 100 > 26 ? "Z" : "",
15775 'A' + (version
/ 10000) % 26);
15777 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15778 version
, version
/ 100000000, (version
/ 1000000) % 100,
15779 (version
/ 100) % 100);
15782 case NT_NETBSD_MARCH
:
15783 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15791 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15796 static const char *
15797 get_freebsd_elfcore_note_type (unsigned e_type
)
15801 case NT_FREEBSD_THRMISC
:
15802 return _("NT_THRMISC (thrmisc structure)");
15803 case NT_FREEBSD_PROCSTAT_PROC
:
15804 return _("NT_PROCSTAT_PROC (proc data)");
15805 case NT_FREEBSD_PROCSTAT_FILES
:
15806 return _("NT_PROCSTAT_FILES (files data)");
15807 case NT_FREEBSD_PROCSTAT_VMMAP
:
15808 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15809 case NT_FREEBSD_PROCSTAT_GROUPS
:
15810 return _("NT_PROCSTAT_GROUPS (groups data)");
15811 case NT_FREEBSD_PROCSTAT_UMASK
:
15812 return _("NT_PROCSTAT_UMASK (umask data)");
15813 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15814 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15815 case NT_FREEBSD_PROCSTAT_OSREL
:
15816 return _("NT_PROCSTAT_OSREL (osreldate data)");
15817 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15818 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15819 case NT_FREEBSD_PROCSTAT_AUXV
:
15820 return _("NT_PROCSTAT_AUXV (auxv data)");
15822 return get_note_type (e_type
);
15825 static const char *
15826 get_netbsd_elfcore_note_type (unsigned e_type
)
15828 static char buff
[64];
15830 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15832 /* NetBSD core "procinfo" structure. */
15833 return _("NetBSD procinfo structure");
15836 /* As of Jan 2002 there are no other machine-independent notes
15837 defined for NetBSD core files. If the note type is less
15838 than the start of the machine-dependent note types, we don't
15841 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15843 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15847 switch (elf_header
.e_machine
)
15849 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15850 and PT_GETFPREGS == mach+2. */
15855 case EM_SPARC32PLUS
:
15859 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15860 return _("PT_GETREGS (reg structure)");
15861 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15862 return _("PT_GETFPREGS (fpreg structure)");
15868 /* On all other arch's, PT_GETREGS == mach+1 and
15869 PT_GETFPREGS == mach+3. */
15873 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15874 return _("PT_GETREGS (reg structure)");
15875 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15876 return _("PT_GETFPREGS (fpreg structure)");
15882 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15883 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15887 static const char *
15888 get_stapsdt_note_type (unsigned e_type
)
15890 static char buff
[64];
15895 return _("NT_STAPSDT (SystemTap probe descriptors)");
15901 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15906 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15908 int addr_size
= is_32bit_elf
? 4 : 8;
15909 char *data
= pnote
->descdata
;
15910 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15911 bfd_vma pc
, base_addr
, semaphore
;
15912 char *provider
, *probe
, *arg_fmt
;
15914 pc
= byte_get ((unsigned char *) data
, addr_size
);
15916 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15918 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15922 data
+= strlen (data
) + 1;
15924 data
+= strlen (data
) + 1;
15926 data
+= strlen (data
) + 1;
15928 printf (_(" Provider: %s\n"), provider
);
15929 printf (_(" Name: %s\n"), probe
);
15930 printf (_(" Location: "));
15931 print_vma (pc
, FULL_HEX
);
15932 printf (_(", Base: "));
15933 print_vma (base_addr
, FULL_HEX
);
15934 printf (_(", Semaphore: "));
15935 print_vma (semaphore
, FULL_HEX
);
15937 printf (_(" Arguments: %s\n"), arg_fmt
);
15939 return data
== data_end
;
15942 static const char *
15943 get_ia64_vms_note_type (unsigned e_type
)
15945 static char buff
[64];
15950 return _("NT_VMS_MHD (module header)");
15952 return _("NT_VMS_LNM (language name)");
15954 return _("NT_VMS_SRC (source files)");
15956 return "NT_VMS_TITLE";
15958 return _("NT_VMS_EIDC (consistency check)");
15959 case NT_VMS_FPMODE
:
15960 return _("NT_VMS_FPMODE (FP mode)");
15961 case NT_VMS_LINKTIME
:
15962 return "NT_VMS_LINKTIME";
15963 case NT_VMS_IMGNAM
:
15964 return _("NT_VMS_IMGNAM (image name)");
15966 return _("NT_VMS_IMGID (image id)");
15967 case NT_VMS_LINKID
:
15968 return _("NT_VMS_LINKID (link id)");
15969 case NT_VMS_IMGBID
:
15970 return _("NT_VMS_IMGBID (build id)");
15971 case NT_VMS_GSTNAM
:
15972 return _("NT_VMS_GSTNAM (sym table name)");
15973 case NT_VMS_ORIG_DYN
:
15974 return "NT_VMS_ORIG_DYN";
15975 case NT_VMS_PATCHTIME
:
15976 return "NT_VMS_PATCHTIME";
15978 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15984 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15986 switch (pnote
->type
)
15989 if (pnote
->descsz
> 36)
15991 size_t l
= strlen (pnote
->descdata
+ 34);
15992 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15993 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15994 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15995 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15998 printf (_(" Invalid size\n"));
16001 printf (_(" Language: %s\n"), pnote
->descdata
);
16004 case NT_VMS_FPMODE
:
16005 printf (_(" Floating Point mode: "));
16006 printf ("0x%016" BFD_VMA_FMT
"x\n",
16007 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16009 case NT_VMS_LINKTIME
:
16010 printf (_(" Link time: "));
16012 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16015 case NT_VMS_PATCHTIME
:
16016 printf (_(" Patch time: "));
16018 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16021 case NT_VMS_ORIG_DYN
:
16022 printf (_(" Major id: %u, minor id: %u\n"),
16023 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16024 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16025 printf (_(" Last modified : "));
16027 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16028 printf (_("\n Link flags : "));
16029 printf ("0x%016" BFD_VMA_FMT
"x\n",
16030 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16031 printf (_(" Header flags: 0x%08x\n"),
16032 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16033 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16036 case NT_VMS_IMGNAM
:
16037 printf (_(" Image name: %s\n"), pnote
->descdata
);
16039 case NT_VMS_GSTNAM
:
16040 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16043 printf (_(" Image id: %s\n"), pnote
->descdata
);
16045 case NT_VMS_LINKID
:
16046 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16054 /* Note that by the ELF standard, the name field is already null byte
16055 terminated, and namesz includes the terminating null byte.
16056 I.E. the value of namesz for the name "FSF" is 4.
16058 If the value of namesz is zero, there is no name present. */
16060 process_note (Elf_Internal_Note
* pnote
)
16062 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16065 if (pnote
->namesz
== 0)
16066 /* If there is no note name, then use the default set of
16067 note type strings. */
16068 nt
= get_note_type (pnote
->type
);
16070 else if (const_strneq (pnote
->namedata
, "GNU"))
16071 /* GNU-specific object file notes. */
16072 nt
= get_gnu_elf_note_type (pnote
->type
);
16074 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16075 /* FreeBSD-specific core file notes. */
16076 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16078 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16079 /* NetBSD-specific core file notes. */
16080 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16082 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16083 /* NetBSD-specific core file notes. */
16084 return process_netbsd_elf_note (pnote
);
16086 else if (strneq (pnote
->namedata
, "SPU/", 4))
16088 /* SPU-specific core file notes. */
16089 nt
= pnote
->namedata
+ 4;
16093 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16094 /* VMS/ia64-specific file notes. */
16095 nt
= get_ia64_vms_note_type (pnote
->type
);
16097 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16098 nt
= get_stapsdt_note_type (pnote
->type
);
16101 /* Don't recognize this note name; just use the default set of
16102 note type strings. */
16103 nt
= get_note_type (pnote
->type
);
16105 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
16107 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16108 return print_ia64_vms_note (pnote
);
16109 else if (const_strneq (pnote
->namedata
, "GNU"))
16110 return print_gnu_note (pnote
);
16111 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16112 return print_stapsdt_note (pnote
);
16113 else if (const_strneq (pnote
->namedata
, "CORE"))
16114 return print_core_note (pnote
);
16121 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
16123 Elf_External_Note
* pnotes
;
16124 Elf_External_Note
* external
;
16131 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16133 if (pnotes
== NULL
)
16138 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16139 (unsigned long) offset
, (unsigned long) length
);
16140 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16142 end
= (char *) pnotes
+ length
;
16143 while ((char *) external
< end
)
16145 Elf_Internal_Note inote
;
16148 char * temp
= NULL
;
16149 size_t data_remaining
= end
- (char *) external
;
16151 if (!is_ia64_vms ())
16153 /* PR binutils/15191
16154 Make sure that there is enough data to read. */
16155 min_notesz
= offsetof (Elf_External_Note
, name
);
16156 if (data_remaining
< min_notesz
)
16158 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16159 (int) data_remaining
);
16162 inote
.type
= BYTE_GET (external
->type
);
16163 inote
.namesz
= BYTE_GET (external
->namesz
);
16164 inote
.namedata
= external
->name
;
16165 inote
.descsz
= BYTE_GET (external
->descsz
);
16166 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16167 /* PR 17531: file: 3443835e. */
16168 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16170 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16171 inote
.descdata
= inote
.namedata
;
16175 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16176 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16180 Elf64_External_VMS_Note
*vms_external
;
16182 /* PR binutils/15191
16183 Make sure that there is enough data to read. */
16184 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16185 if (data_remaining
< min_notesz
)
16187 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16188 (int) data_remaining
);
16192 vms_external
= (Elf64_External_VMS_Note
*) external
;
16193 inote
.type
= BYTE_GET (vms_external
->type
);
16194 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16195 inote
.namedata
= vms_external
->name
;
16196 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16197 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16198 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16199 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16202 if (inote
.descdata
< (char *) external
+ min_notesz
16203 || next
< (char *) external
+ min_notesz
16204 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16205 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16206 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16207 || data_remaining
< (size_t)(next
- (char *) external
))
16209 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16210 (unsigned long) ((char *) external
- (char *) pnotes
));
16211 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16212 inote
.type
, inote
.namesz
, inote
.descsz
);
16216 external
= (Elf_External_Note
*) next
;
16218 /* Verify that name is null terminated. It appears that at least
16219 one version of Linux (RedHat 6.0) generates corefiles that don't
16220 comply with the ELF spec by failing to include the null byte in
16222 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16224 temp
= (char *) malloc (inote
.namesz
+ 1);
16227 error (_("Out of memory allocating space for inote name\n"));
16232 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16233 temp
[inote
.namesz
] = 0;
16235 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16236 inote
.namedata
= temp
;
16239 res
&= process_note (& inote
);
16254 process_corefile_note_segments (FILE * file
)
16256 Elf_Internal_Phdr
* segment
;
16260 if (! get_program_headers (file
))
16263 for (i
= 0, segment
= program_headers
;
16264 i
< elf_header
.e_phnum
;
16267 if (segment
->p_type
== PT_NOTE
)
16268 res
&= process_corefile_note_segment (file
,
16269 (bfd_vma
) segment
->p_offset
,
16270 (bfd_vma
) segment
->p_filesz
);
16277 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16279 Elf_External_Note
* pnotes
;
16280 Elf_External_Note
* external
;
16287 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16289 if (pnotes
== NULL
)
16293 end
= (char*) pnotes
+ length
;
16295 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16296 (unsigned long) offset
, (unsigned long) length
);
16298 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16300 Elf_External_Note
* next
;
16301 Elf_Internal_Note inote
;
16303 inote
.type
= BYTE_GET (external
->type
);
16304 inote
.namesz
= BYTE_GET (external
->namesz
);
16305 inote
.namedata
= external
->name
;
16306 inote
.descsz
= BYTE_GET (external
->descsz
);
16307 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16308 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16310 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16312 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16313 inote
.descdata
= inote
.namedata
;
16317 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16319 if ( ((char *) next
> end
)
16320 || ((char *) next
< (char *) pnotes
))
16322 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16323 (unsigned long) ((char *) external
- (char *) pnotes
));
16324 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16325 inote
.type
, inote
.namesz
, inote
.descsz
);
16331 /* Prevent out-of-bounds indexing. */
16332 if ( inote
.namedata
+ inote
.namesz
> end
16333 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16335 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16336 (unsigned long) ((char *) external
- (char *) pnotes
));
16337 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16338 inote
.type
, inote
.namesz
, inote
.descsz
);
16342 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16344 if (! print_v850_note (& inote
))
16347 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16348 inote
.namesz
, inote
.descsz
);
16358 process_note_sections (FILE * file
)
16360 Elf_Internal_Shdr
* section
;
16365 for (i
= 0, section
= section_headers
;
16366 i
< elf_header
.e_shnum
&& section
!= NULL
;
16369 if (section
->sh_type
== SHT_NOTE
)
16371 res
&= process_corefile_note_segment (file
,
16372 (bfd_vma
) section
->sh_offset
,
16373 (bfd_vma
) section
->sh_size
);
16377 if (( elf_header
.e_machine
== EM_V800
16378 || elf_header
.e_machine
== EM_V850
16379 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16380 && section
->sh_type
== SHT_RENESAS_INFO
)
16382 res
&= process_v850_notes (file
,
16383 (bfd_vma
) section
->sh_offset
,
16384 (bfd_vma
) section
->sh_size
);
16390 /* Try processing NOTE segments instead. */
16391 return process_corefile_note_segments (file
);
16397 process_notes (FILE * file
)
16399 /* If we have not been asked to display the notes then do nothing. */
16403 if (elf_header
.e_type
!= ET_CORE
)
16404 return process_note_sections (file
);
16406 /* No program headers means no NOTE segment. */
16407 if (elf_header
.e_phnum
> 0)
16408 return process_corefile_note_segments (file
);
16410 printf (_("No note segments present in the core file.\n"));
16415 process_arch_specific (FILE * file
)
16420 switch (elf_header
.e_machine
)
16423 return process_arm_specific (file
);
16425 case EM_MIPS_RS3_LE
:
16426 return process_mips_specific (file
);
16429 return process_nds32_specific (file
);
16433 return process_power_specific (file
);
16437 return process_s390_specific (file
);
16440 case EM_SPARC32PLUS
:
16442 return process_sparc_specific (file
);
16445 return process_tic6x_specific (file
);
16448 return process_msp430x_specific (file
);
16456 get_file_header (FILE * file
)
16458 /* Read in the identity array. */
16459 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16462 /* Determine how to read the rest of the header. */
16463 switch (elf_header
.e_ident
[EI_DATA
])
16468 byte_get
= byte_get_little_endian
;
16469 byte_put
= byte_put_little_endian
;
16472 byte_get
= byte_get_big_endian
;
16473 byte_put
= byte_put_big_endian
;
16477 /* For now we only support 32 bit and 64 bit ELF files. */
16478 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16480 /* Read in the rest of the header. */
16483 Elf32_External_Ehdr ehdr32
;
16485 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16488 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16489 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16490 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16491 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16492 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16493 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16494 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16495 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16496 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16497 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16498 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16499 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16500 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16504 Elf64_External_Ehdr ehdr64
;
16506 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16507 we will not be able to cope with the 64bit data found in
16508 64 ELF files. Detect this now and abort before we start
16509 overwriting things. */
16510 if (sizeof (bfd_vma
) < 8)
16512 error (_("This instance of readelf has been built without support for a\n\
16513 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16517 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16520 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16521 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16522 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16523 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16524 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16525 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16526 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16527 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16528 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16529 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16530 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16531 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16532 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16535 if (elf_header
.e_shoff
)
16537 /* There may be some extensions in the first section header. Don't
16538 bomb if we can't read it. */
16540 get_32bit_section_headers (file
, TRUE
);
16542 get_64bit_section_headers (file
, TRUE
);
16548 /* Process one ELF object file according to the command line options.
16549 This file may actually be stored in an archive. The file is
16550 positioned at the start of the ELF object. */
16553 process_object (char * file_name
, FILE * file
)
16557 if (! get_file_header (file
))
16559 error (_("%s: Failed to read file header\n"), file_name
);
16563 /* Initialise per file variables. */
16564 for (i
= ARRAY_SIZE (version_info
); i
--;)
16565 version_info
[i
] = 0;
16567 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16568 dynamic_info
[i
] = 0;
16569 dynamic_info_DT_GNU_HASH
= 0;
16571 /* Process the file. */
16573 printf (_("\nFile: %s\n"), file_name
);
16575 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16576 Note we do this even if cmdline_dump_sects is empty because we
16577 must make sure that the dump_sets array is zeroed out before each
16578 object file is processed. */
16579 if (num_dump_sects
> num_cmdline_dump_sects
)
16580 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16582 if (num_cmdline_dump_sects
> 0)
16584 if (num_dump_sects
== 0)
16585 /* A sneaky way of allocating the dump_sects array. */
16586 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16588 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16589 memcpy (dump_sects
, cmdline_dump_sects
,
16590 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16593 if (! process_file_header ())
16596 if (! process_section_headers (file
))
16598 /* Without loaded section headers we cannot process lots of
16600 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16602 if (! do_using_dynamic
)
16603 do_syms
= do_dyn_syms
= do_reloc
= 0;
16606 if (! process_section_groups (file
))
16608 /* Without loaded section groups we cannot process unwind. */
16612 if (process_program_headers (file
))
16613 process_dynamic_section (file
);
16615 process_relocs (file
);
16617 process_unwind (file
);
16619 process_symbol_table (file
);
16621 process_syminfo (file
);
16623 process_version_sections (file
);
16625 process_section_contents (file
);
16627 process_notes (file
);
16629 process_gnu_liblist (file
);
16631 process_arch_specific (file
);
16633 if (program_headers
)
16635 free (program_headers
);
16636 program_headers
= NULL
;
16639 if (section_headers
)
16641 free (section_headers
);
16642 section_headers
= NULL
;
16647 free (string_table
);
16648 string_table
= NULL
;
16649 string_table_length
= 0;
16652 if (dynamic_strings
)
16654 free (dynamic_strings
);
16655 dynamic_strings
= NULL
;
16656 dynamic_strings_length
= 0;
16659 if (dynamic_symbols
)
16661 free (dynamic_symbols
);
16662 dynamic_symbols
= NULL
;
16663 num_dynamic_syms
= 0;
16666 if (dynamic_syminfo
)
16668 free (dynamic_syminfo
);
16669 dynamic_syminfo
= NULL
;
16672 if (dynamic_section
)
16674 free (dynamic_section
);
16675 dynamic_section
= NULL
;
16678 if (section_headers_groups
)
16680 free (section_headers_groups
);
16681 section_headers_groups
= NULL
;
16684 if (section_groups
)
16686 struct group_list
* g
;
16687 struct group_list
* next
;
16689 for (i
= 0; i
< group_count
; i
++)
16691 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16698 free (section_groups
);
16699 section_groups
= NULL
;
16702 free_debug_memory ();
16707 /* Process an ELF archive.
16708 On entry the file is positioned just after the ARMAG string. */
16711 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16713 struct archive_info arch
;
16714 struct archive_info nested_arch
;
16720 /* The ARCH structure is used to hold information about this archive. */
16721 arch
.file_name
= NULL
;
16723 arch
.index_array
= NULL
;
16724 arch
.sym_table
= NULL
;
16725 arch
.longnames
= NULL
;
16727 /* The NESTED_ARCH structure is used as a single-item cache of information
16728 about a nested archive (when members of a thin archive reside within
16729 another regular archive file). */
16730 nested_arch
.file_name
= NULL
;
16731 nested_arch
.file
= NULL
;
16732 nested_arch
.index_array
= NULL
;
16733 nested_arch
.sym_table
= NULL
;
16734 nested_arch
.longnames
= NULL
;
16736 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16742 if (do_archive_index
)
16744 if (arch
.sym_table
== NULL
)
16745 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16748 unsigned long i
, l
;
16749 unsigned long current_pos
;
16751 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16752 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16753 current_pos
= ftell (file
);
16755 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16757 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16759 char * member_name
;
16761 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16763 if (member_name
!= NULL
)
16765 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16767 if (qualified_name
!= NULL
)
16769 printf (_("Contents of binary %s at offset "), qualified_name
);
16770 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16772 free (qualified_name
);
16777 if (l
>= arch
.sym_size
)
16779 error (_("%s: end of the symbol table reached before the end of the index\n"),
16783 /* PR 17531: file: 0b6630b2. */
16784 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16785 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16788 if (arch
.uses_64bit_indicies
)
16793 if (l
< arch
.sym_size
)
16794 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16795 file_name
, arch
.sym_size
- l
);
16797 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16799 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16805 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16806 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16807 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16808 && !do_section_groups
&& !do_dyn_syms
)
16810 ret
= 0; /* Archive index only. */
16821 char * qualified_name
;
16823 /* Read the next archive header. */
16824 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16826 error (_("%s: failed to seek to next archive header\n"), file_name
);
16829 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16830 if (got
!= sizeof arch
.arhdr
)
16834 error (_("%s: failed to read archive header\n"), file_name
);
16838 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16840 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16845 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16847 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16848 if (archive_file_size
& 01)
16849 ++archive_file_size
;
16851 name
= get_archive_member_name (&arch
, &nested_arch
);
16854 error (_("%s: bad archive file name\n"), file_name
);
16858 namelen
= strlen (name
);
16860 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16861 if (qualified_name
== NULL
)
16863 error (_("%s: bad archive file name\n"), file_name
);
16868 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16870 /* This is a proxy for an external member of a thin archive. */
16871 FILE * member_file
;
16872 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16873 if (member_file_name
== NULL
)
16879 member_file
= fopen (member_file_name
, "rb");
16880 if (member_file
== NULL
)
16882 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16883 free (member_file_name
);
16888 archive_file_offset
= arch
.nested_member_origin
;
16890 ret
|= process_object (qualified_name
, member_file
);
16892 fclose (member_file
);
16893 free (member_file_name
);
16895 else if (is_thin_archive
)
16897 /* PR 15140: Allow for corrupt thin archives. */
16898 if (nested_arch
.file
== NULL
)
16900 error (_("%s: contains corrupt thin archive: %s\n"),
16906 /* This is a proxy for a member of a nested archive. */
16907 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16909 /* The nested archive file will have been opened and setup by
16910 get_archive_member_name. */
16911 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16913 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16918 ret
|= process_object (qualified_name
, nested_arch
.file
);
16922 archive_file_offset
= arch
.next_arhdr_offset
;
16923 arch
.next_arhdr_offset
+= archive_file_size
;
16925 ret
|= process_object (qualified_name
, file
);
16928 if (dump_sects
!= NULL
)
16932 num_dump_sects
= 0;
16935 free (qualified_name
);
16939 if (nested_arch
.file
!= NULL
)
16940 fclose (nested_arch
.file
);
16941 release_archive (&nested_arch
);
16942 release_archive (&arch
);
16948 process_file (char * file_name
)
16951 struct stat statbuf
;
16952 char armag
[SARMAG
];
16955 if (stat (file_name
, &statbuf
) < 0)
16957 if (errno
== ENOENT
)
16958 error (_("'%s': No such file\n"), file_name
);
16960 error (_("Could not locate '%s'. System error message: %s\n"),
16961 file_name
, strerror (errno
));
16965 if (! S_ISREG (statbuf
.st_mode
))
16967 error (_("'%s' is not an ordinary file\n"), file_name
);
16971 file
= fopen (file_name
, "rb");
16974 error (_("Input file '%s' is not readable.\n"), file_name
);
16978 if (fread (armag
, SARMAG
, 1, file
) != 1)
16980 error (_("%s: Failed to read file's magic number\n"), file_name
);
16985 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16987 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16988 ret
= process_archive (file_name
, file
, FALSE
);
16989 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16990 ret
= process_archive (file_name
, file
, TRUE
);
16993 if (do_archive_index
)
16994 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16998 archive_file_size
= archive_file_offset
= 0;
16999 ret
= process_object (file_name
, file
);
17004 current_file_size
= 0;
17008 #ifdef SUPPORT_DISASSEMBLY
17009 /* Needed by the i386 disassembler. For extra credit, someone could
17010 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17014 print_address (unsigned int addr
, FILE * outfile
)
17016 fprintf (outfile
,"0x%8.8x", addr
);
17019 /* Needed by the i386 disassembler. */
17021 db_task_printsym (unsigned int addr
)
17023 print_address (addr
, stderr
);
17028 main (int argc
, char ** argv
)
17032 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17033 setlocale (LC_MESSAGES
, "");
17035 #if defined (HAVE_SETLOCALE)
17036 setlocale (LC_CTYPE
, "");
17038 bindtextdomain (PACKAGE
, LOCALEDIR
);
17039 textdomain (PACKAGE
);
17041 expandargv (&argc
, &argv
);
17043 parse_args (argc
, argv
);
17045 if (num_dump_sects
> 0)
17047 /* Make a copy of the dump_sects array. */
17048 cmdline_dump_sects
= (dump_type
*)
17049 malloc (num_dump_sects
* sizeof (* dump_sects
));
17050 if (cmdline_dump_sects
== NULL
)
17051 error (_("Out of memory allocating dump request table.\n"));
17054 memcpy (cmdline_dump_sects
, dump_sects
,
17055 num_dump_sects
* sizeof (* dump_sects
));
17056 num_cmdline_dump_sects
= num_dump_sects
;
17060 if (optind
< (argc
- 1))
17062 else if (optind
>= argc
)
17064 warn (_("Nothing to do.\n"));
17069 while (optind
< argc
)
17070 err
|= process_file (argv
[optind
++]);
17072 if (dump_sects
!= NULL
)
17074 if (cmdline_dump_sects
!= NULL
)
17075 free (cmdline_dump_sects
);