1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 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/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Print a BFD_VMA to an internal buffer, for use in error messages.
325 BFD_FMA_FMT can't be used in translated strings. */
328 bfd_vmatoa (char *fmtch
, bfd_vma value
)
330 /* bfd_vmatoa is used more then once in a printf call for output.
331 Cycle through an array of buffers. */
332 static int buf_pos
= 0;
333 static struct bfd_vmatoa_buf
340 ret
= buf
[buf_pos
++].place
;
341 buf_pos
%= ARRAY_SIZE (buf
);
343 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
344 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
348 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
349 the offset of the current archive member, if we are examining an archive.
350 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
351 using malloc and fill that. In either case return the pointer to the start of
352 the retrieved data or NULL if something went wrong. If something does go wrong
353 and REASON is not NULL then emit an error message using REASON as part of the
357 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
358 bfd_size_type nmemb
, const char * reason
)
361 bfd_size_type amt
= size
* nmemb
;
363 if (size
== 0 || nmemb
== 0)
366 /* If the size_t type is smaller than the bfd_size_type, eg because
367 you are building a 32-bit tool on a 64-bit host, then make sure
368 that when the sizes are cast to (size_t) no information is lost. */
369 if (sizeof (size_t) < sizeof (bfd_size_type
)
370 && ( (bfd_size_type
) ((size_t) size
) != size
371 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
374 error (_("Size truncation prevents reading %s"
375 " elements of size %s for %s\n"),
376 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
380 /* Check for size overflow. */
384 error (_("Size overflow prevents reading %s"
385 " elements of size %s for %s\n"),
386 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
390 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
391 attempting to allocate memory when the read is bound to fail. */
392 if (amt
> current_file_size
393 || offset
+ archive_file_offset
+ amt
> current_file_size
)
396 error (_("Reading %s bytes extends past end of file for %s\n"),
397 bfd_vmatoa ("u", amt
), reason
);
401 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
404 error (_("Unable to seek to 0x%lx for %s\n"),
405 archive_file_offset
+ offset
, reason
);
412 /* Check for overflow. */
413 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
414 /* + 1 so that we can '\0' terminate invalid string table sections. */
415 mvar
= malloc ((size_t) amt
+ 1);
420 error (_("Out of memory allocating %s bytes for %s\n"),
421 bfd_vmatoa ("u", amt
), reason
);
425 ((char *) mvar
)[amt
] = '\0';
428 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
431 error (_("Unable to read in %s bytes of %s\n"),
432 bfd_vmatoa ("u", amt
), reason
);
441 /* Print a VMA value in the MODE specified.
442 Returns the number of characters displayed. */
445 print_vma (bfd_vma vma
, print_mode mode
)
457 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
464 return printf ("%5" BFD_VMA_FMT
"d", vma
);
470 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
473 return printf ("%" BFD_VMA_FMT
"d", vma
);
476 return printf ("%" BFD_VMA_FMT
"u", vma
);
479 /* FIXME: Report unrecognised mode ? */
484 /* Display a symbol on stdout. Handles the display of control characters and
485 multibye characters (assuming the host environment supports them).
487 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
489 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
490 padding as necessary.
492 Returns the number of emitted characters. */
495 print_symbol (signed int width
, const char *symbol
)
497 bfd_boolean extra_padding
= FALSE
;
498 signed int num_printed
= 0;
499 #ifdef HAVE_MBSTATE_T
502 unsigned int width_remaining
;
506 /* Keep the width positive. This helps the code below. */
508 extra_padding
= TRUE
;
513 /* Set the remaining width to a very large value.
514 This simplifies the code below. */
515 width_remaining
= INT_MAX
;
517 width_remaining
= width
;
519 #ifdef HAVE_MBSTATE_T
520 /* Initialise the multibyte conversion state. */
521 memset (& state
, 0, sizeof (state
));
524 while (width_remaining
)
527 const char c
= *symbol
++;
532 /* Do not print control characters directly as they can affect terminal
533 settings. Such characters usually appear in the names generated
534 by the assembler for local labels. */
537 if (width_remaining
< 2)
540 printf ("^%c", c
+ 0x40);
541 width_remaining
-= 2;
544 else if (ISPRINT (c
))
552 #ifdef HAVE_MBSTATE_T
555 /* Let printf do the hard work of displaying multibyte characters. */
556 printf ("%.1s", symbol
- 1);
560 #ifdef HAVE_MBSTATE_T
561 /* Try to find out how many bytes made up the character that was
562 just printed. Advance the symbol pointer past the bytes that
564 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
568 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
573 if (extra_padding
&& num_printed
< width
)
575 /* Fill in the remaining spaces. */
576 printf ("%-*s", width
- num_printed
, " ");
583 /* Returns a pointer to a static buffer containing a printable version of
584 the given section's name. Like print_symbol, except that it does not try
585 to print multibyte characters, it just interprets them as hex values. */
588 printable_section_name (const Elf_Internal_Shdr
* sec
)
590 #define MAX_PRINT_SEC_NAME_LEN 128
591 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
592 const char * name
= SECTION_NAME (sec
);
593 char * buf
= sec_name_buf
;
595 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
597 while ((c
= * name
++) != 0)
608 else if (ISPRINT (c
))
615 static char hex
[17] = "0123456789ABCDEF";
620 * buf
++ = hex
[(c
& 0xf0) >> 4];
621 * buf
++ = hex
[c
& 0x0f];
635 printable_section_name_from_index (unsigned long ndx
)
637 if (ndx
>= elf_header
.e_shnum
)
638 return _("<corrupt>");
640 return printable_section_name (section_headers
+ ndx
);
643 /* Return a pointer to section NAME, or NULL if no such section exists. */
645 static Elf_Internal_Shdr
*
646 find_section (const char * name
)
650 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
651 if (streq (SECTION_NAME (section_headers
+ i
), name
))
652 return section_headers
+ i
;
657 /* Return a pointer to a section containing ADDR, or NULL if no such
660 static Elf_Internal_Shdr
*
661 find_section_by_address (bfd_vma addr
)
665 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
667 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
668 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
675 static Elf_Internal_Shdr
*
676 find_section_by_type (unsigned int type
)
680 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
682 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
683 if (sec
->sh_type
== type
)
690 /* Return a pointer to section NAME, or NULL if no such section exists,
691 restricted to the list of sections given in SET. */
693 static Elf_Internal_Shdr
*
694 find_section_in_set (const char * name
, unsigned int * set
)
700 while ((i
= *set
++) > 0)
702 /* See PR 21156 for a reproducer. */
703 if (i
>= elf_header
.e_shnum
)
704 continue; /* FIXME: Should we issue an error message ? */
706 if (streq (SECTION_NAME (section_headers
+ i
), name
))
707 return section_headers
+ i
;
711 return find_section (name
);
714 /* Read an unsigned LEB128 encoded value from DATA.
715 Set *LENGTH_RETURN to the number of bytes read. */
717 static inline unsigned long
718 read_uleb128 (unsigned char * data
,
719 unsigned int * length_return
,
720 const unsigned char * const end
)
722 return read_leb128 (data
, length_return
, FALSE
, end
);
725 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
726 This OS has so many departures from the ELF standard that we test it at
729 static inline bfd_boolean
732 return elf_header
.e_machine
== EM_IA_64
733 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
736 /* Guess the relocation size commonly used by the specific machines. */
739 guess_is_rela (unsigned int e_machine
)
743 /* Targets that use REL relocations. */
758 /* Targets that use RELA relocations. */
762 case EM_ADAPTEVA_EPIPHANY
:
764 case EM_ALTERA_NIOS2
:
767 case EM_ARC_COMPACT2
:
787 case EM_LATTICEMICO32
:
796 case EM_CYGNUS_MN10200
:
798 case EM_CYGNUS_MN10300
:
834 case EM_MICROBLAZE_OLD
:
856 warn (_("Don't know about relocations on this machine architecture\n"));
861 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
862 Returns TRUE upon success, FALSE otherwise. If successful then a
863 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
864 and the number of relocs loaded is placed in *NRELASP. It is the caller's
865 responsibility to free the allocated buffer. */
868 slurp_rela_relocs (FILE * file
,
869 unsigned long rel_offset
,
870 unsigned long rel_size
,
871 Elf_Internal_Rela
** relasp
,
872 unsigned long * nrelasp
)
874 Elf_Internal_Rela
* relas
;
880 Elf32_External_Rela
* erelas
;
882 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
883 rel_size
, _("32-bit relocation data"));
887 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
889 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
890 sizeof (Elf_Internal_Rela
));
895 error (_("out of memory parsing relocs\n"));
899 for (i
= 0; i
< nrelas
; i
++)
901 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
902 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
903 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
910 Elf64_External_Rela
* erelas
;
912 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
913 rel_size
, _("64-bit relocation data"));
917 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
919 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
920 sizeof (Elf_Internal_Rela
));
925 error (_("out of memory parsing relocs\n"));
929 for (i
= 0; i
< nrelas
; i
++)
931 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
932 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
933 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
935 /* The #ifdef BFD64 below is to prevent a compile time
936 warning. We know that if we do not have a 64 bit data
937 type that we will never execute this code anyway. */
939 if (elf_header
.e_machine
== EM_MIPS
940 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
942 /* In little-endian objects, r_info isn't really a
943 64-bit little-endian value: it has a 32-bit
944 little-endian symbol index followed by four
945 individual byte fields. Reorder INFO
947 bfd_vma inf
= relas
[i
].r_info
;
948 inf
= (((inf
& 0xffffffff) << 32)
949 | ((inf
>> 56) & 0xff)
950 | ((inf
>> 40) & 0xff00)
951 | ((inf
>> 24) & 0xff0000)
952 | ((inf
>> 8) & 0xff000000));
953 relas
[i
].r_info
= inf
;
966 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
967 Returns TRUE upon success, FALSE otherwise. If successful then a
968 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
969 and the number of relocs loaded is placed in *NRELSP. It is the caller's
970 responsibility to free the allocated buffer. */
973 slurp_rel_relocs (FILE * file
,
974 unsigned long rel_offset
,
975 unsigned long rel_size
,
976 Elf_Internal_Rela
** relsp
,
977 unsigned long * nrelsp
)
979 Elf_Internal_Rela
* rels
;
985 Elf32_External_Rel
* erels
;
987 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
988 rel_size
, _("32-bit relocation data"));
992 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
994 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
999 error (_("out of memory parsing relocs\n"));
1003 for (i
= 0; i
< nrels
; i
++)
1005 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1006 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1007 rels
[i
].r_addend
= 0;
1014 Elf64_External_Rel
* erels
;
1016 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
1017 rel_size
, _("64-bit relocation data"));
1021 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1023 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1028 error (_("out of memory parsing relocs\n"));
1032 for (i
= 0; i
< nrels
; i
++)
1034 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1035 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1036 rels
[i
].r_addend
= 0;
1038 /* The #ifdef BFD64 below is to prevent a compile time
1039 warning. We know that if we do not have a 64 bit data
1040 type that we will never execute this code anyway. */
1042 if (elf_header
.e_machine
== EM_MIPS
1043 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1045 /* In little-endian objects, r_info isn't really a
1046 64-bit little-endian value: it has a 32-bit
1047 little-endian symbol index followed by four
1048 individual byte fields. Reorder INFO
1050 bfd_vma inf
= rels
[i
].r_info
;
1051 inf
= (((inf
& 0xffffffff) << 32)
1052 | ((inf
>> 56) & 0xff)
1053 | ((inf
>> 40) & 0xff00)
1054 | ((inf
>> 24) & 0xff0000)
1055 | ((inf
>> 8) & 0xff000000));
1056 rels
[i
].r_info
= inf
;
1069 /* Returns the reloc type extracted from the reloc info field. */
1072 get_reloc_type (bfd_vma reloc_info
)
1075 return ELF32_R_TYPE (reloc_info
);
1077 switch (elf_header
.e_machine
)
1080 /* Note: We assume that reloc_info has already been adjusted for us. */
1081 return ELF64_MIPS_R_TYPE (reloc_info
);
1084 return ELF64_R_TYPE_ID (reloc_info
);
1087 return ELF64_R_TYPE (reloc_info
);
1091 /* Return the symbol index extracted from the reloc info field. */
1094 get_reloc_symindex (bfd_vma reloc_info
)
1096 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1099 static inline bfd_boolean
1100 uses_msp430x_relocs (void)
1103 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1104 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1105 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1106 /* TI compiler uses ELFOSABI_NONE. */
1107 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1110 /* Display the contents of the relocation data found at the specified
1114 dump_relocations (FILE * file
,
1115 unsigned long rel_offset
,
1116 unsigned long rel_size
,
1117 Elf_Internal_Sym
* symtab
,
1118 unsigned long nsyms
,
1120 unsigned long strtablen
,
1122 bfd_boolean is_dynsym
)
1125 Elf_Internal_Rela
* rels
;
1126 bfd_boolean res
= TRUE
;
1128 if (is_rela
== UNKNOWN
)
1129 is_rela
= guess_is_rela (elf_header
.e_machine
);
1133 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1138 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1147 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1149 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1154 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1156 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1164 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1166 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1171 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1173 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1177 for (i
= 0; i
< rel_size
; i
++)
1182 bfd_vma symtab_index
;
1185 offset
= rels
[i
].r_offset
;
1186 inf
= rels
[i
].r_info
;
1188 type
= get_reloc_type (inf
);
1189 symtab_index
= get_reloc_symindex (inf
);
1193 printf ("%8.8lx %8.8lx ",
1194 (unsigned long) offset
& 0xffffffff,
1195 (unsigned long) inf
& 0xffffffff);
1199 #if BFD_HOST_64BIT_LONG
1201 ? "%16.16lx %16.16lx "
1202 : "%12.12lx %12.12lx ",
1204 #elif BFD_HOST_64BIT_LONG_LONG
1207 ? "%16.16llx %16.16llx "
1208 : "%12.12llx %12.12llx ",
1212 ? "%16.16I64x %16.16I64x "
1213 : "%12.12I64x %12.12I64x ",
1218 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1219 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1220 _bfd_int64_high (offset
),
1221 _bfd_int64_low (offset
),
1222 _bfd_int64_high (inf
),
1223 _bfd_int64_low (inf
));
1227 switch (elf_header
.e_machine
)
1234 rtype
= elf_aarch64_reloc_type (type
);
1238 case EM_CYGNUS_M32R
:
1239 rtype
= elf_m32r_reloc_type (type
);
1244 rtype
= elf_i386_reloc_type (type
);
1249 rtype
= elf_m68hc11_reloc_type (type
);
1253 rtype
= elf_m68k_reloc_type (type
);
1257 rtype
= elf_i960_reloc_type (type
);
1262 rtype
= elf_avr_reloc_type (type
);
1265 case EM_OLD_SPARCV9
:
1266 case EM_SPARC32PLUS
:
1269 rtype
= elf_sparc_reloc_type (type
);
1273 rtype
= elf_spu_reloc_type (type
);
1277 rtype
= v800_reloc_type (type
);
1280 case EM_CYGNUS_V850
:
1281 rtype
= v850_reloc_type (type
);
1285 case EM_CYGNUS_D10V
:
1286 rtype
= elf_d10v_reloc_type (type
);
1290 case EM_CYGNUS_D30V
:
1291 rtype
= elf_d30v_reloc_type (type
);
1295 rtype
= elf_dlx_reloc_type (type
);
1299 rtype
= elf_sh_reloc_type (type
);
1303 case EM_CYGNUS_MN10300
:
1304 rtype
= elf_mn10300_reloc_type (type
);
1308 case EM_CYGNUS_MN10200
:
1309 rtype
= elf_mn10200_reloc_type (type
);
1313 case EM_CYGNUS_FR30
:
1314 rtype
= elf_fr30_reloc_type (type
);
1318 rtype
= elf_frv_reloc_type (type
);
1322 rtype
= elf_ft32_reloc_type (type
);
1326 rtype
= elf_mcore_reloc_type (type
);
1330 rtype
= elf_mmix_reloc_type (type
);
1334 rtype
= elf_moxie_reloc_type (type
);
1338 if (uses_msp430x_relocs ())
1340 rtype
= elf_msp430x_reloc_type (type
);
1345 rtype
= elf_msp430_reloc_type (type
);
1349 rtype
= elf_nds32_reloc_type (type
);
1353 rtype
= elf_ppc_reloc_type (type
);
1357 rtype
= elf_ppc64_reloc_type (type
);
1361 case EM_MIPS_RS3_LE
:
1362 rtype
= elf_mips_reloc_type (type
);
1366 rtype
= elf_riscv_reloc_type (type
);
1370 rtype
= elf_alpha_reloc_type (type
);
1374 rtype
= elf_arm_reloc_type (type
);
1378 case EM_ARC_COMPACT
:
1379 case EM_ARC_COMPACT2
:
1380 rtype
= elf_arc_reloc_type (type
);
1384 rtype
= elf_hppa_reloc_type (type
);
1390 rtype
= elf_h8_reloc_type (type
);
1394 rtype
= elf_or1k_reloc_type (type
);
1399 rtype
= elf_pj_reloc_type (type
);
1402 rtype
= elf_ia64_reloc_type (type
);
1406 rtype
= elf_cris_reloc_type (type
);
1410 rtype
= elf_i860_reloc_type (type
);
1416 rtype
= elf_x86_64_reloc_type (type
);
1420 rtype
= i370_reloc_type (type
);
1425 rtype
= elf_s390_reloc_type (type
);
1429 rtype
= elf_score_reloc_type (type
);
1433 rtype
= elf_xstormy16_reloc_type (type
);
1437 rtype
= elf_crx_reloc_type (type
);
1441 rtype
= elf_vax_reloc_type (type
);
1445 rtype
= elf_visium_reloc_type (type
);
1448 case EM_ADAPTEVA_EPIPHANY
:
1449 rtype
= elf_epiphany_reloc_type (type
);
1454 rtype
= elf_ip2k_reloc_type (type
);
1458 rtype
= elf_iq2000_reloc_type (type
);
1463 rtype
= elf_xtensa_reloc_type (type
);
1466 case EM_LATTICEMICO32
:
1467 rtype
= elf_lm32_reloc_type (type
);
1472 rtype
= elf_m32c_reloc_type (type
);
1476 rtype
= elf_mt_reloc_type (type
);
1480 rtype
= elf_bfin_reloc_type (type
);
1484 rtype
= elf_mep_reloc_type (type
);
1488 rtype
= elf_cr16_reloc_type (type
);
1492 case EM_MICROBLAZE_OLD
:
1493 rtype
= elf_microblaze_reloc_type (type
);
1497 rtype
= elf_rl78_reloc_type (type
);
1501 rtype
= elf_rx_reloc_type (type
);
1505 rtype
= elf_metag_reloc_type (type
);
1510 rtype
= elf_xc16x_reloc_type (type
);
1514 rtype
= elf_tic6x_reloc_type (type
);
1518 rtype
= elf_tilegx_reloc_type (type
);
1522 rtype
= elf_tilepro_reloc_type (type
);
1525 case EM_WEBASSEMBLY
:
1526 rtype
= elf_wasm32_reloc_type (type
);
1530 rtype
= elf_xgate_reloc_type (type
);
1533 case EM_ALTERA_NIOS2
:
1534 rtype
= elf_nios2_reloc_type (type
);
1538 rtype
= elf_pru_reloc_type (type
);
1543 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1545 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1547 if (elf_header
.e_machine
== EM_ALPHA
1549 && streq (rtype
, "R_ALPHA_LITUSE")
1552 switch (rels
[i
].r_addend
)
1554 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1555 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1556 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1557 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1558 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1559 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1560 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1561 default: rtype
= NULL
;
1565 printf (" (%s)", rtype
);
1569 printf (_("<unknown addend: %lx>"),
1570 (unsigned long) rels
[i
].r_addend
);
1574 else if (symtab_index
)
1576 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1578 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1583 Elf_Internal_Sym
* psym
;
1584 const char * version_string
;
1585 enum versioned_symbol_info sym_info
;
1586 unsigned short vna_other
;
1588 psym
= symtab
+ symtab_index
;
1591 = get_symbol_version_string (file
, is_dynsym
,
1600 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1604 unsigned int width
= is_32bit_elf
? 8 : 14;
1606 /* Relocations against GNU_IFUNC symbols do not use the value
1607 of the symbol as the address to relocate against. Instead
1608 they invoke the function named by the symbol and use its
1609 result as the address for relocation.
1611 To indicate this to the user, do not display the value of
1612 the symbol in the "Symbols's Value" field. Instead show
1613 its name followed by () as a hint that the symbol is
1617 || psym
->st_name
== 0
1618 || psym
->st_name
>= strtablen
)
1621 name
= strtab
+ psym
->st_name
;
1623 len
= print_symbol (width
, name
);
1625 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1627 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1631 print_vma (psym
->st_value
, LONG_HEX
);
1633 printf (is_32bit_elf
? " " : " ");
1636 if (psym
->st_name
== 0)
1638 const char * sec_name
= "<null>";
1641 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1643 if (psym
->st_shndx
< elf_header
.e_shnum
)
1644 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1645 else if (psym
->st_shndx
== SHN_ABS
)
1647 else if (psym
->st_shndx
== SHN_COMMON
)
1648 sec_name
= "COMMON";
1649 else if ((elf_header
.e_machine
== EM_MIPS
1650 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1651 || (elf_header
.e_machine
== EM_TI_C6000
1652 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1653 sec_name
= "SCOMMON";
1654 else if (elf_header
.e_machine
== EM_MIPS
1655 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1656 sec_name
= "SUNDEF";
1657 else if ((elf_header
.e_machine
== EM_X86_64
1658 || elf_header
.e_machine
== EM_L1OM
1659 || elf_header
.e_machine
== EM_K1OM
)
1660 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1661 sec_name
= "LARGE_COMMON";
1662 else if (elf_header
.e_machine
== EM_IA_64
1663 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1664 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1665 sec_name
= "ANSI_COM";
1666 else if (is_ia64_vms ()
1667 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1668 sec_name
= "VMS_SYMVEC";
1671 sprintf (name_buf
, "<section 0x%x>",
1672 (unsigned int) psym
->st_shndx
);
1673 sec_name
= name_buf
;
1676 print_symbol (22, sec_name
);
1678 else if (strtab
== NULL
)
1679 printf (_("<string table index: %3ld>"), psym
->st_name
);
1680 else if (psym
->st_name
>= strtablen
)
1682 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1687 print_symbol (22, strtab
+ psym
->st_name
);
1689 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1695 bfd_vma off
= rels
[i
].r_addend
;
1697 if ((bfd_signed_vma
) off
< 0)
1698 printf (" - %" BFD_VMA_FMT
"x", - off
);
1700 printf (" + %" BFD_VMA_FMT
"x", off
);
1706 bfd_vma off
= rels
[i
].r_addend
;
1708 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1709 if ((bfd_signed_vma
) off
< 0)
1710 printf ("-%" BFD_VMA_FMT
"x", - off
);
1712 printf ("%" BFD_VMA_FMT
"x", off
);
1715 if (elf_header
.e_machine
== EM_SPARCV9
1717 && streq (rtype
, "R_SPARC_OLO10"))
1718 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1723 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1725 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1726 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1727 const char * rtype2
= elf_mips_reloc_type (type2
);
1728 const char * rtype3
= elf_mips_reloc_type (type3
);
1730 printf (" Type2: ");
1733 printf (_("unrecognized: %-7lx"),
1734 (unsigned long) type2
& 0xffffffff);
1736 printf ("%-17.17s", rtype2
);
1738 printf ("\n Type3: ");
1741 printf (_("unrecognized: %-7lx"),
1742 (unsigned long) type3
& 0xffffffff);
1744 printf ("%-17.17s", rtype3
);
1757 get_mips_dynamic_type (unsigned long type
)
1761 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1762 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1763 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1764 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1765 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1766 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1767 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1768 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1769 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1770 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1771 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1772 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1773 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1774 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1775 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1776 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1777 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1778 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1779 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1780 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1781 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1782 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1783 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1784 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1785 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1786 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1787 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1788 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1789 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1790 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1791 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1792 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1793 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1794 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1795 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1796 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1797 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1798 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1799 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1800 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1801 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1802 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1803 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1804 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1805 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1806 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1813 get_sparc64_dynamic_type (unsigned long type
)
1817 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1824 get_ppc_dynamic_type (unsigned long type
)
1828 case DT_PPC_GOT
: return "PPC_GOT";
1829 case DT_PPC_OPT
: return "PPC_OPT";
1836 get_ppc64_dynamic_type (unsigned long type
)
1840 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1841 case DT_PPC64_OPD
: return "PPC64_OPD";
1842 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1843 case DT_PPC64_OPT
: return "PPC64_OPT";
1850 get_parisc_dynamic_type (unsigned long type
)
1854 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1855 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1856 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1857 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1858 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1859 case DT_HP_PREINIT
: return "HP_PREINIT";
1860 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1861 case DT_HP_NEEDED
: return "HP_NEEDED";
1862 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1863 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1864 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1865 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1866 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1867 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1868 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1869 case DT_HP_FILTERED
: return "HP_FILTERED";
1870 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1871 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1872 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1873 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1874 case DT_PLT
: return "PLT";
1875 case DT_PLT_SIZE
: return "PLT_SIZE";
1876 case DT_DLT
: return "DLT";
1877 case DT_DLT_SIZE
: return "DLT_SIZE";
1884 get_ia64_dynamic_type (unsigned long type
)
1888 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1889 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1890 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1891 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1892 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1893 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1894 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1895 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1896 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1897 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1898 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1899 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1900 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1901 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1902 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1903 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1904 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1905 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1906 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1907 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1908 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1909 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1910 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1911 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1912 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1913 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1914 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1915 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1916 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1917 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1918 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1925 get_solaris_section_type (unsigned long type
)
1929 case 0x6fffffee: return "SUNW_ancillary";
1930 case 0x6fffffef: return "SUNW_capchain";
1931 case 0x6ffffff0: return "SUNW_capinfo";
1932 case 0x6ffffff1: return "SUNW_symsort";
1933 case 0x6ffffff2: return "SUNW_tlssort";
1934 case 0x6ffffff3: return "SUNW_LDYNSYM";
1935 case 0x6ffffff4: return "SUNW_dof";
1936 case 0x6ffffff5: return "SUNW_cap";
1937 case 0x6ffffff6: return "SUNW_SIGNATURE";
1938 case 0x6ffffff7: return "SUNW_ANNOTATE";
1939 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1940 case 0x6ffffff9: return "SUNW_DEBUG";
1941 case 0x6ffffffa: return "SUNW_move";
1942 case 0x6ffffffb: return "SUNW_COMDAT";
1943 case 0x6ffffffc: return "SUNW_syminfo";
1944 case 0x6ffffffd: return "SUNW_verdef";
1945 case 0x6ffffffe: return "SUNW_verneed";
1946 case 0x6fffffff: return "SUNW_versym";
1947 case 0x70000000: return "SPARC_GOTDATA";
1948 default: return NULL
;
1953 get_alpha_dynamic_type (unsigned long type
)
1957 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1958 default: return NULL
;
1963 get_score_dynamic_type (unsigned long type
)
1967 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1968 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1969 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1970 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1971 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1972 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1973 default: return NULL
;
1978 get_tic6x_dynamic_type (unsigned long type
)
1982 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1983 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1984 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1985 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1986 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1987 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1988 default: return NULL
;
1993 get_nios2_dynamic_type (unsigned long type
)
1997 case DT_NIOS2_GP
: return "NIOS2_GP";
1998 default: return NULL
;
2003 get_solaris_dynamic_type (unsigned long type
)
2007 case 0x6000000d: return "SUNW_AUXILIARY";
2008 case 0x6000000e: return "SUNW_RTLDINF";
2009 case 0x6000000f: return "SUNW_FILTER";
2010 case 0x60000010: return "SUNW_CAP";
2011 case 0x60000011: return "SUNW_SYMTAB";
2012 case 0x60000012: return "SUNW_SYMSZ";
2013 case 0x60000013: return "SUNW_SORTENT";
2014 case 0x60000014: return "SUNW_SYMSORT";
2015 case 0x60000015: return "SUNW_SYMSORTSZ";
2016 case 0x60000016: return "SUNW_TLSSORT";
2017 case 0x60000017: return "SUNW_TLSSORTSZ";
2018 case 0x60000018: return "SUNW_CAPINFO";
2019 case 0x60000019: return "SUNW_STRPAD";
2020 case 0x6000001a: return "SUNW_CAPCHAIN";
2021 case 0x6000001b: return "SUNW_LDMACH";
2022 case 0x6000001d: return "SUNW_CAPCHAINENT";
2023 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2024 case 0x60000021: return "SUNW_PARENT";
2025 case 0x60000023: return "SUNW_ASLR";
2026 case 0x60000025: return "SUNW_RELAX";
2027 case 0x60000029: return "SUNW_NXHEAP";
2028 case 0x6000002b: return "SUNW_NXSTACK";
2030 case 0x70000001: return "SPARC_REGISTER";
2031 case 0x7ffffffd: return "AUXILIARY";
2032 case 0x7ffffffe: return "USED";
2033 case 0x7fffffff: return "FILTER";
2035 default: return NULL
;
2040 get_dynamic_type (unsigned long type
)
2042 static char buff
[64];
2046 case DT_NULL
: return "NULL";
2047 case DT_NEEDED
: return "NEEDED";
2048 case DT_PLTRELSZ
: return "PLTRELSZ";
2049 case DT_PLTGOT
: return "PLTGOT";
2050 case DT_HASH
: return "HASH";
2051 case DT_STRTAB
: return "STRTAB";
2052 case DT_SYMTAB
: return "SYMTAB";
2053 case DT_RELA
: return "RELA";
2054 case DT_RELASZ
: return "RELASZ";
2055 case DT_RELAENT
: return "RELAENT";
2056 case DT_STRSZ
: return "STRSZ";
2057 case DT_SYMENT
: return "SYMENT";
2058 case DT_INIT
: return "INIT";
2059 case DT_FINI
: return "FINI";
2060 case DT_SONAME
: return "SONAME";
2061 case DT_RPATH
: return "RPATH";
2062 case DT_SYMBOLIC
: return "SYMBOLIC";
2063 case DT_REL
: return "REL";
2064 case DT_RELSZ
: return "RELSZ";
2065 case DT_RELENT
: return "RELENT";
2066 case DT_PLTREL
: return "PLTREL";
2067 case DT_DEBUG
: return "DEBUG";
2068 case DT_TEXTREL
: return "TEXTREL";
2069 case DT_JMPREL
: return "JMPREL";
2070 case DT_BIND_NOW
: return "BIND_NOW";
2071 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2072 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2073 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2074 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2075 case DT_RUNPATH
: return "RUNPATH";
2076 case DT_FLAGS
: return "FLAGS";
2078 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2079 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2080 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2082 case DT_CHECKSUM
: return "CHECKSUM";
2083 case DT_PLTPADSZ
: return "PLTPADSZ";
2084 case DT_MOVEENT
: return "MOVEENT";
2085 case DT_MOVESZ
: return "MOVESZ";
2086 case DT_FEATURE
: return "FEATURE";
2087 case DT_POSFLAG_1
: return "POSFLAG_1";
2088 case DT_SYMINSZ
: return "SYMINSZ";
2089 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2091 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2092 case DT_CONFIG
: return "CONFIG";
2093 case DT_DEPAUDIT
: return "DEPAUDIT";
2094 case DT_AUDIT
: return "AUDIT";
2095 case DT_PLTPAD
: return "PLTPAD";
2096 case DT_MOVETAB
: return "MOVETAB";
2097 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2099 case DT_VERSYM
: return "VERSYM";
2101 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2102 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2103 case DT_RELACOUNT
: return "RELACOUNT";
2104 case DT_RELCOUNT
: return "RELCOUNT";
2105 case DT_FLAGS_1
: return "FLAGS_1";
2106 case DT_VERDEF
: return "VERDEF";
2107 case DT_VERDEFNUM
: return "VERDEFNUM";
2108 case DT_VERNEED
: return "VERNEED";
2109 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2111 case DT_AUXILIARY
: return "AUXILIARY";
2112 case DT_USED
: return "USED";
2113 case DT_FILTER
: return "FILTER";
2115 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2116 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2117 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2118 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2119 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2120 case DT_GNU_HASH
: return "GNU_HASH";
2123 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2125 const char * result
;
2127 switch (elf_header
.e_machine
)
2130 case EM_MIPS_RS3_LE
:
2131 result
= get_mips_dynamic_type (type
);
2134 result
= get_sparc64_dynamic_type (type
);
2137 result
= get_ppc_dynamic_type (type
);
2140 result
= get_ppc64_dynamic_type (type
);
2143 result
= get_ia64_dynamic_type (type
);
2146 result
= get_alpha_dynamic_type (type
);
2149 result
= get_score_dynamic_type (type
);
2152 result
= get_tic6x_dynamic_type (type
);
2154 case EM_ALTERA_NIOS2
:
2155 result
= get_nios2_dynamic_type (type
);
2158 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2159 result
= get_solaris_dynamic_type (type
);
2168 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2170 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2171 || (elf_header
.e_machine
== EM_PARISC
2172 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2174 const char * result
;
2176 switch (elf_header
.e_machine
)
2179 result
= get_parisc_dynamic_type (type
);
2182 result
= get_ia64_dynamic_type (type
);
2185 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2186 result
= get_solaris_dynamic_type (type
);
2195 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2199 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2206 get_file_type (unsigned e_type
)
2208 static char buff
[32];
2212 case ET_NONE
: return _("NONE (None)");
2213 case ET_REL
: return _("REL (Relocatable file)");
2214 case ET_EXEC
: return _("EXEC (Executable file)");
2215 case ET_DYN
: return _("DYN (Shared object file)");
2216 case ET_CORE
: return _("CORE (Core file)");
2219 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2220 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2221 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2222 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2224 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2230 get_machine_name (unsigned e_machine
)
2232 static char buff
[64]; /* XXX */
2236 /* Please keep this switch table sorted by increasing EM_ value. */
2238 case EM_NONE
: return _("None");
2239 case EM_M32
: return "WE32100";
2240 case EM_SPARC
: return "Sparc";
2241 case EM_386
: return "Intel 80386";
2242 case EM_68K
: return "MC68000";
2243 case EM_88K
: return "MC88000";
2244 case EM_IAMCU
: return "Intel MCU";
2245 case EM_860
: return "Intel 80860";
2246 case EM_MIPS
: return "MIPS R3000";
2247 case EM_S370
: return "IBM System/370";
2249 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2250 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2251 case EM_PARISC
: return "HPPA";
2252 case EM_VPP550
: return "Fujitsu VPP500";
2253 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2254 case EM_960
: return "Intel 90860";
2255 case EM_PPC
: return "PowerPC";
2257 case EM_PPC64
: return "PowerPC64";
2259 case EM_S390
: return "IBM S/390";
2260 case EM_SPU
: return "SPU";
2262 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2263 case EM_FR20
: return "Fujitsu FR20";
2264 case EM_RH32
: return "TRW RH32";
2265 case EM_MCORE
: return "MCORE";
2267 case EM_ARM
: return "ARM";
2268 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2269 case EM_SH
: return "Renesas / SuperH SH";
2270 case EM_SPARCV9
: return "Sparc v9";
2271 case EM_TRICORE
: return "Siemens Tricore";
2272 case EM_ARC
: return "ARC";
2273 case EM_H8_300
: return "Renesas H8/300";
2274 case EM_H8_300H
: return "Renesas H8/300H";
2275 case EM_H8S
: return "Renesas H8S";
2276 case EM_H8_500
: return "Renesas H8/500";
2278 case EM_IA_64
: return "Intel IA-64";
2279 case EM_MIPS_X
: return "Stanford MIPS-X";
2280 case EM_COLDFIRE
: return "Motorola Coldfire";
2281 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2282 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2283 case EM_PCP
: return "Siemens PCP";
2284 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2285 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2286 case EM_STARCORE
: return "Motorola Star*Core processor";
2287 case EM_ME16
: return "Toyota ME16 processor";
2289 case EM_ST100
: return "STMicroelectronics ST100 processor";
2290 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2291 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2292 case EM_PDSP
: return "Sony DSP processor";
2293 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2294 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2295 case EM_FX66
: return "Siemens FX66 microcontroller";
2296 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2297 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2298 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2300 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2301 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2302 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2303 case EM_SVX
: return "Silicon Graphics SVx";
2304 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2305 case EM_VAX
: return "Digital VAX";
2306 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2307 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2308 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2309 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2311 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2312 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2313 case EM_PRISM
: return "Vitesse Prism";
2315 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2316 case EM_CYGNUS_FR30
:
2317 case EM_FR30
: return "Fujitsu FR30";
2318 case EM_CYGNUS_D10V
:
2319 case EM_D10V
: return "d10v";
2320 case EM_CYGNUS_D30V
:
2321 case EM_D30V
: return "d30v";
2322 case EM_CYGNUS_V850
:
2323 case EM_V850
: return "Renesas V850";
2324 case EM_CYGNUS_M32R
:
2325 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2326 case EM_CYGNUS_MN10300
:
2327 case EM_MN10300
: return "mn10300";
2329 case EM_CYGNUS_MN10200
:
2330 case EM_MN10200
: return "mn10200";
2331 case EM_PJ
: return "picoJava";
2332 case EM_OR1K
: return "OpenRISC 1000";
2333 case EM_ARC_COMPACT
: return "ARCompact";
2335 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2336 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2337 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2338 case EM_NS32K
: return "National Semiconductor 32000 series";
2339 case EM_TPC
: return "Tenor Network TPC processor";
2340 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2342 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2344 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2345 case EM_MAX
: return "MAX Processor";
2346 case EM_CR
: return "National Semiconductor CompactRISC";
2347 case EM_F2MC16
: return "Fujitsu F2MC16";
2348 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2349 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2350 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2351 case EM_SEP
: return "Sharp embedded microprocessor";
2352 case EM_ARCA
: return "Arca RISC microprocessor";
2354 case EM_UNICORE
: return "Unicore";
2355 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2356 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2357 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2358 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2359 case EM_XGATE
: return "Motorola XGATE embedded processor";
2361 case EM_XC16X
: return "Infineon Technologies xc16x";
2362 case EM_M16C
: return "Renesas M16C series microprocessors";
2363 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2364 case EM_CE
: return "Freescale Communication Engine RISC core";
2366 case EM_M32C
: return "Renesas M32c";
2368 case EM_TSK3000
: return "Altium TSK3000 core";
2369 case EM_RS08
: return "Freescale RS08 embedded processor";
2370 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2371 case EM_SCORE
: return "SUNPLUS S+Core";
2372 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2373 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2374 case EM_LATTICEMICO32
: return "Lattice Mico32";
2375 case EM_SE_C17
: return "Seiko Epson C17 family";
2377 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2378 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2379 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2380 case EM_TI_PRU
: return "TI PRU I/O processor";
2382 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2383 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2384 case EM_R32C
: return "Renesas R32C series microprocessors";
2385 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2386 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2387 case EM_8051
: return "Intel 8051 and variants";
2388 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2389 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2390 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2391 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2393 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2394 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2395 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2396 case EM_RX
: return "Renesas RX";
2397 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2398 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2399 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2402 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2403 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2404 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2406 case EM_L1OM
: return "Intel L1OM";
2407 case EM_K1OM
: return "Intel K1OM";
2408 case EM_INTEL182
: return "Intel (reserved)";
2409 case EM_AARCH64
: return "AArch64";
2410 case EM_ARM184
: return "ARM (reserved)";
2411 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2412 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2413 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2414 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2416 case EM_CUDA
: return "NVIDIA CUDA architecture";
2417 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2418 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2419 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2420 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2421 case EM_ARC_COMPACT2
: return "ARCv2";
2422 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2423 case EM_RL78
: return "Renesas RL78";
2424 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2425 case EM_78K0R
: return "Renesas 78K0R";
2427 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2428 case EM_BA1
: return "Beyond BA1 CPU architecture";
2429 case EM_BA2
: return "Beyond BA2 CPU architecture";
2430 case EM_XCORE
: return "XMOS xCORE processor family";
2431 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2433 case EM_KM32
: return "KM211 KM32 32-bit processor";
2434 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2435 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2436 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2437 case EM_KVARC
: return "KM211 KVARC processor";
2438 case EM_CDP
: return "Paneve CDP architecture family";
2439 case EM_COGE
: return "Cognitive Smart Memory Processor";
2440 case EM_COOL
: return "Bluechip Systems CoolEngine";
2441 case EM_NORC
: return "Nanoradio Optimized RISC";
2442 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2444 case EM_Z80
: return "Zilog Z80";
2445 case EM_VISIUM
: return "CDS VISIUMcore processor";
2446 case EM_FT32
: return "FTDI Chip FT32";
2447 case EM_MOXIE
: return "Moxie";
2448 case EM_AMDGPU
: return "AMD GPU";
2449 case EM_RISCV
: return "RISC-V";
2450 case EM_LANAI
: return "Lanai 32-bit processor";
2451 case EM_BPF
: return "Linux BPF";
2453 /* Large numbers... */
2454 case EM_MT
: return "Morpho Techologies MT processor";
2455 case EM_ALPHA
: return "Alpha";
2456 case EM_WEBASSEMBLY
: return "Web Assembly";
2457 case EM_DLX
: return "OpenDLX";
2458 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2459 case EM_IQ2000
: return "Vitesse IQ2000";
2461 case EM_NIOS32
: return "Altera Nios";
2462 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2463 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2464 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2467 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2473 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2475 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2476 other compilers don't a specific architecture type in the e_flags, and
2477 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2478 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2481 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2482 but also sets a specific architecture type in the e_flags field.
2484 However, when decoding the flags we don't worry if we see an
2485 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2486 ARCEM architecture type. */
2488 switch (e_flags
& EF_ARC_MACH_MSK
)
2490 /* We only expect these to occur for EM_ARC_COMPACT2. */
2491 case EF_ARC_CPU_ARCV2EM
:
2492 strcat (buf
, ", ARC EM");
2494 case EF_ARC_CPU_ARCV2HS
:
2495 strcat (buf
, ", ARC HS");
2498 /* We only expect these to occur for EM_ARC_COMPACT. */
2499 case E_ARC_MACH_ARC600
:
2500 strcat (buf
, ", ARC600");
2502 case E_ARC_MACH_ARC601
:
2503 strcat (buf
, ", ARC601");
2505 case E_ARC_MACH_ARC700
:
2506 strcat (buf
, ", ARC700");
2509 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2510 new ELF with new architecture being read by an old version of
2511 readelf, or (c) An ELF built with non-GNU compiler that does not
2512 set the architecture in the e_flags. */
2514 if (e_machine
== EM_ARC_COMPACT
)
2515 strcat (buf
, ", Unknown ARCompact");
2517 strcat (buf
, ", Unknown ARC");
2521 switch (e_flags
& EF_ARC_OSABI_MSK
)
2523 case E_ARC_OSABI_ORIG
:
2524 strcat (buf
, ", (ABI:legacy)");
2526 case E_ARC_OSABI_V2
:
2527 strcat (buf
, ", (ABI:v2)");
2529 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2530 case E_ARC_OSABI_V3
:
2531 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2533 case E_ARC_OSABI_V4
:
2534 strcat (buf
, ", v4 ABI");
2537 strcat (buf
, ", unrecognised ARC OSABI flag");
2543 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2546 bfd_boolean unknown
= FALSE
;
2548 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2549 e_flags
&= ~ EF_ARM_EABIMASK
;
2551 /* Handle "generic" ARM flags. */
2552 if (e_flags
& EF_ARM_RELEXEC
)
2554 strcat (buf
, ", relocatable executable");
2555 e_flags
&= ~ EF_ARM_RELEXEC
;
2558 /* Now handle EABI specific flags. */
2562 strcat (buf
, ", <unrecognized EABI>");
2567 case EF_ARM_EABI_VER1
:
2568 strcat (buf
, ", Version1 EABI");
2573 /* Process flags one bit at a time. */
2574 flag
= e_flags
& - e_flags
;
2579 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2580 strcat (buf
, ", sorted symbol tables");
2590 case EF_ARM_EABI_VER2
:
2591 strcat (buf
, ", Version2 EABI");
2596 /* Process flags one bit at a time. */
2597 flag
= e_flags
& - e_flags
;
2602 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf
, ", sorted symbol tables");
2606 case EF_ARM_DYNSYMSUSESEGIDX
:
2607 strcat (buf
, ", dynamic symbols use segment index");
2610 case EF_ARM_MAPSYMSFIRST
:
2611 strcat (buf
, ", mapping symbols precede others");
2621 case EF_ARM_EABI_VER3
:
2622 strcat (buf
, ", Version3 EABI");
2625 case EF_ARM_EABI_VER4
:
2626 strcat (buf
, ", Version4 EABI");
2631 /* Process flags one bit at a time. */
2632 flag
= e_flags
& - e_flags
;
2638 strcat (buf
, ", BE8");
2642 strcat (buf
, ", LE8");
2652 case EF_ARM_EABI_VER5
:
2653 strcat (buf
, ", Version5 EABI");
2658 /* Process flags one bit at a time. */
2659 flag
= e_flags
& - e_flags
;
2665 strcat (buf
, ", BE8");
2669 strcat (buf
, ", LE8");
2672 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2673 strcat (buf
, ", soft-float ABI");
2676 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2677 strcat (buf
, ", hard-float ABI");
2687 case EF_ARM_EABI_UNKNOWN
:
2688 strcat (buf
, ", GNU EABI");
2693 /* Process flags one bit at a time. */
2694 flag
= e_flags
& - e_flags
;
2699 case EF_ARM_INTERWORK
:
2700 strcat (buf
, ", interworking enabled");
2703 case EF_ARM_APCS_26
:
2704 strcat (buf
, ", uses APCS/26");
2707 case EF_ARM_APCS_FLOAT
:
2708 strcat (buf
, ", uses APCS/float");
2712 strcat (buf
, ", position independent");
2716 strcat (buf
, ", 8 bit structure alignment");
2719 case EF_ARM_NEW_ABI
:
2720 strcat (buf
, ", uses new ABI");
2723 case EF_ARM_OLD_ABI
:
2724 strcat (buf
, ", uses old ABI");
2727 case EF_ARM_SOFT_FLOAT
:
2728 strcat (buf
, ", software FP");
2731 case EF_ARM_VFP_FLOAT
:
2732 strcat (buf
, ", VFP");
2735 case EF_ARM_MAVERICK_FLOAT
:
2736 strcat (buf
, ", Maverick FP");
2747 strcat (buf
,_(", <unknown>"));
2751 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2753 --size
; /* Leave space for null terminator. */
2755 switch (e_flags
& EF_AVR_MACH
)
2757 case E_AVR_MACH_AVR1
:
2758 strncat (buf
, ", avr:1", size
);
2760 case E_AVR_MACH_AVR2
:
2761 strncat (buf
, ", avr:2", size
);
2763 case E_AVR_MACH_AVR25
:
2764 strncat (buf
, ", avr:25", size
);
2766 case E_AVR_MACH_AVR3
:
2767 strncat (buf
, ", avr:3", size
);
2769 case E_AVR_MACH_AVR31
:
2770 strncat (buf
, ", avr:31", size
);
2772 case E_AVR_MACH_AVR35
:
2773 strncat (buf
, ", avr:35", size
);
2775 case E_AVR_MACH_AVR4
:
2776 strncat (buf
, ", avr:4", size
);
2778 case E_AVR_MACH_AVR5
:
2779 strncat (buf
, ", avr:5", size
);
2781 case E_AVR_MACH_AVR51
:
2782 strncat (buf
, ", avr:51", size
);
2784 case E_AVR_MACH_AVR6
:
2785 strncat (buf
, ", avr:6", size
);
2787 case E_AVR_MACH_AVRTINY
:
2788 strncat (buf
, ", avr:100", size
);
2790 case E_AVR_MACH_XMEGA1
:
2791 strncat (buf
, ", avr:101", size
);
2793 case E_AVR_MACH_XMEGA2
:
2794 strncat (buf
, ", avr:102", size
);
2796 case E_AVR_MACH_XMEGA3
:
2797 strncat (buf
, ", avr:103", size
);
2799 case E_AVR_MACH_XMEGA4
:
2800 strncat (buf
, ", avr:104", size
);
2802 case E_AVR_MACH_XMEGA5
:
2803 strncat (buf
, ", avr:105", size
);
2805 case E_AVR_MACH_XMEGA6
:
2806 strncat (buf
, ", avr:106", size
);
2808 case E_AVR_MACH_XMEGA7
:
2809 strncat (buf
, ", avr:107", size
);
2812 strncat (buf
, ", avr:<unknown>", size
);
2816 size
-= strlen (buf
);
2817 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2818 strncat (buf
, ", link-relax", size
);
2822 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2828 bfd_boolean has_fpu
= FALSE
;
2831 static const char *ABI_STRINGS
[] =
2833 "ABI v0", /* use r5 as return register; only used in N1213HC */
2834 "ABI v1", /* use r0 as return register */
2835 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2836 "ABI v2fp", /* for FPU */
2840 static const char *VER_STRINGS
[] =
2842 "Andes ELF V1.3 or older",
2846 static const char *ARCH_STRINGS
[] =
2855 abi
= EF_NDS_ABI
& e_flags
;
2856 arch
= EF_NDS_ARCH
& e_flags
;
2857 config
= EF_NDS_INST
& e_flags
;
2858 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2860 memset (buf
, 0, size
);
2867 case E_NDS_ABI_V2FP
:
2868 case E_NDS_ABI_AABI
:
2869 case E_NDS_ABI_V2FP_PLUS
:
2870 /* In case there are holes in the array. */
2871 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2875 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2881 case E_NDS32_ELF_VER_1_2
:
2882 case E_NDS32_ELF_VER_1_3
:
2883 case E_NDS32_ELF_VER_1_4
:
2884 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2888 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2892 if (E_NDS_ABI_V0
== abi
)
2894 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2895 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2897 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2903 case E_NDS_ARCH_STAR_V1_0
:
2904 case E_NDS_ARCH_STAR_V2_0
:
2905 case E_NDS_ARCH_STAR_V3_0
:
2906 case E_NDS_ARCH_STAR_V3_M
:
2907 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2911 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2912 /* ARCH version determines how the e_flags are interpreted.
2913 If it is unknown, we cannot proceed. */
2917 /* Newer ABI; Now handle architecture specific flags. */
2918 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2920 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2923 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2924 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2926 if (config
& E_NDS32_HAS_DIV_INST
)
2927 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2929 if (config
& E_NDS32_HAS_16BIT_INST
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2934 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2936 if (version
<= E_NDS32_ELF_VER_1_3
)
2937 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2939 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2942 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2943 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2945 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2946 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2948 if (config
& E_NDS32_HAS_16BIT_INST
)
2950 if (version
<= E_NDS32_ELF_VER_1_3
)
2951 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2953 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2957 if (config
& E_NDS32_HAS_EXT_INST
)
2958 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2960 if (config
& E_NDS32_HAS_EXT2_INST
)
2961 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2963 if (config
& E_NDS32_HAS_FPU_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2969 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2972 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2975 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2978 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2983 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2985 case E_NDS32_FPU_REG_8SP_4DP
:
2986 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2988 case E_NDS32_FPU_REG_16SP_8DP
:
2989 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2991 case E_NDS32_FPU_REG_32SP_16DP
:
2992 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2994 case E_NDS32_FPU_REG_32SP_32DP
:
2995 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3000 if (config
& E_NDS32_HAS_AUDIO_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3003 if (config
& E_NDS32_HAS_STRING_INST
)
3004 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3006 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3009 if (config
& E_NDS32_HAS_VIDEO_INST
)
3011 if (version
<= E_NDS32_ELF_VER_1_3
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3014 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3017 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3018 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3020 if (config
& E_NDS32_HAS_L2C_INST
)
3021 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3027 static char buf
[1024];
3038 case EM_ARC_COMPACT2
:
3039 case EM_ARC_COMPACT
:
3040 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3044 decode_ARM_machine_flags (e_flags
, buf
);
3048 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3052 if (e_flags
& EF_BFIN_PIC
)
3053 strcat (buf
, ", PIC");
3055 if (e_flags
& EF_BFIN_FDPIC
)
3056 strcat (buf
, ", FDPIC");
3058 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3059 strcat (buf
, ", code in L1");
3061 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3062 strcat (buf
, ", data in L1");
3067 switch (e_flags
& EF_FRV_CPU_MASK
)
3069 case EF_FRV_CPU_GENERIC
:
3073 strcat (buf
, ", fr???");
3076 case EF_FRV_CPU_FR300
:
3077 strcat (buf
, ", fr300");
3080 case EF_FRV_CPU_FR400
:
3081 strcat (buf
, ", fr400");
3083 case EF_FRV_CPU_FR405
:
3084 strcat (buf
, ", fr405");
3087 case EF_FRV_CPU_FR450
:
3088 strcat (buf
, ", fr450");
3091 case EF_FRV_CPU_FR500
:
3092 strcat (buf
, ", fr500");
3094 case EF_FRV_CPU_FR550
:
3095 strcat (buf
, ", fr550");
3098 case EF_FRV_CPU_SIMPLE
:
3099 strcat (buf
, ", simple");
3101 case EF_FRV_CPU_TOMCAT
:
3102 strcat (buf
, ", tomcat");
3108 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3109 strcat (buf
, ", m68000");
3110 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3111 strcat (buf
, ", cpu32");
3112 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3113 strcat (buf
, ", fido_a");
3116 char const * isa
= _("unknown");
3117 char const * mac
= _("unknown mac");
3118 char const * additional
= NULL
;
3120 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3122 case EF_M68K_CF_ISA_A_NODIV
:
3124 additional
= ", nodiv";
3126 case EF_M68K_CF_ISA_A
:
3129 case EF_M68K_CF_ISA_A_PLUS
:
3132 case EF_M68K_CF_ISA_B_NOUSP
:
3134 additional
= ", nousp";
3136 case EF_M68K_CF_ISA_B
:
3139 case EF_M68K_CF_ISA_C
:
3142 case EF_M68K_CF_ISA_C_NODIV
:
3144 additional
= ", nodiv";
3147 strcat (buf
, ", cf, isa ");
3150 strcat (buf
, additional
);
3151 if (e_flags
& EF_M68K_CF_FLOAT
)
3152 strcat (buf
, ", float");
3153 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3158 case EF_M68K_CF_MAC
:
3161 case EF_M68K_CF_EMAC
:
3164 case EF_M68K_CF_EMAC_B
:
3177 switch (e_flags
& EF_MEP_CPU_MASK
)
3179 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3180 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3181 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3182 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3183 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3184 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3185 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3188 switch (e_flags
& EF_MEP_COP_MASK
)
3190 case EF_MEP_COP_NONE
: break;
3191 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3192 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3193 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3194 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3195 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3198 if (e_flags
& EF_MEP_LIBRARY
)
3199 strcat (buf
, ", Built for Library");
3201 if (e_flags
& EF_MEP_INDEX_MASK
)
3202 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3203 e_flags
& EF_MEP_INDEX_MASK
);
3205 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3206 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3207 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3211 if (e_flags
& EF_PPC_EMB
)
3212 strcat (buf
, ", emb");
3214 if (e_flags
& EF_PPC_RELOCATABLE
)
3215 strcat (buf
, _(", relocatable"));
3217 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3218 strcat (buf
, _(", relocatable-lib"));
3222 if (e_flags
& EF_PPC64_ABI
)
3224 char abi
[] = ", abiv0";
3226 abi
[6] += e_flags
& EF_PPC64_ABI
;
3232 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3233 strcat (buf
, ", RH850 ABI");
3235 if (e_flags
& EF_V800_850E3
)
3236 strcat (buf
, ", V3 architecture");
3238 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3239 strcat (buf
, ", FPU not used");
3241 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3242 strcat (buf
, ", regmode: COMMON");
3244 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3245 strcat (buf
, ", r4 not used");
3247 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3248 strcat (buf
, ", r30 not used");
3250 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3251 strcat (buf
, ", r5 not used");
3253 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3254 strcat (buf
, ", r2 not used");
3256 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3258 switch (e_flags
& - e_flags
)
3260 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3261 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3262 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3263 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3264 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3265 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3266 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3267 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3268 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3269 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3270 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3271 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3278 case EM_CYGNUS_V850
:
3279 switch (e_flags
& EF_V850_ARCH
)
3281 case E_V850E3V5_ARCH
:
3282 strcat (buf
, ", v850e3v5");
3284 case E_V850E2V3_ARCH
:
3285 strcat (buf
, ", v850e2v3");
3288 strcat (buf
, ", v850e2");
3291 strcat (buf
, ", v850e1");
3294 strcat (buf
, ", v850e");
3297 strcat (buf
, ", v850");
3300 strcat (buf
, _(", unknown v850 architecture variant"));
3306 case EM_CYGNUS_M32R
:
3307 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3308 strcat (buf
, ", m32r");
3312 case EM_MIPS_RS3_LE
:
3313 if (e_flags
& EF_MIPS_NOREORDER
)
3314 strcat (buf
, ", noreorder");
3316 if (e_flags
& EF_MIPS_PIC
)
3317 strcat (buf
, ", pic");
3319 if (e_flags
& EF_MIPS_CPIC
)
3320 strcat (buf
, ", cpic");
3322 if (e_flags
& EF_MIPS_UCODE
)
3323 strcat (buf
, ", ugen_reserved");
3325 if (e_flags
& EF_MIPS_ABI2
)
3326 strcat (buf
, ", abi2");
3328 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3329 strcat (buf
, ", odk first");
3331 if (e_flags
& EF_MIPS_32BITMODE
)
3332 strcat (buf
, ", 32bitmode");
3334 if (e_flags
& EF_MIPS_NAN2008
)
3335 strcat (buf
, ", nan2008");
3337 if (e_flags
& EF_MIPS_FP64
)
3338 strcat (buf
, ", fp64");
3340 switch ((e_flags
& EF_MIPS_MACH
))
3342 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3343 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3344 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3345 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3346 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3347 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3348 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3349 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3350 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3351 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3352 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3353 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3354 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3355 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3356 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3357 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3358 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3359 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3360 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3362 /* We simply ignore the field in this case to avoid confusion:
3363 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3366 default: strcat (buf
, _(", unknown CPU")); break;
3369 switch ((e_flags
& EF_MIPS_ABI
))
3371 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3372 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3373 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3374 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3376 /* We simply ignore the field in this case to avoid confusion:
3377 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3378 This means it is likely to be an o32 file, but not for
3381 default: strcat (buf
, _(", unknown ABI")); break;
3384 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3385 strcat (buf
, ", mdmx");
3387 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3388 strcat (buf
, ", mips16");
3390 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3391 strcat (buf
, ", micromips");
3393 switch ((e_flags
& EF_MIPS_ARCH
))
3395 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3396 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3397 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3398 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3399 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3400 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3401 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3402 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3403 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3404 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3405 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3406 default: strcat (buf
, _(", unknown ISA")); break;
3411 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3415 if (e_flags
& EF_RISCV_RVC
)
3416 strcat (buf
, ", RVC");
3418 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3420 case EF_RISCV_FLOAT_ABI_SOFT
:
3421 strcat (buf
, ", soft-float ABI");
3424 case EF_RISCV_FLOAT_ABI_SINGLE
:
3425 strcat (buf
, ", single-float ABI");
3428 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3429 strcat (buf
, ", double-float ABI");
3432 case EF_RISCV_FLOAT_ABI_QUAD
:
3433 strcat (buf
, ", quad-float ABI");
3439 switch ((e_flags
& EF_SH_MACH_MASK
))
3441 case EF_SH1
: strcat (buf
, ", sh1"); break;
3442 case EF_SH2
: strcat (buf
, ", sh2"); break;
3443 case EF_SH3
: strcat (buf
, ", sh3"); break;
3444 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3445 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3446 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3447 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3448 case EF_SH4
: strcat (buf
, ", sh4"); break;
3449 case EF_SH5
: strcat (buf
, ", sh5"); break;
3450 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3451 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3452 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3453 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3454 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3455 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3456 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3457 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3458 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3459 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3460 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3461 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3462 default: strcat (buf
, _(", unknown ISA")); break;
3465 if (e_flags
& EF_SH_PIC
)
3466 strcat (buf
, ", pic");
3468 if (e_flags
& EF_SH_FDPIC
)
3469 strcat (buf
, ", fdpic");
3473 if (e_flags
& EF_OR1K_NODELAY
)
3474 strcat (buf
, ", no delay");
3478 if (e_flags
& EF_SPARC_32PLUS
)
3479 strcat (buf
, ", v8+");
3481 if (e_flags
& EF_SPARC_SUN_US1
)
3482 strcat (buf
, ", ultrasparcI");
3484 if (e_flags
& EF_SPARC_SUN_US3
)
3485 strcat (buf
, ", ultrasparcIII");
3487 if (e_flags
& EF_SPARC_HAL_R1
)
3488 strcat (buf
, ", halr1");
3490 if (e_flags
& EF_SPARC_LEDATA
)
3491 strcat (buf
, ", ledata");
3493 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3494 strcat (buf
, ", tso");
3496 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3497 strcat (buf
, ", pso");
3499 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3500 strcat (buf
, ", rmo");
3504 switch (e_flags
& EF_PARISC_ARCH
)
3506 case EFA_PARISC_1_0
:
3507 strcpy (buf
, ", PA-RISC 1.0");
3509 case EFA_PARISC_1_1
:
3510 strcpy (buf
, ", PA-RISC 1.1");
3512 case EFA_PARISC_2_0
:
3513 strcpy (buf
, ", PA-RISC 2.0");
3518 if (e_flags
& EF_PARISC_TRAPNIL
)
3519 strcat (buf
, ", trapnil");
3520 if (e_flags
& EF_PARISC_EXT
)
3521 strcat (buf
, ", ext");
3522 if (e_flags
& EF_PARISC_LSB
)
3523 strcat (buf
, ", lsb");
3524 if (e_flags
& EF_PARISC_WIDE
)
3525 strcat (buf
, ", wide");
3526 if (e_flags
& EF_PARISC_NO_KABP
)
3527 strcat (buf
, ", no kabp");
3528 if (e_flags
& EF_PARISC_LAZYSWAP
)
3529 strcat (buf
, ", lazyswap");
3534 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3535 strcat (buf
, ", new calling convention");
3537 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3538 strcat (buf
, ", gnu calling convention");
3542 if ((e_flags
& EF_IA_64_ABI64
))
3543 strcat (buf
, ", 64-bit");
3545 strcat (buf
, ", 32-bit");
3546 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3547 strcat (buf
, ", reduced fp model");
3548 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3549 strcat (buf
, ", no function descriptors, constant gp");
3550 else if ((e_flags
& EF_IA_64_CONS_GP
))
3551 strcat (buf
, ", constant gp");
3552 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3553 strcat (buf
, ", absolute");
3554 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3556 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3557 strcat (buf
, ", vms_linkages");
3558 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3560 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3562 case EF_IA_64_VMS_COMCOD_WARNING
:
3563 strcat (buf
, ", warning");
3565 case EF_IA_64_VMS_COMCOD_ERROR
:
3566 strcat (buf
, ", error");
3568 case EF_IA_64_VMS_COMCOD_ABORT
:
3569 strcat (buf
, ", abort");
3572 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573 e_flags
& EF_IA_64_VMS_COMCOD
);
3574 strcat (buf
, ", <unknown>");
3580 if ((e_flags
& EF_VAX_NONPIC
))
3581 strcat (buf
, ", non-PIC");
3582 if ((e_flags
& EF_VAX_DFLOAT
))
3583 strcat (buf
, ", D-Float");
3584 if ((e_flags
& EF_VAX_GFLOAT
))
3585 strcat (buf
, ", G-Float");
3589 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3590 strcat (buf
, ", mcm");
3591 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3592 strcat (buf
, ", mcm24");
3593 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3594 strcat (buf
, ", gr6");
3598 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3600 case E_FLAG_RL78_ANY_CPU
: break;
3601 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3602 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3603 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3605 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3606 strcat (buf
, ", 64-bit doubles");
3610 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3611 strcat (buf
, ", 64-bit doubles");
3612 if (e_flags
& E_FLAG_RX_DSP
)
3613 strcat (buf
, ", dsp");
3614 if (e_flags
& E_FLAG_RX_PID
)
3615 strcat (buf
, ", pid");
3616 if (e_flags
& E_FLAG_RX_ABI
)
3617 strcat (buf
, ", RX ABI");
3618 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3619 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3620 ? ", uses String instructions" : ", bans String instructions");
3621 if (e_flags
& E_FLAG_RX_V2
)
3622 strcat (buf
, ", V2");
3626 if (e_flags
& EF_S390_HIGH_GPRS
)
3627 strcat (buf
, ", highgprs");
3631 if ((e_flags
& EF_C6000_REL
))
3632 strcat (buf
, ", relocatable module");
3636 strcat (buf
, _(": architecture variant: "));
3637 switch (e_flags
& EF_MSP430_MACH
)
3639 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3640 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3641 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3642 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3643 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3644 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3645 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3646 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3647 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3648 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3649 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3650 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3651 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3652 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3653 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3655 strcat (buf
, _(": unknown")); break;
3658 if (e_flags
& ~ EF_MSP430_MACH
)
3659 strcat (buf
, _(": unknown extra flag bits also present"));
3667 get_osabi_name (unsigned int osabi
)
3669 static char buff
[32];
3673 case ELFOSABI_NONE
: return "UNIX - System V";
3674 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3675 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3676 case ELFOSABI_GNU
: return "UNIX - GNU";
3677 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3678 case ELFOSABI_AIX
: return "UNIX - AIX";
3679 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3680 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3681 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3682 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3683 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3684 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3685 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3686 case ELFOSABI_AROS
: return "AROS";
3687 case ELFOSABI_FENIXOS
: return "FenixOS";
3688 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3689 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3692 switch (elf_header
.e_machine
)
3697 case ELFOSABI_ARM
: return "ARM";
3708 case ELFOSABI_STANDALONE
: return _("Standalone App");
3717 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3718 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3727 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3733 get_aarch64_segment_type (unsigned long type
)
3737 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3738 default: return NULL
;
3743 get_arm_segment_type (unsigned long type
)
3747 case PT_ARM_EXIDX
: return "EXIDX";
3748 default: return NULL
;
3753 get_s390_segment_type (unsigned long type
)
3757 case PT_S390_PGSTE
: return "S390_PGSTE";
3758 default: return NULL
;
3763 get_mips_segment_type (unsigned long type
)
3767 case PT_MIPS_REGINFO
: return "REGINFO";
3768 case PT_MIPS_RTPROC
: return "RTPROC";
3769 case PT_MIPS_OPTIONS
: return "OPTIONS";
3770 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3771 default: return NULL
;
3776 get_parisc_segment_type (unsigned long type
)
3780 case PT_HP_TLS
: return "HP_TLS";
3781 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3782 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3783 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3784 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3785 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3786 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3787 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3788 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3789 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3790 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3791 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3792 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3793 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3794 case PT_HP_STACK
: return "HP_STACK";
3795 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3796 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3797 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3798 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3799 default: return NULL
;
3804 get_ia64_segment_type (unsigned long type
)
3808 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3809 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3810 case PT_HP_TLS
: return "HP_TLS";
3811 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3812 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3813 case PT_IA_64_HP_STACK
: return "HP_STACK";
3814 default: return NULL
;
3819 get_tic6x_segment_type (unsigned long type
)
3823 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3824 default: return NULL
;
3829 get_solaris_segment_type (unsigned long type
)
3833 case 0x6464e550: return "PT_SUNW_UNWIND";
3834 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3835 case 0x6ffffff7: return "PT_LOSUNW";
3836 case 0x6ffffffa: return "PT_SUNWBSS";
3837 case 0x6ffffffb: return "PT_SUNWSTACK";
3838 case 0x6ffffffc: return "PT_SUNWDTRACE";
3839 case 0x6ffffffd: return "PT_SUNWCAP";
3840 case 0x6fffffff: return "PT_HISUNW";
3841 default: return NULL
;
3846 get_segment_type (unsigned long p_type
)
3848 static char buff
[32];
3852 case PT_NULL
: return "NULL";
3853 case PT_LOAD
: return "LOAD";
3854 case PT_DYNAMIC
: return "DYNAMIC";
3855 case PT_INTERP
: return "INTERP";
3856 case PT_NOTE
: return "NOTE";
3857 case PT_SHLIB
: return "SHLIB";
3858 case PT_PHDR
: return "PHDR";
3859 case PT_TLS
: return "TLS";
3860 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3861 case PT_GNU_STACK
: return "GNU_STACK";
3862 case PT_GNU_RELRO
: return "GNU_RELRO";
3865 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3867 sprintf (buff
, "GNU_MBIND+%#lx",
3868 p_type
- PT_GNU_MBIND_LO
);
3870 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3872 const char * result
;
3874 switch (elf_header
.e_machine
)
3877 result
= get_aarch64_segment_type (p_type
);
3880 result
= get_arm_segment_type (p_type
);
3883 case EM_MIPS_RS3_LE
:
3884 result
= get_mips_segment_type (p_type
);
3887 result
= get_parisc_segment_type (p_type
);
3890 result
= get_ia64_segment_type (p_type
);
3893 result
= get_tic6x_segment_type (p_type
);
3897 result
= get_s390_segment_type (p_type
);
3907 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3909 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3911 const char * result
;
3913 switch (elf_header
.e_machine
)
3916 result
= get_parisc_segment_type (p_type
);
3919 result
= get_ia64_segment_type (p_type
);
3922 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3923 result
= get_solaris_segment_type (p_type
);
3932 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3935 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3942 get_arc_section_type_name (unsigned int sh_type
)
3946 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3954 get_mips_section_type_name (unsigned int sh_type
)
3958 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3959 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3960 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3961 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3962 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3963 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3964 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3965 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3966 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3967 case SHT_MIPS_RELD
: return "MIPS_RELD";
3968 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3969 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3970 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3971 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3972 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3973 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3974 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3975 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3976 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3977 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3978 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3979 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3980 case SHT_MIPS_LINE
: return "MIPS_LINE";
3981 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3982 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3983 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3984 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3985 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3986 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3987 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3988 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3989 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3990 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3991 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3992 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3993 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3994 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3995 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3996 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3997 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4005 get_parisc_section_type_name (unsigned int sh_type
)
4009 case SHT_PARISC_EXT
: return "PARISC_EXT";
4010 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4011 case SHT_PARISC_DOC
: return "PARISC_DOC";
4012 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4013 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4014 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4015 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4016 default: return NULL
;
4021 get_ia64_section_type_name (unsigned int sh_type
)
4023 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4024 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4025 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4029 case SHT_IA_64_EXT
: return "IA_64_EXT";
4030 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4031 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4032 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4033 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4034 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4035 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4036 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4037 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4038 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4046 get_x86_64_section_type_name (unsigned int sh_type
)
4050 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4051 default: return NULL
;
4056 get_aarch64_section_type_name (unsigned int sh_type
)
4060 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4061 default: return NULL
;
4066 get_arm_section_type_name (unsigned int sh_type
)
4070 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4071 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4072 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4073 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4074 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4075 default: return NULL
;
4080 get_tic6x_section_type_name (unsigned int sh_type
)
4084 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4085 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4086 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4087 case SHT_TI_ICODE
: return "TI_ICODE";
4088 case SHT_TI_XREF
: return "TI_XREF";
4089 case SHT_TI_HANDLER
: return "TI_HANDLER";
4090 case SHT_TI_INITINFO
: return "TI_INITINFO";
4091 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4092 default: return NULL
;
4097 get_msp430x_section_type_name (unsigned int sh_type
)
4101 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4102 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4103 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4104 default: return NULL
;
4109 get_v850_section_type_name (unsigned int sh_type
)
4113 case SHT_V850_SCOMMON
: return "V850 Small Common";
4114 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4115 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4116 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4117 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4118 default: return NULL
;
4123 get_section_type_name (unsigned int sh_type
)
4125 static char buff
[32];
4126 const char * result
;
4130 case SHT_NULL
: return "NULL";
4131 case SHT_PROGBITS
: return "PROGBITS";
4132 case SHT_SYMTAB
: return "SYMTAB";
4133 case SHT_STRTAB
: return "STRTAB";
4134 case SHT_RELA
: return "RELA";
4135 case SHT_HASH
: return "HASH";
4136 case SHT_DYNAMIC
: return "DYNAMIC";
4137 case SHT_NOTE
: return "NOTE";
4138 case SHT_NOBITS
: return "NOBITS";
4139 case SHT_REL
: return "REL";
4140 case SHT_SHLIB
: return "SHLIB";
4141 case SHT_DYNSYM
: return "DYNSYM";
4142 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4143 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4144 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4145 case SHT_GNU_HASH
: return "GNU_HASH";
4146 case SHT_GROUP
: return "GROUP";
4147 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4148 case SHT_GNU_verdef
: return "VERDEF";
4149 case SHT_GNU_verneed
: return "VERNEED";
4150 case SHT_GNU_versym
: return "VERSYM";
4151 case 0x6ffffff0: return "VERSYM";
4152 case 0x6ffffffc: return "VERDEF";
4153 case 0x7ffffffd: return "AUXILIARY";
4154 case 0x7fffffff: return "FILTER";
4155 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4158 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4160 switch (elf_header
.e_machine
)
4163 case EM_ARC_COMPACT
:
4164 case EM_ARC_COMPACT2
:
4165 result
= get_arc_section_type_name (sh_type
);
4168 case EM_MIPS_RS3_LE
:
4169 result
= get_mips_section_type_name (sh_type
);
4172 result
= get_parisc_section_type_name (sh_type
);
4175 result
= get_ia64_section_type_name (sh_type
);
4180 result
= get_x86_64_section_type_name (sh_type
);
4183 result
= get_aarch64_section_type_name (sh_type
);
4186 result
= get_arm_section_type_name (sh_type
);
4189 result
= get_tic6x_section_type_name (sh_type
);
4192 result
= get_msp430x_section_type_name (sh_type
);
4196 case EM_CYGNUS_V850
:
4197 result
= get_v850_section_type_name (sh_type
);
4207 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4209 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4211 switch (elf_header
.e_machine
)
4214 result
= get_ia64_section_type_name (sh_type
);
4217 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4218 result
= get_solaris_section_type (sh_type
);
4223 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4224 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4225 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4226 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4238 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4240 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4242 switch (elf_header
.e_machine
)
4246 case EM_CYGNUS_V850
:
4247 result
= get_v850_section_type_name (sh_type
);
4257 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4260 /* This message is probably going to be displayed in a 15
4261 character wide field, so put the hex value first. */
4262 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4268 #define OPTION_DEBUG_DUMP 512
4269 #define OPTION_DYN_SYMS 513
4270 #define OPTION_DWARF_DEPTH 514
4271 #define OPTION_DWARF_START 515
4272 #define OPTION_DWARF_CHECK 516
4274 static struct option options
[] =
4276 {"all", no_argument
, 0, 'a'},
4277 {"file-header", no_argument
, 0, 'h'},
4278 {"program-headers", no_argument
, 0, 'l'},
4279 {"headers", no_argument
, 0, 'e'},
4280 {"histogram", no_argument
, 0, 'I'},
4281 {"segments", no_argument
, 0, 'l'},
4282 {"sections", no_argument
, 0, 'S'},
4283 {"section-headers", no_argument
, 0, 'S'},
4284 {"section-groups", no_argument
, 0, 'g'},
4285 {"section-details", no_argument
, 0, 't'},
4286 {"full-section-name",no_argument
, 0, 'N'},
4287 {"symbols", no_argument
, 0, 's'},
4288 {"syms", no_argument
, 0, 's'},
4289 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4290 {"relocs", no_argument
, 0, 'r'},
4291 {"notes", no_argument
, 0, 'n'},
4292 {"dynamic", no_argument
, 0, 'd'},
4293 {"arch-specific", no_argument
, 0, 'A'},
4294 {"version-info", no_argument
, 0, 'V'},
4295 {"use-dynamic", no_argument
, 0, 'D'},
4296 {"unwind", no_argument
, 0, 'u'},
4297 {"archive-index", no_argument
, 0, 'c'},
4298 {"hex-dump", required_argument
, 0, 'x'},
4299 {"relocated-dump", required_argument
, 0, 'R'},
4300 {"string-dump", required_argument
, 0, 'p'},
4301 {"decompress", no_argument
, 0, 'z'},
4302 #ifdef SUPPORT_DISASSEMBLY
4303 {"instruction-dump", required_argument
, 0, 'i'},
4305 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4307 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4308 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4309 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4311 {"version", no_argument
, 0, 'v'},
4312 {"wide", no_argument
, 0, 'W'},
4313 {"help", no_argument
, 0, 'H'},
4314 {0, no_argument
, 0, 0}
4318 usage (FILE * stream
)
4320 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4321 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4322 fprintf (stream
, _(" Options are:\n\
4323 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4324 -h --file-header Display the ELF file header\n\
4325 -l --program-headers Display the program headers\n\
4326 --segments An alias for --program-headers\n\
4327 -S --section-headers Display the sections' header\n\
4328 --sections An alias for --section-headers\n\
4329 -g --section-groups Display the section groups\n\
4330 -t --section-details Display the section details\n\
4331 -e --headers Equivalent to: -h -l -S\n\
4332 -s --syms Display the symbol table\n\
4333 --symbols An alias for --syms\n\
4334 --dyn-syms Display the dynamic symbol table\n\
4335 -n --notes Display the core notes (if present)\n\
4336 -r --relocs Display the relocations (if present)\n\
4337 -u --unwind Display the unwind info (if present)\n\
4338 -d --dynamic Display the dynamic section (if present)\n\
4339 -V --version-info Display the version sections (if present)\n\
4340 -A --arch-specific Display architecture specific information (if any)\n\
4341 -c --archive-index Display the symbol/file index in an archive\n\
4342 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4343 -x --hex-dump=<number|name>\n\
4344 Dump the contents of section <number|name> as bytes\n\
4345 -p --string-dump=<number|name>\n\
4346 Dump the contents of section <number|name> as strings\n\
4347 -R --relocated-dump=<number|name>\n\
4348 Dump the contents of section <number|name> as relocated bytes\n\
4349 -z --decompress Decompress section before dumping it\n\
4350 -w[lLiaprmfFsoRt] or\n\
4351 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4352 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4353 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4355 Display the contents of DWARF2 debug sections\n"));
4356 fprintf (stream
, _("\
4357 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4358 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4360 #ifdef SUPPORT_DISASSEMBLY
4361 fprintf (stream
, _("\
4362 -i --instruction-dump=<number|name>\n\
4363 Disassemble the contents of section <number|name>\n"));
4365 fprintf (stream
, _("\
4366 -I --histogram Display histogram of bucket list lengths\n\
4367 -W --wide Allow output width to exceed 80 characters\n\
4368 @<file> Read options from <file>\n\
4369 -H --help Display this information\n\
4370 -v --version Display the version number of readelf\n"));
4372 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4373 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4375 exit (stream
== stdout
? 0 : 1);
4378 /* Record the fact that the user wants the contents of section number
4379 SECTION to be displayed using the method(s) encoded as flags bits
4380 in TYPE. Note, TYPE can be zero if we are creating the array for
4384 request_dump_bynumber (unsigned int section
, dump_type type
)
4386 if (section
>= num_dump_sects
)
4388 dump_type
* new_dump_sects
;
4390 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4391 sizeof (* dump_sects
));
4393 if (new_dump_sects
== NULL
)
4394 error (_("Out of memory allocating dump request table.\n"));
4399 /* Copy current flag settings. */
4400 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4405 dump_sects
= new_dump_sects
;
4406 num_dump_sects
= section
+ 1;
4411 dump_sects
[section
] |= type
;
4416 /* Request a dump by section name. */
4419 request_dump_byname (const char * section
, dump_type type
)
4421 struct dump_list_entry
* new_request
;
4423 new_request
= (struct dump_list_entry
*)
4424 malloc (sizeof (struct dump_list_entry
));
4426 error (_("Out of memory allocating dump request table.\n"));
4428 new_request
->name
= strdup (section
);
4429 if (!new_request
->name
)
4430 error (_("Out of memory allocating dump request table.\n"));
4432 new_request
->type
= type
;
4434 new_request
->next
= dump_sects_byname
;
4435 dump_sects_byname
= new_request
;
4439 request_dump (dump_type type
)
4445 section
= strtoul (optarg
, & cp
, 0);
4447 if (! *cp
&& section
>= 0)
4448 request_dump_bynumber (section
, type
);
4450 request_dump_byname (optarg
, type
);
4455 parse_args (int argc
, char ** argv
)
4462 while ((c
= getopt_long
4463 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4481 do_section_groups
= TRUE
;
4484 do_histogram
= TRUE
;
4489 do_section_groups
= TRUE
;
4494 do_section_details
= TRUE
;
4505 do_using_dynamic
= TRUE
;
4529 do_histogram
= TRUE
;
4535 do_archive_index
= TRUE
;
4538 request_dump (HEX_DUMP
);
4541 request_dump (STRING_DUMP
);
4544 request_dump (RELOC_DUMP
);
4547 decompress_dumps
= TRUE
;
4553 do_debugging
= TRUE
;
4554 dwarf_select_sections_all ();
4558 do_debugging
= FALSE
;
4559 dwarf_select_sections_by_letters (optarg
);
4562 case OPTION_DEBUG_DUMP
:
4565 do_debugging
= TRUE
;
4568 do_debugging
= FALSE
;
4569 dwarf_select_sections_by_names (optarg
);
4572 case OPTION_DWARF_DEPTH
:
4576 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4579 case OPTION_DWARF_START
:
4583 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4586 case OPTION_DWARF_CHECK
:
4589 case OPTION_DYN_SYMS
:
4592 #ifdef SUPPORT_DISASSEMBLY
4594 request_dump (DISASS_DUMP
);
4598 print_version (program_name
);
4607 /* xgettext:c-format */
4608 error (_("Invalid option '-%c'\n"), c
);
4615 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4616 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4617 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4618 && !do_section_groups
&& !do_archive_index
4624 get_elf_class (unsigned int elf_class
)
4626 static char buff
[32];
4630 case ELFCLASSNONE
: return _("none");
4631 case ELFCLASS32
: return "ELF32";
4632 case ELFCLASS64
: return "ELF64";
4634 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4640 get_data_encoding (unsigned int encoding
)
4642 static char buff
[32];
4646 case ELFDATANONE
: return _("none");
4647 case ELFDATA2LSB
: return _("2's complement, little endian");
4648 case ELFDATA2MSB
: return _("2's complement, big endian");
4650 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4655 /* Decode the data held in 'elf_header'. */
4658 process_file_header (void)
4660 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4661 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4662 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4663 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4666 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4670 init_dwarf_regnames (elf_header
.e_machine
);
4676 printf (_("ELF Header:\n"));
4677 printf (_(" Magic: "));
4678 for (i
= 0; i
< EI_NIDENT
; i
++)
4679 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4681 printf (_(" Class: %s\n"),
4682 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4683 printf (_(" Data: %s\n"),
4684 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4685 printf (_(" Version: %d %s\n"),
4686 elf_header
.e_ident
[EI_VERSION
],
4687 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4689 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4690 ? _("<unknown: %lx>")
4692 printf (_(" OS/ABI: %s\n"),
4693 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4694 printf (_(" ABI Version: %d\n"),
4695 elf_header
.e_ident
[EI_ABIVERSION
]);
4696 printf (_(" Type: %s\n"),
4697 get_file_type (elf_header
.e_type
));
4698 printf (_(" Machine: %s\n"),
4699 get_machine_name (elf_header
.e_machine
));
4700 printf (_(" Version: 0x%lx\n"),
4701 (unsigned long) elf_header
.e_version
);
4703 printf (_(" Entry point address: "));
4704 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4705 printf (_("\n Start of program headers: "));
4706 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4707 printf (_(" (bytes into file)\n Start of section headers: "));
4708 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4709 printf (_(" (bytes into file)\n"));
4711 printf (_(" Flags: 0x%lx%s\n"),
4712 (unsigned long) elf_header
.e_flags
,
4713 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4714 printf (_(" Size of this header: %ld (bytes)\n"),
4715 (long) elf_header
.e_ehsize
);
4716 printf (_(" Size of program headers: %ld (bytes)\n"),
4717 (long) elf_header
.e_phentsize
);
4718 printf (_(" Number of program headers: %ld"),
4719 (long) elf_header
.e_phnum
);
4720 if (section_headers
!= NULL
4721 && elf_header
.e_phnum
== PN_XNUM
4722 && section_headers
[0].sh_info
!= 0)
4723 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4724 putc ('\n', stdout
);
4725 printf (_(" Size of section headers: %ld (bytes)\n"),
4726 (long) elf_header
.e_shentsize
);
4727 printf (_(" Number of section headers: %ld"),
4728 (long) elf_header
.e_shnum
);
4729 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4730 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4731 putc ('\n', stdout
);
4732 printf (_(" Section header string table index: %ld"),
4733 (long) elf_header
.e_shstrndx
);
4734 if (section_headers
!= NULL
4735 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4736 printf (" (%u)", section_headers
[0].sh_link
);
4737 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4738 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4739 printf (_(" <corrupt: out of range>"));
4740 putc ('\n', stdout
);
4743 if (section_headers
!= NULL
)
4745 if (elf_header
.e_phnum
== PN_XNUM
4746 && section_headers
[0].sh_info
!= 0)
4747 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4748 if (elf_header
.e_shnum
== SHN_UNDEF
)
4749 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4750 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4751 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4752 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4753 elf_header
.e_shstrndx
= SHN_UNDEF
;
4754 free (section_headers
);
4755 section_headers
= NULL
;
4762 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4764 Elf32_External_Phdr
* phdrs
;
4765 Elf32_External_Phdr
* external
;
4766 Elf_Internal_Phdr
* internal
;
4768 unsigned int size
= elf_header
.e_phentsize
;
4769 unsigned int num
= elf_header
.e_phnum
;
4771 /* PR binutils/17531: Cope with unexpected section header sizes. */
4772 if (size
== 0 || num
== 0)
4774 if (size
< sizeof * phdrs
)
4776 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4779 if (size
> sizeof * phdrs
)
4780 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4782 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4783 size
, num
, _("program headers"));
4787 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4788 i
< elf_header
.e_phnum
;
4789 i
++, internal
++, external
++)
4791 internal
->p_type
= BYTE_GET (external
->p_type
);
4792 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4793 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4794 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4795 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4796 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4797 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4798 internal
->p_align
= BYTE_GET (external
->p_align
);
4806 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4808 Elf64_External_Phdr
* phdrs
;
4809 Elf64_External_Phdr
* external
;
4810 Elf_Internal_Phdr
* internal
;
4812 unsigned int size
= elf_header
.e_phentsize
;
4813 unsigned int num
= elf_header
.e_phnum
;
4815 /* PR binutils/17531: Cope with unexpected section header sizes. */
4816 if (size
== 0 || num
== 0)
4818 if (size
< sizeof * phdrs
)
4820 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4823 if (size
> sizeof * phdrs
)
4824 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4826 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4827 size
, num
, _("program headers"));
4831 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4832 i
< elf_header
.e_phnum
;
4833 i
++, internal
++, external
++)
4835 internal
->p_type
= BYTE_GET (external
->p_type
);
4836 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4837 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4838 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4839 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4840 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4841 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4842 internal
->p_align
= BYTE_GET (external
->p_align
);
4849 /* Returns TRUE if the program headers were read into `program_headers'. */
4852 get_program_headers (FILE * file
)
4854 Elf_Internal_Phdr
* phdrs
;
4856 /* Check cache of prior read. */
4857 if (program_headers
!= NULL
)
4860 /* Be kind to memory checkers by looking for
4861 e_phnum values which we know must be invalid. */
4862 if (elf_header
.e_phnum
4863 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4864 >= current_file_size
)
4866 error (_("Too many program headers - %#x - the file is not that big\n"),
4867 elf_header
.e_phnum
);
4871 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4872 sizeof (Elf_Internal_Phdr
));
4875 error (_("Out of memory reading %u program headers\n"),
4876 elf_header
.e_phnum
);
4881 ? get_32bit_program_headers (file
, phdrs
)
4882 : get_64bit_program_headers (file
, phdrs
))
4884 program_headers
= phdrs
;
4892 /* Returns TRUE if the program headers were loaded. */
4895 process_program_headers (FILE * file
)
4897 Elf_Internal_Phdr
* segment
;
4899 Elf_Internal_Phdr
* previous_load
= NULL
;
4901 if (elf_header
.e_phnum
== 0)
4903 /* PR binutils/12467. */
4904 if (elf_header
.e_phoff
!= 0)
4906 warn (_("possibly corrupt ELF header - it has a non-zero program"
4907 " header offset, but no program headers\n"));
4910 else if (do_segments
)
4911 printf (_("\nThere are no program headers in this file.\n"));
4915 if (do_segments
&& !do_header
)
4917 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4918 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", elf_header
.e_entry
));
4919 printf (ngettext ("There is %d program header, starting at offset %s\n",
4920 "There are %d program headers, starting at offset %s\n",
4921 elf_header
.e_phnum
),
4923 bfd_vmatoa ("u", elf_header
.e_phoff
));
4926 if (! get_program_headers (file
))
4931 if (elf_header
.e_phnum
> 1)
4932 printf (_("\nProgram Headers:\n"));
4934 printf (_("\nProgram Headers:\n"));
4938 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4941 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4945 (_(" Type Offset VirtAddr PhysAddr\n"));
4947 (_(" FileSiz MemSiz Flags Align\n"));
4954 for (i
= 0, segment
= program_headers
;
4955 i
< elf_header
.e_phnum
;
4960 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4964 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4965 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4966 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4967 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4968 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4970 (segment
->p_flags
& PF_R
? 'R' : ' '),
4971 (segment
->p_flags
& PF_W
? 'W' : ' '),
4972 (segment
->p_flags
& PF_X
? 'E' : ' '));
4973 printf ("%#lx", (unsigned long) segment
->p_align
);
4977 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4978 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4981 print_vma (segment
->p_offset
, FULL_HEX
);
4985 print_vma (segment
->p_vaddr
, FULL_HEX
);
4987 print_vma (segment
->p_paddr
, FULL_HEX
);
4990 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4991 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4994 print_vma (segment
->p_filesz
, FULL_HEX
);
4998 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4999 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5002 print_vma (segment
->p_memsz
, FULL_HEX
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5010 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5011 printf ("%#lx", (unsigned long) segment
->p_align
);
5014 print_vma (segment
->p_align
, PREFIX_HEX
);
5019 print_vma (segment
->p_offset
, FULL_HEX
);
5021 print_vma (segment
->p_vaddr
, FULL_HEX
);
5023 print_vma (segment
->p_paddr
, FULL_HEX
);
5025 print_vma (segment
->p_filesz
, FULL_HEX
);
5027 print_vma (segment
->p_memsz
, FULL_HEX
);
5029 (segment
->p_flags
& PF_R
? 'R' : ' '),
5030 (segment
->p_flags
& PF_W
? 'W' : ' '),
5031 (segment
->p_flags
& PF_X
? 'E' : ' '));
5032 print_vma (segment
->p_align
, PREFIX_HEX
);
5035 putc ('\n', stdout
);
5038 switch (segment
->p_type
)
5041 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5042 required by the ELF standard, several programs, including the Linux
5043 kernel, make use of non-ordered segments. */
5045 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5046 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5048 if (segment
->p_memsz
< segment
->p_filesz
)
5049 error (_("the segment's file size is larger than its memory size\n"));
5050 previous_load
= segment
;
5054 /* PR 20815 - Verify that the program header is loaded into memory. */
5055 if (i
> 0 && previous_load
!= NULL
)
5056 error (_("the PHDR segment must occur before any LOAD segment\n"));
5057 if (elf_header
.e_machine
!= EM_PARISC
)
5061 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5062 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5063 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5064 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5066 if (j
== elf_header
.e_phnum
)
5067 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5073 error (_("more than one dynamic segment\n"));
5075 /* By default, assume that the .dynamic section is the first
5076 section in the DYNAMIC segment. */
5077 dynamic_addr
= segment
->p_offset
;
5078 dynamic_size
= segment
->p_filesz
;
5080 /* Try to locate the .dynamic section. If there is
5081 a section header table, we can easily locate it. */
5082 if (section_headers
!= NULL
)
5084 Elf_Internal_Shdr
* sec
;
5086 sec
= find_section (".dynamic");
5087 if (sec
== NULL
|| sec
->sh_size
== 0)
5089 /* A corresponding .dynamic section is expected, but on
5090 IA-64/OpenVMS it is OK for it to be missing. */
5091 if (!is_ia64_vms ())
5092 error (_("no .dynamic section in the dynamic segment\n"));
5096 if (sec
->sh_type
== SHT_NOBITS
)
5102 dynamic_addr
= sec
->sh_offset
;
5103 dynamic_size
= sec
->sh_size
;
5105 if (dynamic_addr
< segment
->p_offset
5106 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5107 warn (_("the .dynamic section is not contained"
5108 " within the dynamic segment\n"));
5109 else if (dynamic_addr
> segment
->p_offset
)
5110 warn (_("the .dynamic section is not the first section"
5111 " in the dynamic segment.\n"));
5114 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5115 segment. Check this after matching against the section headers
5116 so we don't warn on debuginfo file (which have NOBITS .dynamic
5118 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5120 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121 dynamic_addr
= dynamic_size
= 0;
5126 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5128 error (_("Unable to find program interpreter name\n"));
5132 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5134 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5135 error (_("Internal error: failed to create format string to display program interpreter\n"));
5137 program_interpreter
[0] = 0;
5138 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5139 error (_("Unable to read program interpreter name\n"));
5142 printf (_(" [Requesting program interpreter: %s]\n"),
5143 program_interpreter
);
5149 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5151 printf (_("\n Section to Segment mapping:\n"));
5152 printf (_(" Segment Sections...\n"));
5154 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5157 Elf_Internal_Shdr
* section
;
5159 segment
= program_headers
+ i
;
5160 section
= section_headers
+ 1;
5162 printf (" %2.2d ", i
);
5164 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5166 if (!ELF_TBSS_SPECIAL (section
, segment
)
5167 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5168 printf ("%s ", printable_section_name (section
));
5179 /* Find the file offset corresponding to VMA by using the program headers. */
5182 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5184 Elf_Internal_Phdr
* seg
;
5186 if (! get_program_headers (file
))
5188 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5192 for (seg
= program_headers
;
5193 seg
< program_headers
+ elf_header
.e_phnum
;
5196 if (seg
->p_type
!= PT_LOAD
)
5199 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5200 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5201 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5204 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205 (unsigned long) vma
);
5210 /* Allocate memory and load the sections headers into the global pointer
5211 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5212 generate any error messages if the load fails. */
5215 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5217 Elf32_External_Shdr
* shdrs
;
5218 Elf_Internal_Shdr
* internal
;
5220 unsigned int size
= elf_header
.e_shentsize
;
5221 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5223 /* PR binutils/17531: Cope with unexpected section header sizes. */
5224 if (size
== 0 || num
== 0)
5226 if (size
< sizeof * shdrs
)
5229 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5232 if (!probe
&& size
> sizeof * shdrs
)
5233 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5235 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5237 probe
? NULL
: _("section headers"));
5241 if (section_headers
!= NULL
)
5242 free (section_headers
);
5243 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5244 sizeof (Elf_Internal_Shdr
));
5245 if (section_headers
== NULL
)
5248 error (_("Out of memory reading %u section headers\n"), num
);
5252 for (i
= 0, internal
= section_headers
;
5256 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5257 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5258 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5259 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5260 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5261 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5262 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5263 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5264 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5265 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5266 if (!probe
&& internal
->sh_link
> num
)
5267 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5268 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5269 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5277 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5279 Elf64_External_Shdr
* shdrs
;
5280 Elf_Internal_Shdr
* internal
;
5282 unsigned int size
= elf_header
.e_shentsize
;
5283 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5285 /* PR binutils/17531: Cope with unexpected section header sizes. */
5286 if (size
== 0 || num
== 0)
5288 if (size
< sizeof * shdrs
)
5291 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5294 if (! probe
&& size
> sizeof * shdrs
)
5295 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5297 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5299 probe
? NULL
: _("section headers"));
5303 if (section_headers
!= NULL
)
5304 free (section_headers
);
5305 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5306 sizeof (Elf_Internal_Shdr
));
5307 if (section_headers
== NULL
)
5310 error (_("Out of memory reading %u section headers\n"), num
);
5314 for (i
= 0, internal
= section_headers
;
5318 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5319 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5320 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5321 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5322 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5323 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5324 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5325 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5326 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5327 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5328 if (!probe
&& internal
->sh_link
> num
)
5329 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5330 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5331 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5338 static Elf_Internal_Sym
*
5339 get_32bit_elf_symbols (FILE * file
,
5340 Elf_Internal_Shdr
* section
,
5341 unsigned long * num_syms_return
)
5343 unsigned long number
= 0;
5344 Elf32_External_Sym
* esyms
= NULL
;
5345 Elf_External_Sym_Shndx
* shndx
= NULL
;
5346 Elf_Internal_Sym
* isyms
= NULL
;
5347 Elf_Internal_Sym
* psym
;
5350 if (section
->sh_size
== 0)
5352 if (num_syms_return
!= NULL
)
5353 * num_syms_return
= 0;
5357 /* Run some sanity checks first. */
5358 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5360 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5365 if (section
->sh_size
> current_file_size
)
5367 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368 printable_section_name (section
), (unsigned long) section
->sh_size
);
5372 number
= section
->sh_size
/ section
->sh_entsize
;
5374 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5376 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5377 (unsigned long) section
->sh_size
,
5378 printable_section_name (section
),
5379 (unsigned long) section
->sh_entsize
);
5383 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5384 section
->sh_size
, _("symbols"));
5389 elf_section_list
* entry
;
5392 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5393 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5395 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5396 entry
->hdr
->sh_offset
,
5397 1, entry
->hdr
->sh_size
,
5398 _("symbol table section indicies"));
5401 /* PR17531: file: heap-buffer-overflow */
5402 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5404 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5405 printable_section_name (entry
->hdr
),
5406 (unsigned long) entry
->hdr
->sh_size
,
5407 (unsigned long) section
->sh_size
);
5413 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5417 error (_("Out of memory reading %lu symbols\n"),
5418 (unsigned long) number
);
5422 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5424 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5425 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5426 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5427 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5428 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5430 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5431 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5432 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5433 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5434 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5443 if (num_syms_return
!= NULL
)
5444 * num_syms_return
= isyms
== NULL
? 0 : number
;
5449 static Elf_Internal_Sym
*
5450 get_64bit_elf_symbols (FILE * file
,
5451 Elf_Internal_Shdr
* section
,
5452 unsigned long * num_syms_return
)
5454 unsigned long number
= 0;
5455 Elf64_External_Sym
* esyms
= NULL
;
5456 Elf_External_Sym_Shndx
* shndx
= NULL
;
5457 Elf_Internal_Sym
* isyms
= NULL
;
5458 Elf_Internal_Sym
* psym
;
5461 if (section
->sh_size
== 0)
5463 if (num_syms_return
!= NULL
)
5464 * num_syms_return
= 0;
5468 /* Run some sanity checks first. */
5469 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (section
),
5473 (unsigned long) section
->sh_entsize
);
5477 if (section
->sh_size
> current_file_size
)
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (section
),
5481 (unsigned long) section
->sh_size
);
5485 number
= section
->sh_size
/ section
->sh_entsize
;
5487 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5489 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490 (unsigned long) section
->sh_size
,
5491 printable_section_name (section
),
5492 (unsigned long) section
->sh_entsize
);
5496 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5497 section
->sh_size
, _("symbols"));
5502 elf_section_list
* entry
;
5505 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5506 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5508 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5509 entry
->hdr
->sh_offset
,
5510 1, entry
->hdr
->sh_size
,
5511 _("symbol table section indicies"));
5514 /* PR17531: file: heap-buffer-overflow */
5515 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5517 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5518 printable_section_name (entry
->hdr
),
5519 (unsigned long) entry
->hdr
->sh_size
,
5520 (unsigned long) section
->sh_size
);
5526 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5530 error (_("Out of memory reading %lu symbols\n"),
5531 (unsigned long) number
);
5535 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5537 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5538 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5539 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5540 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5542 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5544 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5545 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5546 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5548 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5549 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5558 if (num_syms_return
!= NULL
)
5559 * num_syms_return
= isyms
== NULL
? 0 : number
;
5565 get_elf_section_flags (bfd_vma sh_flags
)
5567 static char buff
[1024];
5569 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5571 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5572 bfd_vma os_flags
= 0;
5573 bfd_vma proc_flags
= 0;
5574 bfd_vma unknown_flags
= 0;
5582 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5583 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5584 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5585 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5586 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5587 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5588 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5589 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5590 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5591 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5592 /* IA-64 specific. */
5593 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5594 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5595 /* IA-64 OpenVMS specific. */
5596 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5597 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5598 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5599 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5600 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5601 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5603 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604 /* SPARC specific. */
5605 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5608 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5612 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5614 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5617 if (do_section_details
)
5619 sprintf (buff
, "[%*.*lx]: ",
5620 field_size
, field_size
, (unsigned long) sh_flags
);
5621 p
+= field_size
+ 4;
5628 flag
= sh_flags
& - sh_flags
;
5631 if (do_section_details
)
5635 case SHF_WRITE
: sindex
= 0; break;
5636 case SHF_ALLOC
: sindex
= 1; break;
5637 case SHF_EXECINSTR
: sindex
= 2; break;
5638 case SHF_MERGE
: sindex
= 3; break;
5639 case SHF_STRINGS
: sindex
= 4; break;
5640 case SHF_INFO_LINK
: sindex
= 5; break;
5641 case SHF_LINK_ORDER
: sindex
= 6; break;
5642 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5643 case SHF_GROUP
: sindex
= 8; break;
5644 case SHF_TLS
: sindex
= 9; break;
5645 case SHF_EXCLUDE
: sindex
= 18; break;
5646 case SHF_COMPRESSED
: sindex
= 20; break;
5647 case SHF_GNU_MBIND
: sindex
= 24; break;
5651 switch (elf_header
.e_machine
)
5654 if (flag
== SHF_IA_64_SHORT
)
5656 else if (flag
== SHF_IA_64_NORECOV
)
5659 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5662 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5663 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5664 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5665 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5666 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5667 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5678 case EM_OLD_SPARCV9
:
5679 case EM_SPARC32PLUS
:
5682 if (flag
== SHF_ORDERED
)
5689 case SHF_ENTRYSECT
: sindex
= 21; break;
5690 case SHF_ARM_PURECODE
: sindex
= 22; break;
5691 case SHF_COMDEF
: sindex
= 23; break;
5696 if (flag
== SHF_PPC_VLE
)
5707 if (p
!= buff
+ field_size
+ 4)
5709 if (size
< (10 + 2))
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5719 size
-= flags
[sindex
].len
;
5720 p
= stpcpy (p
, flags
[sindex
].str
);
5722 else if (flag
& SHF_MASKOS
)
5724 else if (flag
& SHF_MASKPROC
)
5727 unknown_flags
|= flag
;
5733 case SHF_WRITE
: *p
= 'W'; break;
5734 case SHF_ALLOC
: *p
= 'A'; break;
5735 case SHF_EXECINSTR
: *p
= 'X'; break;
5736 case SHF_MERGE
: *p
= 'M'; break;
5737 case SHF_STRINGS
: *p
= 'S'; break;
5738 case SHF_INFO_LINK
: *p
= 'I'; break;
5739 case SHF_LINK_ORDER
: *p
= 'L'; break;
5740 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5741 case SHF_GROUP
: *p
= 'G'; break;
5742 case SHF_TLS
: *p
= 'T'; break;
5743 case SHF_EXCLUDE
: *p
= 'E'; break;
5744 case SHF_COMPRESSED
: *p
= 'C'; break;
5745 case SHF_GNU_MBIND
: *p
= 'D'; break;
5748 if ((elf_header
.e_machine
== EM_X86_64
5749 || elf_header
.e_machine
== EM_L1OM
5750 || elf_header
.e_machine
== EM_K1OM
)
5751 && flag
== SHF_X86_64_LARGE
)
5753 else if (elf_header
.e_machine
== EM_ARM
5754 && flag
== SHF_ARM_PURECODE
)
5756 else if (elf_header
.e_machine
== EM_PPC
5757 && flag
== SHF_PPC_VLE
)
5759 else if (flag
& SHF_MASKOS
)
5762 sh_flags
&= ~ SHF_MASKOS
;
5764 else if (flag
& SHF_MASKPROC
)
5767 sh_flags
&= ~ SHF_MASKPROC
;
5777 if (do_section_details
)
5781 size
-= 5 + field_size
;
5782 if (p
!= buff
+ field_size
+ 4)
5786 warn (_("Internal error: not enough buffer room for section flag info"));
5787 return _("<unknown>");
5793 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5794 (unsigned long) os_flags
);
5795 p
+= 5 + field_size
;
5799 size
-= 7 + field_size
;
5800 if (p
!= buff
+ field_size
+ 4)
5804 warn (_("Internal error: not enough buffer room for section flag info"));
5805 return _("<unknown>");
5811 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5812 (unsigned long) proc_flags
);
5813 p
+= 7 + field_size
;
5817 size
-= 10 + field_size
;
5818 if (p
!= buff
+ field_size
+ 4)
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5829 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5830 (unsigned long) unknown_flags
);
5831 p
+= 10 + field_size
;
5840 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5844 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5846 if (size
< sizeof (* echdr
))
5848 error (_("Compressed section is too small even for a compression header\n"));
5852 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5853 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5854 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5855 return sizeof (*echdr
);
5859 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5861 if (size
< sizeof (* echdr
))
5863 error (_("Compressed section is too small even for a compression header\n"));
5867 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5868 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5869 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5870 return sizeof (*echdr
);
5875 process_section_headers (FILE * file
)
5877 Elf_Internal_Shdr
* section
;
5880 section_headers
= NULL
;
5882 if (elf_header
.e_shnum
== 0)
5884 /* PR binutils/12467. */
5885 if (elf_header
.e_shoff
!= 0)
5887 warn (_("possibly corrupt ELF file header - it has a non-zero"
5888 " section header offset, but no section headers\n"));
5891 else if (do_sections
)
5892 printf (_("\nThere are no sections in this file.\n"));
5897 if (do_sections
&& !do_header
)
5898 printf (ngettext ("There is %d section header, "
5899 "starting at offset 0x%lx:\n",
5900 "There are %d section headers, "
5901 "starting at offset 0x%lx:\n",
5902 elf_header
.e_shnum
),
5903 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5907 if (! get_32bit_section_headers (file
, FALSE
))
5912 if (! get_64bit_section_headers (file
, FALSE
))
5916 /* Read in the string table, so that we have names to display. */
5917 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5918 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5920 section
= section_headers
+ elf_header
.e_shstrndx
;
5922 if (section
->sh_size
!= 0)
5924 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5925 1, section
->sh_size
,
5928 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5932 /* Scan the sections for the dynamic symbol table
5933 and dynamic string table and debug sections. */
5934 dynamic_symbols
= NULL
;
5935 dynamic_strings
= NULL
;
5936 dynamic_syminfo
= NULL
;
5937 symtab_shndx_list
= NULL
;
5939 eh_addr_size
= is_32bit_elf
? 4 : 8;
5940 switch (elf_header
.e_machine
)
5943 case EM_MIPS_RS3_LE
:
5944 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5945 FDE addresses. However, the ABI also has a semi-official ILP32
5946 variant for which the normal FDE address size rules apply.
5948 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5949 section, where XX is the size of longs in bits. Unfortunately,
5950 earlier compilers provided no way of distinguishing ILP32 objects
5951 from LP64 objects, so if there's any doubt, we should assume that
5952 the official LP64 form is being used. */
5953 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5954 && find_section (".gcc_compiled_long32") == NULL
)
5960 switch (elf_header
.e_flags
& EF_H8_MACH
)
5962 case E_H8_MACH_H8300
:
5963 case E_H8_MACH_H8300HN
:
5964 case E_H8_MACH_H8300SN
:
5965 case E_H8_MACH_H8300SXN
:
5968 case E_H8_MACH_H8300H
:
5969 case E_H8_MACH_H8300S
:
5970 case E_H8_MACH_H8300SX
:
5978 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5980 case EF_M32C_CPU_M16C
:
5987 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5990 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5991 if (section->sh_entsize != expected_entsize) \
5994 sprintf_vma (buf, section->sh_entsize); \
5995 /* Note: coded this way so that there is a single string for \
5997 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5998 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5999 (unsigned) expected_entsize); \
6000 section->sh_entsize = expected_entsize; \
6005 #define CHECK_ENTSIZE(section, i, type) \
6006 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6007 sizeof (Elf64_External_##type))
6009 for (i
= 0, section
= section_headers
;
6010 i
< elf_header
.e_shnum
;
6013 char * name
= SECTION_NAME (section
);
6015 if (section
->sh_type
== SHT_DYNSYM
)
6017 if (dynamic_symbols
!= NULL
)
6019 error (_("File contains multiple dynamic symbol tables\n"));
6023 CHECK_ENTSIZE (section
, i
, Sym
);
6024 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
6026 else if (section
->sh_type
== SHT_STRTAB
6027 && streq (name
, ".dynstr"))
6029 if (dynamic_strings
!= NULL
)
6031 error (_("File contains multiple dynamic string tables\n"));
6035 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6036 1, section
->sh_size
,
6037 _("dynamic strings"));
6038 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6040 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6042 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6043 entry
->hdr
= section
;
6044 entry
->next
= symtab_shndx_list
;
6045 symtab_shndx_list
= entry
;
6047 else if (section
->sh_type
== SHT_SYMTAB
)
6048 CHECK_ENTSIZE (section
, i
, Sym
);
6049 else if (section
->sh_type
== SHT_GROUP
)
6050 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6051 else if (section
->sh_type
== SHT_REL
)
6052 CHECK_ENTSIZE (section
, i
, Rel
);
6053 else if (section
->sh_type
== SHT_RELA
)
6054 CHECK_ENTSIZE (section
, i
, Rela
);
6055 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6056 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6057 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6058 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6059 || do_debug_addr
|| do_debug_cu_index
)
6060 && (const_strneq (name
, ".debug_")
6061 || const_strneq (name
, ".zdebug_")))
6064 name
+= sizeof (".zdebug_") - 1;
6066 name
+= sizeof (".debug_") - 1;
6069 || (do_debug_info
&& const_strneq (name
, "info"))
6070 || (do_debug_info
&& const_strneq (name
, "types"))
6071 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6072 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6073 || (do_debug_lines
&& const_strneq (name
, "line."))
6074 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6075 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6076 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6077 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6078 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6079 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6080 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6081 || (do_debug_frames
&& const_strneq (name
, "frame"))
6082 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6083 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6084 || (do_debug_str
&& const_strneq (name
, "str"))
6085 || (do_debug_loc
&& const_strneq (name
, "loc"))
6086 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6087 || (do_debug_addr
&& const_strneq (name
, "addr"))
6088 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6089 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6091 request_dump_bynumber (i
, DEBUG_DUMP
);
6093 /* Linkonce section to be combined with .debug_info at link time. */
6094 else if ((do_debugging
|| do_debug_info
)
6095 && const_strneq (name
, ".gnu.linkonce.wi."))
6096 request_dump_bynumber (i
, DEBUG_DUMP
);
6097 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6098 request_dump_bynumber (i
, DEBUG_DUMP
);
6099 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6100 || streq (name
, ".debug_names")))
6101 request_dump_bynumber (i
, DEBUG_DUMP
);
6102 /* Trace sections for Itanium VMS. */
6103 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6104 || do_trace_aranges
)
6105 && const_strneq (name
, ".trace_"))
6107 name
+= sizeof (".trace_") - 1;
6110 || (do_trace_info
&& streq (name
, "info"))
6111 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6112 || (do_trace_aranges
&& streq (name
, "aranges"))
6114 request_dump_bynumber (i
, DEBUG_DUMP
);
6121 if (elf_header
.e_shnum
> 1)
6122 printf (_("\nSection Headers:\n"));
6124 printf (_("\nSection Header:\n"));
6128 if (do_section_details
)
6130 printf (_(" [Nr] Name\n"));
6131 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6135 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6139 if (do_section_details
)
6141 printf (_(" [Nr] Name\n"));
6142 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6146 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6150 if (do_section_details
)
6152 printf (_(" [Nr] Name\n"));
6153 printf (_(" Type Address Offset Link\n"));
6154 printf (_(" Size EntSize Info Align\n"));
6158 printf (_(" [Nr] Name Type Address Offset\n"));
6159 printf (_(" Size EntSize Flags Link Info Align\n"));
6163 if (do_section_details
)
6164 printf (_(" Flags\n"));
6166 for (i
= 0, section
= section_headers
;
6167 i
< elf_header
.e_shnum
;
6170 /* Run some sanity checks on the section header. */
6172 /* Check the sh_link field. */
6173 switch (section
->sh_type
)
6175 case SHT_SYMTAB_SHNDX
:
6179 case SHT_GNU_versym
:
6182 if (section
->sh_link
< 1
6183 || section
->sh_link
>= elf_header
.e_shnum
6184 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6185 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6186 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6187 i
, section
->sh_link
);
6193 case SHT_GNU_verneed
:
6194 case SHT_GNU_verdef
:
6195 case SHT_GNU_LIBLIST
:
6196 if (section
->sh_link
< 1
6197 || section
->sh_link
>= elf_header
.e_shnum
6198 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6199 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6200 i
, section
->sh_link
);
6203 case SHT_INIT_ARRAY
:
6204 case SHT_FINI_ARRAY
:
6205 case SHT_PREINIT_ARRAY
:
6206 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6207 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6208 i
, section
->sh_link
);
6212 /* FIXME: Add support for target specific section types. */
6213 #if 0 /* Currently we do not check other section types as there are too
6214 many special cases. Stab sections for example have a type
6215 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6217 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6218 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6219 i
, section
->sh_link
);
6224 /* Check the sh_info field. */
6225 switch (section
->sh_type
)
6229 if (section
->sh_info
< 1
6230 || section
->sh_info
>= elf_header
.e_shnum
6231 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6232 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6233 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6234 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6235 /* FIXME: Are other section types valid ? */
6236 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6238 if (section
->sh_info
== 0
6239 && (streq (SECTION_NAME (section
), ".rel.dyn")
6240 || streq (SECTION_NAME (section
), ".rela.dyn")))
6241 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6242 of zero. The relocations in these sections may apply
6243 to many different sections. */
6246 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6247 i
, section
->sh_info
);
6253 case SHT_SYMTAB_SHNDX
:
6254 case SHT_INIT_ARRAY
:
6255 case SHT_FINI_ARRAY
:
6256 case SHT_PREINIT_ARRAY
:
6257 if (section
->sh_info
!= 0)
6258 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6259 i
, section
->sh_info
);
6265 /* A symbol index - we assume that it is valid. */
6269 /* FIXME: Add support for target specific section types. */
6270 if (section
->sh_type
== SHT_NOBITS
)
6271 /* NOBITS section headers with non-zero sh_info fields can be
6272 created when a binary is stripped of everything but its debug
6273 information. The stripped sections have their headers
6274 preserved but their types set to SHT_NOBITS. So do not check
6275 this type of section. */
6277 else if (section
->sh_flags
& SHF_INFO_LINK
)
6279 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6280 warn (_("[%2u]: Expected link to another section in info field"), i
);
6282 else if (section
->sh_type
< SHT_LOOS
6283 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6284 && section
->sh_info
!= 0)
6285 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6286 i
, section
->sh_info
);
6290 /* Check the sh_size field. */
6291 if (section
->sh_size
> current_file_size
6292 && section
->sh_type
!= SHT_NOBITS
6293 && section
->sh_type
!= SHT_NULL
6294 && section
->sh_type
< SHT_LOOS
)
6295 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6297 printf (" [%2u] ", i
);
6298 if (do_section_details
)
6299 printf ("%s\n ", printable_section_name (section
));
6301 print_symbol (-17, SECTION_NAME (section
));
6303 printf (do_wide
? " %-15s " : " %-15.15s ",
6304 get_section_type_name (section
->sh_type
));
6308 const char * link_too_big
= NULL
;
6310 print_vma (section
->sh_addr
, LONG_HEX
);
6312 printf ( " %6.6lx %6.6lx %2.2lx",
6313 (unsigned long) section
->sh_offset
,
6314 (unsigned long) section
->sh_size
,
6315 (unsigned long) section
->sh_entsize
);
6317 if (do_section_details
)
6318 fputs (" ", stdout
);
6320 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6322 if (section
->sh_link
>= elf_header
.e_shnum
)
6325 /* The sh_link value is out of range. Normally this indicates
6326 an error but it can have special values in Solaris binaries. */
6327 switch (elf_header
.e_machine
)
6334 case EM_OLD_SPARCV9
:
6335 case EM_SPARC32PLUS
:
6338 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6339 link_too_big
= "BEFORE";
6340 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6341 link_too_big
= "AFTER";
6348 if (do_section_details
)
6350 if (link_too_big
!= NULL
&& * link_too_big
)
6351 printf ("<%s> ", link_too_big
);
6353 printf ("%2u ", section
->sh_link
);
6354 printf ("%3u %2lu\n", section
->sh_info
,
6355 (unsigned long) section
->sh_addralign
);
6358 printf ("%2u %3u %2lu\n",
6361 (unsigned long) section
->sh_addralign
);
6363 if (link_too_big
&& ! * link_too_big
)
6364 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6365 i
, section
->sh_link
);
6369 print_vma (section
->sh_addr
, LONG_HEX
);
6371 if ((long) section
->sh_offset
== section
->sh_offset
)
6372 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6376 print_vma (section
->sh_offset
, LONG_HEX
);
6379 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6380 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6384 print_vma (section
->sh_size
, LONG_HEX
);
6387 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6388 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6392 print_vma (section
->sh_entsize
, LONG_HEX
);
6395 if (do_section_details
)
6396 fputs (" ", stdout
);
6398 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6400 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6402 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6403 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6406 print_vma (section
->sh_addralign
, DEC
);
6410 else if (do_section_details
)
6412 printf (" %-15.15s ",
6413 get_section_type_name (section
->sh_type
));
6414 print_vma (section
->sh_addr
, LONG_HEX
);
6415 if ((long) section
->sh_offset
== section
->sh_offset
)
6416 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6420 print_vma (section
->sh_offset
, LONG_HEX
);
6422 printf (" %u\n ", section
->sh_link
);
6423 print_vma (section
->sh_size
, LONG_HEX
);
6425 print_vma (section
->sh_entsize
, LONG_HEX
);
6427 printf (" %-16u %lu\n",
6429 (unsigned long) section
->sh_addralign
);
6434 print_vma (section
->sh_addr
, LONG_HEX
);
6435 if ((long) section
->sh_offset
== section
->sh_offset
)
6436 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6440 print_vma (section
->sh_offset
, LONG_HEX
);
6443 print_vma (section
->sh_size
, LONG_HEX
);
6445 print_vma (section
->sh_entsize
, LONG_HEX
);
6447 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6449 printf (" %2u %3u %lu\n",
6452 (unsigned long) section
->sh_addralign
);
6455 if (do_section_details
)
6457 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6458 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6460 /* Minimum section size is 12 bytes for 32-bit compression
6461 header + 12 bytes for compressed data header. */
6462 unsigned char buf
[24];
6464 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6465 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6466 sizeof (buf
), _("compression header")))
6468 Elf_Internal_Chdr chdr
;
6470 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6472 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6475 printf (_(" [<unknown>: 0x%x], "),
6477 print_vma (chdr
.ch_size
, LONG_HEX
);
6478 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6484 if (!do_section_details
)
6486 /* The ordering of the letters shown here matches the ordering of the
6487 corresponding SHF_xxx values, and hence the order in which these
6488 letters will be displayed to the user. */
6489 printf (_("Key to Flags:\n\
6490 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6491 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6492 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6493 if (elf_header
.e_machine
== EM_X86_64
6494 || elf_header
.e_machine
== EM_L1OM
6495 || elf_header
.e_machine
== EM_K1OM
)
6496 printf (_("l (large), "));
6497 else if (elf_header
.e_machine
== EM_ARM
)
6498 printf (_("y (purecode), "));
6499 else if (elf_header
.e_machine
== EM_PPC
)
6500 printf (_("v (VLE), "));
6501 printf ("p (processor specific)\n");
6508 get_group_flags (unsigned int flags
)
6510 static char buff
[128];
6514 else if (flags
== GRP_COMDAT
)
6517 snprintf (buff
, 14, _("[0x%x: "), flags
);
6519 flags
&= ~ GRP_COMDAT
;
6520 if (flags
& GRP_MASKOS
)
6522 strcat (buff
, "<OS specific>");
6523 flags
&= ~ GRP_MASKOS
;
6526 if (flags
& GRP_MASKPROC
)
6528 strcat (buff
, "<PROC specific>");
6529 flags
&= ~ GRP_MASKPROC
;
6533 strcat (buff
, "<unknown>");
6540 process_section_groups (FILE * file
)
6542 Elf_Internal_Shdr
* section
;
6544 struct group
* group
;
6545 Elf_Internal_Shdr
* symtab_sec
;
6546 Elf_Internal_Shdr
* strtab_sec
;
6547 Elf_Internal_Sym
* symtab
;
6548 unsigned long num_syms
;
6552 /* Don't process section groups unless needed. */
6553 if (!do_unwind
&& !do_section_groups
)
6556 if (elf_header
.e_shnum
== 0)
6558 if (do_section_groups
)
6559 printf (_("\nThere are no sections to group in this file.\n"));
6564 if (section_headers
== NULL
)
6566 error (_("Section headers are not available!\n"));
6567 /* PR 13622: This can happen with a corrupt ELF header. */
6571 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6572 sizeof (struct group
*));
6574 if (section_headers_groups
== NULL
)
6576 error (_("Out of memory reading %u section group headers\n"),
6577 elf_header
.e_shnum
);
6581 /* Scan the sections for the group section. */
6583 for (i
= 0, section
= section_headers
;
6584 i
< elf_header
.e_shnum
;
6586 if (section
->sh_type
== SHT_GROUP
)
6589 if (group_count
== 0)
6591 if (do_section_groups
)
6592 printf (_("\nThere are no section groups in this file.\n"));
6597 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6599 if (section_groups
== NULL
)
6601 error (_("Out of memory reading %lu groups\n"),
6602 (unsigned long) group_count
);
6612 for (i
= 0, section
= section_headers
, group
= section_groups
;
6613 i
< elf_header
.e_shnum
;
6616 if (section
->sh_type
== SHT_GROUP
)
6618 const char * name
= printable_section_name (section
);
6619 const char * group_name
;
6620 unsigned char * start
;
6621 unsigned char * indices
;
6622 unsigned int entry
, j
, size
;
6623 Elf_Internal_Shdr
* sec
;
6624 Elf_Internal_Sym
* sym
;
6626 /* Get the symbol table. */
6627 if (section
->sh_link
>= elf_header
.e_shnum
6628 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6631 error (_("Bad sh_link in group section `%s'\n"), name
);
6635 if (symtab_sec
!= sec
)
6640 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6645 error (_("Corrupt header in group section `%s'\n"), name
);
6649 if (section
->sh_info
>= num_syms
)
6651 error (_("Bad sh_info in group section `%s'\n"), name
);
6655 sym
= symtab
+ section
->sh_info
;
6657 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6659 if (sym
->st_shndx
== 0
6660 || sym
->st_shndx
>= elf_header
.e_shnum
)
6662 error (_("Bad sh_info in group section `%s'\n"), name
);
6666 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6675 /* Get the string table. */
6676 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6685 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6691 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6692 1, strtab_sec
->sh_size
,
6694 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6696 group_name
= sym
->st_name
< strtab_size
6697 ? strtab
+ sym
->st_name
: _("<corrupt>");
6700 /* PR 17531: file: loop. */
6701 if (section
->sh_entsize
> section
->sh_size
)
6703 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6704 printable_section_name (section
),
6705 (unsigned long) section
->sh_entsize
,
6706 (unsigned long) section
->sh_size
);
6710 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6711 1, section
->sh_size
,
6717 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6718 entry
= byte_get (indices
, 4);
6721 if (do_section_groups
)
6723 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6724 get_group_flags (entry
), i
, name
, group_name
, size
);
6726 printf (_(" [Index] Name\n"));
6729 group
->group_index
= i
;
6731 for (j
= 0; j
< size
; j
++)
6733 struct group_list
* g
;
6735 entry
= byte_get (indices
, 4);
6738 if (entry
>= elf_header
.e_shnum
)
6740 static unsigned num_group_errors
= 0;
6742 if (num_group_errors
++ < 10)
6744 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6745 entry
, i
, elf_header
.e_shnum
- 1);
6746 if (num_group_errors
== 10)
6747 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6752 if (section_headers_groups
[entry
] != NULL
)
6756 static unsigned num_errs
= 0;
6758 if (num_errs
++ < 10)
6760 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6762 section_headers_groups
[entry
]->group_index
);
6764 warn (_("Further error messages about already contained group sections suppressed\n"));
6770 /* Intel C/C++ compiler may put section 0 in a
6771 section group. We just warn it the first time
6772 and ignore it afterwards. */
6773 static bfd_boolean warned
= FALSE
;
6776 error (_("section 0 in group section [%5u]\n"),
6777 section_headers_groups
[entry
]->group_index
);
6783 section_headers_groups
[entry
] = group
;
6785 if (do_section_groups
)
6787 sec
= section_headers
+ entry
;
6788 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6791 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6792 g
->section_index
= entry
;
6793 g
->next
= group
->root
;
6811 /* Data used to display dynamic fixups. */
6813 struct ia64_vms_dynfixup
6815 bfd_vma needed_ident
; /* Library ident number. */
6816 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6817 bfd_vma fixup_needed
; /* Index of the library. */
6818 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6819 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6822 /* Data used to display dynamic relocations. */
6824 struct ia64_vms_dynimgrela
6826 bfd_vma img_rela_cnt
; /* Number of relocations. */
6827 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6830 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6834 dump_ia64_vms_dynamic_fixups (FILE * file
,
6835 struct ia64_vms_dynfixup
* fixup
,
6836 const char * strtab
,
6837 unsigned int strtab_sz
)
6839 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6841 const char * lib_name
;
6843 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6844 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6845 _("dynamic section image fixups"));
6849 if (fixup
->needed
< strtab_sz
)
6850 lib_name
= strtab
+ fixup
->needed
;
6853 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6854 (unsigned long) fixup
->needed
);
6857 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6858 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6860 (_("Seg Offset Type SymVec DataType\n"));
6862 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6867 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6868 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6869 type
= BYTE_GET (imfs
[i
].type
);
6870 rtype
= elf_ia64_reloc_type (type
);
6872 printf (" 0x%08x ", type
);
6874 printf (" %-32s ", rtype
);
6875 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6876 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6883 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6886 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6888 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6891 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6892 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6893 _("dynamic section image relocations"));
6897 printf (_("\nImage relocs\n"));
6899 (_("Seg Offset Type Addend Seg Sym Off\n"));
6901 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6906 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6907 printf ("%08" BFD_VMA_FMT
"x ",
6908 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6909 type
= BYTE_GET (imrs
[i
].type
);
6910 rtype
= elf_ia64_reloc_type (type
);
6912 printf ("0x%08x ", type
);
6914 printf ("%-31s ", rtype
);
6915 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6916 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6917 printf ("%08" BFD_VMA_FMT
"x\n",
6918 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6925 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6928 process_ia64_vms_dynamic_relocs (FILE *file
)
6930 struct ia64_vms_dynfixup fixup
;
6931 struct ia64_vms_dynimgrela imgrela
;
6932 Elf_Internal_Dyn
*entry
;
6933 bfd_vma strtab_off
= 0;
6934 bfd_vma strtab_sz
= 0;
6935 char *strtab
= NULL
;
6936 bfd_boolean res
= TRUE
;
6938 memset (&fixup
, 0, sizeof (fixup
));
6939 memset (&imgrela
, 0, sizeof (imgrela
));
6941 /* Note: the order of the entries is specified by the OpenVMS specs. */
6942 for (entry
= dynamic_section
;
6943 entry
< dynamic_section
+ dynamic_nent
;
6946 switch (entry
->d_tag
)
6948 case DT_IA_64_VMS_STRTAB_OFFSET
:
6949 strtab_off
= entry
->d_un
.d_val
;
6952 strtab_sz
= entry
->d_un
.d_val
;
6954 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6955 1, strtab_sz
, _("dynamic string section"));
6958 case DT_IA_64_VMS_NEEDED_IDENT
:
6959 fixup
.needed_ident
= entry
->d_un
.d_val
;
6962 fixup
.needed
= entry
->d_un
.d_val
;
6964 case DT_IA_64_VMS_FIXUP_NEEDED
:
6965 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6967 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6968 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6970 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6971 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6972 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6975 case DT_IA_64_VMS_IMG_RELA_CNT
:
6976 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6978 case DT_IA_64_VMS_IMG_RELA_OFF
:
6979 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6980 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
7002 dynamic_relocations
[] =
7004 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7005 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7006 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7009 /* Process the reloc section. */
7012 process_relocs (FILE * file
)
7014 unsigned long rel_size
;
7015 unsigned long rel_offset
;
7020 if (do_using_dynamic
)
7024 bfd_boolean has_dynamic_reloc
;
7027 has_dynamic_reloc
= FALSE
;
7029 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7031 is_rela
= dynamic_relocations
[i
].rela
;
7032 name
= dynamic_relocations
[i
].name
;
7033 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7034 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7037 has_dynamic_reloc
= TRUE
;
7039 if (is_rela
== UNKNOWN
)
7041 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7042 switch (dynamic_info
[DT_PLTREL
])
7056 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7057 name
, rel_offset
, rel_size
);
7059 dump_relocations (file
,
7060 offset_from_vma (file
, rel_offset
, rel_size
),
7062 dynamic_symbols
, num_dynamic_syms
,
7063 dynamic_strings
, dynamic_strings_length
,
7064 is_rela
, TRUE
/* is_dynamic */);
7069 if (process_ia64_vms_dynamic_relocs (file
))
7070 has_dynamic_reloc
= TRUE
;
7072 if (! has_dynamic_reloc
)
7073 printf (_("\nThere are no dynamic relocations in this file.\n"));
7077 Elf_Internal_Shdr
* section
;
7079 bfd_boolean found
= FALSE
;
7081 for (i
= 0, section
= section_headers
;
7082 i
< elf_header
.e_shnum
;
7085 if ( section
->sh_type
!= SHT_RELA
7086 && section
->sh_type
!= SHT_REL
)
7089 rel_offset
= section
->sh_offset
;
7090 rel_size
= section
->sh_size
;
7094 Elf_Internal_Shdr
* strsec
;
7096 unsigned long num_rela
;
7098 printf (_("\nRelocation section "));
7100 if (string_table
== NULL
)
7101 printf ("%d", section
->sh_name
);
7103 printf ("'%s'", printable_section_name (section
));
7105 num_rela
= rel_size
/ section
->sh_entsize
;
7106 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7107 " at offset 0x%lx contains %lu entries:\n",
7109 rel_offset
, num_rela
);
7111 is_rela
= section
->sh_type
== SHT_RELA
;
7113 if (section
->sh_link
!= 0
7114 && section
->sh_link
< elf_header
.e_shnum
)
7116 Elf_Internal_Shdr
* symsec
;
7117 Elf_Internal_Sym
* symtab
;
7118 unsigned long nsyms
;
7119 unsigned long strtablen
= 0;
7120 char * strtab
= NULL
;
7122 symsec
= section_headers
+ section
->sh_link
;
7123 if (symsec
->sh_type
!= SHT_SYMTAB
7124 && symsec
->sh_type
!= SHT_DYNSYM
)
7127 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7132 if (symsec
->sh_link
!= 0
7133 && symsec
->sh_link
< elf_header
.e_shnum
)
7135 strsec
= section_headers
+ symsec
->sh_link
;
7137 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7140 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7143 dump_relocations (file
, rel_offset
, rel_size
,
7144 symtab
, nsyms
, strtab
, strtablen
,
7146 symsec
->sh_type
== SHT_DYNSYM
);
7152 dump_relocations (file
, rel_offset
, rel_size
,
7153 NULL
, 0, NULL
, 0, is_rela
,
7154 FALSE
/* is_dynamic */);
7162 /* Users sometimes forget the -D option, so try to be helpful. */
7163 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7165 if (dynamic_info
[dynamic_relocations
[i
].size
])
7167 printf (_("\nThere are no static relocations in this file."));
7168 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7173 if (i
== ARRAY_SIZE (dynamic_relocations
))
7174 printf (_("\nThere are no relocations in this file.\n"));
7181 /* An absolute address consists of a section and an offset. If the
7182 section is NULL, the offset itself is the address, otherwise, the
7183 address equals to LOAD_ADDRESS(section) + offset. */
7187 unsigned short section
;
7191 #define ABSADDR(a) \
7193 ? section_headers [(a).section].sh_addr + (a).offset \
7196 /* Find the nearest symbol at or below ADDR. Returns the symbol
7197 name, if found, and the offset from the symbol to ADDR. */
7200 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7201 unsigned long nsyms
,
7202 const char * strtab
,
7203 unsigned long strtab_size
,
7204 struct absaddr addr
,
7205 const char ** symname
,
7208 bfd_vma dist
= 0x100000;
7209 Elf_Internal_Sym
* sym
;
7210 Elf_Internal_Sym
* beg
;
7211 Elf_Internal_Sym
* end
;
7212 Elf_Internal_Sym
* best
= NULL
;
7214 REMOVE_ARCH_BITS (addr
.offset
);
7216 end
= symtab
+ nsyms
;
7222 sym
= beg
+ (end
- beg
) / 2;
7224 value
= sym
->st_value
;
7225 REMOVE_ARCH_BITS (value
);
7227 if (sym
->st_name
!= 0
7228 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7229 && addr
.offset
>= value
7230 && addr
.offset
- value
< dist
)
7233 dist
= addr
.offset
- value
;
7238 if (addr
.offset
< value
)
7246 *symname
= (best
->st_name
>= strtab_size
7247 ? _("<corrupt>") : strtab
+ best
->st_name
);
7253 *offset
= addr
.offset
;
7256 static /* signed */ int
7257 symcmp (const void *p
, const void *q
)
7259 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7260 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7262 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7265 /* Process the unwind section. */
7267 #include "unwind-ia64.h"
7269 struct ia64_unw_table_entry
7271 struct absaddr start
;
7273 struct absaddr info
;
7276 struct ia64_unw_aux_info
7278 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7279 unsigned long table_len
; /* Length of unwind table. */
7280 unsigned char * info
; /* Unwind info. */
7281 unsigned long info_size
; /* Size of unwind info. */
7282 bfd_vma info_addr
; /* Starting address of unwind info. */
7283 bfd_vma seg_base
; /* Starting address of segment. */
7284 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7285 unsigned long nsyms
; /* Number of symbols. */
7286 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7287 unsigned long nfuns
; /* Number of entries in funtab. */
7288 char * strtab
; /* The string table. */
7289 unsigned long strtab_size
; /* Size of string table. */
7293 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7295 struct ia64_unw_table_entry
* tp
;
7296 unsigned long j
, nfuns
;
7298 bfd_boolean res
= TRUE
;
7300 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7301 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7302 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7303 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7305 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7307 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7311 const unsigned char * dp
;
7312 const unsigned char * head
;
7313 const unsigned char * end
;
7314 const char * procname
;
7316 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7317 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7319 fputs ("\n<", stdout
);
7323 fputs (procname
, stdout
);
7326 printf ("+%lx", (unsigned long) offset
);
7329 fputs (">: [", stdout
);
7330 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7331 fputc ('-', stdout
);
7332 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7333 printf ("], info at +0x%lx\n",
7334 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7336 /* PR 17531: file: 86232b32. */
7337 if (aux
->info
== NULL
)
7340 /* PR 17531: file: 0997b4d1. */
7341 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7343 warn (_("Invalid offset %lx in table entry %ld\n"),
7344 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7349 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7350 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7352 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7353 (unsigned) UNW_VER (stamp
),
7354 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7355 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7356 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7357 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7359 if (UNW_VER (stamp
) != 1)
7361 printf (_("\tUnknown version.\n"));
7366 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7367 /* PR 17531: file: 16ceda89. */
7368 if (end
> aux
->info
+ aux
->info_size
)
7369 end
= aux
->info
+ aux
->info_size
;
7370 for (dp
= head
+ 8; dp
< end
;)
7371 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7380 slurp_ia64_unwind_table (FILE * file
,
7381 struct ia64_unw_aux_info
* aux
,
7382 Elf_Internal_Shdr
* sec
)
7384 unsigned long size
, nrelas
, i
;
7385 Elf_Internal_Phdr
* seg
;
7386 struct ia64_unw_table_entry
* tep
;
7387 Elf_Internal_Shdr
* relsec
;
7388 Elf_Internal_Rela
* rela
;
7389 Elf_Internal_Rela
* rp
;
7390 unsigned char * table
;
7392 Elf_Internal_Sym
* sym
;
7393 const char * relname
;
7397 /* First, find the starting address of the segment that includes
7400 if (elf_header
.e_phnum
)
7402 if (! get_program_headers (file
))
7405 for (seg
= program_headers
;
7406 seg
< program_headers
+ elf_header
.e_phnum
;
7409 if (seg
->p_type
!= PT_LOAD
)
7412 if (sec
->sh_addr
>= seg
->p_vaddr
7413 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7415 aux
->seg_base
= seg
->p_vaddr
;
7421 /* Second, build the unwind table from the contents of the unwind section: */
7422 size
= sec
->sh_size
;
7423 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7428 aux
->table_len
= size
/ (3 * eh_addr_size
);
7429 aux
->table
= (struct ia64_unw_table_entry
*)
7430 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7433 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7435 tep
->start
.section
= SHN_UNDEF
;
7436 tep
->end
.section
= SHN_UNDEF
;
7437 tep
->info
.section
= SHN_UNDEF
;
7438 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7439 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7440 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7441 tep
->start
.offset
+= aux
->seg_base
;
7442 tep
->end
.offset
+= aux
->seg_base
;
7443 tep
->info
.offset
+= aux
->seg_base
;
7447 /* Third, apply any relocations to the unwind table: */
7448 for (relsec
= section_headers
;
7449 relsec
< section_headers
+ elf_header
.e_shnum
;
7452 if (relsec
->sh_type
!= SHT_RELA
7453 || relsec
->sh_info
>= elf_header
.e_shnum
7454 || section_headers
+ relsec
->sh_info
!= sec
)
7457 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7466 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7468 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7469 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7471 /* PR 17531: file: 9fa67536. */
7472 if (relname
== NULL
)
7474 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7478 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7480 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7484 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7486 /* PR 17531: file: 5bc8d9bf. */
7487 if (i
>= aux
->table_len
)
7489 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7493 switch (rp
->r_offset
/ eh_addr_size
% 3)
7496 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7497 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7500 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7501 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7504 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7505 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7519 ia64_process_unwind (FILE * file
)
7521 Elf_Internal_Shdr
* sec
;
7522 Elf_Internal_Shdr
* unwsec
= NULL
;
7523 Elf_Internal_Shdr
* strsec
;
7524 unsigned long i
, unwcount
= 0, unwstart
= 0;
7525 struct ia64_unw_aux_info aux
;
7526 bfd_boolean res
= TRUE
;
7528 memset (& aux
, 0, sizeof (aux
));
7530 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7532 if (sec
->sh_type
== SHT_SYMTAB
7533 && sec
->sh_link
< elf_header
.e_shnum
)
7535 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7537 strsec
= section_headers
+ sec
->sh_link
;
7538 if (aux
.strtab
!= NULL
)
7540 error (_("Multiple auxillary string tables encountered\n"));
7544 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7547 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7549 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7554 printf (_("\nThere are no unwind sections in this file.\n"));
7556 while (unwcount
-- > 0)
7561 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7562 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7563 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7568 /* We have already counted the number of SHT_IA64_UNWIND
7569 sections so the loop above should never fail. */
7570 assert (unwsec
!= NULL
);
7573 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7575 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7577 /* We need to find which section group it is in. */
7578 struct group_list
* g
;
7580 if (section_headers_groups
== NULL
7581 || section_headers_groups
[i
] == NULL
)
7582 i
= elf_header
.e_shnum
;
7585 g
= section_headers_groups
[i
]->root
;
7587 for (; g
!= NULL
; g
= g
->next
)
7589 sec
= section_headers
+ g
->section_index
;
7591 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7596 i
= elf_header
.e_shnum
;
7599 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7601 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7602 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7603 suffix
= SECTION_NAME (unwsec
) + len
;
7604 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7606 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7607 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7612 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7613 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7614 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7615 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7617 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7618 suffix
= SECTION_NAME (unwsec
) + len
;
7619 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7621 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7622 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7626 if (i
== elf_header
.e_shnum
)
7628 printf (_("\nCould not find unwind info section for "));
7630 if (string_table
== NULL
)
7631 printf ("%d", unwsec
->sh_name
);
7633 printf ("'%s'", printable_section_name (unwsec
));
7637 aux
.info_addr
= sec
->sh_addr
;
7638 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7641 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7643 printf (_("\nUnwind section "));
7645 if (string_table
== NULL
)
7646 printf ("%d", unwsec
->sh_name
);
7648 printf ("'%s'", printable_section_name (unwsec
));
7650 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7651 (unsigned long) unwsec
->sh_offset
,
7652 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7654 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7655 && aux
.table_len
> 0)
7656 dump_ia64_unwind (& aux
);
7659 free ((char *) aux
.table
);
7661 free ((char *) aux
.info
);
7670 free ((char *) aux
.strtab
);
7675 struct hppa_unw_table_entry
7677 struct absaddr start
;
7679 unsigned int Cannot_unwind
:1; /* 0 */
7680 unsigned int Millicode
:1; /* 1 */
7681 unsigned int Millicode_save_sr0
:1; /* 2 */
7682 unsigned int Region_description
:2; /* 3..4 */
7683 unsigned int reserved1
:1; /* 5 */
7684 unsigned int Entry_SR
:1; /* 6 */
7685 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7686 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7687 unsigned int Args_stored
:1; /* 16 */
7688 unsigned int Variable_Frame
:1; /* 17 */
7689 unsigned int Separate_Package_Body
:1; /* 18 */
7690 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7691 unsigned int Stack_Overflow_Check
:1; /* 20 */
7692 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7693 unsigned int Ada_Region
:1; /* 22 */
7694 unsigned int cxx_info
:1; /* 23 */
7695 unsigned int cxx_try_catch
:1; /* 24 */
7696 unsigned int sched_entry_seq
:1; /* 25 */
7697 unsigned int reserved2
:1; /* 26 */
7698 unsigned int Save_SP
:1; /* 27 */
7699 unsigned int Save_RP
:1; /* 28 */
7700 unsigned int Save_MRP_in_frame
:1; /* 29 */
7701 unsigned int extn_ptr_defined
:1; /* 30 */
7702 unsigned int Cleanup_defined
:1; /* 31 */
7704 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7705 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7706 unsigned int Large_frame
:1; /* 2 */
7707 unsigned int Pseudo_SP_Set
:1; /* 3 */
7708 unsigned int reserved4
:1; /* 4 */
7709 unsigned int Total_frame_size
:27; /* 5..31 */
7712 struct hppa_unw_aux_info
7714 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7715 unsigned long table_len
; /* Length of unwind table. */
7716 bfd_vma seg_base
; /* Starting address of segment. */
7717 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7718 unsigned long nsyms
; /* Number of symbols. */
7719 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7720 unsigned long nfuns
; /* Number of entries in funtab. */
7721 char * strtab
; /* The string table. */
7722 unsigned long strtab_size
; /* Size of string table. */
7726 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7728 struct hppa_unw_table_entry
* tp
;
7729 unsigned long j
, nfuns
;
7730 bfd_boolean res
= TRUE
;
7732 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7733 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7734 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7735 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7737 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7739 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7742 const char * procname
;
7744 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7745 aux
->strtab_size
, tp
->start
, &procname
,
7748 fputs ("\n<", stdout
);
7752 fputs (procname
, stdout
);
7755 printf ("+%lx", (unsigned long) offset
);
7758 fputs (">: [", stdout
);
7759 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7760 fputc ('-', stdout
);
7761 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7764 #define PF(_m) if (tp->_m) printf (#_m " ");
7765 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7768 PF(Millicode_save_sr0
);
7769 /* PV(Region_description); */
7775 PF(Separate_Package_Body
);
7776 PF(Frame_Extension_Millicode
);
7777 PF(Stack_Overflow_Check
);
7778 PF(Two_Instruction_SP_Increment
);
7782 PF(sched_entry_seq
);
7785 PF(Save_MRP_in_frame
);
7786 PF(extn_ptr_defined
);
7787 PF(Cleanup_defined
);
7788 PF(MPE_XL_interrupt_marker
);
7789 PF(HP_UX_interrupt_marker
);
7792 PV(Total_frame_size
);
7805 slurp_hppa_unwind_table (FILE * file
,
7806 struct hppa_unw_aux_info
* aux
,
7807 Elf_Internal_Shdr
* sec
)
7809 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7810 Elf_Internal_Phdr
* seg
;
7811 struct hppa_unw_table_entry
* tep
;
7812 Elf_Internal_Shdr
* relsec
;
7813 Elf_Internal_Rela
* rela
;
7814 Elf_Internal_Rela
* rp
;
7815 unsigned char * table
;
7817 Elf_Internal_Sym
* sym
;
7818 const char * relname
;
7820 /* First, find the starting address of the segment that includes
7822 if (elf_header
.e_phnum
)
7824 if (! get_program_headers (file
))
7827 for (seg
= program_headers
;
7828 seg
< program_headers
+ elf_header
.e_phnum
;
7831 if (seg
->p_type
!= PT_LOAD
)
7834 if (sec
->sh_addr
>= seg
->p_vaddr
7835 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7837 aux
->seg_base
= seg
->p_vaddr
;
7843 /* Second, build the unwind table from the contents of the unwind
7845 size
= sec
->sh_size
;
7846 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7852 nentries
= size
/ unw_ent_size
;
7853 size
= unw_ent_size
* nentries
;
7855 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7856 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7858 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7860 unsigned int tmp1
, tmp2
;
7862 tep
->start
.section
= SHN_UNDEF
;
7863 tep
->end
.section
= SHN_UNDEF
;
7865 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7866 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7867 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7868 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7870 tep
->start
.offset
+= aux
->seg_base
;
7871 tep
->end
.offset
+= aux
->seg_base
;
7873 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7874 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7875 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7876 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7877 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7878 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7879 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7880 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7881 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7882 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7883 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7884 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7885 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7886 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7887 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7888 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7889 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7890 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7891 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7892 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7893 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7894 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7895 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7896 tep
->Cleanup_defined
= tmp1
& 0x1;
7898 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7899 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7900 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7901 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7902 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7903 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7907 /* Third, apply any relocations to the unwind table. */
7908 for (relsec
= section_headers
;
7909 relsec
< section_headers
+ elf_header
.e_shnum
;
7912 if (relsec
->sh_type
!= SHT_RELA
7913 || relsec
->sh_info
>= elf_header
.e_shnum
7914 || section_headers
+ relsec
->sh_info
!= sec
)
7917 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7921 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7923 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7924 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7926 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7927 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7929 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7933 i
= rp
->r_offset
/ unw_ent_size
;
7935 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7938 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7939 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7942 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7943 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7953 aux
->table_len
= nentries
;
7959 hppa_process_unwind (FILE * file
)
7961 struct hppa_unw_aux_info aux
;
7962 Elf_Internal_Shdr
* unwsec
= NULL
;
7963 Elf_Internal_Shdr
* strsec
;
7964 Elf_Internal_Shdr
* sec
;
7966 bfd_boolean res
= TRUE
;
7968 if (string_table
== NULL
)
7971 memset (& aux
, 0, sizeof (aux
));
7973 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7975 if (sec
->sh_type
== SHT_SYMTAB
7976 && sec
->sh_link
< elf_header
.e_shnum
)
7978 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7980 strsec
= section_headers
+ sec
->sh_link
;
7981 if (aux
.strtab
!= NULL
)
7983 error (_("Multiple auxillary string tables encountered\n"));
7987 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7990 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7992 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7997 printf (_("\nThere are no unwind sections in this file.\n"));
7999 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8001 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8003 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8004 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8005 "contains %lu entry:\n",
8006 "\nUnwind section '%s' at offset 0x%lx "
8007 "contains %lu entries:\n",
8009 printable_section_name (sec
),
8010 (unsigned long) sec
->sh_offset
,
8013 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
8016 if (aux
.table_len
> 0)
8018 if (! dump_hppa_unwind (&aux
))
8023 free ((char *) aux
.table
);
8031 free ((char *) aux
.strtab
);
8038 unsigned char * data
; /* The unwind data. */
8039 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8040 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8041 unsigned long nrelas
; /* The number of relocations. */
8042 unsigned int rel_type
; /* REL or RELA ? */
8043 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8046 struct arm_unw_aux_info
8048 FILE * file
; /* The file containing the unwind sections. */
8049 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8050 unsigned long nsyms
; /* Number of symbols. */
8051 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8052 unsigned long nfuns
; /* Number of these symbols. */
8053 char * strtab
; /* The file's string table. */
8054 unsigned long strtab_size
; /* Size of string table. */
8058 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
8059 bfd_vma fn
, struct absaddr addr
)
8061 const char *procname
;
8064 if (addr
.section
== SHN_UNDEF
)
8067 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8068 aux
->strtab_size
, addr
, &procname
,
8071 print_vma (fn
, PREFIX_HEX
);
8075 fputs (" <", stdout
);
8076 fputs (procname
, stdout
);
8079 printf ("+0x%lx", (unsigned long) sym_offset
);
8080 fputc ('>', stdout
);
8087 arm_free_section (struct arm_section
*arm_sec
)
8089 if (arm_sec
->data
!= NULL
)
8090 free (arm_sec
->data
);
8092 if (arm_sec
->rela
!= NULL
)
8093 free (arm_sec
->rela
);
8096 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8097 cached section and install SEC instead.
8098 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8099 and return its valued in * WORDP, relocating if necessary.
8100 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8101 relocation's offset in ADDR.
8102 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8103 into the string table of the symbol associated with the reloc. If no
8104 reloc was applied store -1 there.
8105 5) Return TRUE upon success, FALSE otherwise. */
8108 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8109 struct arm_section
* arm_sec
,
8110 Elf_Internal_Shdr
* sec
,
8111 bfd_vma word_offset
,
8112 unsigned int * wordp
,
8113 struct absaddr
* addr
,
8116 Elf_Internal_Rela
*rp
;
8117 Elf_Internal_Sym
*sym
;
8118 const char * relname
;
8120 bfd_boolean wrapped
;
8122 if (sec
== NULL
|| arm_sec
== NULL
)
8125 addr
->section
= SHN_UNDEF
;
8128 if (sym_name
!= NULL
)
8129 *sym_name
= (bfd_vma
) -1;
8131 /* If necessary, update the section cache. */
8132 if (sec
!= arm_sec
->sec
)
8134 Elf_Internal_Shdr
*relsec
;
8136 arm_free_section (arm_sec
);
8139 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8140 sec
->sh_size
, _("unwind data"));
8141 arm_sec
->rela
= NULL
;
8142 arm_sec
->nrelas
= 0;
8144 for (relsec
= section_headers
;
8145 relsec
< section_headers
+ elf_header
.e_shnum
;
8148 if (relsec
->sh_info
>= elf_header
.e_shnum
8149 || section_headers
+ relsec
->sh_info
!= sec
8150 /* PR 15745: Check the section type as well. */
8151 || (relsec
->sh_type
!= SHT_REL
8152 && relsec
->sh_type
!= SHT_RELA
))
8155 arm_sec
->rel_type
= relsec
->sh_type
;
8156 if (relsec
->sh_type
== SHT_REL
)
8158 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8160 & arm_sec
->rela
, & arm_sec
->nrelas
))
8163 else /* relsec->sh_type == SHT_RELA */
8165 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8167 & arm_sec
->rela
, & arm_sec
->nrelas
))
8173 arm_sec
->next_rela
= arm_sec
->rela
;
8176 /* If there is no unwind data we can do nothing. */
8177 if (arm_sec
->data
== NULL
)
8180 /* If the offset is invalid then fail. */
8181 if (/* PR 21343 *//* PR 18879 */
8183 || word_offset
> (sec
->sh_size
- 4)
8184 || ((bfd_signed_vma
) word_offset
) < 0)
8187 /* Get the word at the required offset. */
8188 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8190 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8191 if (arm_sec
->rela
== NULL
)
8197 /* Look through the relocs to find the one that applies to the provided offset. */
8199 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8201 bfd_vma prelval
, offset
;
8203 if (rp
->r_offset
> word_offset
&& !wrapped
)
8208 if (rp
->r_offset
> word_offset
)
8211 if (rp
->r_offset
& 3)
8213 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8214 (unsigned long) rp
->r_offset
);
8218 if (rp
->r_offset
< word_offset
)
8221 /* PR 17531: file: 027-161405-0.004 */
8222 if (aux
->symtab
== NULL
)
8225 if (arm_sec
->rel_type
== SHT_REL
)
8227 offset
= word
& 0x7fffffff;
8228 if (offset
& 0x40000000)
8229 offset
|= ~ (bfd_vma
) 0x7fffffff;
8231 else if (arm_sec
->rel_type
== SHT_RELA
)
8232 offset
= rp
->r_addend
;
8235 error (_("Unknown section relocation type %d encountered\n"),
8240 /* PR 17531 file: 027-1241568-0.004. */
8241 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8243 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8244 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8248 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8249 offset
+= sym
->st_value
;
8250 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8252 /* Check that we are processing the expected reloc type. */
8253 if (elf_header
.e_machine
== EM_ARM
)
8255 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8256 if (relname
== NULL
)
8258 warn (_("Skipping unknown ARM relocation type: %d\n"),
8259 (int) ELF32_R_TYPE (rp
->r_info
));
8263 if (streq (relname
, "R_ARM_NONE"))
8266 if (! streq (relname
, "R_ARM_PREL31"))
8268 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8272 else if (elf_header
.e_machine
== EM_TI_C6000
)
8274 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8275 if (relname
== NULL
)
8277 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8278 (int) ELF32_R_TYPE (rp
->r_info
));
8282 if (streq (relname
, "R_C6000_NONE"))
8285 if (! streq (relname
, "R_C6000_PREL31"))
8287 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8295 /* This function currently only supports ARM and TI unwinders. */
8296 warn (_("Only TI and ARM unwinders are currently supported\n"));
8300 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8301 addr
->section
= sym
->st_shndx
;
8302 addr
->offset
= offset
;
8305 * sym_name
= sym
->st_name
;
8310 arm_sec
->next_rela
= rp
;
8315 static const char *tic6x_unwind_regnames
[16] =
8317 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8318 "A14", "A13", "A12", "A11", "A10",
8319 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8323 decode_tic6x_unwind_regmask (unsigned int mask
)
8327 for (i
= 12; mask
; mask
>>= 1, i
--)
8331 fputs (tic6x_unwind_regnames
[i
], stdout
);
8333 fputs (", ", stdout
);
8339 if (remaining == 0 && more_words) \
8342 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8343 data_offset, & word, & addr, NULL)) \
8349 #define GET_OP(OP) \
8354 (OP) = word >> 24; \
8359 printf (_("[Truncated opcode]\n")); \
8362 printf ("0x%02x ", OP)
8365 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8367 unsigned int remaining
,
8368 unsigned int more_words
,
8369 bfd_vma data_offset
,
8370 Elf_Internal_Shdr
* data_sec
,
8371 struct arm_section
* data_arm_sec
)
8373 struct absaddr addr
;
8374 bfd_boolean res
= TRUE
;
8376 /* Decode the unwinding instructions. */
8379 unsigned int op
, op2
;
8388 printf (" 0x%02x ", op
);
8390 if ((op
& 0xc0) == 0x00)
8392 int offset
= ((op
& 0x3f) << 2) + 4;
8394 printf (" vsp = vsp + %d", offset
);
8396 else if ((op
& 0xc0) == 0x40)
8398 int offset
= ((op
& 0x3f) << 2) + 4;
8400 printf (" vsp = vsp - %d", offset
);
8402 else if ((op
& 0xf0) == 0x80)
8405 if (op
== 0x80 && op2
== 0)
8406 printf (_("Refuse to unwind"));
8409 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8410 bfd_boolean first
= TRUE
;
8414 for (i
= 0; i
< 12; i
++)
8415 if (mask
& (1 << i
))
8421 printf ("r%d", 4 + i
);
8426 else if ((op
& 0xf0) == 0x90)
8428 if (op
== 0x9d || op
== 0x9f)
8429 printf (_(" [Reserved]"));
8431 printf (" vsp = r%d", op
& 0x0f);
8433 else if ((op
& 0xf0) == 0xa0)
8435 int end
= 4 + (op
& 0x07);
8436 bfd_boolean first
= TRUE
;
8440 for (i
= 4; i
<= end
; i
++)
8456 else if (op
== 0xb0)
8457 printf (_(" finish"));
8458 else if (op
== 0xb1)
8461 if (op2
== 0 || (op2
& 0xf0) != 0)
8462 printf (_("[Spare]"));
8465 unsigned int mask
= op2
& 0x0f;
8466 bfd_boolean first
= TRUE
;
8470 for (i
= 0; i
< 12; i
++)
8471 if (mask
& (1 << i
))
8482 else if (op
== 0xb2)
8484 unsigned char buf
[9];
8485 unsigned int i
, len
;
8486 unsigned long offset
;
8488 for (i
= 0; i
< sizeof (buf
); i
++)
8491 if ((buf
[i
] & 0x80) == 0)
8494 if (i
== sizeof (buf
))
8496 error (_("corrupt change to vsp"));
8501 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8502 assert (len
== i
+ 1);
8503 offset
= offset
* 4 + 0x204;
8504 printf ("vsp = vsp + %ld", offset
);
8507 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8509 unsigned int first
, last
;
8516 printf ("pop {D%d", first
);
8518 printf ("-D%d", first
+ last
);
8521 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8523 unsigned int count
= op
& 0x07;
8527 printf ("-D%d", 8 + count
);
8530 else if (op
>= 0xc0 && op
<= 0xc5)
8532 unsigned int count
= op
& 0x07;
8534 printf (" pop {wR10");
8536 printf ("-wR%d", 10 + count
);
8539 else if (op
== 0xc6)
8541 unsigned int first
, last
;
8546 printf ("pop {wR%d", first
);
8548 printf ("-wR%d", first
+ last
);
8551 else if (op
== 0xc7)
8554 if (op2
== 0 || (op2
& 0xf0) != 0)
8555 printf (_("[Spare]"));
8558 unsigned int mask
= op2
& 0x0f;
8559 bfd_boolean first
= TRUE
;
8563 for (i
= 0; i
< 4; i
++)
8564 if (mask
& (1 << i
))
8570 printf ("wCGR%d", i
);
8577 printf (_(" [unsupported opcode]"));
8588 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8590 unsigned int remaining
,
8591 unsigned int more_words
,
8592 bfd_vma data_offset
,
8593 Elf_Internal_Shdr
* data_sec
,
8594 struct arm_section
* data_arm_sec
)
8596 struct absaddr addr
;
8598 /* Decode the unwinding instructions. */
8601 unsigned int op
, op2
;
8610 printf (" 0x%02x ", op
);
8612 if ((op
& 0xc0) == 0x00)
8614 int offset
= ((op
& 0x3f) << 3) + 8;
8615 printf (" sp = sp + %d", offset
);
8617 else if ((op
& 0xc0) == 0x80)
8620 if (op
== 0x80 && op2
== 0)
8621 printf (_("Refuse to unwind"));
8624 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8626 printf ("pop compact {");
8630 decode_tic6x_unwind_regmask (mask
);
8634 else if ((op
& 0xf0) == 0xc0)
8642 unsigned int offset
;
8646 /* Scan entire instruction first so that GET_OP output is not
8647 interleaved with disassembly. */
8649 for (i
= 0; nregs
< (op
& 0xf); i
++)
8655 regpos
[nregs
].offset
= i
* 2;
8656 regpos
[nregs
].reg
= reg
;
8663 regpos
[nregs
].offset
= i
* 2 + 1;
8664 regpos
[nregs
].reg
= reg
;
8669 printf (_("pop frame {"));
8671 for (i
= i
* 2; i
> 0; i
--)
8673 if (regpos
[reg
].offset
== i
- 1)
8675 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8682 fputs (name
, stdout
);
8689 else if (op
== 0xd0)
8690 printf (" MOV FP, SP");
8691 else if (op
== 0xd1)
8692 printf (" __c6xabi_pop_rts");
8693 else if (op
== 0xd2)
8695 unsigned char buf
[9];
8696 unsigned int i
, len
;
8697 unsigned long offset
;
8699 for (i
= 0; i
< sizeof (buf
); i
++)
8702 if ((buf
[i
] & 0x80) == 0)
8705 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8706 if (i
== sizeof (buf
))
8708 warn (_("Corrupt stack pointer adjustment detected\n"));
8712 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8713 assert (len
== i
+ 1);
8714 offset
= offset
* 8 + 0x408;
8715 printf (_("sp = sp + %ld"), offset
);
8717 else if ((op
& 0xf0) == 0xe0)
8719 if ((op
& 0x0f) == 7)
8722 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8726 printf (_(" [unsupported opcode]"));
8735 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8739 offset
= word
& 0x7fffffff;
8740 if (offset
& 0x40000000)
8741 offset
|= ~ (bfd_vma
) 0x7fffffff;
8743 if (elf_header
.e_machine
== EM_TI_C6000
)
8746 return offset
+ where
;
8750 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8752 unsigned int remaining
,
8753 bfd_vma data_offset
,
8754 Elf_Internal_Shdr
* data_sec
,
8755 struct arm_section
* data_arm_sec
)
8758 unsigned int more_words
= 0;
8759 struct absaddr addr
;
8760 bfd_vma sym_name
= (bfd_vma
) -1;
8761 bfd_boolean res
= TRUE
;
8765 /* Fetch the first word.
8766 Note - when decoding an object file the address extracted
8767 here will always be 0. So we also pass in the sym_name
8768 parameter so that we can find the symbol associated with
8769 the personality routine. */
8770 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8771 & word
, & addr
, & sym_name
))
8777 if ((word
& 0x80000000) == 0)
8779 /* Expand prel31 for personality routine. */
8781 const char *procname
;
8783 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8784 printf (_(" Personality routine: "));
8786 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8787 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8789 procname
= aux
->strtab
+ sym_name
;
8790 print_vma (fn
, PREFIX_HEX
);
8793 fputs (" <", stdout
);
8794 fputs (procname
, stdout
);
8795 fputc ('>', stdout
);
8799 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8800 fputc ('\n', stdout
);
8802 /* The GCC personality routines use the standard compact
8803 encoding, starting with one byte giving the number of
8805 if (procname
!= NULL
8806 && (const_strneq (procname
, "__gcc_personality_v0")
8807 || const_strneq (procname
, "__gxx_personality_v0")
8808 || const_strneq (procname
, "__gcj_personality_v0")
8809 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8816 printf (_(" [Truncated data]\n"));
8819 more_words
= word
>> 24;
8829 /* ARM EHABI Section 6.3:
8831 An exception-handling table entry for the compact model looks like:
8835 1 0 index Data for personalityRoutine[index] */
8837 if (elf_header
.e_machine
== EM_ARM
8838 && (word
& 0x70000000))
8840 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8844 per_index
= (word
>> 24) & 0x7f;
8845 printf (_(" Compact model index: %d\n"), per_index
);
8852 else if (per_index
< 3)
8854 more_words
= (word
>> 16) & 0xff;
8860 switch (elf_header
.e_machine
)
8865 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8866 data_offset
, data_sec
, data_arm_sec
))
8871 warn (_("Unknown ARM compact model index encountered\n"));
8872 printf (_(" [reserved]\n"));
8880 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8881 data_offset
, data_sec
, data_arm_sec
))
8884 else if (per_index
< 5)
8886 if (((word
>> 17) & 0x7f) == 0x7f)
8887 printf (_(" Restore stack from frame pointer\n"));
8889 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8890 printf (_(" Registers restored: "));
8892 printf (" (compact) ");
8893 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8895 printf (_(" Return register: %s\n"),
8896 tic6x_unwind_regnames
[word
& 0xf]);
8899 printf (_(" [reserved (%d)]\n"), per_index
);
8903 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8904 elf_header
.e_machine
);
8908 /* Decode the descriptors. Not implemented. */
8914 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8916 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8917 unsigned int i
, exidx_len
;
8918 unsigned long j
, nfuns
;
8919 bfd_boolean res
= TRUE
;
8921 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8922 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8923 exidx_len
= exidx_sec
->sh_size
/ 8;
8925 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8926 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8927 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8928 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8930 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8932 for (i
= 0; i
< exidx_len
; i
++)
8934 unsigned int exidx_fn
, exidx_entry
;
8935 struct absaddr fn_addr
, entry_addr
;
8938 fputc ('\n', stdout
);
8940 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8941 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8942 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8943 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8946 arm_free_section (& exidx_arm_sec
);
8947 arm_free_section (& extab_arm_sec
);
8951 /* ARM EHABI, Section 5:
8952 An index table entry consists of 2 words.
8953 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8954 if (exidx_fn
& 0x80000000)
8956 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8960 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8962 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8963 fputs (": ", stdout
);
8965 if (exidx_entry
== 1)
8967 print_vma (exidx_entry
, PREFIX_HEX
);
8968 fputs (" [cantunwind]\n", stdout
);
8970 else if (exidx_entry
& 0x80000000)
8972 print_vma (exidx_entry
, PREFIX_HEX
);
8973 fputc ('\n', stdout
);
8974 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8978 bfd_vma table
, table_offset
= 0;
8979 Elf_Internal_Shdr
*table_sec
;
8981 fputs ("@", stdout
);
8982 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8983 print_vma (table
, PREFIX_HEX
);
8986 /* Locate the matching .ARM.extab. */
8987 if (entry_addr
.section
!= SHN_UNDEF
8988 && entry_addr
.section
< elf_header
.e_shnum
)
8990 table_sec
= section_headers
+ entry_addr
.section
;
8991 table_offset
= entry_addr
.offset
;
8993 if (table_offset
> table_sec
->sh_size
8994 || ((bfd_signed_vma
) table_offset
) < 0)
8996 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8997 (unsigned long) table_offset
,
8998 printable_section_name (table_sec
));
9005 table_sec
= find_section_by_address (table
);
9006 if (table_sec
!= NULL
)
9007 table_offset
= table
- table_sec
->sh_addr
;
9010 if (table_sec
== NULL
)
9012 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9013 (unsigned long) table
);
9018 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
9027 arm_free_section (&exidx_arm_sec
);
9028 arm_free_section (&extab_arm_sec
);
9033 /* Used for both ARM and C6X unwinding tables. */
9036 arm_process_unwind (FILE *file
)
9038 struct arm_unw_aux_info aux
;
9039 Elf_Internal_Shdr
*unwsec
= NULL
;
9040 Elf_Internal_Shdr
*strsec
;
9041 Elf_Internal_Shdr
*sec
;
9043 unsigned int sec_type
;
9044 bfd_boolean res
= TRUE
;
9046 switch (elf_header
.e_machine
)
9049 sec_type
= SHT_ARM_EXIDX
;
9053 sec_type
= SHT_C6000_UNWIND
;
9057 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9058 elf_header
.e_machine
);
9062 if (string_table
== NULL
)
9065 memset (& aux
, 0, sizeof (aux
));
9068 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9070 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9072 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9074 strsec
= section_headers
+ sec
->sh_link
;
9076 /* PR binutils/17531 file: 011-12666-0.004. */
9077 if (aux
.strtab
!= NULL
)
9079 error (_("Multiple string tables found in file.\n"));
9083 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9084 1, strsec
->sh_size
, _("string table"));
9085 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9087 else if (sec
->sh_type
== sec_type
)
9092 printf (_("\nThere are no unwind sections in this file.\n"));
9094 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9096 if (sec
->sh_type
== sec_type
)
9098 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9099 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9100 "contains %lu entry:\n",
9101 "\nUnwind section '%s' at offset 0x%lx "
9102 "contains %lu entries:\n",
9104 printable_section_name (sec
),
9105 (unsigned long) sec
->sh_offset
,
9108 if (! dump_arm_unwind (&aux
, sec
))
9116 free ((char *) aux
.strtab
);
9122 process_unwind (FILE * file
)
9124 struct unwind_handler
9126 unsigned int machtype
;
9127 bfd_boolean (* handler
)(FILE *);
9130 { EM_ARM
, arm_process_unwind
},
9131 { EM_IA_64
, ia64_process_unwind
},
9132 { EM_PARISC
, hppa_process_unwind
},
9133 { EM_TI_C6000
, arm_process_unwind
},
9141 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9142 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9143 return handlers
[i
].handler (file
);
9145 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9146 get_machine_name (elf_header
.e_machine
));
9151 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9153 switch (entry
->d_tag
)
9156 if (entry
->d_un
.d_val
== 0)
9160 static const char * opts
[] =
9162 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9163 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9164 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9165 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9169 bfd_boolean first
= TRUE
;
9171 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9172 if (entry
->d_un
.d_val
& (1 << cnt
))
9174 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9180 case DT_MIPS_IVERSION
:
9181 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9182 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9186 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9187 /* Note: coded this way so that there is a single string for translation. */
9188 printf (_("<corrupt: %s>"), buf
);
9192 case DT_MIPS_TIME_STAMP
:
9196 time_t atime
= entry
->d_un
.d_val
;
9198 tmp
= gmtime (&atime
);
9199 /* PR 17531: file: 6accc532. */
9201 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9203 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9204 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9205 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9206 printf (_("Time Stamp: %s"), timebuf
);
9210 case DT_MIPS_RLD_VERSION
:
9211 case DT_MIPS_LOCAL_GOTNO
:
9212 case DT_MIPS_CONFLICTNO
:
9213 case DT_MIPS_LIBLISTNO
:
9214 case DT_MIPS_SYMTABNO
:
9215 case DT_MIPS_UNREFEXTNO
:
9216 case DT_MIPS_HIPAGENO
:
9217 case DT_MIPS_DELTA_CLASS_NO
:
9218 case DT_MIPS_DELTA_INSTANCE_NO
:
9219 case DT_MIPS_DELTA_RELOC_NO
:
9220 case DT_MIPS_DELTA_SYM_NO
:
9221 case DT_MIPS_DELTA_CLASSSYM_NO
:
9222 case DT_MIPS_COMPACT_SIZE
:
9223 print_vma (entry
->d_un
.d_val
, DEC
);
9227 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9233 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9235 switch (entry
->d_tag
)
9237 case DT_HP_DLD_FLAGS
:
9246 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9247 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9248 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9249 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9250 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9251 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9252 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9253 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9254 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9255 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9256 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9257 { DT_HP_GST
, "HP_GST" },
9258 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9259 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9260 { DT_HP_NODELETE
, "HP_NODELETE" },
9261 { DT_HP_GROUP
, "HP_GROUP" },
9262 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9264 bfd_boolean first
= TRUE
;
9266 bfd_vma val
= entry
->d_un
.d_val
;
9268 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9269 if (val
& flags
[cnt
].bit
)
9273 fputs (flags
[cnt
].str
, stdout
);
9275 val
^= flags
[cnt
].bit
;
9278 if (val
!= 0 || first
)
9282 print_vma (val
, HEX
);
9288 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9296 /* VMS vs Unix time offset and factor. */
9298 #define VMS_EPOCH_OFFSET 35067168000000000LL
9299 #define VMS_GRANULARITY_FACTOR 10000000
9301 /* Display a VMS time in a human readable format. */
9304 print_vms_time (bfd_int64_t vmstime
)
9309 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9310 tm
= gmtime (&unxtime
);
9311 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9312 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9313 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9318 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9320 switch (entry
->d_tag
)
9322 case DT_IA_64_PLT_RESERVE
:
9323 /* First 3 slots reserved. */
9324 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9326 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9329 case DT_IA_64_VMS_LINKTIME
:
9331 print_vms_time (entry
->d_un
.d_val
);
9335 case DT_IA_64_VMS_LNKFLAGS
:
9336 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9337 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9338 printf (" CALL_DEBUG");
9339 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9340 printf (" NOP0BUFS");
9341 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9342 printf (" P0IMAGE");
9343 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9344 printf (" MKTHREADS");
9345 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9346 printf (" UPCALLS");
9347 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9349 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9350 printf (" INITIALIZE");
9351 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9353 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9354 printf (" EXE_INIT");
9355 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9356 printf (" TBK_IN_IMG");
9357 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9358 printf (" DBG_IN_IMG");
9359 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9360 printf (" TBK_IN_DSF");
9361 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9362 printf (" DBG_IN_DSF");
9363 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9364 printf (" SIGNATURES");
9365 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9366 printf (" REL_SEG_OFF");
9370 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9377 get_32bit_dynamic_section (FILE * file
)
9379 Elf32_External_Dyn
* edyn
;
9380 Elf32_External_Dyn
* ext
;
9381 Elf_Internal_Dyn
* entry
;
9383 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9384 dynamic_size
, _("dynamic section"));
9388 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9389 might not have the luxury of section headers. Look for the DT_NULL
9390 terminator to determine the number of entries. */
9391 for (ext
= edyn
, dynamic_nent
= 0;
9392 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9396 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9400 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9402 if (dynamic_section
== NULL
)
9404 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9405 (unsigned long) dynamic_nent
);
9410 for (ext
= edyn
, entry
= dynamic_section
;
9411 entry
< dynamic_section
+ dynamic_nent
;
9414 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9415 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9424 get_64bit_dynamic_section (FILE * file
)
9426 Elf64_External_Dyn
* edyn
;
9427 Elf64_External_Dyn
* ext
;
9428 Elf_Internal_Dyn
* entry
;
9430 /* Read in the data. */
9431 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9432 dynamic_size
, _("dynamic section"));
9436 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9437 might not have the luxury of section headers. Look for the DT_NULL
9438 terminator to determine the number of entries. */
9439 for (ext
= edyn
, dynamic_nent
= 0;
9440 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9441 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9445 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9449 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9451 if (dynamic_section
== NULL
)
9453 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9454 (unsigned long) dynamic_nent
);
9459 /* Convert from external to internal formats. */
9460 for (ext
= edyn
, entry
= dynamic_section
;
9461 entry
< dynamic_section
+ dynamic_nent
;
9464 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9465 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9474 print_dynamic_flags (bfd_vma flags
)
9476 bfd_boolean first
= TRUE
;
9482 flag
= flags
& - flags
;
9492 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9493 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9494 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9495 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9496 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9497 default: fputs (_("unknown"), stdout
); break;
9503 /* Parse and display the contents of the dynamic section. */
9506 process_dynamic_section (FILE * file
)
9508 Elf_Internal_Dyn
* entry
;
9510 if (dynamic_size
== 0)
9513 printf (_("\nThere is no dynamic section in this file.\n"));
9520 if (! get_32bit_dynamic_section (file
))
9525 if (! get_64bit_dynamic_section (file
))
9529 /* Find the appropriate symbol table. */
9530 if (dynamic_symbols
== NULL
)
9532 for (entry
= dynamic_section
;
9533 entry
< dynamic_section
+ dynamic_nent
;
9536 Elf_Internal_Shdr section
;
9538 if (entry
->d_tag
!= DT_SYMTAB
)
9541 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9543 /* Since we do not know how big the symbol table is,
9544 we default to reading in the entire file (!) and
9545 processing that. This is overkill, I know, but it
9547 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9548 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9550 /* See PR 21379 for a reproducer. */
9551 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9555 if (archive_file_offset
!= 0)
9556 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9559 if (fseek (file
, 0, SEEK_END
))
9560 error (_("Unable to seek to end of file!\n"));
9562 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9566 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9568 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9569 section
.sh_name
= string_table_length
;
9571 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9572 if (num_dynamic_syms
< 1)
9574 error (_("Unable to determine the number of symbols to load\n"));
9580 /* Similarly find a string table. */
9581 if (dynamic_strings
== NULL
)
9583 for (entry
= dynamic_section
;
9584 entry
< dynamic_section
+ dynamic_nent
;
9587 unsigned long offset
;
9590 if (entry
->d_tag
!= DT_STRTAB
)
9593 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9595 /* Since we do not know how big the string table is,
9596 we default to reading in the entire file (!) and
9597 processing that. This is overkill, I know, but it
9600 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9602 if (archive_file_offset
!= 0)
9603 str_tab_len
= archive_file_size
- offset
;
9606 if (fseek (file
, 0, SEEK_END
))
9607 error (_("Unable to seek to end of file\n"));
9608 str_tab_len
= ftell (file
) - offset
;
9611 if (str_tab_len
< 1)
9614 (_("Unable to determine the length of the dynamic string table\n"));
9618 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9620 _("dynamic string table"));
9621 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9626 /* And find the syminfo section if available. */
9627 if (dynamic_syminfo
== NULL
)
9629 unsigned long syminsz
= 0;
9631 for (entry
= dynamic_section
;
9632 entry
< dynamic_section
+ dynamic_nent
;
9635 if (entry
->d_tag
== DT_SYMINENT
)
9637 /* Note: these braces are necessary to avoid a syntax
9638 error from the SunOS4 C compiler. */
9639 /* PR binutils/17531: A corrupt file can trigger this test.
9640 So do not use an assert, instead generate an error message. */
9641 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9642 error (_("Bad value (%d) for SYMINENT entry\n"),
9643 (int) entry
->d_un
.d_val
);
9645 else if (entry
->d_tag
== DT_SYMINSZ
)
9646 syminsz
= entry
->d_un
.d_val
;
9647 else if (entry
->d_tag
== DT_SYMINFO
)
9648 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9652 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9654 Elf_External_Syminfo
* extsyminfo
;
9655 Elf_External_Syminfo
* extsym
;
9656 Elf_Internal_Syminfo
* syminfo
;
9658 /* There is a syminfo section. Read the data. */
9659 extsyminfo
= (Elf_External_Syminfo
*)
9660 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9661 _("symbol information"));
9665 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9666 if (dynamic_syminfo
== NULL
)
9668 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9669 (unsigned long) syminsz
);
9673 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9674 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9675 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9676 ++syminfo
, ++extsym
)
9678 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9679 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9686 if (do_dynamic
&& dynamic_addr
)
9687 printf (ngettext ("\nDynamic section at offset 0x%lx "
9688 "contains %lu entry:\n",
9689 "\nDynamic section at offset 0x%lx "
9690 "contains %lu entries:\n",
9692 dynamic_addr
, (unsigned long) dynamic_nent
);
9694 printf (_(" Tag Type Name/Value\n"));
9696 for (entry
= dynamic_section
;
9697 entry
< dynamic_section
+ dynamic_nent
;
9705 print_vma (entry
->d_tag
, FULL_HEX
);
9706 dtype
= get_dynamic_type (entry
->d_tag
);
9707 printf (" (%s)%*s", dtype
,
9708 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9711 switch (entry
->d_tag
)
9715 print_dynamic_flags (entry
->d_un
.d_val
);
9725 switch (entry
->d_tag
)
9728 printf (_("Auxiliary library"));
9732 printf (_("Filter library"));
9736 printf (_("Configuration file"));
9740 printf (_("Dependency audit library"));
9744 printf (_("Audit library"));
9748 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9749 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9753 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9762 printf (_("Flags:"));
9764 if (entry
->d_un
.d_val
== 0)
9765 printf (_(" None\n"));
9768 unsigned long int val
= entry
->d_un
.d_val
;
9770 if (val
& DTF_1_PARINIT
)
9772 printf (" PARINIT");
9773 val
^= DTF_1_PARINIT
;
9775 if (val
& DTF_1_CONFEXP
)
9777 printf (" CONFEXP");
9778 val
^= DTF_1_CONFEXP
;
9781 printf (" %lx", val
);
9790 printf (_("Flags:"));
9792 if (entry
->d_un
.d_val
== 0)
9793 printf (_(" None\n"));
9796 unsigned long int val
= entry
->d_un
.d_val
;
9798 if (val
& DF_P1_LAZYLOAD
)
9800 printf (" LAZYLOAD");
9801 val
^= DF_P1_LAZYLOAD
;
9803 if (val
& DF_P1_GROUPPERM
)
9805 printf (" GROUPPERM");
9806 val
^= DF_P1_GROUPPERM
;
9809 printf (" %lx", val
);
9818 printf (_("Flags:"));
9819 if (entry
->d_un
.d_val
== 0)
9820 printf (_(" None\n"));
9823 unsigned long int val
= entry
->d_un
.d_val
;
9830 if (val
& DF_1_GLOBAL
)
9835 if (val
& DF_1_GROUP
)
9840 if (val
& DF_1_NODELETE
)
9842 printf (" NODELETE");
9843 val
^= DF_1_NODELETE
;
9845 if (val
& DF_1_LOADFLTR
)
9847 printf (" LOADFLTR");
9848 val
^= DF_1_LOADFLTR
;
9850 if (val
& DF_1_INITFIRST
)
9852 printf (" INITFIRST");
9853 val
^= DF_1_INITFIRST
;
9855 if (val
& DF_1_NOOPEN
)
9860 if (val
& DF_1_ORIGIN
)
9865 if (val
& DF_1_DIRECT
)
9870 if (val
& DF_1_TRANS
)
9875 if (val
& DF_1_INTERPOSE
)
9877 printf (" INTERPOSE");
9878 val
^= DF_1_INTERPOSE
;
9880 if (val
& DF_1_NODEFLIB
)
9882 printf (" NODEFLIB");
9883 val
^= DF_1_NODEFLIB
;
9885 if (val
& DF_1_NODUMP
)
9890 if (val
& DF_1_CONFALT
)
9892 printf (" CONFALT");
9893 val
^= DF_1_CONFALT
;
9895 if (val
& DF_1_ENDFILTEE
)
9897 printf (" ENDFILTEE");
9898 val
^= DF_1_ENDFILTEE
;
9900 if (val
& DF_1_DISPRELDNE
)
9902 printf (" DISPRELDNE");
9903 val
^= DF_1_DISPRELDNE
;
9905 if (val
& DF_1_DISPRELPND
)
9907 printf (" DISPRELPND");
9908 val
^= DF_1_DISPRELPND
;
9910 if (val
& DF_1_NODIRECT
)
9912 printf (" NODIRECT");
9913 val
^= DF_1_NODIRECT
;
9915 if (val
& DF_1_IGNMULDEF
)
9917 printf (" IGNMULDEF");
9918 val
^= DF_1_IGNMULDEF
;
9920 if (val
& DF_1_NOKSYMS
)
9922 printf (" NOKSYMS");
9923 val
^= DF_1_NOKSYMS
;
9925 if (val
& DF_1_NOHDR
)
9930 if (val
& DF_1_EDITED
)
9935 if (val
& DF_1_NORELOC
)
9937 printf (" NORELOC");
9938 val
^= DF_1_NORELOC
;
9940 if (val
& DF_1_SYMINTPOSE
)
9942 printf (" SYMINTPOSE");
9943 val
^= DF_1_SYMINTPOSE
;
9945 if (val
& DF_1_GLOBAUDIT
)
9947 printf (" GLOBAUDIT");
9948 val
^= DF_1_GLOBAUDIT
;
9950 if (val
& DF_1_SINGLETON
)
9952 printf (" SINGLETON");
9953 val
^= DF_1_SINGLETON
;
9955 if (val
& DF_1_STUB
)
9966 printf (" %lx", val
);
9973 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9975 puts (get_dynamic_type (entry
->d_un
.d_val
));
9995 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10001 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10002 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10008 switch (entry
->d_tag
)
10011 printf (_("Shared library: [%s]"), name
);
10013 if (streq (name
, program_interpreter
))
10014 printf (_(" program interpreter"));
10018 printf (_("Library soname: [%s]"), name
);
10022 printf (_("Library rpath: [%s]"), name
);
10026 printf (_("Library runpath: [%s]"), name
);
10030 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10035 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10048 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10049 /* Fall through. */
10053 case DT_INIT_ARRAYSZ
:
10054 case DT_FINI_ARRAYSZ
:
10055 case DT_GNU_CONFLICTSZ
:
10056 case DT_GNU_LIBLISTSZ
:
10059 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10060 printf (_(" (bytes)\n"));
10065 case DT_VERNEEDNUM
:
10070 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10079 case DT_INIT_ARRAY
:
10080 case DT_FINI_ARRAY
:
10083 if (entry
->d_tag
== DT_USED
10084 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10086 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10090 printf (_("Not needed object: [%s]\n"), name
);
10095 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10101 /* The value of this entry is ignored. */
10106 case DT_GNU_PRELINKED
:
10110 time_t atime
= entry
->d_un
.d_val
;
10112 tmp
= gmtime (&atime
);
10113 /* PR 17533 file: 041-1244816-0.004. */
10115 printf (_("<corrupt time val: %lx"),
10116 (unsigned long) atime
);
10118 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10119 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10120 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10126 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10129 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10135 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10136 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10141 switch (elf_header
.e_machine
)
10144 case EM_MIPS_RS3_LE
:
10145 dynamic_section_mips_val (entry
);
10148 dynamic_section_parisc_val (entry
);
10151 dynamic_section_ia64_val (entry
);
10154 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10166 get_ver_flags (unsigned int flags
)
10168 static char buff
[32];
10175 if (flags
& VER_FLG_BASE
)
10176 strcat (buff
, "BASE");
10178 if (flags
& VER_FLG_WEAK
)
10180 if (flags
& VER_FLG_BASE
)
10181 strcat (buff
, " | ");
10183 strcat (buff
, "WEAK");
10186 if (flags
& VER_FLG_INFO
)
10188 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10189 strcat (buff
, " | ");
10191 strcat (buff
, "INFO");
10194 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10196 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10197 strcat (buff
, " | ");
10199 strcat (buff
, _("<unknown>"));
10205 /* Display the contents of the version sections. */
10208 process_version_sections (FILE * file
)
10210 Elf_Internal_Shdr
* section
;
10212 bfd_boolean found
= FALSE
;
10217 for (i
= 0, section
= section_headers
;
10218 i
< elf_header
.e_shnum
;
10221 switch (section
->sh_type
)
10223 case SHT_GNU_verdef
:
10225 Elf_External_Verdef
* edefs
;
10232 printf (ngettext ("\nVersion definition section '%s' "
10233 "contains %u entry:\n",
10234 "\nVersion definition section '%s' "
10235 "contains %u entries:\n",
10237 printable_section_name (section
),
10240 printf (_(" Addr: 0x"));
10241 printf_vma (section
->sh_addr
);
10242 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10243 (unsigned long) section
->sh_offset
, section
->sh_link
,
10244 printable_section_name_from_index (section
->sh_link
));
10246 edefs
= (Elf_External_Verdef
*)
10247 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10248 _("version definition section"));
10251 endbuf
= (char *) edefs
+ section
->sh_size
;
10253 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10256 Elf_External_Verdef
* edef
;
10257 Elf_Internal_Verdef ent
;
10258 Elf_External_Verdaux
* eaux
;
10259 Elf_Internal_Verdaux aux
;
10260 unsigned long isum
;
10263 vstart
= ((char *) edefs
) + idx
;
10264 if (vstart
+ sizeof (*edef
) > endbuf
)
10267 edef
= (Elf_External_Verdef
*) vstart
;
10269 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10270 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10271 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10272 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10273 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10274 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10275 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10277 printf (_(" %#06lx: Rev: %d Flags: %s"),
10278 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10280 printf (_(" Index: %d Cnt: %d "),
10281 ent
.vd_ndx
, ent
.vd_cnt
);
10283 /* Check for overflow. */
10284 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10287 vstart
+= ent
.vd_aux
;
10289 if (vstart
+ sizeof (*eaux
) > endbuf
)
10291 eaux
= (Elf_External_Verdaux
*) vstart
;
10293 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10294 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10296 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10297 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10299 printf (_("Name index: %ld\n"), aux
.vda_name
);
10301 isum
= idx
+ ent
.vd_aux
;
10303 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10305 if (aux
.vda_next
< sizeof (*eaux
)
10306 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10308 warn (_("Invalid vda_next field of %lx\n"),
10313 /* Check for overflow. */
10314 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10317 isum
+= aux
.vda_next
;
10318 vstart
+= aux
.vda_next
;
10320 if (vstart
+ sizeof (*eaux
) > endbuf
)
10322 eaux
= (Elf_External_Verdaux
*) vstart
;
10324 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10325 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10327 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10328 printf (_(" %#06lx: Parent %d: %s\n"),
10329 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10331 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10332 isum
, j
, aux
.vda_name
);
10335 if (j
< ent
.vd_cnt
)
10336 printf (_(" Version def aux past end of section\n"));
10339 file: id:000001,src:000172+005151,op:splice,rep:2. */
10340 if (ent
.vd_next
< sizeof (*edef
)
10341 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10343 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10344 cnt
= section
->sh_info
;
10347 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10350 idx
+= ent
.vd_next
;
10353 if (cnt
< section
->sh_info
)
10354 printf (_(" Version definition past end of section\n"));
10360 case SHT_GNU_verneed
:
10362 Elf_External_Verneed
* eneed
;
10369 printf (ngettext ("\nVersion needs section '%s' "
10370 "contains %u entry:\n",
10371 "\nVersion needs section '%s' "
10372 "contains %u entries:\n",
10374 printable_section_name (section
), section
->sh_info
);
10376 printf (_(" Addr: 0x"));
10377 printf_vma (section
->sh_addr
);
10378 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10379 (unsigned long) section
->sh_offset
, section
->sh_link
,
10380 printable_section_name_from_index (section
->sh_link
));
10382 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10383 section
->sh_offset
, 1,
10385 _("Version Needs section"));
10388 endbuf
= (char *) eneed
+ section
->sh_size
;
10390 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10392 Elf_External_Verneed
* entry
;
10393 Elf_Internal_Verneed ent
;
10394 unsigned long isum
;
10398 vstart
= ((char *) eneed
) + idx
;
10399 if (vstart
+ sizeof (*entry
) > endbuf
)
10402 entry
= (Elf_External_Verneed
*) vstart
;
10404 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10405 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10406 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10407 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10408 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10410 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10412 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10413 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10415 printf (_(" File: %lx"), ent
.vn_file
);
10417 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10419 /* Check for overflow. */
10420 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10422 vstart
+= ent
.vn_aux
;
10424 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10426 Elf_External_Vernaux
* eaux
;
10427 Elf_Internal_Vernaux aux
;
10429 if (vstart
+ sizeof (*eaux
) > endbuf
)
10431 eaux
= (Elf_External_Vernaux
*) vstart
;
10433 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10434 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10435 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10436 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10437 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10439 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10440 printf (_(" %#06lx: Name: %s"),
10441 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10443 printf (_(" %#06lx: Name index: %lx"),
10444 isum
, aux
.vna_name
);
10446 printf (_(" Flags: %s Version: %d\n"),
10447 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10449 if (aux
.vna_next
< sizeof (*eaux
)
10450 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10452 warn (_("Invalid vna_next field of %lx\n"),
10457 /* Check for overflow. */
10458 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10460 isum
+= aux
.vna_next
;
10461 vstart
+= aux
.vna_next
;
10464 if (j
< ent
.vn_cnt
)
10465 warn (_("Missing Version Needs auxillary information\n"));
10467 if (ent
.vn_next
< sizeof (*entry
)
10468 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10470 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10471 cnt
= section
->sh_info
;
10474 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10476 idx
+= ent
.vn_next
;
10479 if (cnt
< section
->sh_info
)
10480 warn (_("Missing Version Needs information\n"));
10486 case SHT_GNU_versym
:
10488 Elf_Internal_Shdr
* link_section
;
10491 unsigned char * edata
;
10492 unsigned short * data
;
10494 Elf_Internal_Sym
* symbols
;
10495 Elf_Internal_Shdr
* string_sec
;
10496 unsigned long num_syms
;
10499 if (section
->sh_link
>= elf_header
.e_shnum
)
10502 link_section
= section_headers
+ section
->sh_link
;
10503 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10505 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10510 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10511 if (symbols
== NULL
)
10514 string_sec
= section_headers
+ link_section
->sh_link
;
10516 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10517 string_sec
->sh_size
,
10518 _("version string table"));
10525 printf (ngettext ("\nVersion symbols section '%s' "
10526 "contains %lu entry:\n",
10527 "\nVersion symbols section '%s' "
10528 "contains %lu entries:\n",
10530 printable_section_name (section
), (unsigned long) total
);
10532 printf (_(" Addr: "));
10533 printf_vma (section
->sh_addr
);
10534 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10535 (unsigned long) section
->sh_offset
, section
->sh_link
,
10536 printable_section_name (link_section
));
10538 off
= offset_from_vma (file
,
10539 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10540 total
* sizeof (short));
10541 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10543 _("version symbol data"));
10551 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10553 for (cnt
= total
; cnt
--;)
10554 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10559 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10563 char *invalid
= _("*invalid*");
10565 printf (" %03x:", cnt
);
10567 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10568 switch (data
[cnt
+ j
])
10571 fputs (_(" 0 (*local*) "), stdout
);
10575 fputs (_(" 1 (*global*) "), stdout
);
10579 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10580 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10582 /* If this index value is greater than the size of the symbols
10583 array, break to avoid an out-of-bounds read. */
10584 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10586 warn (_("invalid index into symbol array\n"));
10591 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10593 Elf_Internal_Verneed ivn
;
10594 unsigned long offset
;
10596 offset
= offset_from_vma
10597 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10598 sizeof (Elf_External_Verneed
));
10602 Elf_Internal_Vernaux ivna
;
10603 Elf_External_Verneed evn
;
10604 Elf_External_Vernaux evna
;
10605 unsigned long a_off
;
10607 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10608 _("version need")) == NULL
)
10611 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10612 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10614 a_off
= offset
+ ivn
.vn_aux
;
10618 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10619 1, _("version need aux (2)")) == NULL
)
10622 ivna
.vna_other
= 0;
10626 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10627 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10630 a_off
+= ivna
.vna_next
;
10632 while (ivna
.vna_other
!= data
[cnt
+ j
]
10633 && ivna
.vna_next
!= 0);
10635 if (ivna
.vna_other
== data
[cnt
+ j
])
10637 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10639 if (ivna
.vna_name
>= string_sec
->sh_size
)
10642 name
= strtab
+ ivna
.vna_name
;
10646 offset
+= ivn
.vn_next
;
10648 while (ivn
.vn_next
);
10651 if (data
[cnt
+ j
] != 0x8001
10652 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10654 Elf_Internal_Verdef ivd
;
10655 Elf_External_Verdef evd
;
10656 unsigned long offset
;
10658 offset
= offset_from_vma
10659 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10664 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10665 _("version def")) == NULL
)
10668 /* PR 17531: file: 046-1082287-0.004. */
10669 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10674 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10675 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10678 offset
+= ivd
.vd_next
;
10680 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10681 && ivd
.vd_next
!= 0);
10683 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10685 Elf_External_Verdaux evda
;
10686 Elf_Internal_Verdaux ivda
;
10688 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10690 if (get_data (&evda
, file
,
10691 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10693 _("version def aux")) == NULL
)
10696 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10698 if (ivda
.vda_name
>= string_sec
->sh_size
)
10700 else if (name
!= NULL
&& name
!= invalid
)
10701 name
= _("*both*");
10703 name
= strtab
+ ivda
.vda_name
;
10707 nn
+= printf ("(%s%-*s",
10709 12 - (int) strlen (name
),
10713 printf ("%*c", 18 - nn
, ' ');
10731 printf (_("\nNo version information found in this file.\n"));
10736 static const char *
10737 get_symbol_binding (unsigned int binding
)
10739 static char buff
[32];
10743 case STB_LOCAL
: return "LOCAL";
10744 case STB_GLOBAL
: return "GLOBAL";
10745 case STB_WEAK
: return "WEAK";
10747 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10748 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10750 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10752 if (binding
== STB_GNU_UNIQUE
10753 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10754 /* GNU is still using the default value 0. */
10755 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10757 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10760 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10765 static const char *
10766 get_symbol_type (unsigned int type
)
10768 static char buff
[32];
10772 case STT_NOTYPE
: return "NOTYPE";
10773 case STT_OBJECT
: return "OBJECT";
10774 case STT_FUNC
: return "FUNC";
10775 case STT_SECTION
: return "SECTION";
10776 case STT_FILE
: return "FILE";
10777 case STT_COMMON
: return "COMMON";
10778 case STT_TLS
: return "TLS";
10779 case STT_RELC
: return "RELC";
10780 case STT_SRELC
: return "SRELC";
10782 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10784 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10785 return "THUMB_FUNC";
10787 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10790 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10791 return "PARISC_MILLI";
10793 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10795 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10797 if (elf_header
.e_machine
== EM_PARISC
)
10799 if (type
== STT_HP_OPAQUE
)
10800 return "HP_OPAQUE";
10801 if (type
== STT_HP_STUB
)
10805 if (type
== STT_GNU_IFUNC
10806 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10807 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10808 /* GNU is still using the default value 0. */
10809 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10812 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10815 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10820 static const char *
10821 get_symbol_visibility (unsigned int visibility
)
10823 switch (visibility
)
10825 case STV_DEFAULT
: return "DEFAULT";
10826 case STV_INTERNAL
: return "INTERNAL";
10827 case STV_HIDDEN
: return "HIDDEN";
10828 case STV_PROTECTED
: return "PROTECTED";
10830 error (_("Unrecognized visibility value: %u"), visibility
);
10831 return _("<unknown>");
10835 static const char *
10836 get_solaris_symbol_visibility (unsigned int visibility
)
10838 switch (visibility
)
10840 case 4: return "EXPORTED";
10841 case 5: return "SINGLETON";
10842 case 6: return "ELIMINATE";
10843 default: return get_symbol_visibility (visibility
);
10847 static const char *
10848 get_mips_symbol_other (unsigned int other
)
10852 case STO_OPTIONAL
: return "OPTIONAL";
10853 case STO_MIPS_PLT
: return "MIPS PLT";
10854 case STO_MIPS_PIC
: return "MIPS PIC";
10855 case STO_MICROMIPS
: return "MICROMIPS";
10856 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10857 case STO_MIPS16
: return "MIPS16";
10858 default: return NULL
;
10862 static const char *
10863 get_ia64_symbol_other (unsigned int other
)
10865 if (is_ia64_vms ())
10867 static char res
[32];
10871 /* Function types is for images and .STB files only. */
10872 switch (elf_header
.e_type
)
10876 switch (VMS_ST_FUNC_TYPE (other
))
10878 case VMS_SFT_CODE_ADDR
:
10879 strcat (res
, " CA");
10881 case VMS_SFT_SYMV_IDX
:
10882 strcat (res
, " VEC");
10885 strcat (res
, " FD");
10887 case VMS_SFT_RESERVE
:
10888 strcat (res
, " RSV");
10891 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10892 VMS_ST_FUNC_TYPE (other
));
10893 strcat (res
, " <unknown>");
10900 switch (VMS_ST_LINKAGE (other
))
10902 case VMS_STL_IGNORE
:
10903 strcat (res
, " IGN");
10905 case VMS_STL_RESERVE
:
10906 strcat (res
, " RSV");
10909 strcat (res
, " STD");
10912 strcat (res
, " LNK");
10915 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10916 VMS_ST_LINKAGE (other
));
10917 strcat (res
, " <unknown>");
10929 static const char *
10930 get_ppc64_symbol_other (unsigned int other
)
10932 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10934 static char buf
[32];
10935 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10936 PPC64_LOCAL_ENTRY_OFFSET (other
));
10942 static const char *
10943 get_symbol_other (unsigned int other
)
10945 const char * result
= NULL
;
10946 static char buff
[32];
10951 switch (elf_header
.e_machine
)
10954 result
= get_mips_symbol_other (other
);
10957 result
= get_ia64_symbol_other (other
);
10960 result
= get_ppc64_symbol_other (other
);
10970 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10974 static const char *
10975 get_symbol_index_type (unsigned int type
)
10977 static char buff
[32];
10981 case SHN_UNDEF
: return "UND";
10982 case SHN_ABS
: return "ABS";
10983 case SHN_COMMON
: return "COM";
10985 if (type
== SHN_IA_64_ANSI_COMMON
10986 && elf_header
.e_machine
== EM_IA_64
10987 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10989 else if ((elf_header
.e_machine
== EM_X86_64
10990 || elf_header
.e_machine
== EM_L1OM
10991 || elf_header
.e_machine
== EM_K1OM
)
10992 && type
== SHN_X86_64_LCOMMON
)
10993 return "LARGE_COM";
10994 else if ((type
== SHN_MIPS_SCOMMON
10995 && elf_header
.e_machine
== EM_MIPS
)
10996 || (type
== SHN_TIC6X_SCOMMON
10997 && elf_header
.e_machine
== EM_TI_C6000
))
10999 else if (type
== SHN_MIPS_SUNDEFINED
11000 && elf_header
.e_machine
== EM_MIPS
)
11002 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11003 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11004 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11005 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11006 else if (type
>= SHN_LORESERVE
)
11007 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11008 else if (type
>= elf_header
.e_shnum
)
11009 sprintf (buff
, _("bad section index[%3d]"), type
);
11011 sprintf (buff
, "%3d", type
);
11019 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
11021 unsigned char * e_data
;
11024 /* If the size_t type is smaller than the bfd_size_type, eg because
11025 you are building a 32-bit tool on a 64-bit host, then make sure
11026 that when (number) is cast to (size_t) no information is lost. */
11027 if (sizeof (size_t) < sizeof (bfd_size_type
)
11028 && (bfd_size_type
) ((size_t) number
) != number
)
11030 error (_("Size truncation prevents reading %s elements of size %u\n"),
11031 bfd_vmatoa ("u", number
), ent_size
);
11035 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11036 attempting to allocate memory when the read is bound to fail. */
11037 if (ent_size
* number
> current_file_size
)
11039 error (_("Invalid number of dynamic entries: %s\n"),
11040 bfd_vmatoa ("u", number
));
11044 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11045 if (e_data
== NULL
)
11047 error (_("Out of memory reading %s dynamic entries\n"),
11048 bfd_vmatoa ("u", number
));
11052 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
11054 error (_("Unable to read in %s bytes of dynamic data\n"),
11055 bfd_vmatoa ("u", number
* ent_size
));
11060 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11061 if (i_data
== NULL
)
11063 error (_("Out of memory allocating space for %s dynamic entries\n"),
11064 bfd_vmatoa ("u", number
));
11070 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11078 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
11080 Elf_Internal_Sym
* psym
;
11083 n
= print_vma (si
, DEC_5
);
11085 fputs (&" "[n
], stdout
);
11086 printf (" %3lu: ", hn
);
11088 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11090 printf (_("<No info available for dynamic symbol number %lu>\n"),
11091 (unsigned long) si
);
11095 psym
= dynamic_symbols
+ si
;
11096 print_vma (psym
->st_value
, LONG_HEX
);
11098 print_vma (psym
->st_size
, DEC_5
);
11100 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11101 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11103 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11104 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11107 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11109 printf (" %-7s", get_symbol_visibility (vis
));
11110 /* Check to see if any other bits in the st_other field are set.
11111 Note - displaying this information disrupts the layout of the
11112 table being generated, but for the moment this case is very
11114 if (psym
->st_other
^ vis
)
11115 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11118 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11119 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11120 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11122 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11126 static const char *
11127 get_symbol_version_string (FILE * file
,
11128 bfd_boolean is_dynsym
,
11129 const char * strtab
,
11130 unsigned long int strtab_size
,
11132 Elf_Internal_Sym
* psym
,
11133 enum versioned_symbol_info
* sym_info
,
11134 unsigned short * vna_other
)
11136 unsigned char data
[2];
11137 unsigned short vers_data
;
11138 unsigned long offset
;
11141 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11144 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11145 sizeof data
+ si
* sizeof (vers_data
));
11147 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11148 sizeof (data
), 1, _("version data")) == NULL
)
11151 vers_data
= byte_get (data
, 2);
11153 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11156 /* Usually we'd only see verdef for defined symbols, and verneed for
11157 undefined symbols. However, symbols defined by the linker in
11158 .dynbss for variables copied from a shared library in order to
11159 avoid text relocations are defined yet have verneed. We could
11160 use a heuristic to detect the special case, for example, check
11161 for verneed first on symbols defined in SHT_NOBITS sections, but
11162 it is simpler and more reliable to just look for both verdef and
11163 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11165 if (psym
->st_shndx
!= SHN_UNDEF
11166 && vers_data
!= 0x8001
11167 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11169 Elf_Internal_Verdef ivd
;
11170 Elf_Internal_Verdaux ivda
;
11171 Elf_External_Verdaux evda
;
11174 off
= offset_from_vma (file
,
11175 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11176 sizeof (Elf_External_Verdef
));
11180 Elf_External_Verdef evd
;
11182 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11183 _("version def")) == NULL
)
11191 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11192 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11193 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11196 off
+= ivd
.vd_next
;
11198 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11200 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11202 off
-= ivd
.vd_next
;
11205 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11206 _("version def aux")) != NULL
)
11208 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11210 if (psym
->st_name
!= ivda
.vda_name
)
11212 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11213 ? symbol_hidden
: symbol_public
);
11214 return (ivda
.vda_name
< strtab_size
11215 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11221 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11223 Elf_External_Verneed evn
;
11224 Elf_Internal_Verneed ivn
;
11225 Elf_Internal_Vernaux ivna
;
11227 offset
= offset_from_vma (file
,
11228 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11232 unsigned long vna_off
;
11234 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11235 _("version need")) == NULL
)
11238 ivna
.vna_other
= 0;
11243 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11244 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11246 vna_off
= offset
+ ivn
.vn_aux
;
11250 Elf_External_Vernaux evna
;
11252 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11253 _("version need aux (3)")) == NULL
)
11256 ivna
.vna_other
= 0;
11261 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11262 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11263 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11266 vna_off
+= ivna
.vna_next
;
11268 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11270 if (ivna
.vna_other
== vers_data
)
11273 offset
+= ivn
.vn_next
;
11275 while (ivn
.vn_next
!= 0);
11277 if (ivna
.vna_other
== vers_data
)
11279 *sym_info
= symbol_undefined
;
11280 *vna_other
= ivna
.vna_other
;
11281 return (ivna
.vna_name
< strtab_size
11282 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11288 /* Dump the symbol table. */
11290 process_symbol_table (FILE * file
)
11292 Elf_Internal_Shdr
* section
;
11293 bfd_size_type nbuckets
= 0;
11294 bfd_size_type nchains
= 0;
11295 bfd_vma
* buckets
= NULL
;
11296 bfd_vma
* chains
= NULL
;
11297 bfd_vma ngnubuckets
= 0;
11298 bfd_vma
* gnubuckets
= NULL
;
11299 bfd_vma
* gnuchains
= NULL
;
11300 bfd_vma gnusymidx
= 0;
11301 bfd_size_type ngnuchains
= 0;
11303 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11306 if (dynamic_info
[DT_HASH
]
11308 || (do_using_dynamic
11310 && dynamic_strings
!= NULL
)))
11312 unsigned char nb
[8];
11313 unsigned char nc
[8];
11314 unsigned int hash_ent_size
= 4;
11316 if ((elf_header
.e_machine
== EM_ALPHA
11317 || elf_header
.e_machine
== EM_S390
11318 || elf_header
.e_machine
== EM_S390_OLD
)
11319 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11323 (archive_file_offset
11324 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11325 sizeof nb
+ sizeof nc
)),
11328 error (_("Unable to seek to start of dynamic information\n"));
11332 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11334 error (_("Failed to read in number of buckets\n"));
11338 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11340 error (_("Failed to read in number of chains\n"));
11344 nbuckets
= byte_get (nb
, hash_ent_size
);
11345 nchains
= byte_get (nc
, hash_ent_size
);
11347 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11348 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11351 if (buckets
== NULL
|| chains
== NULL
)
11353 if (do_using_dynamic
)
11364 if (dynamic_info_DT_GNU_HASH
11366 || (do_using_dynamic
11368 && dynamic_strings
!= NULL
)))
11370 unsigned char nb
[16];
11371 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11372 bfd_vma buckets_vma
;
11375 (archive_file_offset
11376 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11380 error (_("Unable to seek to start of dynamic information\n"));
11384 if (fread (nb
, 16, 1, file
) != 1)
11386 error (_("Failed to read in number of buckets\n"));
11390 ngnubuckets
= byte_get (nb
, 4);
11391 gnusymidx
= byte_get (nb
+ 4, 4);
11392 bitmaskwords
= byte_get (nb
+ 8, 4);
11393 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11395 buckets_vma
+= bitmaskwords
* 4;
11397 buckets_vma
+= bitmaskwords
* 8;
11400 (archive_file_offset
11401 + offset_from_vma (file
, buckets_vma
, 4)),
11404 error (_("Unable to seek to start of dynamic information\n"));
11408 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11410 if (gnubuckets
== NULL
)
11413 for (i
= 0; i
< ngnubuckets
; i
++)
11414 if (gnubuckets
[i
] != 0)
11416 if (gnubuckets
[i
] < gnusymidx
)
11419 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11420 maxchain
= gnubuckets
[i
];
11423 if (maxchain
== 0xffffffff)
11426 maxchain
-= gnusymidx
;
11429 (archive_file_offset
11430 + offset_from_vma (file
, buckets_vma
11431 + 4 * (ngnubuckets
+ maxchain
), 4)),
11434 error (_("Unable to seek to start of dynamic information\n"));
11440 if (fread (nb
, 4, 1, file
) != 1)
11442 error (_("Failed to determine last chain length\n"));
11446 if (maxchain
+ 1 == 0)
11451 while ((byte_get (nb
, 4) & 1) == 0);
11454 (archive_file_offset
11455 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11458 error (_("Unable to seek to start of dynamic information\n"));
11462 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11463 ngnuchains
= maxchain
;
11466 if (gnuchains
== NULL
)
11471 if (do_using_dynamic
)
11476 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11478 && do_using_dynamic
11479 && dynamic_strings
!= NULL
11480 && dynamic_symbols
!= NULL
)
11484 if (dynamic_info
[DT_HASH
])
11489 printf (_("\nSymbol table for image:\n"));
11491 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11493 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11495 visited
= xcmalloc (nchains
, 1);
11496 memset (visited
, 0, nchains
);
11497 for (hn
= 0; hn
< nbuckets
; hn
++)
11499 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11501 print_dynamic_symbol (si
, hn
);
11502 if (si
>= nchains
|| visited
[si
])
11504 error (_("histogram chain is corrupt\n"));
11513 if (dynamic_info_DT_GNU_HASH
)
11515 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11517 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11519 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11521 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11522 if (gnubuckets
[hn
] != 0)
11524 bfd_vma si
= gnubuckets
[hn
];
11525 bfd_vma off
= si
- gnusymidx
;
11529 print_dynamic_symbol (si
, hn
);
11532 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11536 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11537 && section_headers
!= NULL
)
11541 for (i
= 0, section
= section_headers
;
11542 i
< elf_header
.e_shnum
;
11546 char * strtab
= NULL
;
11547 unsigned long int strtab_size
= 0;
11548 Elf_Internal_Sym
* symtab
;
11549 Elf_Internal_Sym
* psym
;
11550 unsigned long num_syms
;
11552 if ((section
->sh_type
!= SHT_SYMTAB
11553 && section
->sh_type
!= SHT_DYNSYM
)
11555 && section
->sh_type
== SHT_SYMTAB
))
11558 if (section
->sh_entsize
== 0)
11560 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11561 printable_section_name (section
));
11565 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11566 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11567 "\nSymbol table '%s' contains %lu entries:\n",
11569 printable_section_name (section
),
11573 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11575 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11577 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11578 if (symtab
== NULL
)
11581 if (section
->sh_link
== elf_header
.e_shstrndx
)
11583 strtab
= string_table
;
11584 strtab_size
= string_table_length
;
11586 else if (section
->sh_link
< elf_header
.e_shnum
)
11588 Elf_Internal_Shdr
* string_sec
;
11590 string_sec
= section_headers
+ section
->sh_link
;
11592 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11593 1, string_sec
->sh_size
,
11594 _("string table"));
11595 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11598 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11600 const char *version_string
;
11601 enum versioned_symbol_info sym_info
;
11602 unsigned short vna_other
;
11604 printf ("%6d: ", si
);
11605 print_vma (psym
->st_value
, LONG_HEX
);
11607 print_vma (psym
->st_size
, DEC_5
);
11608 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11609 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11610 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11611 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11614 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11616 printf (" %-7s", get_symbol_visibility (vis
));
11617 /* Check to see if any other bits in the st_other field are set.
11618 Note - displaying this information disrupts the layout of the
11619 table being generated, but for the moment this case is very rare. */
11620 if (psym
->st_other
^ vis
)
11621 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11623 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11624 print_symbol (25, psym
->st_name
< strtab_size
11625 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11628 = get_symbol_version_string (file
,
11629 section
->sh_type
== SHT_DYNSYM
,
11630 strtab
, strtab_size
, si
,
11631 psym
, &sym_info
, &vna_other
);
11632 if (version_string
)
11634 if (sym_info
== symbol_undefined
)
11635 printf ("@%s (%d)", version_string
, vna_other
);
11637 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11643 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11644 && si
>= section
->sh_info
11645 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11646 && elf_header
.e_machine
!= EM_MIPS
11647 /* Solaris binaries have been found to violate this requirement as
11648 well. Not sure if this is a bug or an ABI requirement. */
11649 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11650 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11651 si
, printable_section_name (section
), section
->sh_info
);
11655 if (strtab
!= string_table
)
11661 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11663 if (do_histogram
&& buckets
!= NULL
)
11665 unsigned long * lengths
;
11666 unsigned long * counts
;
11669 unsigned long maxlength
= 0;
11670 unsigned long nzero_counts
= 0;
11671 unsigned long nsyms
= 0;
11674 printf (ngettext ("\nHistogram for bucket list length "
11675 "(total of %lu bucket):\n",
11676 "\nHistogram for bucket list length "
11677 "(total of %lu buckets):\n",
11678 (unsigned long) nbuckets
),
11679 (unsigned long) nbuckets
);
11681 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11682 if (lengths
== NULL
)
11684 error (_("Out of memory allocating space for histogram buckets\n"));
11687 visited
= xcmalloc (nchains
, 1);
11688 memset (visited
, 0, nchains
);
11690 printf (_(" Length Number %% of total Coverage\n"));
11691 for (hn
= 0; hn
< nbuckets
; ++hn
)
11693 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11696 if (maxlength
< ++lengths
[hn
])
11698 if (si
>= nchains
|| visited
[si
])
11700 error (_("histogram chain is corrupt\n"));
11708 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11709 if (counts
== NULL
)
11712 error (_("Out of memory allocating space for histogram counts\n"));
11716 for (hn
= 0; hn
< nbuckets
; ++hn
)
11717 ++counts
[lengths
[hn
]];
11722 printf (" 0 %-10lu (%5.1f%%)\n",
11723 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11724 for (i
= 1; i
<= maxlength
; ++i
)
11726 nzero_counts
+= counts
[i
] * i
;
11727 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11728 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11729 (nzero_counts
* 100.0) / nsyms
);
11737 if (buckets
!= NULL
)
11743 if (do_histogram
&& gnubuckets
!= NULL
)
11745 unsigned long * lengths
;
11746 unsigned long * counts
;
11748 unsigned long maxlength
= 0;
11749 unsigned long nzero_counts
= 0;
11750 unsigned long nsyms
= 0;
11752 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11753 "(total of %lu bucket):\n",
11754 "\nHistogram for `.gnu.hash' bucket list length "
11755 "(total of %lu buckets):\n",
11756 (unsigned long) ngnubuckets
),
11757 (unsigned long) ngnubuckets
);
11759 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11760 if (lengths
== NULL
)
11762 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11766 printf (_(" Length Number %% of total Coverage\n"));
11768 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11769 if (gnubuckets
[hn
] != 0)
11771 bfd_vma off
, length
= 1;
11773 for (off
= gnubuckets
[hn
] - gnusymidx
;
11774 /* PR 17531 file: 010-77222-0.004. */
11775 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11778 lengths
[hn
] = length
;
11779 if (length
> maxlength
)
11780 maxlength
= length
;
11784 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11785 if (counts
== NULL
)
11788 error (_("Out of memory allocating space for gnu histogram counts\n"));
11792 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11793 ++counts
[lengths
[hn
]];
11795 if (ngnubuckets
> 0)
11798 printf (" 0 %-10lu (%5.1f%%)\n",
11799 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11800 for (j
= 1; j
<= maxlength
; ++j
)
11802 nzero_counts
+= counts
[j
] * j
;
11803 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11804 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11805 (nzero_counts
* 100.0) / nsyms
);
11819 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11823 if (dynamic_syminfo
== NULL
11825 /* No syminfo, this is ok. */
11828 /* There better should be a dynamic symbol section. */
11829 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11833 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11834 "contains %d entry:\n",
11835 "\nDynamic info segment at offset 0x%lx "
11836 "contains %d entries:\n",
11837 dynamic_syminfo_nent
),
11838 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11840 printf (_(" Num: Name BoundTo Flags\n"));
11841 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11843 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11845 printf ("%4d: ", i
);
11846 if (i
>= num_dynamic_syms
)
11847 printf (_("<corrupt index>"));
11848 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11849 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11851 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11854 switch (dynamic_syminfo
[i
].si_boundto
)
11856 case SYMINFO_BT_SELF
:
11857 fputs ("SELF ", stdout
);
11859 case SYMINFO_BT_PARENT
:
11860 fputs ("PARENT ", stdout
);
11863 if (dynamic_syminfo
[i
].si_boundto
> 0
11864 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11865 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11867 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11871 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11875 if (flags
& SYMINFO_FLG_DIRECT
)
11876 printf (" DIRECT");
11877 if (flags
& SYMINFO_FLG_PASSTHRU
)
11878 printf (" PASSTHRU");
11879 if (flags
& SYMINFO_FLG_COPY
)
11881 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11882 printf (" LAZYLOAD");
11890 #define IN_RANGE(START,END,ADDR,OFF) \
11891 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11893 /* Check to see if the given reloc needs to be handled in a target specific
11894 manner. If so then process the reloc and return TRUE otherwise return
11897 If called with reloc == NULL, then this is a signal that reloc processing
11898 for the current section has finished, and any saved state should be
11902 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11903 unsigned char * start
,
11904 unsigned char * end
,
11905 Elf_Internal_Sym
* symtab
,
11906 unsigned long num_syms
)
11908 unsigned int reloc_type
= 0;
11909 unsigned long sym_index
= 0;
11913 reloc_type
= get_reloc_type (reloc
->r_info
);
11914 sym_index
= get_reloc_symindex (reloc
->r_info
);
11917 switch (elf_header
.e_machine
)
11920 case EM_MSP430_OLD
:
11922 static Elf_Internal_Sym
* saved_sym
= NULL
;
11930 switch (reloc_type
)
11932 case 10: /* R_MSP430_SYM_DIFF */
11933 if (uses_msp430x_relocs ())
11935 /* Fall through. */
11936 case 21: /* R_MSP430X_SYM_DIFF */
11938 if (sym_index
>= num_syms
)
11939 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11942 saved_sym
= symtab
+ sym_index
;
11945 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11946 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11947 goto handle_sym_diff
;
11949 case 5: /* R_MSP430_16_BYTE */
11950 case 9: /* R_MSP430_8 */
11951 if (uses_msp430x_relocs ())
11953 goto handle_sym_diff
;
11955 case 2: /* R_MSP430_ABS16 */
11956 case 15: /* R_MSP430X_ABS16 */
11957 if (! uses_msp430x_relocs ())
11959 goto handle_sym_diff
;
11962 if (saved_sym
!= NULL
)
11964 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11967 if (sym_index
>= num_syms
)
11968 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11972 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11973 - saved_sym
->st_value
);
11975 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11976 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11979 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11980 (long) reloc
->r_offset
);
11989 if (saved_sym
!= NULL
)
11990 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11997 case EM_CYGNUS_MN10300
:
11999 static Elf_Internal_Sym
* saved_sym
= NULL
;
12007 switch (reloc_type
)
12009 case 34: /* R_MN10300_ALIGN */
12011 case 33: /* R_MN10300_SYM_DIFF */
12012 if (sym_index
>= num_syms
)
12013 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12016 saved_sym
= symtab
+ sym_index
;
12019 case 1: /* R_MN10300_32 */
12020 case 2: /* R_MN10300_16 */
12021 if (saved_sym
!= NULL
)
12023 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12026 if (sym_index
>= num_syms
)
12027 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12031 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12032 - saved_sym
->st_value
);
12034 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12035 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12037 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12038 (long) reloc
->r_offset
);
12046 if (saved_sym
!= NULL
)
12047 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12055 static bfd_vma saved_sym1
= 0;
12056 static bfd_vma saved_sym2
= 0;
12057 static bfd_vma value
;
12061 saved_sym1
= saved_sym2
= 0;
12065 switch (reloc_type
)
12067 case 0x80: /* R_RL78_SYM. */
12068 saved_sym1
= saved_sym2
;
12069 if (sym_index
>= num_syms
)
12070 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12074 saved_sym2
= symtab
[sym_index
].st_value
;
12075 saved_sym2
+= reloc
->r_addend
;
12079 case 0x83: /* R_RL78_OPsub. */
12080 value
= saved_sym1
- saved_sym2
;
12081 saved_sym2
= saved_sym1
= 0;
12085 case 0x41: /* R_RL78_ABS32. */
12086 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12087 byte_put (start
+ reloc
->r_offset
, value
, 4);
12089 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12090 (long) reloc
->r_offset
);
12094 case 0x43: /* R_RL78_ABS16. */
12095 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12096 byte_put (start
+ reloc
->r_offset
, value
, 2);
12098 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12099 (long) reloc
->r_offset
);
12113 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12114 DWARF debug sections. This is a target specific test. Note - we do not
12115 go through the whole including-target-headers-multiple-times route, (as
12116 we have already done with <elf/h8.h>) because this would become very
12117 messy and even then this function would have to contain target specific
12118 information (the names of the relocs instead of their numeric values).
12119 FIXME: This is not the correct way to solve this problem. The proper way
12120 is to have target specific reloc sizing and typing functions created by
12121 the reloc-macros.h header, in the same way that it already creates the
12122 reloc naming functions. */
12125 is_32bit_abs_reloc (unsigned int reloc_type
)
12127 /* Please keep this table alpha-sorted for ease of visual lookup. */
12128 switch (elf_header
.e_machine
)
12132 return reloc_type
== 1; /* R_386_32. */
12134 return reloc_type
== 1; /* R_68K_32. */
12136 return reloc_type
== 1; /* R_860_32. */
12138 return reloc_type
== 2; /* R_960_32. */
12140 return (reloc_type
== 258
12141 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12142 case EM_ADAPTEVA_EPIPHANY
:
12143 return reloc_type
== 3;
12145 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12147 return reloc_type
== 1; /* R_ARC_32. */
12148 case EM_ARC_COMPACT
:
12149 case EM_ARC_COMPACT2
:
12150 return reloc_type
== 4; /* R_ARC_32. */
12152 return reloc_type
== 2; /* R_ARM_ABS32 */
12155 return reloc_type
== 1;
12157 return reloc_type
== 0x12; /* R_byte4_data. */
12159 return reloc_type
== 3; /* R_CRIS_32. */
12161 return reloc_type
== 3; /* R_CR16_NUM32. */
12163 return reloc_type
== 15; /* R_CRX_NUM32. */
12164 case EM_CYGNUS_FRV
:
12165 return reloc_type
== 1;
12166 case EM_CYGNUS_D10V
:
12168 return reloc_type
== 6; /* R_D10V_32. */
12169 case EM_CYGNUS_D30V
:
12171 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12173 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12174 case EM_CYGNUS_FR30
:
12176 return reloc_type
== 3; /* R_FR30_32. */
12178 return reloc_type
== 1; /* R_FT32_32. */
12182 return reloc_type
== 1; /* R_H8_DIR32. */
12184 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12185 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12186 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12187 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12190 return reloc_type
== 2; /* R_IP2K_32. */
12192 return reloc_type
== 2; /* R_IQ2000_32. */
12193 case EM_LATTICEMICO32
:
12194 return reloc_type
== 3; /* R_LM32_32. */
12197 return reloc_type
== 3; /* R_M32C_32. */
12199 return reloc_type
== 34; /* R_M32R_32_RELA. */
12202 return reloc_type
== 6; /* R_M68HC11_32. */
12204 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12205 case EM_CYGNUS_MEP
:
12206 return reloc_type
== 4; /* R_MEP_32. */
12208 return reloc_type
== 2; /* R_METAG_ADDR32. */
12209 case EM_MICROBLAZE
:
12210 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12212 return reloc_type
== 2; /* R_MIPS_32. */
12214 return reloc_type
== 4; /* R_MMIX_32. */
12215 case EM_CYGNUS_MN10200
:
12217 return reloc_type
== 1; /* R_MN10200_32. */
12218 case EM_CYGNUS_MN10300
:
12220 return reloc_type
== 1; /* R_MN10300_32. */
12222 return reloc_type
== 1; /* R_MOXIE_32. */
12223 case EM_MSP430_OLD
:
12225 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12227 return reloc_type
== 2; /* R_MT_32. */
12229 return reloc_type
== 20; /* R_NDS32_RELA. */
12230 case EM_ALTERA_NIOS2
:
12231 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12233 return reloc_type
== 1; /* R_NIOS_32. */
12235 return reloc_type
== 1; /* R_OR1K_32. */
12237 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12238 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12241 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12243 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12245 return reloc_type
== 1; /* R_PPC_ADDR32. */
12247 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12249 return reloc_type
== 1; /* R_RISCV_32. */
12251 return reloc_type
== 1; /* R_RL78_DIR32. */
12253 return reloc_type
== 1; /* R_RX_DIR32. */
12255 return reloc_type
== 1; /* R_I370_ADDR31. */
12258 return reloc_type
== 4; /* R_S390_32. */
12260 return reloc_type
== 8; /* R_SCORE_ABS32. */
12262 return reloc_type
== 1; /* R_SH_DIR32. */
12263 case EM_SPARC32PLUS
:
12266 return reloc_type
== 3 /* R_SPARC_32. */
12267 || reloc_type
== 23; /* R_SPARC_UA32. */
12269 return reloc_type
== 6; /* R_SPU_ADDR32 */
12271 return reloc_type
== 1; /* R_C6000_ABS32. */
12273 return reloc_type
== 2; /* R_TILEGX_32. */
12275 return reloc_type
== 1; /* R_TILEPRO_32. */
12276 case EM_CYGNUS_V850
:
12278 return reloc_type
== 6; /* R_V850_ABS32. */
12280 return reloc_type
== 0x33; /* R_V810_WORD. */
12282 return reloc_type
== 1; /* R_VAX_32. */
12284 return reloc_type
== 3; /* R_VISIUM_32. */
12285 case EM_WEBASSEMBLY
:
12286 return reloc_type
== 1; /* R_WASM32_32. */
12290 return reloc_type
== 10; /* R_X86_64_32. */
12293 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12295 return reloc_type
== 4; /* R_XGATE_32. */
12297 return reloc_type
== 1; /* R_XSTROMY16_32. */
12298 case EM_XTENSA_OLD
:
12300 return reloc_type
== 1; /* R_XTENSA_32. */
12303 static unsigned int prev_warn
= 0;
12305 /* Avoid repeating the same warning multiple times. */
12306 if (prev_warn
!= elf_header
.e_machine
)
12307 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12308 elf_header
.e_machine
);
12309 prev_warn
= elf_header
.e_machine
;
12315 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12316 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12319 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12321 switch (elf_header
.e_machine
)
12322 /* Please keep this table alpha-sorted for ease of visual lookup. */
12326 return reloc_type
== 2; /* R_386_PC32. */
12328 return reloc_type
== 4; /* R_68K_PC32. */
12330 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12331 case EM_ADAPTEVA_EPIPHANY
:
12332 return reloc_type
== 6;
12334 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12335 case EM_ARC_COMPACT
:
12336 case EM_ARC_COMPACT2
:
12337 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12339 return reloc_type
== 3; /* R_ARM_REL32 */
12342 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12343 case EM_MICROBLAZE
:
12344 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12346 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12348 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12350 return reloc_type
== 26; /* R_PPC_REL32. */
12352 return reloc_type
== 26; /* R_PPC64_REL32. */
12355 return reloc_type
== 5; /* R_390_PC32. */
12357 return reloc_type
== 2; /* R_SH_REL32. */
12358 case EM_SPARC32PLUS
:
12361 return reloc_type
== 6; /* R_SPARC_DISP32. */
12363 return reloc_type
== 13; /* R_SPU_REL32. */
12365 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12367 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12369 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12373 return reloc_type
== 2; /* R_X86_64_PC32. */
12374 case EM_XTENSA_OLD
:
12376 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12378 /* Do not abort or issue an error message here. Not all targets use
12379 pc-relative 32-bit relocs in their DWARF debug information and we
12380 have already tested for target coverage in is_32bit_abs_reloc. A
12381 more helpful warning message will be generated by apply_relocations
12382 anyway, so just return. */
12387 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12388 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12391 is_64bit_abs_reloc (unsigned int reloc_type
)
12393 switch (elf_header
.e_machine
)
12396 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12398 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12400 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12401 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12403 return reloc_type
== 80; /* R_PARISC_DIR64. */
12405 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12407 return reloc_type
== 2; /* R_RISCV_64. */
12408 case EM_SPARC32PLUS
:
12411 return reloc_type
== 32 /* R_SPARC_64. */
12412 || reloc_type
== 54; /* R_SPARC_UA64. */
12416 return reloc_type
== 1; /* R_X86_64_64. */
12419 return reloc_type
== 22; /* R_S390_64. */
12421 return reloc_type
== 1; /* R_TILEGX_64. */
12423 return reloc_type
== 18; /* R_MIPS_64. */
12429 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12430 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12433 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12435 switch (elf_header
.e_machine
)
12438 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12440 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12442 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12443 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12445 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12447 return reloc_type
== 44; /* R_PPC64_REL64. */
12448 case EM_SPARC32PLUS
:
12451 return reloc_type
== 46; /* R_SPARC_DISP64. */
12455 return reloc_type
== 24; /* R_X86_64_PC64. */
12458 return reloc_type
== 23; /* R_S390_PC64. */
12460 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12466 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12467 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12470 is_24bit_abs_reloc (unsigned int reloc_type
)
12472 switch (elf_header
.e_machine
)
12474 case EM_CYGNUS_MN10200
:
12476 return reloc_type
== 4; /* R_MN10200_24. */
12478 return reloc_type
== 5; /* R_FT32_20. */
12484 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12485 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12488 is_16bit_abs_reloc (unsigned int reloc_type
)
12490 /* Please keep this table alpha-sorted for ease of visual lookup. */
12491 switch (elf_header
.e_machine
)
12494 case EM_ARC_COMPACT
:
12495 case EM_ARC_COMPACT2
:
12496 return reloc_type
== 2; /* R_ARC_16. */
12497 case EM_ADAPTEVA_EPIPHANY
:
12498 return reloc_type
== 5;
12501 return reloc_type
== 4; /* R_AVR_16. */
12502 case EM_CYGNUS_D10V
:
12504 return reloc_type
== 3; /* R_D10V_16. */
12506 return reloc_type
== 2; /* R_FT32_16. */
12510 return reloc_type
== R_H8_DIR16
;
12513 return reloc_type
== 1; /* R_IP2K_16. */
12516 return reloc_type
== 1; /* R_M32C_16 */
12517 case EM_CYGNUS_MN10200
:
12519 return reloc_type
== 2; /* R_MN10200_16. */
12520 case EM_CYGNUS_MN10300
:
12522 return reloc_type
== 2; /* R_MN10300_16. */
12524 if (uses_msp430x_relocs ())
12525 return reloc_type
== 2; /* R_MSP430_ABS16. */
12526 /* Fall through. */
12527 case EM_MSP430_OLD
:
12528 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12530 return reloc_type
== 19; /* R_NDS32_RELA. */
12531 case EM_ALTERA_NIOS2
:
12532 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12534 return reloc_type
== 9; /* R_NIOS_16. */
12536 return reloc_type
== 2; /* R_OR1K_16. */
12538 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12540 return reloc_type
== 2; /* R_C6000_ABS16. */
12542 return reloc_type
== 2; /* R_VISIUM_16. */
12545 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12547 return reloc_type
== 3; /* R_XGATE_16. */
12553 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12554 relocation entries (possibly formerly used for SHT_GROUP sections). */
12557 is_none_reloc (unsigned int reloc_type
)
12559 switch (elf_header
.e_machine
)
12561 case EM_386
: /* R_386_NONE. */
12562 case EM_68K
: /* R_68K_NONE. */
12563 case EM_ADAPTEVA_EPIPHANY
:
12564 case EM_ALPHA
: /* R_ALPHA_NONE. */
12565 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12566 case EM_ARC
: /* R_ARC_NONE. */
12567 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12568 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12569 case EM_ARM
: /* R_ARM_NONE. */
12570 case EM_C166
: /* R_XC16X_NONE. */
12571 case EM_CRIS
: /* R_CRIS_NONE. */
12572 case EM_FT32
: /* R_FT32_NONE. */
12573 case EM_IA_64
: /* R_IA64_NONE. */
12574 case EM_K1OM
: /* R_X86_64_NONE. */
12575 case EM_L1OM
: /* R_X86_64_NONE. */
12576 case EM_M32R
: /* R_M32R_NONE. */
12577 case EM_MIPS
: /* R_MIPS_NONE. */
12578 case EM_MN10300
: /* R_MN10300_NONE. */
12579 case EM_MOXIE
: /* R_MOXIE_NONE. */
12580 case EM_NIOS32
: /* R_NIOS_NONE. */
12581 case EM_OR1K
: /* R_OR1K_NONE. */
12582 case EM_PARISC
: /* R_PARISC_NONE. */
12583 case EM_PPC64
: /* R_PPC64_NONE. */
12584 case EM_PPC
: /* R_PPC_NONE. */
12585 case EM_RISCV
: /* R_RISCV_NONE. */
12586 case EM_S390
: /* R_390_NONE. */
12588 case EM_SH
: /* R_SH_NONE. */
12589 case EM_SPARC32PLUS
:
12590 case EM_SPARC
: /* R_SPARC_NONE. */
12592 case EM_TILEGX
: /* R_TILEGX_NONE. */
12593 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12594 case EM_TI_C6000
:/* R_C6000_NONE. */
12595 case EM_X86_64
: /* R_X86_64_NONE. */
12597 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12598 return reloc_type
== 0;
12601 return reloc_type
== 0 || reloc_type
== 256;
12604 return (reloc_type
== 0 /* R_AVR_NONE. */
12605 || reloc_type
== 30 /* R_AVR_DIFF8. */
12606 || reloc_type
== 31 /* R_AVR_DIFF16. */
12607 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12609 return reloc_type
== 3; /* R_METAG_NONE. */
12611 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12612 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12613 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12614 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12615 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12617 return (reloc_type
== 0 /* R_PRU_NONE. */
12618 || reloc_type
== 65 /* R_PRU_DIFF8. */
12619 || reloc_type
== 66 /* R_PRU_DIFF16. */
12620 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12621 case EM_XTENSA_OLD
:
12623 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12624 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12625 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12626 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12631 /* Returns TRUE if there is a relocation against
12632 section NAME at OFFSET bytes. */
12635 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12637 Elf_Internal_Rela
* relocs
;
12638 Elf_Internal_Rela
* rp
;
12640 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12643 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12645 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12646 if (rp
->r_offset
== offset
)
12652 /* Apply relocations to a section.
12653 Returns TRUE upon success, FALSE otherwise.
12654 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12655 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12656 will be set to the number of relocs loaded.
12658 Note: So far support has been added only for those relocations
12659 which can be found in debug sections. FIXME: Add support for
12660 more relocations ? */
12663 apply_relocations (void * file
,
12664 const Elf_Internal_Shdr
* section
,
12665 unsigned char * start
,
12666 bfd_size_type size
,
12667 void ** relocs_return
,
12668 unsigned long * num_relocs_return
)
12670 Elf_Internal_Shdr
* relsec
;
12671 unsigned char * end
= start
+ size
;
12672 bfd_boolean res
= TRUE
;
12674 if (relocs_return
!= NULL
)
12676 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12677 * num_relocs_return
= 0;
12680 if (elf_header
.e_type
!= ET_REL
)
12681 /* No relocs to apply. */
12684 /* Find the reloc section associated with the section. */
12685 for (relsec
= section_headers
;
12686 relsec
< section_headers
+ elf_header
.e_shnum
;
12689 bfd_boolean is_rela
;
12690 unsigned long num_relocs
;
12691 Elf_Internal_Rela
* relocs
;
12692 Elf_Internal_Rela
* rp
;
12693 Elf_Internal_Shdr
* symsec
;
12694 Elf_Internal_Sym
* symtab
;
12695 unsigned long num_syms
;
12696 Elf_Internal_Sym
* sym
;
12698 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12699 || relsec
->sh_info
>= elf_header
.e_shnum
12700 || section_headers
+ relsec
->sh_info
!= section
12701 || relsec
->sh_size
== 0
12702 || relsec
->sh_link
>= elf_header
.e_shnum
)
12705 is_rela
= relsec
->sh_type
== SHT_RELA
;
12709 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12710 relsec
->sh_size
, & relocs
, & num_relocs
))
12715 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12716 relsec
->sh_size
, & relocs
, & num_relocs
))
12720 /* SH uses RELA but uses in place value instead of the addend field. */
12721 if (elf_header
.e_machine
== EM_SH
)
12724 symsec
= section_headers
+ relsec
->sh_link
;
12725 if (symsec
->sh_type
!= SHT_SYMTAB
12726 && symsec
->sh_type
!= SHT_DYNSYM
)
12728 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12730 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12733 unsigned int reloc_type
;
12734 unsigned int reloc_size
;
12735 unsigned char * rloc
;
12736 unsigned long sym_index
;
12738 reloc_type
= get_reloc_type (rp
->r_info
);
12740 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12742 else if (is_none_reloc (reloc_type
))
12744 else if (is_32bit_abs_reloc (reloc_type
)
12745 || is_32bit_pcrel_reloc (reloc_type
))
12747 else if (is_64bit_abs_reloc (reloc_type
)
12748 || is_64bit_pcrel_reloc (reloc_type
))
12750 else if (is_24bit_abs_reloc (reloc_type
))
12752 else if (is_16bit_abs_reloc (reloc_type
))
12756 static unsigned int prev_reloc
= 0;
12757 if (reloc_type
!= prev_reloc
)
12758 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12759 reloc_type
, printable_section_name (section
));
12760 prev_reloc
= reloc_type
;
12765 rloc
= start
+ rp
->r_offset
;
12766 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12768 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12769 (unsigned long) rp
->r_offset
,
12770 printable_section_name (section
));
12775 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12776 if (sym_index
>= num_syms
)
12778 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12779 sym_index
, printable_section_name (section
));
12783 sym
= symtab
+ sym_index
;
12785 /* If the reloc has a symbol associated with it,
12786 make sure that it is of an appropriate type.
12788 Relocations against symbols without type can happen.
12789 Gcc -feliminate-dwarf2-dups may generate symbols
12790 without type for debug info.
12792 Icc generates relocations against function symbols
12793 instead of local labels.
12795 Relocations against object symbols can happen, eg when
12796 referencing a global array. For an example of this see
12797 the _clz.o binary in libgcc.a. */
12799 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12800 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12802 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
12803 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12804 printable_section_name (relsec
),
12805 (long int)(rp
- relocs
));
12812 addend
+= rp
->r_addend
;
12813 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12814 partial_inplace. */
12816 || (elf_header
.e_machine
== EM_XTENSA
12817 && reloc_type
== 1)
12818 || ((elf_header
.e_machine
== EM_PJ
12819 || elf_header
.e_machine
== EM_PJ_OLD
)
12820 && reloc_type
== 1)
12821 || ((elf_header
.e_machine
== EM_D30V
12822 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12823 && reloc_type
== 12))
12824 addend
+= byte_get (rloc
, reloc_size
);
12826 if (is_32bit_pcrel_reloc (reloc_type
)
12827 || is_64bit_pcrel_reloc (reloc_type
))
12829 /* On HPPA, all pc-relative relocations are biased by 8. */
12830 if (elf_header
.e_machine
== EM_PARISC
)
12832 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12836 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12840 /* Let the target specific reloc processing code know that
12841 we have finished with these relocs. */
12842 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12846 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12847 * num_relocs_return
= num_relocs
;
12858 #ifdef SUPPORT_DISASSEMBLY
12860 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12862 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12864 /* FIXME: XXX -- to be done --- XXX */
12870 /* Reads in the contents of SECTION from FILE, returning a pointer
12871 to a malloc'ed buffer or NULL if something went wrong. */
12874 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12876 bfd_size_type num_bytes
;
12878 num_bytes
= section
->sh_size
;
12880 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12882 printf (_("Section '%s' has no data to dump.\n"),
12883 printable_section_name (section
));
12887 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12888 _("section contents"));
12891 /* Uncompresses a section that was compressed using zlib, in place. */
12894 uncompress_section_contents (unsigned char **buffer
,
12895 dwarf_size_type uncompressed_size
,
12896 dwarf_size_type
*size
)
12898 dwarf_size_type compressed_size
= *size
;
12899 unsigned char * compressed_buffer
= *buffer
;
12900 unsigned char * uncompressed_buffer
;
12904 /* It is possible the section consists of several compressed
12905 buffers concatenated together, so we uncompress in a loop. */
12906 /* PR 18313: The state field in the z_stream structure is supposed
12907 to be invisible to the user (ie us), but some compilers will
12908 still complain about it being used without initialisation. So
12909 we first zero the entire z_stream structure and then set the fields
12911 memset (& strm
, 0, sizeof strm
);
12912 strm
.avail_in
= compressed_size
;
12913 strm
.next_in
= (Bytef
*) compressed_buffer
;
12914 strm
.avail_out
= uncompressed_size
;
12915 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12917 rc
= inflateInit (& strm
);
12918 while (strm
.avail_in
> 0)
12922 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12923 + (uncompressed_size
- strm
.avail_out
));
12924 rc
= inflate (&strm
, Z_FINISH
);
12925 if (rc
!= Z_STREAM_END
)
12927 rc
= inflateReset (& strm
);
12929 rc
= inflateEnd (& strm
);
12931 || strm
.avail_out
!= 0)
12934 *buffer
= uncompressed_buffer
;
12935 *size
= uncompressed_size
;
12939 free (uncompressed_buffer
);
12940 /* Indicate decompression failure. */
12946 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12948 Elf_Internal_Shdr
* relsec
;
12949 bfd_size_type num_bytes
;
12950 unsigned char * data
;
12951 unsigned char * end
;
12952 unsigned char * real_start
;
12953 unsigned char * start
;
12954 bfd_boolean some_strings_shown
;
12956 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12958 /* PR 21820: Do not fail if the section was empty. */
12959 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
12961 num_bytes
= section
->sh_size
;
12963 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12965 if (decompress_dumps
)
12967 dwarf_size_type new_size
= num_bytes
;
12968 dwarf_size_type uncompressed_size
= 0;
12970 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12972 Elf_Internal_Chdr chdr
;
12973 unsigned int compression_header_size
12974 = get_compression_header (& chdr
, (unsigned char *) start
,
12977 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12979 warn (_("section '%s' has unsupported compress type: %d\n"),
12980 printable_section_name (section
), chdr
.ch_type
);
12983 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12985 warn (_("compressed section '%s' is corrupted\n"),
12986 printable_section_name (section
));
12989 uncompressed_size
= chdr
.ch_size
;
12990 start
+= compression_header_size
;
12991 new_size
-= compression_header_size
;
12993 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12995 /* Read the zlib header. In this case, it should be "ZLIB"
12996 followed by the uncompressed section size, 8 bytes in
12997 big-endian order. */
12998 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12999 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13000 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13001 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13002 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13003 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13004 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13005 uncompressed_size
+= start
[11];
13010 if (uncompressed_size
)
13012 if (uncompress_section_contents (& start
,
13013 uncompressed_size
, & new_size
))
13014 num_bytes
= new_size
;
13017 error (_("Unable to decompress section %s\n"),
13018 printable_section_name (section
));
13023 start
= real_start
;
13026 /* If the section being dumped has relocations against it the user might
13027 be expecting these relocations to have been applied. Check for this
13028 case and issue a warning message in order to avoid confusion.
13029 FIXME: Maybe we ought to have an option that dumps a section with
13030 relocs applied ? */
13031 for (relsec
= section_headers
;
13032 relsec
< section_headers
+ elf_header
.e_shnum
;
13035 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13036 || relsec
->sh_info
>= elf_header
.e_shnum
13037 || section_headers
+ relsec
->sh_info
!= section
13038 || relsec
->sh_size
== 0
13039 || relsec
->sh_link
>= elf_header
.e_shnum
)
13042 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13047 end
= start
+ num_bytes
;
13048 some_strings_shown
= FALSE
;
13052 while (!ISPRINT (* data
))
13053 if (++ data
>= end
)
13058 size_t maxlen
= end
- data
;
13061 /* PR 11128: Use two separate invocations in order to work
13062 around bugs in the Solaris 8 implementation of printf. */
13063 printf (" [%6tx] ", data
- start
);
13065 printf (" [%6Ix] ", (size_t) (data
- start
));
13069 print_symbol ((int) maxlen
, (const char *) data
);
13071 data
+= strnlen ((const char *) data
, maxlen
);
13075 printf (_("<corrupt>\n"));
13078 some_strings_shown
= TRUE
;
13082 if (! some_strings_shown
)
13083 printf (_(" No strings found in this section."));
13092 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13094 bfd_boolean relocate
)
13096 Elf_Internal_Shdr
* relsec
;
13097 bfd_size_type bytes
;
13098 bfd_size_type section_size
;
13100 unsigned char * data
;
13101 unsigned char * real_start
;
13102 unsigned char * start
;
13104 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
13106 /* PR 21820: Do not fail if the section was empty. */
13107 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13109 section_size
= section
->sh_size
;
13111 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
13113 if (decompress_dumps
)
13115 dwarf_size_type new_size
= section_size
;
13116 dwarf_size_type uncompressed_size
= 0;
13118 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13120 Elf_Internal_Chdr chdr
;
13121 unsigned int compression_header_size
13122 = get_compression_header (& chdr
, start
, section_size
);
13124 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13126 warn (_("section '%s' has unsupported compress type: %d\n"),
13127 printable_section_name (section
), chdr
.ch_type
);
13130 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13132 warn (_("compressed section '%s' is corrupted\n"),
13133 printable_section_name (section
));
13136 uncompressed_size
= chdr
.ch_size
;
13137 start
+= compression_header_size
;
13138 new_size
-= compression_header_size
;
13140 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13142 /* Read the zlib header. In this case, it should be "ZLIB"
13143 followed by the uncompressed section size, 8 bytes in
13144 big-endian order. */
13145 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13146 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13147 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13148 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13149 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13150 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13151 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13152 uncompressed_size
+= start
[11];
13157 if (uncompressed_size
)
13159 if (uncompress_section_contents (& start
, uncompressed_size
,
13162 section_size
= new_size
;
13166 error (_("Unable to decompress section %s\n"),
13167 printable_section_name (section
));
13168 /* FIXME: Print the section anyway ? */
13173 start
= real_start
;
13178 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13183 /* If the section being dumped has relocations against it the user might
13184 be expecting these relocations to have been applied. Check for this
13185 case and issue a warning message in order to avoid confusion.
13186 FIXME: Maybe we ought to have an option that dumps a section with
13187 relocs applied ? */
13188 for (relsec
= section_headers
;
13189 relsec
< section_headers
+ elf_header
.e_shnum
;
13192 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13193 || relsec
->sh_info
>= elf_header
.e_shnum
13194 || section_headers
+ relsec
->sh_info
!= section
13195 || relsec
->sh_size
== 0
13196 || relsec
->sh_link
>= elf_header
.e_shnum
)
13199 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13204 addr
= section
->sh_addr
;
13205 bytes
= section_size
;
13214 lbytes
= (bytes
> 16 ? 16 : bytes
);
13216 printf (" 0x%8.8lx ", (unsigned long) addr
);
13218 for (j
= 0; j
< 16; j
++)
13221 printf ("%2.2x", data
[j
]);
13229 for (j
= 0; j
< lbytes
; j
++)
13232 if (k
>= ' ' && k
< 0x7f)
13252 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13253 const Elf_Internal_Shdr
* sec
, void * file
)
13255 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13258 /* If it is already loaded, do nothing. */
13259 if (section
->start
!= NULL
)
13262 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13263 section
->address
= sec
->sh_addr
;
13264 section
->user_data
= NULL
;
13265 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13267 sec
->sh_size
, buf
);
13268 if (section
->start
== NULL
)
13272 unsigned char *start
= section
->start
;
13273 dwarf_size_type size
= sec
->sh_size
;
13274 dwarf_size_type uncompressed_size
= 0;
13276 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13278 Elf_Internal_Chdr chdr
;
13279 unsigned int compression_header_size
;
13281 if (size
< (is_32bit_elf
13282 ? sizeof (Elf32_External_Chdr
)
13283 : sizeof (Elf64_External_Chdr
)))
13285 warn (_("compressed section %s is too small to contain a compression header"),
13290 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13292 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13294 warn (_("section '%s' has unsupported compress type: %d\n"),
13295 section
->name
, chdr
.ch_type
);
13298 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13300 warn (_("compressed section '%s' is corrupted\n"),
13304 uncompressed_size
= chdr
.ch_size
;
13305 start
+= compression_header_size
;
13306 size
-= compression_header_size
;
13308 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13310 /* Read the zlib header. In this case, it should be "ZLIB"
13311 followed by the uncompressed section size, 8 bytes in
13312 big-endian order. */
13313 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13314 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13315 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13316 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13317 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13318 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13319 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13320 uncompressed_size
+= start
[11];
13325 if (uncompressed_size
)
13327 if (uncompress_section_contents (&start
, uncompressed_size
,
13330 /* Free the compressed buffer, update the section buffer
13331 and the section size if uncompress is successful. */
13332 free (section
->start
);
13333 section
->start
= start
;
13337 error (_("Unable to decompress section %s\n"),
13338 printable_section_name (sec
));
13343 section
->size
= size
;
13346 if (section
->start
== NULL
)
13349 if (debug_displays
[debug
].relocate
)
13351 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13352 & section
->reloc_info
, & section
->num_relocs
))
13357 section
->reloc_info
= NULL
;
13358 section
->num_relocs
= 0;
13364 /* If this is not NULL, load_debug_section will only look for sections
13365 within the list of sections given here. */
13366 static unsigned int * section_subset
= NULL
;
13369 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13371 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13372 Elf_Internal_Shdr
* sec
;
13374 /* Locate the debug section. */
13375 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13377 section
->name
= section
->uncompressed_name
;
13380 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13382 section
->name
= section
->compressed_name
;
13387 /* If we're loading from a subset of sections, and we've loaded
13388 a section matching this name before, it's likely that it's a
13390 if (section_subset
!= NULL
)
13391 free_debug_section (debug
);
13393 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13397 free_debug_section (enum dwarf_section_display_enum debug
)
13399 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13401 if (section
->start
== NULL
)
13404 free ((char *) section
->start
);
13405 section
->start
= NULL
;
13406 section
->address
= 0;
13411 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13413 char * name
= SECTION_NAME (section
);
13414 const char * print_name
= printable_section_name (section
);
13415 bfd_size_type length
;
13416 bfd_boolean result
= TRUE
;
13419 length
= section
->sh_size
;
13422 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13425 if (section
->sh_type
== SHT_NOBITS
)
13427 /* There is no point in dumping the contents of a debugging section
13428 which has the NOBITS type - the bits in the file will be random.
13429 This can happen when a file containing a .eh_frame section is
13430 stripped with the --only-keep-debug command line option. */
13431 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13436 if (const_strneq (name
, ".gnu.linkonce.wi."))
13437 name
= ".debug_info";
13439 /* See if we know how to display the contents of this section. */
13440 for (i
= 0; i
< max
; i
++)
13441 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13442 || (i
== line
&& const_strneq (name
, ".debug_line."))
13443 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13445 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13446 int secondary
= (section
!= find_section (name
));
13449 free_debug_section ((enum dwarf_section_display_enum
) i
);
13451 if (i
== line
&& const_strneq (name
, ".debug_line."))
13453 else if (streq (sec
->uncompressed_name
, name
))
13454 sec
->name
= sec
->uncompressed_name
;
13456 sec
->name
= sec
->compressed_name
;
13457 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13460 /* If this debug section is part of a CU/TU set in a .dwp file,
13461 restrict load_debug_section to the sections in that set. */
13462 section_subset
= find_cu_tu_set (file
, shndx
);
13464 result
&= debug_displays
[i
].display (sec
, file
);
13466 section_subset
= NULL
;
13468 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13469 free_debug_section ((enum dwarf_section_display_enum
) i
);
13477 printf (_("Unrecognized debug section: %s\n"), print_name
);
13484 /* Set DUMP_SECTS for all sections where dumps were requested
13485 based on section name. */
13488 initialise_dumps_byname (void)
13490 struct dump_list_entry
* cur
;
13492 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13495 bfd_boolean any
= FALSE
;
13497 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13498 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13500 request_dump_bynumber (i
, cur
->type
);
13505 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13511 process_section_contents (FILE * file
)
13513 Elf_Internal_Shdr
* section
;
13515 bfd_boolean res
= TRUE
;
13520 initialise_dumps_byname ();
13522 for (i
= 0, section
= section_headers
;
13523 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13526 #ifdef SUPPORT_DISASSEMBLY
13527 if (dump_sects
[i
] & DISASS_DUMP
)
13528 disassemble_section (section
, file
);
13530 if (dump_sects
[i
] & HEX_DUMP
)
13532 if (! dump_section_as_bytes (section
, file
, FALSE
))
13536 if (dump_sects
[i
] & RELOC_DUMP
)
13538 if (! dump_section_as_bytes (section
, file
, TRUE
))
13542 if (dump_sects
[i
] & STRING_DUMP
)
13544 if (! dump_section_as_strings (section
, file
))
13548 if (dump_sects
[i
] & DEBUG_DUMP
)
13550 if (! display_debug_section (i
, section
, file
))
13555 /* Check to see if the user requested a
13556 dump of a section that does not exist. */
13557 while (i
< num_dump_sects
)
13561 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13571 process_mips_fpe_exception (int mask
)
13575 bfd_boolean first
= TRUE
;
13577 if (mask
& OEX_FPU_INEX
)
13578 fputs ("INEX", stdout
), first
= FALSE
;
13579 if (mask
& OEX_FPU_UFLO
)
13580 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13581 if (mask
& OEX_FPU_OFLO
)
13582 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13583 if (mask
& OEX_FPU_DIV0
)
13584 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13585 if (mask
& OEX_FPU_INVAL
)
13586 printf ("%sINVAL", first
? "" : "|");
13589 fputs ("0", stdout
);
13592 /* Display's the value of TAG at location P. If TAG is
13593 greater than 0 it is assumed to be an unknown tag, and
13594 a message is printed to this effect. Otherwise it is
13595 assumed that a message has already been printed.
13597 If the bottom bit of TAG is set it assumed to have a
13598 string value, otherwise it is assumed to have an integer
13601 Returns an updated P pointing to the first unread byte
13602 beyond the end of TAG's value.
13604 Reads at or beyond END will not be made. */
13606 static unsigned char *
13607 display_tag_value (signed int tag
,
13609 const unsigned char * const end
)
13614 printf (" Tag_unknown_%d: ", tag
);
13618 warn (_("<corrupt tag>\n"));
13622 /* PR 17531 file: 027-19978-0.004. */
13623 size_t maxlen
= (end
- p
) - 1;
13628 print_symbol ((int) maxlen
, (const char *) p
);
13629 p
+= strnlen ((char *) p
, maxlen
) + 1;
13633 printf (_("<corrupt string tag>"));
13634 p
= (unsigned char *) end
;
13642 val
= read_uleb128 (p
, &len
, end
);
13644 printf ("%ld (0x%lx)\n", val
, val
);
13651 /* ARC ABI attributes section. */
13653 static unsigned char *
13654 display_arc_attribute (unsigned char * p
,
13655 const unsigned char * const end
)
13661 tag
= read_uleb128 (p
, &len
, end
);
13666 case Tag_ARC_PCS_config
:
13667 val
= read_uleb128 (p
, &len
, end
);
13669 printf (" Tag_ARC_PCS_config: ");
13673 printf (_("Absent/Non standard\n"));
13676 printf (_("Bare metal/mwdt\n"));
13679 printf (_("Bare metal/newlib\n"));
13682 printf (_("Linux/uclibc\n"));
13685 printf (_("Linux/glibc\n"));
13688 printf (_("Unknown\n"));
13693 case Tag_ARC_CPU_base
:
13694 val
= read_uleb128 (p
, &len
, end
);
13696 printf (" Tag_ARC_CPU_base: ");
13701 printf (_("Absent\n"));
13703 case TAG_CPU_ARC6xx
:
13704 printf ("ARC6xx\n");
13706 case TAG_CPU_ARC7xx
:
13707 printf ("ARC7xx\n");
13709 case TAG_CPU_ARCEM
:
13710 printf ("ARCEM\n");
13712 case TAG_CPU_ARCHS
:
13713 printf ("ARCHS\n");
13718 case Tag_ARC_CPU_variation
:
13719 val
= read_uleb128 (p
, &len
, end
);
13721 printf (" Tag_ARC_CPU_variation: ");
13725 if (val
> 0 && val
< 16)
13726 printf ("Core%d\n", val
);
13728 printf ("Unknown\n");
13732 printf (_("Absent\n"));
13737 case Tag_ARC_CPU_name
:
13738 printf (" Tag_ARC_CPU_name: ");
13739 p
= display_tag_value (-1, p
, end
);
13742 case Tag_ARC_ABI_rf16
:
13743 val
= read_uleb128 (p
, &len
, end
);
13745 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13748 case Tag_ARC_ABI_osver
:
13749 val
= read_uleb128 (p
, &len
, end
);
13751 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13754 case Tag_ARC_ABI_pic
:
13755 case Tag_ARC_ABI_sda
:
13756 val
= read_uleb128 (p
, &len
, end
);
13758 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13759 : " Tag_ARC_ABI_pic: ");
13763 printf (_("Absent\n"));
13772 printf (_("Unknown\n"));
13777 case Tag_ARC_ABI_tls
:
13778 val
= read_uleb128 (p
, &len
, end
);
13780 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13783 case Tag_ARC_ABI_enumsize
:
13784 val
= read_uleb128 (p
, &len
, end
);
13786 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13790 case Tag_ARC_ABI_exceptions
:
13791 val
= read_uleb128 (p
, &len
, end
);
13793 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13797 case Tag_ARC_ABI_double_size
:
13798 val
= read_uleb128 (p
, &len
, end
);
13800 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13803 case Tag_ARC_ISA_config
:
13804 printf (" Tag_ARC_ISA_config: ");
13805 p
= display_tag_value (-1, p
, end
);
13808 case Tag_ARC_ISA_apex
:
13809 printf (" Tag_ARC_ISA_apex: ");
13810 p
= display_tag_value (-1, p
, end
);
13813 case Tag_ARC_ISA_mpy_option
:
13814 val
= read_uleb128 (p
, &len
, end
);
13816 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13820 return display_tag_value (tag
& 1, p
, end
);
13826 /* ARM EABI attributes section. */
13831 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13833 const char ** table
;
13834 } arm_attr_public_tag
;
13836 static const char * arm_attr_tag_CPU_arch
[] =
13837 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13838 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13840 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13841 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13842 {"No", "Thumb-1", "Thumb-2", "Yes"};
13843 static const char * arm_attr_tag_FP_arch
[] =
13844 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13845 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13846 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13847 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13848 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13849 "NEON for ARMv8.1"};
13850 static const char * arm_attr_tag_PCS_config
[] =
13851 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13852 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13853 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13854 {"V6", "SB", "TLS", "Unused"};
13855 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13856 {"Absolute", "PC-relative", "SB-relative", "None"};
13857 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13858 {"Absolute", "PC-relative", "None"};
13859 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13860 {"None", "direct", "GOT-indirect"};
13861 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13862 {"None", "??? 1", "2", "??? 3", "4"};
13863 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13864 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13865 {"Unused", "Needed", "Sign only"};
13866 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13867 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13868 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13869 {"Unused", "Finite", "RTABI", "IEEE 754"};
13870 static const char * arm_attr_tag_ABI_enum_size
[] =
13871 {"Unused", "small", "int", "forced to int"};
13872 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13873 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13874 static const char * arm_attr_tag_ABI_VFP_args
[] =
13875 {"AAPCS", "VFP registers", "custom", "compatible"};
13876 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13877 {"AAPCS", "WMMX registers", "custom"};
13878 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13879 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13880 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13881 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13882 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13883 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13884 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13885 static const char * arm_attr_tag_FP_HP_extension
[] =
13886 {"Not Allowed", "Allowed"};
13887 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13888 {"None", "IEEE 754", "Alternative Format"};
13889 static const char * arm_attr_tag_DSP_extension
[] =
13890 {"Follow architecture", "Allowed"};
13891 static const char * arm_attr_tag_MPextension_use
[] =
13892 {"Not Allowed", "Allowed"};
13893 static const char * arm_attr_tag_DIV_use
[] =
13894 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13895 "Allowed in v7-A with integer division extension"};
13896 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13897 static const char * arm_attr_tag_Virtualization_use
[] =
13898 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13899 "TrustZone and Virtualization Extensions"};
13900 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13901 {"Not Allowed", "Allowed"};
13903 #define LOOKUP(id, name) \
13904 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13905 static arm_attr_public_tag arm_attr_public_tags
[] =
13907 {4, "CPU_raw_name", 1, NULL
},
13908 {5, "CPU_name", 1, NULL
},
13909 LOOKUP(6, CPU_arch
),
13910 {7, "CPU_arch_profile", 0, NULL
},
13911 LOOKUP(8, ARM_ISA_use
),
13912 LOOKUP(9, THUMB_ISA_use
),
13913 LOOKUP(10, FP_arch
),
13914 LOOKUP(11, WMMX_arch
),
13915 LOOKUP(12, Advanced_SIMD_arch
),
13916 LOOKUP(13, PCS_config
),
13917 LOOKUP(14, ABI_PCS_R9_use
),
13918 LOOKUP(15, ABI_PCS_RW_data
),
13919 LOOKUP(16, ABI_PCS_RO_data
),
13920 LOOKUP(17, ABI_PCS_GOT_use
),
13921 LOOKUP(18, ABI_PCS_wchar_t
),
13922 LOOKUP(19, ABI_FP_rounding
),
13923 LOOKUP(20, ABI_FP_denormal
),
13924 LOOKUP(21, ABI_FP_exceptions
),
13925 LOOKUP(22, ABI_FP_user_exceptions
),
13926 LOOKUP(23, ABI_FP_number_model
),
13927 {24, "ABI_align_needed", 0, NULL
},
13928 {25, "ABI_align_preserved", 0, NULL
},
13929 LOOKUP(26, ABI_enum_size
),
13930 LOOKUP(27, ABI_HardFP_use
),
13931 LOOKUP(28, ABI_VFP_args
),
13932 LOOKUP(29, ABI_WMMX_args
),
13933 LOOKUP(30, ABI_optimization_goals
),
13934 LOOKUP(31, ABI_FP_optimization_goals
),
13935 {32, "compatibility", 0, NULL
},
13936 LOOKUP(34, CPU_unaligned_access
),
13937 LOOKUP(36, FP_HP_extension
),
13938 LOOKUP(38, ABI_FP_16bit_format
),
13939 LOOKUP(42, MPextension_use
),
13940 LOOKUP(44, DIV_use
),
13941 LOOKUP(46, DSP_extension
),
13942 {64, "nodefaults", 0, NULL
},
13943 {65, "also_compatible_with", 0, NULL
},
13944 LOOKUP(66, T2EE_use
),
13945 {67, "conformance", 1, NULL
},
13946 LOOKUP(68, Virtualization_use
),
13947 LOOKUP(70, MPextension_use_legacy
)
13951 static unsigned char *
13952 display_arm_attribute (unsigned char * p
,
13953 const unsigned char * const end
)
13958 arm_attr_public_tag
* attr
;
13962 tag
= read_uleb128 (p
, &len
, end
);
13965 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13967 if (arm_attr_public_tags
[i
].tag
== tag
)
13969 attr
= &arm_attr_public_tags
[i
];
13976 printf (" Tag_%s: ", attr
->name
);
13977 switch (attr
->type
)
13982 case 7: /* Tag_CPU_arch_profile. */
13983 val
= read_uleb128 (p
, &len
, end
);
13987 case 0: printf (_("None\n")); break;
13988 case 'A': printf (_("Application\n")); break;
13989 case 'R': printf (_("Realtime\n")); break;
13990 case 'M': printf (_("Microcontroller\n")); break;
13991 case 'S': printf (_("Application or Realtime\n")); break;
13992 default: printf ("??? (%d)\n", val
); break;
13996 case 24: /* Tag_align_needed. */
13997 val
= read_uleb128 (p
, &len
, end
);
14001 case 0: printf (_("None\n")); break;
14002 case 1: printf (_("8-byte\n")); break;
14003 case 2: printf (_("4-byte\n")); break;
14004 case 3: printf ("??? 3\n"); break;
14007 printf (_("8-byte and up to %d-byte extended\n"),
14010 printf ("??? (%d)\n", val
);
14015 case 25: /* Tag_align_preserved. */
14016 val
= read_uleb128 (p
, &len
, end
);
14020 case 0: printf (_("None\n")); break;
14021 case 1: printf (_("8-byte, except leaf SP\n")); break;
14022 case 2: printf (_("8-byte\n")); break;
14023 case 3: printf ("??? 3\n"); break;
14026 printf (_("8-byte and up to %d-byte extended\n"),
14029 printf ("??? (%d)\n", val
);
14034 case 32: /* Tag_compatibility. */
14036 val
= read_uleb128 (p
, &len
, end
);
14038 printf (_("flag = %d, vendor = "), val
);
14041 size_t maxlen
= (end
- p
) - 1;
14043 print_symbol ((int) maxlen
, (const char *) p
);
14044 p
+= strnlen ((char *) p
, maxlen
) + 1;
14048 printf (_("<corrupt>"));
14049 p
= (unsigned char *) end
;
14055 case 64: /* Tag_nodefaults. */
14056 /* PR 17531: file: 001-505008-0.01. */
14059 printf (_("True\n"));
14062 case 65: /* Tag_also_compatible_with. */
14063 val
= read_uleb128 (p
, &len
, end
);
14065 if (val
== 6 /* Tag_CPU_arch. */)
14067 val
= read_uleb128 (p
, &len
, end
);
14069 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14070 printf ("??? (%d)\n", val
);
14072 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14076 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14081 printf (_("<unknown: %d>\n"), tag
);
14087 return display_tag_value (-1, p
, end
);
14089 return display_tag_value (0, p
, end
);
14092 assert (attr
->type
& 0x80);
14093 val
= read_uleb128 (p
, &len
, end
);
14095 type
= attr
->type
& 0x7f;
14097 printf ("??? (%d)\n", val
);
14099 printf ("%s\n", attr
->table
[val
]);
14104 return display_tag_value (tag
, p
, end
);
14107 static unsigned char *
14108 display_gnu_attribute (unsigned char * p
,
14109 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14110 const unsigned char * const end
)
14116 tag
= read_uleb128 (p
, &len
, end
);
14119 /* Tag_compatibility is the only generic GNU attribute defined at
14123 val
= read_uleb128 (p
, &len
, end
);
14126 printf (_("flag = %d, vendor = "), val
);
14129 printf (_("<corrupt>\n"));
14130 warn (_("corrupt vendor attribute\n"));
14136 size_t maxlen
= (end
- p
) - 1;
14138 print_symbol ((int) maxlen
, (const char *) p
);
14139 p
+= strnlen ((char *) p
, maxlen
) + 1;
14143 printf (_("<corrupt>"));
14144 p
= (unsigned char *) end
;
14151 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14152 return display_proc_gnu_attribute (p
, tag
, end
);
14154 return display_tag_value (tag
, p
, end
);
14157 static unsigned char *
14158 display_power_gnu_attribute (unsigned char * p
,
14160 const unsigned char * const end
)
14165 if (tag
== Tag_GNU_Power_ABI_FP
)
14167 val
= read_uleb128 (p
, &len
, end
);
14169 printf (" Tag_GNU_Power_ABI_FP: ");
14172 printf (_("<corrupt>\n"));
14177 printf ("(%#x), ", val
);
14182 printf (_("unspecified hard/soft float, "));
14185 printf (_("hard float, "));
14188 printf (_("soft float, "));
14191 printf (_("single-precision hard float, "));
14198 printf (_("unspecified long double\n"));
14201 printf (_("128-bit IBM long double\n"));
14204 printf (_("64-bit long double\n"));
14207 printf (_("128-bit IEEE long double\n"));
14213 if (tag
== Tag_GNU_Power_ABI_Vector
)
14215 val
= read_uleb128 (p
, &len
, end
);
14217 printf (" Tag_GNU_Power_ABI_Vector: ");
14220 printf (_("<corrupt>\n"));
14225 printf ("(%#x), ", val
);
14230 printf (_("unspecified\n"));
14233 printf (_("generic\n"));
14236 printf ("AltiVec\n");
14245 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14247 val
= read_uleb128 (p
, &len
, end
);
14249 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14252 printf (_("<corrupt>\n"));
14257 printf ("(%#x), ", val
);
14262 printf (_("unspecified\n"));
14265 printf ("r3/r4\n");
14268 printf (_("memory\n"));
14277 return display_tag_value (tag
& 1, p
, end
);
14280 static unsigned char *
14281 display_s390_gnu_attribute (unsigned char * p
,
14283 const unsigned char * const end
)
14288 if (tag
== Tag_GNU_S390_ABI_Vector
)
14290 val
= read_uleb128 (p
, &len
, end
);
14292 printf (" Tag_GNU_S390_ABI_Vector: ");
14297 printf (_("any\n"));
14300 printf (_("software\n"));
14303 printf (_("hardware\n"));
14306 printf ("??? (%d)\n", val
);
14312 return display_tag_value (tag
& 1, p
, end
);
14316 display_sparc_hwcaps (unsigned int mask
)
14320 bfd_boolean first
= TRUE
;
14322 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14323 fputs ("mul32", stdout
), first
= FALSE
;
14324 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14325 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14326 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14327 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14328 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14329 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14330 if (mask
& ELF_SPARC_HWCAP_POPC
)
14331 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14332 if (mask
& ELF_SPARC_HWCAP_VIS
)
14333 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14334 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14335 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14336 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14337 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14338 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14339 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14340 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14341 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14342 if (mask
& ELF_SPARC_HWCAP_HPC
)
14343 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14344 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14345 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14346 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14347 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14348 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14349 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14350 if (mask
& ELF_SPARC_HWCAP_IMA
)
14351 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14352 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14353 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14356 fputc ('0', stdout
);
14357 fputc ('\n', stdout
);
14361 display_sparc_hwcaps2 (unsigned int mask
)
14365 bfd_boolean first
= TRUE
;
14367 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14368 fputs ("fjathplus", stdout
), first
= FALSE
;
14369 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14370 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14371 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14372 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14373 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14374 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14375 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14376 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14377 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14378 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14379 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14380 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14381 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14382 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14383 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14384 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14385 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14386 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14387 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14388 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14391 fputc ('0', stdout
);
14392 fputc ('\n', stdout
);
14395 static unsigned char *
14396 display_sparc_gnu_attribute (unsigned char * p
,
14398 const unsigned char * const end
)
14403 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14405 val
= read_uleb128 (p
, &len
, end
);
14407 printf (" Tag_GNU_Sparc_HWCAPS: ");
14408 display_sparc_hwcaps (val
);
14411 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14413 val
= read_uleb128 (p
, &len
, end
);
14415 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14416 display_sparc_hwcaps2 (val
);
14420 return display_tag_value (tag
, p
, end
);
14424 print_mips_fp_abi_value (unsigned int val
)
14428 case Val_GNU_MIPS_ABI_FP_ANY
:
14429 printf (_("Hard or soft float\n"));
14431 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14432 printf (_("Hard float (double precision)\n"));
14434 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14435 printf (_("Hard float (single precision)\n"));
14437 case Val_GNU_MIPS_ABI_FP_SOFT
:
14438 printf (_("Soft float\n"));
14440 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14441 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14443 case Val_GNU_MIPS_ABI_FP_XX
:
14444 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14446 case Val_GNU_MIPS_ABI_FP_64
:
14447 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14449 case Val_GNU_MIPS_ABI_FP_64A
:
14450 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14452 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14453 printf (_("NaN 2008 compatibility\n"));
14456 printf ("??? (%d)\n", val
);
14461 static unsigned char *
14462 display_mips_gnu_attribute (unsigned char * p
,
14464 const unsigned char * const end
)
14466 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14471 val
= read_uleb128 (p
, &len
, end
);
14473 printf (" Tag_GNU_MIPS_ABI_FP: ");
14475 print_mips_fp_abi_value (val
);
14480 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14485 val
= read_uleb128 (p
, &len
, end
);
14487 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14491 case Val_GNU_MIPS_ABI_MSA_ANY
:
14492 printf (_("Any MSA or not\n"));
14494 case Val_GNU_MIPS_ABI_MSA_128
:
14495 printf (_("128-bit MSA\n"));
14498 printf ("??? (%d)\n", val
);
14504 return display_tag_value (tag
& 1, p
, end
);
14507 static unsigned char *
14508 display_tic6x_attribute (unsigned char * p
,
14509 const unsigned char * const end
)
14515 tag
= read_uleb128 (p
, &len
, end
);
14521 val
= read_uleb128 (p
, &len
, end
);
14523 printf (" Tag_ISA: ");
14527 case C6XABI_Tag_ISA_none
:
14528 printf (_("None\n"));
14530 case C6XABI_Tag_ISA_C62X
:
14533 case C6XABI_Tag_ISA_C67X
:
14536 case C6XABI_Tag_ISA_C67XP
:
14537 printf ("C67x+\n");
14539 case C6XABI_Tag_ISA_C64X
:
14542 case C6XABI_Tag_ISA_C64XP
:
14543 printf ("C64x+\n");
14545 case C6XABI_Tag_ISA_C674X
:
14546 printf ("C674x\n");
14549 printf ("??? (%d)\n", val
);
14554 case Tag_ABI_wchar_t
:
14555 val
= read_uleb128 (p
, &len
, end
);
14557 printf (" Tag_ABI_wchar_t: ");
14561 printf (_("Not used\n"));
14564 printf (_("2 bytes\n"));
14567 printf (_("4 bytes\n"));
14570 printf ("??? (%d)\n", val
);
14575 case Tag_ABI_stack_align_needed
:
14576 val
= read_uleb128 (p
, &len
, end
);
14578 printf (" Tag_ABI_stack_align_needed: ");
14582 printf (_("8-byte\n"));
14585 printf (_("16-byte\n"));
14588 printf ("??? (%d)\n", val
);
14593 case Tag_ABI_stack_align_preserved
:
14594 val
= read_uleb128 (p
, &len
, end
);
14596 printf (" Tag_ABI_stack_align_preserved: ");
14600 printf (_("8-byte\n"));
14603 printf (_("16-byte\n"));
14606 printf ("??? (%d)\n", val
);
14612 val
= read_uleb128 (p
, &len
, end
);
14614 printf (" Tag_ABI_DSBT: ");
14618 printf (_("DSBT addressing not used\n"));
14621 printf (_("DSBT addressing used\n"));
14624 printf ("??? (%d)\n", val
);
14630 val
= read_uleb128 (p
, &len
, end
);
14632 printf (" Tag_ABI_PID: ");
14636 printf (_("Data addressing position-dependent\n"));
14639 printf (_("Data addressing position-independent, GOT near DP\n"));
14642 printf (_("Data addressing position-independent, GOT far from DP\n"));
14645 printf ("??? (%d)\n", val
);
14651 val
= read_uleb128 (p
, &len
, end
);
14653 printf (" Tag_ABI_PIC: ");
14657 printf (_("Code addressing position-dependent\n"));
14660 printf (_("Code addressing position-independent\n"));
14663 printf ("??? (%d)\n", val
);
14668 case Tag_ABI_array_object_alignment
:
14669 val
= read_uleb128 (p
, &len
, end
);
14671 printf (" Tag_ABI_array_object_alignment: ");
14675 printf (_("8-byte\n"));
14678 printf (_("4-byte\n"));
14681 printf (_("16-byte\n"));
14684 printf ("??? (%d)\n", val
);
14689 case Tag_ABI_array_object_align_expected
:
14690 val
= read_uleb128 (p
, &len
, end
);
14692 printf (" Tag_ABI_array_object_align_expected: ");
14696 printf (_("8-byte\n"));
14699 printf (_("4-byte\n"));
14702 printf (_("16-byte\n"));
14705 printf ("??? (%d)\n", val
);
14710 case Tag_ABI_compatibility
:
14712 val
= read_uleb128 (p
, &len
, end
);
14714 printf (" Tag_ABI_compatibility: ");
14715 printf (_("flag = %d, vendor = "), val
);
14718 size_t maxlen
= (end
- p
) - 1;
14720 print_symbol ((int) maxlen
, (const char *) p
);
14721 p
+= strnlen ((char *) p
, maxlen
) + 1;
14725 printf (_("<corrupt>"));
14726 p
= (unsigned char *) end
;
14732 case Tag_ABI_conformance
:
14734 printf (" Tag_ABI_conformance: \"");
14737 size_t maxlen
= (end
- p
) - 1;
14739 print_symbol ((int) maxlen
, (const char *) p
);
14740 p
+= strnlen ((char *) p
, maxlen
) + 1;
14744 printf (_("<corrupt>"));
14745 p
= (unsigned char *) end
;
14752 return display_tag_value (tag
, p
, end
);
14756 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14758 unsigned long addr
= 0;
14759 size_t bytes
= end
- p
;
14766 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14768 printf (" 0x%8.8lx ", addr
);
14770 for (j
= 0; j
< 16; j
++)
14773 printf ("%2.2x", p
[j
]);
14781 for (j
= 0; j
< lbytes
; j
++)
14784 if (k
>= ' ' && k
< 0x7f)
14800 static unsigned char *
14801 display_msp430x_attribute (unsigned char * p
,
14802 const unsigned char * const end
)
14808 tag
= read_uleb128 (p
, & len
, end
);
14813 case OFBA_MSPABI_Tag_ISA
:
14814 val
= read_uleb128 (p
, &len
, end
);
14816 printf (" Tag_ISA: ");
14819 case 0: printf (_("None\n")); break;
14820 case 1: printf (_("MSP430\n")); break;
14821 case 2: printf (_("MSP430X\n")); break;
14822 default: printf ("??? (%d)\n", val
); break;
14826 case OFBA_MSPABI_Tag_Code_Model
:
14827 val
= read_uleb128 (p
, &len
, end
);
14829 printf (" Tag_Code_Model: ");
14832 case 0: printf (_("None\n")); break;
14833 case 1: printf (_("Small\n")); break;
14834 case 2: printf (_("Large\n")); break;
14835 default: printf ("??? (%d)\n", val
); break;
14839 case OFBA_MSPABI_Tag_Data_Model
:
14840 val
= read_uleb128 (p
, &len
, end
);
14842 printf (" Tag_Data_Model: ");
14845 case 0: printf (_("None\n")); break;
14846 case 1: printf (_("Small\n")); break;
14847 case 2: printf (_("Large\n")); break;
14848 case 3: printf (_("Restricted Large\n")); break;
14849 default: printf ("??? (%d)\n", val
); break;
14854 printf (_(" <unknown tag %d>: "), tag
);
14861 size_t maxlen
= (end
- p
) - 1;
14863 print_symbol ((int) maxlen
, (const char *) p
);
14864 p
+= strnlen ((char *) p
, maxlen
) + 1;
14868 printf (_("<corrupt>"));
14869 p
= (unsigned char *) end
;
14875 val
= read_uleb128 (p
, &len
, end
);
14877 printf ("%d (0x%x)\n", val
, val
);
14887 process_attributes (FILE * file
,
14888 const char * public_name
,
14889 unsigned int proc_type
,
14890 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14891 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14893 Elf_Internal_Shdr
* sect
;
14895 bfd_boolean res
= TRUE
;
14897 /* Find the section header so that we get the size. */
14898 for (i
= 0, sect
= section_headers
;
14899 i
< elf_header
.e_shnum
;
14902 unsigned char * contents
;
14905 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14908 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14909 sect
->sh_size
, _("attributes"));
14910 if (contents
== NULL
)
14917 /* The first character is the version of the attributes.
14918 Currently only version 1, (aka 'A') is recognised here. */
14921 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14926 bfd_vma section_len
;
14928 section_len
= sect
->sh_size
- 1;
14931 while (section_len
> 0)
14934 unsigned int namelen
;
14935 bfd_boolean public_section
;
14936 bfd_boolean gnu_section
;
14938 if (section_len
<= 4)
14940 error (_("Tag section ends prematurely\n"));
14944 attr_len
= byte_get (p
, 4);
14947 if (attr_len
> section_len
)
14949 error (_("Bad attribute length (%u > %u)\n"),
14950 (unsigned) attr_len
, (unsigned) section_len
);
14951 attr_len
= section_len
;
14954 /* PR 17531: file: 001-101425-0.004 */
14955 else if (attr_len
< 5)
14957 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14962 section_len
-= attr_len
;
14965 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14966 if (namelen
== 0 || namelen
>= attr_len
)
14968 error (_("Corrupt attribute section name\n"));
14973 printf (_("Attribute Section: "));
14974 print_symbol (INT_MAX
, (const char *) p
);
14977 if (public_name
&& streq ((char *) p
, public_name
))
14978 public_section
= TRUE
;
14980 public_section
= FALSE
;
14982 if (streq ((char *) p
, "gnu"))
14983 gnu_section
= TRUE
;
14985 gnu_section
= FALSE
;
14988 attr_len
-= namelen
;
14990 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14995 unsigned char * end
;
14997 /* PR binutils/17531: Safe handling of corrupt files. */
15000 error (_("Unused bytes at end of section\n"));
15007 size
= byte_get (p
, 4);
15008 if (size
> attr_len
)
15010 error (_("Bad subsection length (%u > %u)\n"),
15011 (unsigned) size
, (unsigned) attr_len
);
15015 /* PR binutils/17531: Safe handling of corrupt files. */
15018 error (_("Bad subsection length (%u < 6)\n"),
15026 end
= p
+ size
- 1;
15027 assert (end
<= contents
+ sect
->sh_size
);
15033 printf (_("File Attributes\n"));
15036 printf (_("Section Attributes:"));
15039 printf (_("Symbol Attributes:"));
15040 /* Fall through. */
15046 val
= read_uleb128 (p
, &j
, end
);
15050 printf (" %d", val
);
15055 printf (_("Unknown tag: %d\n"), tag
);
15056 public_section
= FALSE
;
15060 if (public_section
&& display_pub_attribute
!= NULL
)
15063 p
= display_pub_attribute (p
, end
);
15066 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15069 p
= display_gnu_attribute (p
,
15070 display_proc_gnu_attribute
,
15076 printf (_(" Unknown attribute:\n"));
15077 display_raw_attribute (p
, end
);
15092 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15093 Print the Address, Access and Initial fields of an entry at VMA ADDR
15094 and return the VMA of the next entry, or -1 if there was a problem.
15095 Does not read from DATA_END or beyond. */
15098 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15099 unsigned char * data_end
)
15102 print_vma (addr
, LONG_HEX
);
15104 if (addr
< pltgot
+ 0xfff0)
15105 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15107 printf ("%10s", "");
15110 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15114 unsigned char * from
= data
+ addr
- pltgot
;
15116 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15118 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15119 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15120 return (bfd_vma
) -1;
15124 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15125 print_vma (entry
, LONG_HEX
);
15128 return addr
+ (is_32bit_elf
? 4 : 8);
15131 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15132 PLTGOT. Print the Address and Initial fields of an entry at VMA
15133 ADDR and return the VMA of the next entry. */
15136 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15139 print_vma (addr
, LONG_HEX
);
15142 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15147 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15148 print_vma (entry
, LONG_HEX
);
15150 return addr
+ (is_32bit_elf
? 4 : 8);
15154 print_mips_ases (unsigned int mask
)
15156 if (mask
& AFL_ASE_DSP
)
15157 fputs ("\n\tDSP ASE", stdout
);
15158 if (mask
& AFL_ASE_DSPR2
)
15159 fputs ("\n\tDSP R2 ASE", stdout
);
15160 if (mask
& AFL_ASE_DSPR3
)
15161 fputs ("\n\tDSP R3 ASE", stdout
);
15162 if (mask
& AFL_ASE_EVA
)
15163 fputs ("\n\tEnhanced VA Scheme", stdout
);
15164 if (mask
& AFL_ASE_MCU
)
15165 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15166 if (mask
& AFL_ASE_MDMX
)
15167 fputs ("\n\tMDMX ASE", stdout
);
15168 if (mask
& AFL_ASE_MIPS3D
)
15169 fputs ("\n\tMIPS-3D ASE", stdout
);
15170 if (mask
& AFL_ASE_MT
)
15171 fputs ("\n\tMT ASE", stdout
);
15172 if (mask
& AFL_ASE_SMARTMIPS
)
15173 fputs ("\n\tSmartMIPS ASE", stdout
);
15174 if (mask
& AFL_ASE_VIRT
)
15175 fputs ("\n\tVZ ASE", stdout
);
15176 if (mask
& AFL_ASE_MSA
)
15177 fputs ("\n\tMSA ASE", stdout
);
15178 if (mask
& AFL_ASE_MIPS16
)
15179 fputs ("\n\tMIPS16 ASE", stdout
);
15180 if (mask
& AFL_ASE_MICROMIPS
)
15181 fputs ("\n\tMICROMIPS ASE", stdout
);
15182 if (mask
& AFL_ASE_XPA
)
15183 fputs ("\n\tXPA ASE", stdout
);
15184 if (mask
& AFL_ASE_MIPS16E2
)
15185 fputs ("\n\tMIPS16e2 ASE", stdout
);
15187 fprintf (stdout
, "\n\t%s", _("None"));
15188 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15189 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15193 print_mips_isa_ext (unsigned int isa_ext
)
15198 fputs (_("None"), stdout
);
15201 fputs ("RMI XLR", stdout
);
15203 case AFL_EXT_OCTEON3
:
15204 fputs ("Cavium Networks Octeon3", stdout
);
15206 case AFL_EXT_OCTEON2
:
15207 fputs ("Cavium Networks Octeon2", stdout
);
15209 case AFL_EXT_OCTEONP
:
15210 fputs ("Cavium Networks OcteonP", stdout
);
15212 case AFL_EXT_LOONGSON_3A
:
15213 fputs ("Loongson 3A", stdout
);
15215 case AFL_EXT_OCTEON
:
15216 fputs ("Cavium Networks Octeon", stdout
);
15219 fputs ("Toshiba R5900", stdout
);
15222 fputs ("MIPS R4650", stdout
);
15225 fputs ("LSI R4010", stdout
);
15228 fputs ("NEC VR4100", stdout
);
15231 fputs ("Toshiba R3900", stdout
);
15233 case AFL_EXT_10000
:
15234 fputs ("MIPS R10000", stdout
);
15237 fputs ("Broadcom SB-1", stdout
);
15240 fputs ("NEC VR4111/VR4181", stdout
);
15243 fputs ("NEC VR4120", stdout
);
15246 fputs ("NEC VR5400", stdout
);
15249 fputs ("NEC VR5500", stdout
);
15251 case AFL_EXT_LOONGSON_2E
:
15252 fputs ("ST Microelectronics Loongson 2E", stdout
);
15254 case AFL_EXT_LOONGSON_2F
:
15255 fputs ("ST Microelectronics Loongson 2F", stdout
);
15257 case AFL_EXT_INTERAPTIV_MR2
:
15258 fputs ("Imagination interAptiv MR2", stdout
);
15261 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15266 get_mips_reg_size (int reg_size
)
15268 return (reg_size
== AFL_REG_NONE
) ? 0
15269 : (reg_size
== AFL_REG_32
) ? 32
15270 : (reg_size
== AFL_REG_64
) ? 64
15271 : (reg_size
== AFL_REG_128
) ? 128
15276 process_mips_specific (FILE * file
)
15278 Elf_Internal_Dyn
* entry
;
15279 Elf_Internal_Shdr
*sect
= NULL
;
15280 size_t liblist_offset
= 0;
15281 size_t liblistno
= 0;
15282 size_t conflictsno
= 0;
15283 size_t options_offset
= 0;
15284 size_t conflicts_offset
= 0;
15285 size_t pltrelsz
= 0;
15287 bfd_vma pltgot
= 0;
15288 bfd_vma mips_pltgot
= 0;
15289 bfd_vma jmprel
= 0;
15290 bfd_vma local_gotno
= 0;
15291 bfd_vma gotsym
= 0;
15292 bfd_vma symtabno
= 0;
15293 bfd_boolean res
= TRUE
;
15295 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15296 display_mips_gnu_attribute
))
15299 sect
= find_section (".MIPS.abiflags");
15303 Elf_External_ABIFlags_v0
*abiflags_ext
;
15304 Elf_Internal_ABIFlags_v0 abiflags_in
;
15306 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15308 error (_("Corrupt MIPS ABI Flags section.\n"));
15313 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15314 sect
->sh_size
, _("MIPS ABI Flags section"));
15317 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15318 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15319 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15320 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15321 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15322 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15323 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15324 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15325 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15326 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15327 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15329 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15330 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15331 if (abiflags_in
.isa_rev
> 1)
15332 printf ("r%d", abiflags_in
.isa_rev
);
15333 printf ("\nGPR size: %d",
15334 get_mips_reg_size (abiflags_in
.gpr_size
));
15335 printf ("\nCPR1 size: %d",
15336 get_mips_reg_size (abiflags_in
.cpr1_size
));
15337 printf ("\nCPR2 size: %d",
15338 get_mips_reg_size (abiflags_in
.cpr2_size
));
15339 fputs ("\nFP ABI: ", stdout
);
15340 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15341 fputs ("ISA Extension: ", stdout
);
15342 print_mips_isa_ext (abiflags_in
.isa_ext
);
15343 fputs ("\nASEs:", stdout
);
15344 print_mips_ases (abiflags_in
.ases
);
15345 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15346 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15347 fputc ('\n', stdout
);
15348 free (abiflags_ext
);
15353 /* We have a lot of special sections. Thanks SGI! */
15354 if (dynamic_section
== NULL
)
15356 /* No dynamic information available. See if there is static GOT. */
15357 sect
= find_section (".got");
15360 unsigned char *data_end
;
15361 unsigned char *data
;
15365 pltgot
= sect
->sh_addr
;
15368 addr_size
= (is_32bit_elf
? 4 : 8);
15369 end
= pltgot
+ sect
->sh_size
;
15371 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15373 _("Global Offset Table data"));
15374 /* PR 12855: Null data is handled gracefully throughout. */
15375 data_end
= data
+ (end
- pltgot
);
15377 printf (_("\nStatic GOT:\n"));
15378 printf (_(" Canonical gp value: "));
15379 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15382 /* In a dynamic binary GOT[0] is reserved for the dynamic
15383 loader to store the lazy resolver pointer, however in
15384 a static binary it may well have been omitted and GOT
15385 reduced to a table of addresses.
15386 PR 21344: Check for the entry being fully available
15387 before fetching it. */
15389 && data
+ ent
- pltgot
+ addr_size
<= data_end
15390 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15392 printf (_(" Reserved entries:\n"));
15393 printf (_(" %*s %10s %*s\n"),
15394 addr_size
* 2, _("Address"), _("Access"),
15395 addr_size
* 2, _("Value"));
15396 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15398 if (ent
== (bfd_vma
) -1)
15399 goto sgot_print_fail
;
15401 /* Check for the MSB of GOT[1] being set, identifying a
15402 GNU object. This entry will be used by some runtime
15403 loaders, to store the module pointer. Otherwise this
15404 is an ordinary local entry.
15405 PR 21344: Check for the entry being fully available
15406 before fetching it. */
15408 && data
+ ent
- pltgot
+ addr_size
<= data_end
15409 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15410 >> (addr_size
* 8 - 1)) != 0)
15412 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15414 if (ent
== (bfd_vma
) -1)
15415 goto sgot_print_fail
;
15420 if (data
!= NULL
&& ent
< end
)
15422 printf (_(" Local entries:\n"));
15423 printf (" %*s %10s %*s\n",
15424 addr_size
* 2, _("Address"), _("Access"),
15425 addr_size
* 2, _("Value"));
15428 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15430 if (ent
== (bfd_vma
) -1)
15431 goto sgot_print_fail
;
15443 for (entry
= dynamic_section
;
15444 /* PR 17531 file: 012-50589-0.004. */
15445 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15447 switch (entry
->d_tag
)
15449 case DT_MIPS_LIBLIST
:
15451 = offset_from_vma (file
, entry
->d_un
.d_val
,
15452 liblistno
* sizeof (Elf32_External_Lib
));
15454 case DT_MIPS_LIBLISTNO
:
15455 liblistno
= entry
->d_un
.d_val
;
15457 case DT_MIPS_OPTIONS
:
15458 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15460 case DT_MIPS_CONFLICT
:
15462 = offset_from_vma (file
, entry
->d_un
.d_val
,
15463 conflictsno
* sizeof (Elf32_External_Conflict
));
15465 case DT_MIPS_CONFLICTNO
:
15466 conflictsno
= entry
->d_un
.d_val
;
15469 pltgot
= entry
->d_un
.d_ptr
;
15471 case DT_MIPS_LOCAL_GOTNO
:
15472 local_gotno
= entry
->d_un
.d_val
;
15474 case DT_MIPS_GOTSYM
:
15475 gotsym
= entry
->d_un
.d_val
;
15477 case DT_MIPS_SYMTABNO
:
15478 symtabno
= entry
->d_un
.d_val
;
15480 case DT_MIPS_PLTGOT
:
15481 mips_pltgot
= entry
->d_un
.d_ptr
;
15484 pltrel
= entry
->d_un
.d_val
;
15487 pltrelsz
= entry
->d_un
.d_val
;
15490 jmprel
= entry
->d_un
.d_ptr
;
15496 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15498 Elf32_External_Lib
* elib
;
15501 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15503 sizeof (Elf32_External_Lib
),
15504 _("liblist section data"));
15507 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15508 "\nSection '.liblist' contains %lu entries:\n",
15509 (unsigned long) liblistno
),
15510 (unsigned long) liblistno
);
15511 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15514 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15521 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15522 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15523 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15524 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15525 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15527 tmp
= gmtime (&atime
);
15528 snprintf (timebuf
, sizeof (timebuf
),
15529 "%04u-%02u-%02uT%02u:%02u:%02u",
15530 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15531 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15533 printf ("%3lu: ", (unsigned long) cnt
);
15534 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15535 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15537 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15538 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15539 liblist
.l_version
);
15541 if (liblist
.l_flags
== 0)
15545 static const struct
15552 { " EXACT_MATCH", LL_EXACT_MATCH
},
15553 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15554 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15555 { " EXPORTS", LL_EXPORTS
},
15556 { " DELAY_LOAD", LL_DELAY_LOAD
},
15557 { " DELTA", LL_DELTA
}
15559 int flags
= liblist
.l_flags
;
15562 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15563 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15565 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15566 flags
^= l_flags_vals
[fcnt
].bit
;
15569 printf (" %#x", (unsigned int) flags
);
15581 if (options_offset
!= 0)
15583 Elf_External_Options
* eopt
;
15584 Elf_Internal_Options
* iopt
;
15585 Elf_Internal_Options
* option
;
15588 sect
= section_headers
;
15590 /* Find the section header so that we get the size. */
15591 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15592 /* PR 17533 file: 012-277276-0.004. */
15595 error (_("No MIPS_OPTIONS header found\n"));
15599 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15600 sect
->sh_size
, _("options"));
15603 iopt
= (Elf_Internal_Options
*)
15604 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15607 error (_("Out of memory allocating space for MIPS options\n"));
15614 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15616 Elf_External_Options
* eoption
;
15618 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15620 option
->kind
= BYTE_GET (eoption
->kind
);
15621 option
->size
= BYTE_GET (eoption
->size
);
15622 option
->section
= BYTE_GET (eoption
->section
);
15623 option
->info
= BYTE_GET (eoption
->info
);
15625 /* PR 17531: file: ffa0fa3b. */
15626 if (option
->size
< sizeof (* eopt
)
15627 || offset
+ option
->size
> sect
->sh_size
)
15629 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15632 offset
+= option
->size
;
15638 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15639 "\nSection '%s' contains %d entries:\n",
15641 printable_section_name (sect
), cnt
);
15650 switch (option
->kind
)
15653 /* This shouldn't happen. */
15654 printf (" NULL %d %lx", option
->section
, option
->info
);
15657 printf (" REGINFO ");
15658 if (elf_header
.e_machine
== EM_MIPS
)
15661 Elf32_External_RegInfo
* ereg
;
15662 Elf32_RegInfo reginfo
;
15664 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15665 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15666 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15667 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15668 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15669 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15670 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15672 printf ("GPR %08lx GP 0x%lx\n",
15673 reginfo
.ri_gprmask
,
15674 (unsigned long) reginfo
.ri_gp_value
);
15675 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15676 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15677 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15682 Elf64_External_RegInfo
* ereg
;
15683 Elf64_Internal_RegInfo reginfo
;
15685 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15686 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15687 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15688 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15689 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15690 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15691 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15693 printf ("GPR %08lx GP 0x",
15694 reginfo
.ri_gprmask
);
15695 printf_vma (reginfo
.ri_gp_value
);
15698 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15699 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15700 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15704 case ODK_EXCEPTIONS
:
15705 fputs (" EXCEPTIONS fpe_min(", stdout
);
15706 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15707 fputs (") fpe_max(", stdout
);
15708 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15709 fputs (")", stdout
);
15711 if (option
->info
& OEX_PAGE0
)
15712 fputs (" PAGE0", stdout
);
15713 if (option
->info
& OEX_SMM
)
15714 fputs (" SMM", stdout
);
15715 if (option
->info
& OEX_FPDBUG
)
15716 fputs (" FPDBUG", stdout
);
15717 if (option
->info
& OEX_DISMISS
)
15718 fputs (" DISMISS", stdout
);
15721 fputs (" PAD ", stdout
);
15722 if (option
->info
& OPAD_PREFIX
)
15723 fputs (" PREFIX", stdout
);
15724 if (option
->info
& OPAD_POSTFIX
)
15725 fputs (" POSTFIX", stdout
);
15726 if (option
->info
& OPAD_SYMBOL
)
15727 fputs (" SYMBOL", stdout
);
15730 fputs (" HWPATCH ", stdout
);
15731 if (option
->info
& OHW_R4KEOP
)
15732 fputs (" R4KEOP", stdout
);
15733 if (option
->info
& OHW_R8KPFETCH
)
15734 fputs (" R8KPFETCH", stdout
);
15735 if (option
->info
& OHW_R5KEOP
)
15736 fputs (" R5KEOP", stdout
);
15737 if (option
->info
& OHW_R5KCVTL
)
15738 fputs (" R5KCVTL", stdout
);
15741 fputs (" FILL ", stdout
);
15742 /* XXX Print content of info word? */
15745 fputs (" TAGS ", stdout
);
15746 /* XXX Print content of info word? */
15749 fputs (" HWAND ", stdout
);
15750 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15751 fputs (" R4KEOP_CHECKED", stdout
);
15752 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15753 fputs (" R4KEOP_CLEAN", stdout
);
15756 fputs (" HWOR ", stdout
);
15757 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15758 fputs (" R4KEOP_CHECKED", stdout
);
15759 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15760 fputs (" R4KEOP_CLEAN", stdout
);
15763 printf (" GP_GROUP %#06lx self-contained %#06lx",
15764 option
->info
& OGP_GROUP
,
15765 (option
->info
& OGP_SELF
) >> 16);
15768 printf (" IDENT %#06lx self-contained %#06lx",
15769 option
->info
& OGP_GROUP
,
15770 (option
->info
& OGP_SELF
) >> 16);
15773 /* This shouldn't happen. */
15774 printf (" %3d ??? %d %lx",
15775 option
->kind
, option
->section
, option
->info
);
15779 len
= sizeof (* eopt
);
15780 while (len
< option
->size
)
15782 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15784 if (ISPRINT (datum
))
15785 printf ("%c", datum
);
15787 printf ("\\%03o", datum
);
15790 fputs ("\n", stdout
);
15792 offset
+= option
->size
;
15802 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15804 Elf32_Conflict
* iconf
;
15807 if (dynamic_symbols
== NULL
)
15809 error (_("conflict list found without a dynamic symbol table\n"));
15813 /* PR 21345 - print a slightly more helpful error message
15814 if we are sure that the cmalloc will fail. */
15815 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15817 error (_("Overlarge number of conflicts detected: %lx\n"),
15818 (long) conflictsno
);
15822 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15825 error (_("Out of memory allocating space for dynamic conflicts\n"));
15831 Elf32_External_Conflict
* econf32
;
15833 econf32
= (Elf32_External_Conflict
*)
15834 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15835 sizeof (* econf32
), _("conflict"));
15839 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15840 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15846 Elf64_External_Conflict
* econf64
;
15848 econf64
= (Elf64_External_Conflict
*)
15849 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15850 sizeof (* econf64
), _("conflict"));
15854 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15855 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15860 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
15861 "\nSection '.conflict' contains %lu entries:\n",
15862 (unsigned long) conflictsno
),
15863 (unsigned long) conflictsno
);
15864 puts (_(" Num: Index Value Name"));
15866 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15868 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15870 if (iconf
[cnt
] >= num_dynamic_syms
)
15871 printf (_("<corrupt symbol index>"));
15874 Elf_Internal_Sym
* psym
;
15876 psym
= & dynamic_symbols
[iconf
[cnt
]];
15877 print_vma (psym
->st_value
, FULL_HEX
);
15879 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15880 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15882 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15890 if (pltgot
!= 0 && local_gotno
!= 0)
15892 bfd_vma ent
, local_end
, global_end
;
15894 unsigned char * data
;
15895 unsigned char * data_end
;
15899 addr_size
= (is_32bit_elf
? 4 : 8);
15900 local_end
= pltgot
+ local_gotno
* addr_size
;
15902 /* PR binutils/17533 file: 012-111227-0.004 */
15903 if (symtabno
< gotsym
)
15905 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15906 (unsigned long) gotsym
, (unsigned long) symtabno
);
15910 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15911 /* PR 17531: file: 54c91a34. */
15912 if (global_end
< local_end
)
15914 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15918 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15919 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15920 global_end
- pltgot
, 1,
15921 _("Global Offset Table data"));
15922 /* PR 12855: Null data is handled gracefully throughout. */
15923 data_end
= data
+ (global_end
- pltgot
);
15925 printf (_("\nPrimary GOT:\n"));
15926 printf (_(" Canonical gp value: "));
15927 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15930 printf (_(" Reserved entries:\n"));
15931 printf (_(" %*s %10s %*s Purpose\n"),
15932 addr_size
* 2, _("Address"), _("Access"),
15933 addr_size
* 2, _("Initial"));
15934 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15935 printf (_(" Lazy resolver\n"));
15936 if (ent
== (bfd_vma
) -1)
15937 goto got_print_fail
;
15939 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15940 This entry will be used by some runtime loaders, to store the
15941 module pointer. Otherwise this is an ordinary local entry.
15942 PR 21344: Check for the entry being fully available before
15945 && data
+ ent
- pltgot
+ addr_size
<= data_end
15946 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15947 >> (addr_size
* 8 - 1)) != 0)
15949 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15950 printf (_(" Module pointer (GNU extension)\n"));
15951 if (ent
== (bfd_vma
) -1)
15952 goto got_print_fail
;
15956 if (data
!= NULL
&& ent
< local_end
)
15958 printf (_(" Local entries:\n"));
15959 printf (" %*s %10s %*s\n",
15960 addr_size
* 2, _("Address"), _("Access"),
15961 addr_size
* 2, _("Initial"));
15962 while (ent
< local_end
)
15964 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15966 if (ent
== (bfd_vma
) -1)
15967 goto got_print_fail
;
15972 if (data
!= NULL
&& gotsym
< symtabno
)
15976 printf (_(" Global entries:\n"));
15977 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15978 addr_size
* 2, _("Address"),
15980 addr_size
* 2, _("Initial"),
15981 addr_size
* 2, _("Sym.Val."),
15983 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15984 _("Ndx"), _("Name"));
15986 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15988 for (i
= gotsym
; i
< symtabno
; i
++)
15990 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15993 if (dynamic_symbols
== NULL
)
15994 printf (_("<no dynamic symbols>"));
15995 else if (i
< num_dynamic_syms
)
15997 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15999 print_vma (psym
->st_value
, LONG_HEX
);
16000 printf (" %-7s %3s ",
16001 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
16002 get_symbol_index_type (psym
->st_shndx
));
16004 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16005 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16007 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16010 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16011 (unsigned long) i
);
16014 if (ent
== (bfd_vma
) -1)
16025 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16028 size_t offset
, rel_offset
;
16029 unsigned long count
, i
;
16030 unsigned char * data
;
16031 int addr_size
, sym_width
;
16032 Elf_Internal_Rela
* rels
;
16034 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
16035 if (pltrel
== DT_RELA
)
16037 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
16042 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
16047 addr_size
= (is_32bit_elf
? 4 : 8);
16048 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16050 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
16051 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
16052 1, _("Procedure Linkage Table data"));
16056 printf ("\nPLT GOT:\n\n");
16057 printf (_(" Reserved entries:\n"));
16058 printf (_(" %*s %*s Purpose\n"),
16059 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16060 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16061 printf (_(" PLT lazy resolver\n"));
16062 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16063 printf (_(" Module pointer\n"));
16066 printf (_(" Entries:\n"));
16067 printf (" %*s %*s %*s %-7s %3s %s\n",
16068 addr_size
* 2, _("Address"),
16069 addr_size
* 2, _("Initial"),
16070 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16071 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16072 for (i
= 0; i
< count
; i
++)
16074 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16076 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16079 if (idx
>= num_dynamic_syms
)
16080 printf (_("<corrupt symbol index: %lu>"), idx
);
16083 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16085 print_vma (psym
->st_value
, LONG_HEX
);
16086 printf (" %-7s %3s ",
16087 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
16088 get_symbol_index_type (psym
->st_shndx
));
16089 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16090 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16092 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16107 process_nds32_specific (FILE * file
)
16109 Elf_Internal_Shdr
*sect
= NULL
;
16111 sect
= find_section (".nds32_e_flags");
16114 unsigned int *flag
;
16116 printf ("\nNDS32 elf flags section:\n");
16117 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
16118 sect
->sh_size
, _("NDS32 elf flags section"));
16123 switch ((*flag
) & 0x3)
16126 printf ("(VEC_SIZE):\tNo entry.\n");
16129 printf ("(VEC_SIZE):\t4 bytes\n");
16132 printf ("(VEC_SIZE):\t16 bytes\n");
16135 printf ("(VEC_SIZE):\treserved\n");
16144 process_gnu_liblist (FILE * file
)
16146 Elf_Internal_Shdr
* section
;
16147 Elf_Internal_Shdr
* string_sec
;
16148 Elf32_External_Lib
* elib
;
16150 size_t strtab_size
;
16152 unsigned long num_liblist
;
16154 bfd_boolean res
= TRUE
;
16159 for (i
= 0, section
= section_headers
;
16160 i
< elf_header
.e_shnum
;
16163 switch (section
->sh_type
)
16165 case SHT_GNU_LIBLIST
:
16166 if (section
->sh_link
>= elf_header
.e_shnum
)
16169 elib
= (Elf32_External_Lib
*)
16170 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16171 _("liblist section data"));
16179 string_sec
= section_headers
+ section
->sh_link
;
16180 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16181 string_sec
->sh_size
,
16182 _("liblist string table"));
16184 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16191 strtab_size
= string_sec
->sh_size
;
16193 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16194 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16195 "\nLibrary list section '%s' contains %lu entries:\n",
16197 printable_section_name (section
),
16200 puts (_(" Library Time Stamp Checksum Version Flags"));
16202 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16210 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16211 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16212 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16213 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16214 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16216 tmp
= gmtime (&atime
);
16217 snprintf (timebuf
, sizeof (timebuf
),
16218 "%04u-%02u-%02uT%02u:%02u:%02u",
16219 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16220 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16222 printf ("%3lu: ", (unsigned long) cnt
);
16224 printf ("%-20s", liblist
.l_name
< strtab_size
16225 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16227 printf ("%-20.20s", liblist
.l_name
< strtab_size
16228 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16229 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16230 liblist
.l_version
, liblist
.l_flags
);
16241 static const char *
16242 get_note_type (unsigned e_type
)
16244 static char buff
[64];
16246 if (elf_header
.e_type
== ET_CORE
)
16250 return _("NT_AUXV (auxiliary vector)");
16252 return _("NT_PRSTATUS (prstatus structure)");
16254 return _("NT_FPREGSET (floating point registers)");
16256 return _("NT_PRPSINFO (prpsinfo structure)");
16257 case NT_TASKSTRUCT
:
16258 return _("NT_TASKSTRUCT (task structure)");
16260 return _("NT_PRXFPREG (user_xfpregs structure)");
16262 return _("NT_PPC_VMX (ppc Altivec registers)");
16264 return _("NT_PPC_VSX (ppc VSX registers)");
16266 return _("NT_PPC_TAR (ppc TAR register)");
16268 return _("NT_PPC_PPR (ppc PPR register)");
16270 return _("NT_PPC_DSCR (ppc DSCR register)");
16272 return _("NT_PPC_EBB (ppc EBB registers)");
16274 return _("NT_PPC_PMU (ppc PMU registers)");
16275 case NT_PPC_TM_CGPR
:
16276 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16277 case NT_PPC_TM_CFPR
:
16278 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16279 case NT_PPC_TM_CVMX
:
16280 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16281 case NT_PPC_TM_CVSX
:
16282 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16283 case NT_PPC_TM_SPR
:
16284 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16285 case NT_PPC_TM_CTAR
:
16286 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16287 case NT_PPC_TM_CPPR
:
16288 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16289 case NT_PPC_TM_CDSCR
:
16290 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16292 return _("NT_386_TLS (x86 TLS information)");
16293 case NT_386_IOPERM
:
16294 return _("NT_386_IOPERM (x86 I/O permissions)");
16295 case NT_X86_XSTATE
:
16296 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16297 case NT_S390_HIGH_GPRS
:
16298 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16299 case NT_S390_TIMER
:
16300 return _("NT_S390_TIMER (s390 timer register)");
16301 case NT_S390_TODCMP
:
16302 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16303 case NT_S390_TODPREG
:
16304 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16306 return _("NT_S390_CTRS (s390 control registers)");
16307 case NT_S390_PREFIX
:
16308 return _("NT_S390_PREFIX (s390 prefix register)");
16309 case NT_S390_LAST_BREAK
:
16310 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16311 case NT_S390_SYSTEM_CALL
:
16312 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16314 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16315 case NT_S390_VXRS_LOW
:
16316 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16317 case NT_S390_VXRS_HIGH
:
16318 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16319 case NT_S390_GS_CB
:
16320 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16321 case NT_S390_GS_BC
:
16322 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16324 return _("NT_ARM_VFP (arm VFP registers)");
16326 return _("NT_ARM_TLS (AArch TLS registers)");
16327 case NT_ARM_HW_BREAK
:
16328 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16329 case NT_ARM_HW_WATCH
:
16330 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16332 return _("NT_PSTATUS (pstatus structure)");
16334 return _("NT_FPREGS (floating point registers)");
16336 return _("NT_PSINFO (psinfo structure)");
16338 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16340 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16341 case NT_WIN32PSTATUS
:
16342 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16344 return _("NT_SIGINFO (siginfo_t data)");
16346 return _("NT_FILE (mapped files)");
16354 return _("NT_VERSION (version)");
16356 return _("NT_ARCH (architecture)");
16357 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16358 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16359 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16360 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16365 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16370 print_core_note (Elf_Internal_Note
*pnote
)
16372 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16373 bfd_vma count
, page_size
;
16374 unsigned char *descdata
, *filenames
, *descend
;
16376 if (pnote
->type
!= NT_FILE
)
16386 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16387 /* Still "successful". */
16392 if (pnote
->descsz
< 2 * addr_size
)
16394 error (_(" Malformed note - too short for header\n"));
16398 descdata
= (unsigned char *) pnote
->descdata
;
16399 descend
= descdata
+ pnote
->descsz
;
16401 if (descdata
[pnote
->descsz
- 1] != '\0')
16403 error (_(" Malformed note - does not end with \\0\n"));
16407 count
= byte_get (descdata
, addr_size
);
16408 descdata
+= addr_size
;
16410 page_size
= byte_get (descdata
, addr_size
);
16411 descdata
+= addr_size
;
16413 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16414 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16416 error (_(" Malformed note - too short for supplied file count\n"));
16420 printf (_(" Page size: "));
16421 print_vma (page_size
, DEC
);
16424 printf (_(" %*s%*s%*s\n"),
16425 (int) (2 + 2 * addr_size
), _("Start"),
16426 (int) (4 + 2 * addr_size
), _("End"),
16427 (int) (4 + 2 * addr_size
), _("Page Offset"));
16428 filenames
= descdata
+ count
* 3 * addr_size
;
16429 while (count
-- > 0)
16431 bfd_vma start
, end
, file_ofs
;
16433 if (filenames
== descend
)
16435 error (_(" Malformed note - filenames end too early\n"));
16439 start
= byte_get (descdata
, addr_size
);
16440 descdata
+= addr_size
;
16441 end
= byte_get (descdata
, addr_size
);
16442 descdata
+= addr_size
;
16443 file_ofs
= byte_get (descdata
, addr_size
);
16444 descdata
+= addr_size
;
16447 print_vma (start
, FULL_HEX
);
16449 print_vma (end
, FULL_HEX
);
16451 print_vma (file_ofs
, FULL_HEX
);
16452 printf ("\n %s\n", filenames
);
16454 filenames
+= 1 + strlen ((char *) filenames
);
16460 static const char *
16461 get_gnu_elf_note_type (unsigned e_type
)
16463 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16466 case NT_GNU_ABI_TAG
:
16467 return _("NT_GNU_ABI_TAG (ABI version tag)");
16469 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16470 case NT_GNU_BUILD_ID
:
16471 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16472 case NT_GNU_GOLD_VERSION
:
16473 return _("NT_GNU_GOLD_VERSION (gold version)");
16474 case NT_GNU_PROPERTY_TYPE_0
:
16475 return _("NT_GNU_PROPERTY_TYPE_0");
16476 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16477 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16478 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16479 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16482 static char buff
[64];
16484 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16491 decode_x86_isa (unsigned int bitmask
)
16495 unsigned int bit
= bitmask
& (- bitmask
);
16500 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16501 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16502 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16503 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16504 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16505 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16506 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16507 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16508 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16509 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16510 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16511 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16512 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16513 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16514 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16515 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16516 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16517 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16518 default: printf (_("<unknown: %x>"), bit
); break;
16526 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16530 unsigned int bit
= bitmask
& (- bitmask
);
16535 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16538 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16542 /* This should never happen. */
16546 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16549 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16553 /* This should never happen. */
16558 printf (_("<unknown: %x>"), bit
);
16567 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16569 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16570 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16571 unsigned int size
= is_32bit_elf
? 4 : 8;
16573 printf (_(" Properties: "));
16575 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16577 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16581 while (ptr
< ptr_end
)
16585 unsigned int datasz
;
16587 if ((size_t) (ptr_end
- ptr
) < 8)
16589 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16593 type
= byte_get (ptr
, 4);
16594 datasz
= byte_get (ptr
+ 4, 4);
16598 if (datasz
> (size_t) (ptr_end
- ptr
))
16600 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16605 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16607 if (elf_header
.e_machine
== EM_X86_64
16608 || elf_header
.e_machine
== EM_IAMCU
16609 || elf_header
.e_machine
== EM_386
)
16613 case GNU_PROPERTY_X86_ISA_1_USED
:
16614 printf ("x86 ISA used: ");
16616 printf (_("<corrupt length: %#x> "), datasz
);
16618 decode_x86_isa (byte_get (ptr
, 4));
16621 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16622 printf ("x86 ISA needed: ");
16624 printf (_("<corrupt length: %#x> "), datasz
);
16626 decode_x86_isa (byte_get (ptr
, 4));
16629 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16630 printf ("x86 feature: ");
16632 printf (_("<corrupt length: %#x> "), datasz
);
16634 decode_x86_feature (type
, byte_get (ptr
, 4));
16646 case GNU_PROPERTY_STACK_SIZE
:
16647 printf (_("stack size: "));
16648 if (datasz
!= size
)
16649 printf (_("<corrupt length: %#x> "), datasz
);
16651 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16654 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16655 printf ("no copy on protected ");
16657 printf (_("<corrupt length: %#x> "), datasz
);
16665 if (type
< GNU_PROPERTY_LOPROC
)
16666 printf (_("<unknown type %#x data: "), type
);
16667 else if (type
< GNU_PROPERTY_LOUSER
)
16668 printf (_("<procesor-specific type %#x data: "), type
);
16670 printf (_("<application-specific type %#x data: "), type
);
16671 for (j
= 0; j
< datasz
; ++j
)
16672 printf ("%02x ", ptr
[j
] & 0xff);
16676 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16677 if (ptr
== ptr_end
)
16690 print_gnu_note (Elf_Internal_Note
*pnote
)
16692 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16693 switch (pnote
->type
)
16695 case NT_GNU_BUILD_ID
:
16699 printf (_(" Build ID: "));
16700 for (i
= 0; i
< pnote
->descsz
; ++i
)
16701 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16706 case NT_GNU_ABI_TAG
:
16708 unsigned long os
, major
, minor
, subminor
;
16709 const char *osname
;
16711 /* PR 17531: file: 030-599401-0.004. */
16712 if (pnote
->descsz
< 16)
16714 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16718 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16719 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16720 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16721 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16725 case GNU_ABI_TAG_LINUX
:
16728 case GNU_ABI_TAG_HURD
:
16731 case GNU_ABI_TAG_SOLARIS
:
16732 osname
= "Solaris";
16734 case GNU_ABI_TAG_FREEBSD
:
16735 osname
= "FreeBSD";
16737 case GNU_ABI_TAG_NETBSD
:
16740 case GNU_ABI_TAG_SYLLABLE
:
16741 osname
= "Syllable";
16743 case GNU_ABI_TAG_NACL
:
16747 osname
= "Unknown";
16751 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16752 major
, minor
, subminor
);
16756 case NT_GNU_GOLD_VERSION
:
16760 printf (_(" Version: "));
16761 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16762 printf ("%c", pnote
->descdata
[i
]);
16769 unsigned long num_entries
, mask
;
16771 /* Hardware capabilities information. Word 0 is the number of entries.
16772 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16773 is a series of entries, where each entry is a single byte followed
16774 by a nul terminated string. The byte gives the bit number to test
16775 if enabled in the bitmask. */
16776 printf (_(" Hardware Capabilities: "));
16777 if (pnote
->descsz
< 8)
16779 error (_("<corrupt GNU_HWCAP>\n"));
16782 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16783 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16784 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16785 /* FIXME: Add code to display the entries... */
16789 case NT_GNU_PROPERTY_TYPE_0
:
16790 print_gnu_property_note (pnote
);
16794 /* Handle unrecognised types. An error message should have already been
16795 created by get_gnu_elf_note_type(), so all that we need to do is to
16796 display the data. */
16800 printf (_(" Description data: "));
16801 for (i
= 0; i
< pnote
->descsz
; ++i
)
16802 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16811 static const char *
16812 get_v850_elf_note_type (enum v850_notes n_type
)
16814 static char buff
[64];
16818 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16819 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16820 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16821 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16822 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16823 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16825 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16831 print_v850_note (Elf_Internal_Note
* pnote
)
16835 if (pnote
->descsz
!= 4)
16838 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16842 printf (_("not set\n"));
16846 switch (pnote
->type
)
16848 case V850_NOTE_ALIGNMENT
:
16851 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16852 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16856 case V850_NOTE_DATA_SIZE
:
16859 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16860 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16864 case V850_NOTE_FPU_INFO
:
16867 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16868 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16872 case V850_NOTE_MMU_INFO
:
16873 case V850_NOTE_CACHE_INFO
:
16874 case V850_NOTE_SIMD_INFO
:
16875 if (val
== EF_RH850_SIMD
)
16877 printf (_("yes\n"));
16883 /* An 'unknown note type' message will already have been displayed. */
16887 printf (_("unknown value: %x\n"), val
);
16892 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16894 unsigned int version
;
16896 switch (pnote
->type
)
16898 case NT_NETBSD_IDENT
:
16899 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16900 if ((version
/ 10000) % 100)
16901 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16902 version
, version
/ 100000000, (version
/ 1000000) % 100,
16903 (version
/ 10000) % 100 > 26 ? "Z" : "",
16904 'A' + (version
/ 10000) % 26);
16906 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16907 version
, version
/ 100000000, (version
/ 1000000) % 100,
16908 (version
/ 100) % 100);
16911 case NT_NETBSD_MARCH
:
16912 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16917 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16923 static const char *
16924 get_freebsd_elfcore_note_type (unsigned e_type
)
16928 case NT_FREEBSD_THRMISC
:
16929 return _("NT_THRMISC (thrmisc structure)");
16930 case NT_FREEBSD_PROCSTAT_PROC
:
16931 return _("NT_PROCSTAT_PROC (proc data)");
16932 case NT_FREEBSD_PROCSTAT_FILES
:
16933 return _("NT_PROCSTAT_FILES (files data)");
16934 case NT_FREEBSD_PROCSTAT_VMMAP
:
16935 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16936 case NT_FREEBSD_PROCSTAT_GROUPS
:
16937 return _("NT_PROCSTAT_GROUPS (groups data)");
16938 case NT_FREEBSD_PROCSTAT_UMASK
:
16939 return _("NT_PROCSTAT_UMASK (umask data)");
16940 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16941 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16942 case NT_FREEBSD_PROCSTAT_OSREL
:
16943 return _("NT_PROCSTAT_OSREL (osreldate data)");
16944 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16945 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16946 case NT_FREEBSD_PROCSTAT_AUXV
:
16947 return _("NT_PROCSTAT_AUXV (auxv data)");
16948 case NT_FREEBSD_PTLWPINFO
:
16949 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16951 return get_note_type (e_type
);
16954 static const char *
16955 get_netbsd_elfcore_note_type (unsigned e_type
)
16957 static char buff
[64];
16959 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16961 /* NetBSD core "procinfo" structure. */
16962 return _("NetBSD procinfo structure");
16965 /* As of Jan 2002 there are no other machine-independent notes
16966 defined for NetBSD core files. If the note type is less
16967 than the start of the machine-dependent note types, we don't
16970 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16972 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16976 switch (elf_header
.e_machine
)
16978 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16979 and PT_GETFPREGS == mach+2. */
16984 case EM_SPARC32PLUS
:
16988 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16989 return _("PT_GETREGS (reg structure)");
16990 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16991 return _("PT_GETFPREGS (fpreg structure)");
16997 /* On all other arch's, PT_GETREGS == mach+1 and
16998 PT_GETFPREGS == mach+3. */
17002 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17003 return _("PT_GETREGS (reg structure)");
17004 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17005 return _("PT_GETFPREGS (fpreg structure)");
17011 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17012 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17016 static const char *
17017 get_stapsdt_note_type (unsigned e_type
)
17019 static char buff
[64];
17024 return _("NT_STAPSDT (SystemTap probe descriptors)");
17030 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17035 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17037 int addr_size
= is_32bit_elf
? 4 : 8;
17038 char *data
= pnote
->descdata
;
17039 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17040 bfd_vma pc
, base_addr
, semaphore
;
17041 char *provider
, *probe
, *arg_fmt
;
17043 pc
= byte_get ((unsigned char *) data
, addr_size
);
17045 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17047 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17051 data
+= strlen (data
) + 1;
17053 data
+= strlen (data
) + 1;
17055 data
+= strlen (data
) + 1;
17057 printf (_(" Provider: %s\n"), provider
);
17058 printf (_(" Name: %s\n"), probe
);
17059 printf (_(" Location: "));
17060 print_vma (pc
, FULL_HEX
);
17061 printf (_(", Base: "));
17062 print_vma (base_addr
, FULL_HEX
);
17063 printf (_(", Semaphore: "));
17064 print_vma (semaphore
, FULL_HEX
);
17066 printf (_(" Arguments: %s\n"), arg_fmt
);
17068 return data
== data_end
;
17071 static const char *
17072 get_ia64_vms_note_type (unsigned e_type
)
17074 static char buff
[64];
17079 return _("NT_VMS_MHD (module header)");
17081 return _("NT_VMS_LNM (language name)");
17083 return _("NT_VMS_SRC (source files)");
17085 return "NT_VMS_TITLE";
17087 return _("NT_VMS_EIDC (consistency check)");
17088 case NT_VMS_FPMODE
:
17089 return _("NT_VMS_FPMODE (FP mode)");
17090 case NT_VMS_LINKTIME
:
17091 return "NT_VMS_LINKTIME";
17092 case NT_VMS_IMGNAM
:
17093 return _("NT_VMS_IMGNAM (image name)");
17095 return _("NT_VMS_IMGID (image id)");
17096 case NT_VMS_LINKID
:
17097 return _("NT_VMS_LINKID (link id)");
17098 case NT_VMS_IMGBID
:
17099 return _("NT_VMS_IMGBID (build id)");
17100 case NT_VMS_GSTNAM
:
17101 return _("NT_VMS_GSTNAM (sym table name)");
17102 case NT_VMS_ORIG_DYN
:
17103 return "NT_VMS_ORIG_DYN";
17104 case NT_VMS_PATCHTIME
:
17105 return "NT_VMS_PATCHTIME";
17107 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17113 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17115 switch (pnote
->type
)
17118 if (pnote
->descsz
> 36)
17120 size_t l
= strlen (pnote
->descdata
+ 34);
17121 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17122 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17123 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17124 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17127 printf (_(" Invalid size\n"));
17130 printf (_(" Language: %s\n"), pnote
->descdata
);
17133 case NT_VMS_FPMODE
:
17134 printf (_(" Floating Point mode: "));
17135 printf ("0x%016" BFD_VMA_FMT
"x\n",
17136 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17138 case NT_VMS_LINKTIME
:
17139 printf (_(" Link time: "));
17141 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17144 case NT_VMS_PATCHTIME
:
17145 printf (_(" Patch time: "));
17147 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17150 case NT_VMS_ORIG_DYN
:
17151 printf (_(" Major id: %u, minor id: %u\n"),
17152 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17153 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17154 printf (_(" Last modified : "));
17156 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17157 printf (_("\n Link flags : "));
17158 printf ("0x%016" BFD_VMA_FMT
"x\n",
17159 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17160 printf (_(" Header flags: 0x%08x\n"),
17161 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17162 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17165 case NT_VMS_IMGNAM
:
17166 printf (_(" Image name: %s\n"), pnote
->descdata
);
17168 case NT_VMS_GSTNAM
:
17169 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17172 printf (_(" Image id: %s\n"), pnote
->descdata
);
17174 case NT_VMS_LINKID
:
17175 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17183 /* Print the name of the symbol associated with a build attribute
17184 that is attached to address OFFSET. */
17187 print_symbol_for_build_attribute (FILE * file
,
17188 unsigned long offset
,
17189 bfd_boolean is_open_attr
)
17191 static FILE * saved_file
= NULL
;
17192 static char * strtab
;
17193 static unsigned long strtablen
;
17194 static Elf_Internal_Sym
* symtab
;
17195 static unsigned long nsyms
;
17196 Elf_Internal_Sym
* saved_sym
= NULL
;
17197 Elf_Internal_Sym
* sym
;
17199 if (section_headers
!= NULL
17200 && (saved_file
== NULL
|| file
!= saved_file
))
17202 Elf_Internal_Shdr
* symsec
;
17204 /* Load the symbol and string sections. */
17205 for (symsec
= section_headers
;
17206 symsec
< section_headers
+ elf_header
.e_shnum
;
17209 if (symsec
->sh_type
== SHT_SYMTAB
)
17211 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17213 if (symsec
->sh_link
< elf_header
.e_shnum
)
17215 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17217 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17218 1, strtab_sec
->sh_size
,
17219 _("string table"));
17220 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17227 if (symtab
== NULL
|| strtab
== NULL
)
17233 /* Find a symbol whose value matches offset. */
17234 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17235 if (sym
->st_value
== offset
)
17237 if (sym
->st_name
>= strtablen
)
17238 /* Huh ? This should not happen. */
17241 if (strtab
[sym
->st_name
] == 0)
17246 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17247 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17248 FUNC symbols entirely. */
17249 switch (ELF_ST_TYPE (sym
->st_info
))
17253 /* We can stop searching now. */
17254 sym
= symtab
+ nsyms
;
17262 /* Ignore function symbols. */
17269 switch (ELF_ST_BIND (sym
->st_info
))
17272 if (saved_sym
== NULL
17273 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17278 if (saved_sym
== NULL
)
17288 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17296 printf (" (%s: %s)\n",
17297 is_open_attr
? _("file") : _("func"),
17298 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17303 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17306 static unsigned long global_offset
= 0;
17307 unsigned long offset
;
17308 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17309 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17311 if (pnote
->descsz
== 0)
17315 printf (_(" Applies from offset %#lx\n"), global_offset
);
17320 printf (_(" Applies to func at %#lx"), global_offset
);
17321 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17325 if (pnote
->descsz
!= desc_size
)
17327 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17328 printf (_(" <invalid descsz>"));
17332 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17336 printf (_(" Applies from offset %#lx"), offset
);
17337 global_offset
= offset
;
17341 printf (_(" Applies to func at %#lx"), offset
);
17344 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17348 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17350 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17351 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17352 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17354 char name_attribute
;
17355 const char * expected_types
;
17356 const char * name
= pnote
->namedata
;
17360 if (name
== NULL
|| pnote
->namesz
< 2)
17362 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17363 print_symbol (-20, _(" <corrupt name>"));
17369 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17370 if (name
[0] == 'G' && name
[1] == 'A')
17377 switch ((name_type
= * name
))
17379 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17380 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17381 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17382 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17383 printf ("%c", * name
);
17387 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17388 print_symbol (-20, _("<unknown name type>"));
17395 switch ((name_attribute
= * name
))
17397 case GNU_BUILD_ATTRIBUTE_VERSION
:
17398 text
= _("<version>");
17399 expected_types
= string_expected
;
17402 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17403 text
= _("<stack prot>");
17404 expected_types
= "!+*";
17407 case GNU_BUILD_ATTRIBUTE_RELRO
:
17408 text
= _("<relro>");
17409 expected_types
= bool_expected
;
17412 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17413 text
= _("<stack size>");
17414 expected_types
= number_expected
;
17417 case GNU_BUILD_ATTRIBUTE_TOOL
:
17418 text
= _("<tool>");
17419 expected_types
= string_expected
;
17422 case GNU_BUILD_ATTRIBUTE_ABI
:
17424 expected_types
= "$*";
17427 case GNU_BUILD_ATTRIBUTE_PIC
:
17429 expected_types
= number_expected
;
17432 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17433 text
= _("<short enum>");
17434 expected_types
= bool_expected
;
17438 if (ISPRINT (* name
))
17440 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17442 if (len
> left
&& ! do_wide
)
17444 printf ("%.*s:", len
, name
);
17450 static char tmpbuf
[128];
17452 error (_("unrecognised byte in name field: %d\n"), * name
);
17453 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17457 expected_types
= "*$!+";
17462 left
-= printf ("%s", text
);
17464 if (strchr (expected_types
, name_type
) == NULL
)
17465 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17467 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17469 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17470 (unsigned long) pnote
->namesz
,
17471 (long) (name
- pnote
->namedata
));
17475 if (left
< 1 && ! do_wide
)
17480 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17482 unsigned int bytes
;
17483 unsigned long long val
= 0;
17484 unsigned int shift
= 0;
17485 char * decoded
= NULL
;
17487 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17489 /* The -1 is because the name field is always 0 terminated, and we
17490 want to be able to ensure that the shift in the while loop below
17491 will not overflow. */
17494 if (bytes
> sizeof (val
))
17496 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17497 pnote
->namesz
, name
, pnote
->namedata
);
17498 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17500 bytes
= sizeof (val
);
17502 /* We do not bother to warn if bytes == 0 as this can
17503 happen with some early versions of the gcc plugin. */
17507 unsigned long byte
= (* name
++) & 0xff;
17509 val
|= byte
<< shift
;
17513 switch (name_attribute
)
17515 case GNU_BUILD_ATTRIBUTE_PIC
:
17518 case 0: decoded
= "static"; break;
17519 case 1: decoded
= "pic"; break;
17520 case 2: decoded
= "PIC"; break;
17521 case 3: decoded
= "pie"; break;
17522 case 4: decoded
= "PIE"; break;
17526 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17529 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17530 case 0: decoded
= "off"; break;
17531 case 1: decoded
= "on"; break;
17532 case 2: decoded
= "all"; break;
17533 case 3: decoded
= "strong"; break;
17534 case 4: decoded
= "explicit"; break;
17542 if (decoded
!= NULL
)
17544 print_symbol (-left
, decoded
);
17555 left
-= printf ("0x%llx", val
);
17557 left
-= printf ("0x%-.*llx", left
, val
);
17561 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17562 left
-= print_symbol (- left
, name
);
17564 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17565 left
-= print_symbol (- left
, "true");
17567 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17568 left
-= print_symbol (- left
, "false");
17572 if (do_wide
&& left
> 0)
17573 printf ("%-*s", left
, " ");
17578 /* Note that by the ELF standard, the name field is already null byte
17579 terminated, and namesz includes the terminating null byte.
17580 I.E. the value of namesz for the name "FSF" is 4.
17582 If the value of namesz is zero, there is no name present. */
17585 process_note (Elf_Internal_Note
* pnote
,
17588 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17591 if (pnote
->namesz
== 0)
17592 /* If there is no note name, then use the default set of
17593 note type strings. */
17594 nt
= get_note_type (pnote
->type
);
17596 else if (const_strneq (pnote
->namedata
, "GNU"))
17597 /* GNU-specific object file notes. */
17598 nt
= get_gnu_elf_note_type (pnote
->type
);
17600 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17601 /* FreeBSD-specific core file notes. */
17602 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17604 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17605 /* NetBSD-specific core file notes. */
17606 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17608 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17609 /* NetBSD-specific core file notes. */
17610 return process_netbsd_elf_note (pnote
);
17612 else if (strneq (pnote
->namedata
, "SPU/", 4))
17614 /* SPU-specific core file notes. */
17615 nt
= pnote
->namedata
+ 4;
17619 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17620 /* VMS/ia64-specific file notes. */
17621 nt
= get_ia64_vms_note_type (pnote
->type
);
17623 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17624 nt
= get_stapsdt_note_type (pnote
->type
);
17627 /* Don't recognize this note name; just use the default set of
17628 note type strings. */
17629 nt
= get_note_type (pnote
->type
);
17633 if (((const_strneq (pnote
->namedata
, "GA")
17634 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17635 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17636 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17637 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17638 print_gnu_build_attribute_name (pnote
);
17640 print_symbol (-20, name
);
17643 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17645 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17647 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17648 return print_ia64_vms_note (pnote
);
17649 else if (const_strneq (pnote
->namedata
, "GNU"))
17650 return print_gnu_note (pnote
);
17651 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17652 return print_stapsdt_note (pnote
);
17653 else if (const_strneq (pnote
->namedata
, "CORE"))
17654 return print_core_note (pnote
);
17655 else if (((const_strneq (pnote
->namedata
, "GA")
17656 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17657 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17658 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17659 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17660 return print_gnu_build_attribute_description (pnote
, file
);
17666 printf (_(" description data: "));
17667 for (i
= 0; i
< pnote
->descsz
; i
++)
17668 printf ("%02x ", pnote
->descdata
[i
]);
17680 process_notes_at (FILE * file
,
17681 Elf_Internal_Shdr
* section
,
17685 Elf_External_Note
* pnotes
;
17686 Elf_External_Note
* external
;
17688 bfd_boolean res
= TRUE
;
17695 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17698 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17703 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17705 if (pnotes
== NULL
)
17711 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17713 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17714 (unsigned long) offset
, (unsigned long) length
);
17716 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17718 end
= (char *) pnotes
+ length
;
17719 while ((char *) external
< end
)
17721 Elf_Internal_Note inote
;
17724 char * temp
= NULL
;
17725 size_t data_remaining
= end
- (char *) external
;
17727 if (!is_ia64_vms ())
17729 /* PR binutils/15191
17730 Make sure that there is enough data to read. */
17731 min_notesz
= offsetof (Elf_External_Note
, name
);
17732 if (data_remaining
< min_notesz
)
17734 warn (ngettext ("Corrupt note: only %ld byte remains, "
17735 "not enough for a full note\n",
17736 "Corrupt note: only %ld bytes remain, "
17737 "not enough for a full note\n",
17739 (long) data_remaining
);
17742 data_remaining
-= min_notesz
;
17744 inote
.type
= BYTE_GET (external
->type
);
17745 inote
.namesz
= BYTE_GET (external
->namesz
);
17746 inote
.namedata
= external
->name
;
17747 inote
.descsz
= BYTE_GET (external
->descsz
);
17748 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17749 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17750 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17754 Elf64_External_VMS_Note
*vms_external
;
17756 /* PR binutils/15191
17757 Make sure that there is enough data to read. */
17758 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17759 if (data_remaining
< min_notesz
)
17761 warn (ngettext ("Corrupt note: only %ld byte remains, "
17762 "not enough for a full note\n",
17763 "Corrupt note: only %ld bytes remain, "
17764 "not enough for a full note\n",
17766 (long) data_remaining
);
17769 data_remaining
-= min_notesz
;
17771 vms_external
= (Elf64_External_VMS_Note
*) external
;
17772 inote
.type
= BYTE_GET (vms_external
->type
);
17773 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17774 inote
.namedata
= vms_external
->name
;
17775 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17776 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17777 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17778 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17781 /* PR 17531: file: 3443835e. */
17782 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17783 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
17784 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
17785 || (size_t) (next
- inote
.descdata
) < inote
.descsz
17786 || ((size_t) (next
- inote
.descdata
)
17787 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
17789 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17790 (unsigned long) ((char *) external
- (char *) pnotes
));
17791 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17792 inote
.type
, inote
.namesz
, inote
.descsz
);
17796 external
= (Elf_External_Note
*) next
;
17798 /* Verify that name is null terminated. It appears that at least
17799 one version of Linux (RedHat 6.0) generates corefiles that don't
17800 comply with the ELF spec by failing to include the null byte in
17802 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17804 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
17806 temp
= (char *) malloc (inote
.namesz
+ 1);
17809 error (_("Out of memory allocating space for inote name\n"));
17814 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17815 inote
.namedata
= temp
;
17817 inote
.namedata
[inote
.namesz
] = 0;
17820 if (! process_note (& inote
, file
))
17836 process_corefile_note_segments (FILE * file
)
17838 Elf_Internal_Phdr
* segment
;
17840 bfd_boolean res
= TRUE
;
17842 if (! get_program_headers (file
))
17845 for (i
= 0, segment
= program_headers
;
17846 i
< elf_header
.e_phnum
;
17849 if (segment
->p_type
== PT_NOTE
)
17850 if (! process_notes_at (file
, NULL
,
17851 (bfd_vma
) segment
->p_offset
,
17852 (bfd_vma
) segment
->p_filesz
))
17860 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17862 Elf_External_Note
* pnotes
;
17863 Elf_External_Note
* external
;
17865 bfd_boolean res
= TRUE
;
17870 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17872 if (pnotes
== NULL
)
17876 end
= (char*) pnotes
+ length
;
17878 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17879 (unsigned long) offset
, (unsigned long) length
);
17881 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17883 Elf_External_Note
* next
;
17884 Elf_Internal_Note inote
;
17886 inote
.type
= BYTE_GET (external
->type
);
17887 inote
.namesz
= BYTE_GET (external
->namesz
);
17888 inote
.namedata
= external
->name
;
17889 inote
.descsz
= BYTE_GET (external
->descsz
);
17890 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17891 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17893 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17895 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17896 inote
.descdata
= inote
.namedata
;
17900 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17902 if ( ((char *) next
> end
)
17903 || ((char *) next
< (char *) pnotes
))
17905 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17906 (unsigned long) ((char *) external
- (char *) pnotes
));
17907 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17908 inote
.type
, inote
.namesz
, inote
.descsz
);
17914 /* Prevent out-of-bounds indexing. */
17915 if ( inote
.namedata
+ inote
.namesz
> end
17916 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17918 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17919 (unsigned long) ((char *) external
- (char *) pnotes
));
17920 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17921 inote
.type
, inote
.namesz
, inote
.descsz
);
17925 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17927 if (! print_v850_note (& inote
))
17930 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17931 inote
.namesz
, inote
.descsz
);
17941 process_note_sections (FILE * file
)
17943 Elf_Internal_Shdr
* section
;
17945 unsigned int n
= 0;
17946 bfd_boolean res
= TRUE
;
17948 for (i
= 0, section
= section_headers
;
17949 i
< elf_header
.e_shnum
&& section
!= NULL
;
17952 if (section
->sh_type
== SHT_NOTE
)
17954 if (! process_notes_at (file
, section
,
17955 (bfd_vma
) section
->sh_offset
,
17956 (bfd_vma
) section
->sh_size
))
17961 if (( elf_header
.e_machine
== EM_V800
17962 || elf_header
.e_machine
== EM_V850
17963 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17964 && section
->sh_type
== SHT_RENESAS_INFO
)
17966 if (! process_v850_notes (file
,
17967 (bfd_vma
) section
->sh_offset
,
17968 (bfd_vma
) section
->sh_size
))
17975 /* Try processing NOTE segments instead. */
17976 return process_corefile_note_segments (file
);
17982 process_notes (FILE * file
)
17984 /* If we have not been asked to display the notes then do nothing. */
17988 if (elf_header
.e_type
!= ET_CORE
)
17989 return process_note_sections (file
);
17991 /* No program headers means no NOTE segment. */
17992 if (elf_header
.e_phnum
> 0)
17993 return process_corefile_note_segments (file
);
17995 printf (_("No note segments present in the core file.\n"));
17999 static unsigned char *
18000 display_public_gnu_attributes (unsigned char * start
,
18001 const unsigned char * const end
)
18003 printf (_(" Unknown GNU attribute: %s\n"), start
);
18005 start
+= strnlen ((char *) start
, end
- start
);
18006 display_raw_attribute (start
, end
);
18008 return (unsigned char *) end
;
18011 static unsigned char *
18012 display_generic_attribute (unsigned char * start
,
18014 const unsigned char * const end
)
18017 return (unsigned char *) end
;
18019 return display_tag_value (tag
, start
, end
);
18023 process_arch_specific (FILE * file
)
18028 switch (elf_header
.e_machine
)
18031 case EM_ARC_COMPACT
:
18032 case EM_ARC_COMPACT2
:
18033 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
18034 display_arc_attribute
,
18035 display_generic_attribute
);
18037 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
18038 display_arm_attribute
,
18039 display_generic_attribute
);
18042 case EM_MIPS_RS3_LE
:
18043 return process_mips_specific (file
);
18046 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18047 display_msp430x_attribute
,
18048 display_generic_attribute
);
18051 return process_nds32_specific (file
);
18055 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18056 display_power_gnu_attribute
);
18060 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18061 display_s390_gnu_attribute
);
18064 case EM_SPARC32PLUS
:
18066 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18067 display_sparc_gnu_attribute
);
18070 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18071 display_tic6x_attribute
,
18072 display_generic_attribute
);
18075 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
18076 display_public_gnu_attributes
,
18077 display_generic_attribute
);
18082 get_file_header (FILE * file
)
18084 /* Read in the identity array. */
18085 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
18088 /* Determine how to read the rest of the header. */
18089 switch (elf_header
.e_ident
[EI_DATA
])
18094 byte_get
= byte_get_little_endian
;
18095 byte_put
= byte_put_little_endian
;
18098 byte_get
= byte_get_big_endian
;
18099 byte_put
= byte_put_big_endian
;
18103 /* For now we only support 32 bit and 64 bit ELF files. */
18104 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18106 /* Read in the rest of the header. */
18109 Elf32_External_Ehdr ehdr32
;
18111 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
18114 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18115 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18116 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18117 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18118 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18119 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18120 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18121 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18122 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18123 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18124 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18125 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18126 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18130 Elf64_External_Ehdr ehdr64
;
18132 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18133 we will not be able to cope with the 64bit data found in
18134 64 ELF files. Detect this now and abort before we start
18135 overwriting things. */
18136 if (sizeof (bfd_vma
) < 8)
18138 error (_("This instance of readelf has been built without support for a\n\
18139 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18143 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
18146 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18147 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18148 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18149 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18150 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18151 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18152 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18153 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18154 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18155 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18156 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18157 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18158 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18161 if (elf_header
.e_shoff
)
18163 /* There may be some extensions in the first section header. Don't
18164 bomb if we can't read it. */
18166 get_32bit_section_headers (file
, TRUE
);
18168 get_64bit_section_headers (file
, TRUE
);
18174 /* Process one ELF object file according to the command line options.
18175 This file may actually be stored in an archive. The file is
18176 positioned at the start of the ELF object. Returns TRUE if no
18177 problems were encountered, FALSE otherwise. */
18180 process_object (char * file_name
, FILE * file
)
18183 bfd_boolean res
= TRUE
;
18185 if (! get_file_header (file
))
18187 error (_("%s: Failed to read file header\n"), file_name
);
18191 /* Initialise per file variables. */
18192 for (i
= ARRAY_SIZE (version_info
); i
--;)
18193 version_info
[i
] = 0;
18195 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18196 dynamic_info
[i
] = 0;
18197 dynamic_info_DT_GNU_HASH
= 0;
18199 /* Process the file. */
18201 printf (_("\nFile: %s\n"), file_name
);
18203 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18204 Note we do this even if cmdline_dump_sects is empty because we
18205 must make sure that the dump_sets array is zeroed out before each
18206 object file is processed. */
18207 if (num_dump_sects
> num_cmdline_dump_sects
)
18208 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18210 if (num_cmdline_dump_sects
> 0)
18212 if (num_dump_sects
== 0)
18213 /* A sneaky way of allocating the dump_sects array. */
18214 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18216 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18217 memcpy (dump_sects
, cmdline_dump_sects
,
18218 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18221 if (! process_file_header ())
18224 if (! process_section_headers (file
))
18226 /* Without loaded section headers we cannot process lots of things. */
18227 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18229 if (! do_using_dynamic
)
18230 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18233 if (! process_section_groups (file
))
18234 /* Without loaded section groups we cannot process unwind. */
18237 if (process_program_headers (file
))
18238 process_dynamic_section (file
);
18242 if (! process_relocs (file
))
18245 if (! process_unwind (file
))
18248 if (! process_symbol_table (file
))
18251 if (! process_syminfo (file
))
18254 if (! process_version_sections (file
))
18257 if (! process_section_contents (file
))
18260 if (! process_notes (file
))
18263 if (! process_gnu_liblist (file
))
18266 if (! process_arch_specific (file
))
18269 if (program_headers
)
18271 free (program_headers
);
18272 program_headers
= NULL
;
18275 if (section_headers
)
18277 free (section_headers
);
18278 section_headers
= NULL
;
18283 free (string_table
);
18284 string_table
= NULL
;
18285 string_table_length
= 0;
18288 if (dynamic_strings
)
18290 free (dynamic_strings
);
18291 dynamic_strings
= NULL
;
18292 dynamic_strings_length
= 0;
18295 if (dynamic_symbols
)
18297 free (dynamic_symbols
);
18298 dynamic_symbols
= NULL
;
18299 num_dynamic_syms
= 0;
18302 if (dynamic_syminfo
)
18304 free (dynamic_syminfo
);
18305 dynamic_syminfo
= NULL
;
18308 if (dynamic_section
)
18310 free (dynamic_section
);
18311 dynamic_section
= NULL
;
18314 if (section_headers_groups
)
18316 free (section_headers_groups
);
18317 section_headers_groups
= NULL
;
18320 if (section_groups
)
18322 struct group_list
* g
;
18323 struct group_list
* next
;
18325 for (i
= 0; i
< group_count
; i
++)
18327 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18334 free (section_groups
);
18335 section_groups
= NULL
;
18338 free_debug_memory ();
18343 /* Process an ELF archive.
18344 On entry the file is positioned just after the ARMAG string.
18345 Returns TRUE upon success, FALSE otherwise. */
18348 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18350 struct archive_info arch
;
18351 struct archive_info nested_arch
;
18353 bfd_boolean ret
= TRUE
;
18357 /* The ARCH structure is used to hold information about this archive. */
18358 arch
.file_name
= NULL
;
18360 arch
.index_array
= NULL
;
18361 arch
.sym_table
= NULL
;
18362 arch
.longnames
= NULL
;
18364 /* The NESTED_ARCH structure is used as a single-item cache of information
18365 about a nested archive (when members of a thin archive reside within
18366 another regular archive file). */
18367 nested_arch
.file_name
= NULL
;
18368 nested_arch
.file
= NULL
;
18369 nested_arch
.index_array
= NULL
;
18370 nested_arch
.sym_table
= NULL
;
18371 nested_arch
.longnames
= NULL
;
18373 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18379 if (do_archive_index
)
18381 if (arch
.sym_table
== NULL
)
18382 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18385 unsigned long i
, l
;
18386 unsigned long current_pos
;
18388 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18389 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18390 current_pos
= ftell (file
);
18392 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18394 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18396 char * member_name
;
18398 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18400 if (member_name
!= NULL
)
18402 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18404 if (qualified_name
!= NULL
)
18406 printf (_("Contents of binary %s at offset "), qualified_name
);
18407 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18409 free (qualified_name
);
18414 if (l
>= arch
.sym_size
)
18416 error (_("%s: end of the symbol table reached before the end of the index\n"),
18421 /* PR 17531: file: 0b6630b2. */
18422 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18423 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18426 if (arch
.uses_64bit_indicies
)
18431 if (l
< arch
.sym_size
)
18433 error (ngettext ("%s: %ld byte remains in the symbol table, "
18434 "but without corresponding entries in "
18435 "the index table\n",
18436 "%s: %ld bytes remain in the symbol table, "
18437 "but without corresponding entries in "
18438 "the index table\n",
18439 arch
.sym_size
- l
),
18440 file_name
, arch
.sym_size
- l
);
18444 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18446 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18452 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18453 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18454 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18455 && !do_section_groups
&& !do_dyn_syms
)
18457 ret
= TRUE
; /* Archive index only. */
18466 char * qualified_name
;
18468 /* Read the next archive header. */
18469 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18471 error (_("%s: failed to seek to next archive header\n"), file_name
);
18474 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18475 if (got
!= sizeof arch
.arhdr
)
18479 error (_("%s: failed to read archive header\n"), file_name
);
18483 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18485 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18490 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18492 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18493 if (archive_file_size
& 01)
18494 ++archive_file_size
;
18496 name
= get_archive_member_name (&arch
, &nested_arch
);
18499 error (_("%s: bad archive file name\n"), file_name
);
18503 namelen
= strlen (name
);
18505 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18506 if (qualified_name
== NULL
)
18508 error (_("%s: bad archive file name\n"), file_name
);
18513 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18515 /* This is a proxy for an external member of a thin archive. */
18516 FILE * member_file
;
18517 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18519 if (member_file_name
== NULL
)
18525 member_file
= fopen (member_file_name
, "rb");
18526 if (member_file
== NULL
)
18528 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18529 free (member_file_name
);
18534 archive_file_offset
= arch
.nested_member_origin
;
18536 if (! process_object (qualified_name
, member_file
))
18539 fclose (member_file
);
18540 free (member_file_name
);
18542 else if (is_thin_archive
)
18544 /* PR 15140: Allow for corrupt thin archives. */
18545 if (nested_arch
.file
== NULL
)
18547 error (_("%s: contains corrupt thin archive: %s\n"),
18553 /* This is a proxy for a member of a nested archive. */
18554 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18556 /* The nested archive file will have been opened and setup by
18557 get_archive_member_name. */
18558 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18560 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18565 if (! process_object (qualified_name
, nested_arch
.file
))
18570 archive_file_offset
= arch
.next_arhdr_offset
;
18571 arch
.next_arhdr_offset
+= archive_file_size
;
18573 if (! process_object (qualified_name
, file
))
18577 if (dump_sects
!= NULL
)
18581 num_dump_sects
= 0;
18584 free (qualified_name
);
18588 if (nested_arch
.file
!= NULL
)
18589 fclose (nested_arch
.file
);
18590 release_archive (&nested_arch
);
18591 release_archive (&arch
);
18597 process_file (char * file_name
)
18600 struct stat statbuf
;
18601 char armag
[SARMAG
];
18602 bfd_boolean ret
= TRUE
;
18604 if (stat (file_name
, &statbuf
) < 0)
18606 if (errno
== ENOENT
)
18607 error (_("'%s': No such file\n"), file_name
);
18609 error (_("Could not locate '%s'. System error message: %s\n"),
18610 file_name
, strerror (errno
));
18614 if (! S_ISREG (statbuf
.st_mode
))
18616 error (_("'%s' is not an ordinary file\n"), file_name
);
18620 file
= fopen (file_name
, "rb");
18623 error (_("Input file '%s' is not readable.\n"), file_name
);
18627 if (fread (armag
, SARMAG
, 1, file
) != 1)
18629 error (_("%s: Failed to read file's magic number\n"), file_name
);
18634 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18636 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18638 if (! process_archive (file_name
, file
, FALSE
))
18641 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18643 if ( ! process_archive (file_name
, file
, TRUE
))
18648 if (do_archive_index
)
18649 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18653 archive_file_size
= archive_file_offset
= 0;
18655 if (! process_object (file_name
, file
))
18660 current_file_size
= 0;
18665 #ifdef SUPPORT_DISASSEMBLY
18666 /* Needed by the i386 disassembler. For extra credit, someone could
18667 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18671 print_address (unsigned int addr
, FILE * outfile
)
18673 fprintf (outfile
,"0x%8.8x", addr
);
18676 /* Needed by the i386 disassembler. */
18678 db_task_printsym (unsigned int addr
)
18680 print_address (addr
, stderr
);
18685 main (int argc
, char ** argv
)
18689 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18690 setlocale (LC_MESSAGES
, "");
18692 #if defined (HAVE_SETLOCALE)
18693 setlocale (LC_CTYPE
, "");
18695 bindtextdomain (PACKAGE
, LOCALEDIR
);
18696 textdomain (PACKAGE
);
18698 expandargv (&argc
, &argv
);
18700 parse_args (argc
, argv
);
18702 if (num_dump_sects
> 0)
18704 /* Make a copy of the dump_sects array. */
18705 cmdline_dump_sects
= (dump_type
*)
18706 malloc (num_dump_sects
* sizeof (* dump_sects
));
18707 if (cmdline_dump_sects
== NULL
)
18708 error (_("Out of memory allocating dump request table.\n"));
18711 memcpy (cmdline_dump_sects
, dump_sects
,
18712 num_dump_sects
* sizeof (* dump_sects
));
18713 num_cmdline_dump_sects
= num_dump_sects
;
18717 if (optind
< (argc
- 1))
18719 else if (optind
>= argc
)
18721 warn (_("Nothing to do.\n"));
18726 while (optind
< argc
)
18727 if (! process_file (argv
[optind
++]))
18730 if (dump_sects
!= NULL
)
18732 if (cmdline_dump_sects
!= NULL
)
18733 free (cmdline_dump_sects
);
18735 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;