1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2019 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. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
167 #include "libiberty.h"
168 #include "safe-ctype.h"
169 #include "filenames.h"
172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
175 typedef struct elf_section_list
177 Elf_Internal_Shdr
* hdr
;
178 struct elf_section_list
* next
;
181 /* Flag bits indicating particular types of dump. */
182 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
183 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
184 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
185 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
186 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
187 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189 typedef unsigned char dump_type
;
191 /* A linked list of the section names for which dumps were requested. */
192 struct dump_list_entry
196 struct dump_list_entry
* next
;
199 typedef struct filedata
201 const char * file_name
;
203 bfd_size_type file_size
;
204 Elf_Internal_Ehdr file_header
;
205 Elf_Internal_Shdr
* section_headers
;
206 Elf_Internal_Phdr
* program_headers
;
208 unsigned long string_table_length
;
209 /* A dynamic array of flags indicating for which sections a dump of
210 some kind has been requested. It is reset on a per-object file
211 basis and then initialised from the cmdline_dump_sects array,
212 the results of interpreting the -w switch, and the
213 dump_sects_byname list. */
214 dump_type
* dump_sects
;
215 unsigned int num_dump_sects
;
218 char * program_name
= "readelf";
220 static unsigned long archive_file_offset
;
221 static unsigned long archive_file_size
;
222 static unsigned long dynamic_addr
;
223 static bfd_size_type dynamic_size
;
224 static size_t dynamic_nent
;
225 static char * dynamic_strings
;
226 static unsigned long dynamic_strings_length
;
227 static unsigned long num_dynamic_syms
;
228 static Elf_Internal_Sym
* dynamic_symbols
;
229 static Elf_Internal_Syminfo
* dynamic_syminfo
;
230 static unsigned long dynamic_syminfo_offset
;
231 static unsigned int dynamic_syminfo_nent
;
232 static char program_interpreter
[PATH_MAX
];
233 static bfd_vma dynamic_info
[DT_ENCODING
];
234 static bfd_vma dynamic_info_DT_GNU_HASH
;
235 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
236 static bfd_vma version_info
[16];
237 static Elf_Internal_Dyn
* dynamic_section
;
238 static elf_section_list
* symtab_shndx_list
;
239 static bfd_boolean show_name
= FALSE
;
240 static bfd_boolean do_dynamic
= FALSE
;
241 static bfd_boolean do_syms
= FALSE
;
242 static bfd_boolean do_dyn_syms
= FALSE
;
243 static bfd_boolean do_reloc
= FALSE
;
244 static bfd_boolean do_sections
= FALSE
;
245 static bfd_boolean do_section_groups
= FALSE
;
246 static bfd_boolean do_section_details
= FALSE
;
247 static bfd_boolean do_segments
= FALSE
;
248 static bfd_boolean do_unwind
= FALSE
;
249 static bfd_boolean do_using_dynamic
= FALSE
;
250 static bfd_boolean do_header
= FALSE
;
251 static bfd_boolean do_dump
= FALSE
;
252 static bfd_boolean do_version
= FALSE
;
253 static bfd_boolean do_histogram
= FALSE
;
254 static bfd_boolean do_debugging
= FALSE
;
255 static bfd_boolean do_ctf
= FALSE
;
256 static bfd_boolean do_arch
= FALSE
;
257 static bfd_boolean do_notes
= FALSE
;
258 static bfd_boolean do_archive_index
= FALSE
;
259 static bfd_boolean is_32bit_elf
= FALSE
;
260 static bfd_boolean decompress_dumps
= FALSE
;
262 static char *dump_ctf_parent_name
;
263 static char *dump_ctf_symtab_name
;
264 static char *dump_ctf_strtab_name
;
268 struct group_list
* next
;
269 unsigned int section_index
;
274 struct group_list
* root
;
275 unsigned int group_index
;
278 static size_t group_count
;
279 static struct group
* section_groups
;
280 static struct group
** section_headers_groups
;
282 /* A dynamic array of flags indicating for which sections a dump
283 has been requested via command line switches. */
284 static Filedata cmdline
;
286 static struct dump_list_entry
* dump_sects_byname
;
288 /* How to print a vma value. */
289 typedef enum print_mode
301 /* Versioned symbol info. */
302 enum versioned_symbol_info
309 static const char * get_symbol_version_string
310 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
311 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
315 #define SECTION_NAME(X) \
316 ((X) == NULL ? _("<none>") \
317 : filedata->string_table == NULL ? _("<no-strings>") \
318 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
319 : filedata->string_table + (X)->sh_name))
321 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
323 #define GET_ELF_SYMBOLS(file, section, sym_count) \
324 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
325 : get_64bit_elf_symbols (file, section, sym_count))
327 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
328 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
329 already been called and verified that the string exists. */
330 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
332 #define REMOVE_ARCH_BITS(ADDR) \
335 if (filedata->file_header.e_machine == EM_ARM) \
340 /* Get the correct GNU hash section name. */
341 #define GNU_HASH_SECTION_NAME \
342 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
344 /* Print a BFD_VMA to an internal buffer, for use in error messages.
345 BFD_FMA_FMT can't be used in translated strings. */
348 bfd_vmatoa (char *fmtch
, bfd_vma value
)
350 /* bfd_vmatoa is used more then once in a printf call for output.
351 Cycle through an array of buffers. */
352 static int buf_pos
= 0;
353 static struct bfd_vmatoa_buf
360 ret
= buf
[buf_pos
++].place
;
361 buf_pos
%= ARRAY_SIZE (buf
);
363 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
364 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
368 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
369 OFFSET + the offset of the current archive member, if we are examining an
370 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
371 allocate a buffer using malloc and fill that. In either case return the
372 pointer to the start of the retrieved data or NULL if something went wrong.
373 If something does go wrong and REASON is not NULL then emit an error
374 message using REASON as part of the context. */
377 get_data (void * var
,
379 unsigned long offset
,
385 bfd_size_type amt
= size
* nmemb
;
387 if (size
== 0 || nmemb
== 0)
390 /* If the size_t type is smaller than the bfd_size_type, eg because
391 you are building a 32-bit tool on a 64-bit host, then make sure
392 that when the sizes are cast to (size_t) no information is lost. */
393 if ((size_t) size
!= size
394 || (size_t) nmemb
!= nmemb
395 || (size_t) amt
!= amt
)
398 error (_("Size truncation prevents reading %s"
399 " elements of size %s for %s\n"),
400 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
404 /* Check for size overflow. */
405 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
408 error (_("Size overflow prevents reading %s"
409 " elements of size %s for %s\n"),
410 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
414 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
415 attempting to allocate memory when the read is bound to fail. */
416 if (archive_file_offset
> filedata
->file_size
417 || offset
> filedata
->file_size
- archive_file_offset
418 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
421 error (_("Reading %s bytes extends past end of file for %s\n"),
422 bfd_vmatoa ("u", amt
), reason
);
426 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
429 error (_("Unable to seek to 0x%lx for %s\n"),
430 archive_file_offset
+ offset
, reason
);
437 /* + 1 so that we can '\0' terminate invalid string table sections. */
438 mvar
= malloc ((size_t) amt
+ 1);
443 error (_("Out of memory allocating %s bytes for %s\n"),
444 bfd_vmatoa ("u", amt
), reason
);
448 ((char *) mvar
)[amt
] = '\0';
451 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
454 error (_("Unable to read in %s bytes of %s\n"),
455 bfd_vmatoa ("u", amt
), reason
);
464 /* Print a VMA value in the MODE specified.
465 Returns the number of characters displayed. */
468 print_vma (bfd_vma vma
, print_mode mode
)
480 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
487 return printf ("%5" BFD_VMA_FMT
"d", vma
);
493 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
496 return printf ("%" BFD_VMA_FMT
"d", vma
);
499 return printf ("%" BFD_VMA_FMT
"u", vma
);
502 /* FIXME: Report unrecognised mode ? */
507 /* Display a symbol on stdout. Handles the display of control characters and
508 multibye characters (assuming the host environment supports them).
510 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
512 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
513 padding as necessary.
515 Returns the number of emitted characters. */
518 print_symbol (signed int width
, const char *symbol
)
520 bfd_boolean extra_padding
= FALSE
;
521 signed int num_printed
= 0;
522 #ifdef HAVE_MBSTATE_T
525 unsigned int width_remaining
;
529 /* Keep the width positive. This helps the code below. */
531 extra_padding
= TRUE
;
537 /* Set the remaining width to a very large value.
538 This simplifies the code below. */
539 width_remaining
= INT_MAX
;
541 width_remaining
= width
;
543 #ifdef HAVE_MBSTATE_T
544 /* Initialise the multibyte conversion state. */
545 memset (& state
, 0, sizeof (state
));
548 while (width_remaining
)
551 const char c
= *symbol
++;
556 /* Do not print control characters directly as they can affect terminal
557 settings. Such characters usually appear in the names generated
558 by the assembler for local labels. */
561 if (width_remaining
< 2)
564 printf ("^%c", c
+ 0x40);
565 width_remaining
-= 2;
568 else if (ISPRINT (c
))
576 #ifdef HAVE_MBSTATE_T
579 /* Let printf do the hard work of displaying multibyte characters. */
580 printf ("%.1s", symbol
- 1);
584 #ifdef HAVE_MBSTATE_T
585 /* Try to find out how many bytes made up the character that was
586 just printed. Advance the symbol pointer past the bytes that
588 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
592 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
597 if (extra_padding
&& num_printed
< width
)
599 /* Fill in the remaining spaces. */
600 printf ("%-*s", width
- num_printed
, " ");
607 /* Returns a pointer to a static buffer containing a printable version of
608 the given section's name. Like print_symbol, except that it does not try
609 to print multibyte characters, it just interprets them as hex values. */
612 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
614 #define MAX_PRINT_SEC_NAME_LEN 128
615 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
616 const char * name
= SECTION_NAME (sec
);
617 char * buf
= sec_name_buf
;
619 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
621 while ((c
= * name
++) != 0)
632 else if (ISPRINT (c
))
639 static char hex
[17] = "0123456789ABCDEF";
644 * buf
++ = hex
[(c
& 0xf0) >> 4];
645 * buf
++ = hex
[c
& 0x0f];
659 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
661 if (ndx
>= filedata
->file_header
.e_shnum
)
662 return _("<corrupt>");
664 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
667 /* Return a pointer to section NAME, or NULL if no such section exists. */
669 static Elf_Internal_Shdr
*
670 find_section (Filedata
* filedata
, const char * name
)
674 if (filedata
->section_headers
== NULL
)
677 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
678 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
679 return filedata
->section_headers
+ i
;
684 /* Return a pointer to a section containing ADDR, or NULL if no such
687 static Elf_Internal_Shdr
*
688 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
692 if (filedata
->section_headers
== NULL
)
695 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
697 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
699 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
706 static Elf_Internal_Shdr
*
707 find_section_by_type (Filedata
* filedata
, unsigned int type
)
711 if (filedata
->section_headers
== NULL
)
714 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
716 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
718 if (sec
->sh_type
== type
)
725 /* Return a pointer to section NAME, or NULL if no such section exists,
726 restricted to the list of sections given in SET. */
728 static Elf_Internal_Shdr
*
729 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
733 if (filedata
->section_headers
== NULL
)
738 while ((i
= *set
++) > 0)
740 /* See PR 21156 for a reproducer. */
741 if (i
>= filedata
->file_header
.e_shnum
)
742 continue; /* FIXME: Should we issue an error message ? */
744 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
745 return filedata
->section_headers
+ i
;
749 return find_section (filedata
, name
);
752 /* Read an unsigned LEB128 encoded value from DATA.
753 Set *LENGTH_RETURN to the number of bytes read. */
755 static inline unsigned long
756 read_uleb128 (unsigned char * data
,
757 unsigned int * length_return
,
758 const unsigned char * const end
)
760 return read_leb128 (data
, length_return
, FALSE
, end
);
763 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
764 This OS has so many departures from the ELF standard that we test it at
767 static inline bfd_boolean
768 is_ia64_vms (Filedata
* filedata
)
770 return filedata
->file_header
.e_machine
== EM_IA_64
771 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
774 /* Guess the relocation size commonly used by the specific machines. */
777 guess_is_rela (unsigned int e_machine
)
781 /* Targets that use REL relocations. */
798 /* Targets that use RELA relocations. */
802 case EM_ADAPTEVA_EPIPHANY
:
804 case EM_ALTERA_NIOS2
:
807 case EM_ARC_COMPACT2
:
828 case EM_LATTICEMICO32
:
837 case EM_CYGNUS_MN10200
:
839 case EM_CYGNUS_MN10300
:
875 case EM_MICROBLAZE_OLD
:
897 warn (_("Don't know about relocations on this machine architecture\n"));
902 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
903 Returns TRUE upon success, FALSE otherwise. If successful then a
904 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
905 and the number of relocs loaded is placed in *NRELASP. It is the caller's
906 responsibility to free the allocated buffer. */
909 slurp_rela_relocs (Filedata
* filedata
,
910 unsigned long rel_offset
,
911 unsigned long rel_size
,
912 Elf_Internal_Rela
** relasp
,
913 unsigned long * nrelasp
)
915 Elf_Internal_Rela
* relas
;
921 Elf32_External_Rela
* erelas
;
923 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
924 rel_size
, _("32-bit relocation data"));
928 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
930 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
931 sizeof (Elf_Internal_Rela
));
936 error (_("out of memory parsing relocs\n"));
940 for (i
= 0; i
< nrelas
; i
++)
942 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
943 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
944 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
951 Elf64_External_Rela
* erelas
;
953 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
954 rel_size
, _("64-bit relocation data"));
958 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
960 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
961 sizeof (Elf_Internal_Rela
));
966 error (_("out of memory parsing relocs\n"));
970 for (i
= 0; i
< nrelas
; i
++)
972 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
973 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
974 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
976 /* The #ifdef BFD64 below is to prevent a compile time
977 warning. We know that if we do not have a 64 bit data
978 type that we will never execute this code anyway. */
980 if (filedata
->file_header
.e_machine
== EM_MIPS
981 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
983 /* In little-endian objects, r_info isn't really a
984 64-bit little-endian value: it has a 32-bit
985 little-endian symbol index followed by four
986 individual byte fields. Reorder INFO
988 bfd_vma inf
= relas
[i
].r_info
;
989 inf
= (((inf
& 0xffffffff) << 32)
990 | ((inf
>> 56) & 0xff)
991 | ((inf
>> 40) & 0xff00)
992 | ((inf
>> 24) & 0xff0000)
993 | ((inf
>> 8) & 0xff000000));
994 relas
[i
].r_info
= inf
;
1007 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1008 Returns TRUE upon success, FALSE otherwise. If successful then a
1009 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1010 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1011 responsibility to free the allocated buffer. */
1014 slurp_rel_relocs (Filedata
* filedata
,
1015 unsigned long rel_offset
,
1016 unsigned long rel_size
,
1017 Elf_Internal_Rela
** relsp
,
1018 unsigned long * nrelsp
)
1020 Elf_Internal_Rela
* rels
;
1026 Elf32_External_Rel
* erels
;
1028 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1029 rel_size
, _("32-bit relocation data"));
1033 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1035 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1040 error (_("out of memory parsing relocs\n"));
1044 for (i
= 0; i
< nrels
; i
++)
1046 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1047 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1048 rels
[i
].r_addend
= 0;
1055 Elf64_External_Rel
* erels
;
1057 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1058 rel_size
, _("64-bit relocation data"));
1062 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1064 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1069 error (_("out of memory parsing relocs\n"));
1073 for (i
= 0; i
< nrels
; i
++)
1075 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1076 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1077 rels
[i
].r_addend
= 0;
1079 /* The #ifdef BFD64 below is to prevent a compile time
1080 warning. We know that if we do not have a 64 bit data
1081 type that we will never execute this code anyway. */
1083 if (filedata
->file_header
.e_machine
== EM_MIPS
1084 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1086 /* In little-endian objects, r_info isn't really a
1087 64-bit little-endian value: it has a 32-bit
1088 little-endian symbol index followed by four
1089 individual byte fields. Reorder INFO
1091 bfd_vma inf
= rels
[i
].r_info
;
1092 inf
= (((inf
& 0xffffffff) << 32)
1093 | ((inf
>> 56) & 0xff)
1094 | ((inf
>> 40) & 0xff00)
1095 | ((inf
>> 24) & 0xff0000)
1096 | ((inf
>> 8) & 0xff000000));
1097 rels
[i
].r_info
= inf
;
1110 /* Returns the reloc type extracted from the reloc info field. */
1113 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1116 return ELF32_R_TYPE (reloc_info
);
1118 switch (filedata
->file_header
.e_machine
)
1121 /* Note: We assume that reloc_info has already been adjusted for us. */
1122 return ELF64_MIPS_R_TYPE (reloc_info
);
1125 return ELF64_R_TYPE_ID (reloc_info
);
1128 return ELF64_R_TYPE (reloc_info
);
1132 /* Return the symbol index extracted from the reloc info field. */
1135 get_reloc_symindex (bfd_vma reloc_info
)
1137 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1140 static inline bfd_boolean
1141 uses_msp430x_relocs (Filedata
* filedata
)
1144 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1145 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1146 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1147 /* TI compiler uses ELFOSABI_NONE. */
1148 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1151 /* Display the contents of the relocation data found at the specified
1155 dump_relocations (Filedata
* filedata
,
1156 unsigned long rel_offset
,
1157 unsigned long rel_size
,
1158 Elf_Internal_Sym
* symtab
,
1159 unsigned long nsyms
,
1161 unsigned long strtablen
,
1163 bfd_boolean is_dynsym
)
1166 Elf_Internal_Rela
* rels
;
1167 bfd_boolean res
= TRUE
;
1169 if (is_rela
== UNKNOWN
)
1170 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1174 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1179 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1188 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1190 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1195 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1197 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1205 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1207 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1212 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1214 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1218 for (i
= 0; i
< rel_size
; i
++)
1223 bfd_vma symtab_index
;
1226 offset
= rels
[i
].r_offset
;
1227 inf
= rels
[i
].r_info
;
1229 type
= get_reloc_type (filedata
, inf
);
1230 symtab_index
= get_reloc_symindex (inf
);
1234 printf ("%8.8lx %8.8lx ",
1235 (unsigned long) offset
& 0xffffffff,
1236 (unsigned long) inf
& 0xffffffff);
1240 #if BFD_HOST_64BIT_LONG
1242 ? "%16.16lx %16.16lx "
1243 : "%12.12lx %12.12lx ",
1245 #elif BFD_HOST_64BIT_LONG_LONG
1248 ? "%16.16llx %16.16llx "
1249 : "%12.12llx %12.12llx ",
1253 ? "%16.16I64x %16.16I64x "
1254 : "%12.12I64x %12.12I64x ",
1259 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1260 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1261 _bfd_int64_high (offset
),
1262 _bfd_int64_low (offset
),
1263 _bfd_int64_high (inf
),
1264 _bfd_int64_low (inf
));
1268 switch (filedata
->file_header
.e_machine
)
1275 rtype
= elf_aarch64_reloc_type (type
);
1279 case EM_CYGNUS_M32R
:
1280 rtype
= elf_m32r_reloc_type (type
);
1285 rtype
= elf_i386_reloc_type (type
);
1290 rtype
= elf_m68hc11_reloc_type (type
);
1294 rtype
= elf_s12z_reloc_type (type
);
1298 rtype
= elf_m68k_reloc_type (type
);
1302 rtype
= elf_i960_reloc_type (type
);
1307 rtype
= elf_avr_reloc_type (type
);
1310 case EM_OLD_SPARCV9
:
1311 case EM_SPARC32PLUS
:
1314 rtype
= elf_sparc_reloc_type (type
);
1318 rtype
= elf_spu_reloc_type (type
);
1322 rtype
= v800_reloc_type (type
);
1325 case EM_CYGNUS_V850
:
1326 rtype
= v850_reloc_type (type
);
1330 case EM_CYGNUS_D10V
:
1331 rtype
= elf_d10v_reloc_type (type
);
1335 case EM_CYGNUS_D30V
:
1336 rtype
= elf_d30v_reloc_type (type
);
1340 rtype
= elf_dlx_reloc_type (type
);
1344 rtype
= elf_sh_reloc_type (type
);
1348 case EM_CYGNUS_MN10300
:
1349 rtype
= elf_mn10300_reloc_type (type
);
1353 case EM_CYGNUS_MN10200
:
1354 rtype
= elf_mn10200_reloc_type (type
);
1358 case EM_CYGNUS_FR30
:
1359 rtype
= elf_fr30_reloc_type (type
);
1363 rtype
= elf_frv_reloc_type (type
);
1367 rtype
= elf_csky_reloc_type (type
);
1371 rtype
= elf_ft32_reloc_type (type
);
1375 rtype
= elf_mcore_reloc_type (type
);
1379 rtype
= elf_mmix_reloc_type (type
);
1383 rtype
= elf_moxie_reloc_type (type
);
1387 if (uses_msp430x_relocs (filedata
))
1389 rtype
= elf_msp430x_reloc_type (type
);
1394 rtype
= elf_msp430_reloc_type (type
);
1398 rtype
= elf_nds32_reloc_type (type
);
1402 rtype
= elf_ppc_reloc_type (type
);
1406 rtype
= elf_ppc64_reloc_type (type
);
1410 case EM_MIPS_RS3_LE
:
1411 rtype
= elf_mips_reloc_type (type
);
1415 rtype
= elf_riscv_reloc_type (type
);
1419 rtype
= elf_alpha_reloc_type (type
);
1423 rtype
= elf_arm_reloc_type (type
);
1427 case EM_ARC_COMPACT
:
1428 case EM_ARC_COMPACT2
:
1429 rtype
= elf_arc_reloc_type (type
);
1433 rtype
= elf_hppa_reloc_type (type
);
1439 rtype
= elf_h8_reloc_type (type
);
1443 rtype
= elf_or1k_reloc_type (type
);
1448 rtype
= elf_pj_reloc_type (type
);
1451 rtype
= elf_ia64_reloc_type (type
);
1455 rtype
= elf_cris_reloc_type (type
);
1459 rtype
= elf_i860_reloc_type (type
);
1465 rtype
= elf_x86_64_reloc_type (type
);
1469 rtype
= i370_reloc_type (type
);
1474 rtype
= elf_s390_reloc_type (type
);
1478 rtype
= elf_score_reloc_type (type
);
1482 rtype
= elf_xstormy16_reloc_type (type
);
1486 rtype
= elf_crx_reloc_type (type
);
1490 rtype
= elf_vax_reloc_type (type
);
1494 rtype
= elf_visium_reloc_type (type
);
1498 rtype
= elf_bpf_reloc_type (type
);
1501 case EM_ADAPTEVA_EPIPHANY
:
1502 rtype
= elf_epiphany_reloc_type (type
);
1507 rtype
= elf_ip2k_reloc_type (type
);
1511 rtype
= elf_iq2000_reloc_type (type
);
1516 rtype
= elf_xtensa_reloc_type (type
);
1519 case EM_LATTICEMICO32
:
1520 rtype
= elf_lm32_reloc_type (type
);
1525 rtype
= elf_m32c_reloc_type (type
);
1529 rtype
= elf_mt_reloc_type (type
);
1533 rtype
= elf_bfin_reloc_type (type
);
1537 rtype
= elf_mep_reloc_type (type
);
1541 rtype
= elf_cr16_reloc_type (type
);
1545 case EM_MICROBLAZE_OLD
:
1546 rtype
= elf_microblaze_reloc_type (type
);
1550 rtype
= elf_rl78_reloc_type (type
);
1554 rtype
= elf_rx_reloc_type (type
);
1558 rtype
= elf_metag_reloc_type (type
);
1563 rtype
= elf_xc16x_reloc_type (type
);
1567 rtype
= elf_tic6x_reloc_type (type
);
1571 rtype
= elf_tilegx_reloc_type (type
);
1575 rtype
= elf_tilepro_reloc_type (type
);
1578 case EM_WEBASSEMBLY
:
1579 rtype
= elf_wasm32_reloc_type (type
);
1583 rtype
= elf_xgate_reloc_type (type
);
1586 case EM_ALTERA_NIOS2
:
1587 rtype
= elf_nios2_reloc_type (type
);
1591 rtype
= elf_pru_reloc_type (type
);
1595 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1596 rtype
= elf_nfp3200_reloc_type (type
);
1598 rtype
= elf_nfp_reloc_type (type
);
1603 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1605 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1607 if (filedata
->file_header
.e_machine
== EM_ALPHA
1609 && streq (rtype
, "R_ALPHA_LITUSE")
1612 switch (rels
[i
].r_addend
)
1614 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1615 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1616 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1617 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1618 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1619 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1620 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1621 default: rtype
= NULL
;
1625 printf (" (%s)", rtype
);
1629 printf (_("<unknown addend: %lx>"),
1630 (unsigned long) rels
[i
].r_addend
);
1634 else if (symtab_index
)
1636 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1638 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1643 Elf_Internal_Sym
* psym
;
1644 const char * version_string
;
1645 enum versioned_symbol_info sym_info
;
1646 unsigned short vna_other
;
1648 psym
= symtab
+ symtab_index
;
1651 = get_symbol_version_string (filedata
, is_dynsym
,
1660 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1664 unsigned int width
= is_32bit_elf
? 8 : 14;
1666 /* Relocations against GNU_IFUNC symbols do not use the value
1667 of the symbol as the address to relocate against. Instead
1668 they invoke the function named by the symbol and use its
1669 result as the address for relocation.
1671 To indicate this to the user, do not display the value of
1672 the symbol in the "Symbols's Value" field. Instead show
1673 its name followed by () as a hint that the symbol is
1677 || psym
->st_name
== 0
1678 || psym
->st_name
>= strtablen
)
1681 name
= strtab
+ psym
->st_name
;
1683 len
= print_symbol (width
, name
);
1685 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1687 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1691 print_vma (psym
->st_value
, LONG_HEX
);
1693 printf (is_32bit_elf
? " " : " ");
1696 if (psym
->st_name
== 0)
1698 const char * sec_name
= "<null>";
1701 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1703 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1704 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1705 else if (psym
->st_shndx
== SHN_ABS
)
1707 else if (psym
->st_shndx
== SHN_COMMON
)
1708 sec_name
= "COMMON";
1709 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1710 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1711 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1712 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1713 sec_name
= "SCOMMON";
1714 else if (filedata
->file_header
.e_machine
== EM_MIPS
1715 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1716 sec_name
= "SUNDEF";
1717 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1718 || filedata
->file_header
.e_machine
== EM_L1OM
1719 || filedata
->file_header
.e_machine
== EM_K1OM
)
1720 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1721 sec_name
= "LARGE_COMMON";
1722 else if (filedata
->file_header
.e_machine
== EM_IA_64
1723 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1724 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1725 sec_name
= "ANSI_COM";
1726 else if (is_ia64_vms (filedata
)
1727 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1728 sec_name
= "VMS_SYMVEC";
1731 sprintf (name_buf
, "<section 0x%x>",
1732 (unsigned int) psym
->st_shndx
);
1733 sec_name
= name_buf
;
1736 print_symbol (22, sec_name
);
1738 else if (strtab
== NULL
)
1739 printf (_("<string table index: %3ld>"), psym
->st_name
);
1740 else if (psym
->st_name
>= strtablen
)
1742 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1747 print_symbol (22, strtab
+ psym
->st_name
);
1749 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1755 bfd_vma off
= rels
[i
].r_addend
;
1757 if ((bfd_signed_vma
) off
< 0)
1758 printf (" - %" BFD_VMA_FMT
"x", - off
);
1760 printf (" + %" BFD_VMA_FMT
"x", off
);
1766 bfd_vma off
= rels
[i
].r_addend
;
1768 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1769 if ((bfd_signed_vma
) off
< 0)
1770 printf ("-%" BFD_VMA_FMT
"x", - off
);
1772 printf ("%" BFD_VMA_FMT
"x", off
);
1775 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1777 && streq (rtype
, "R_SPARC_OLO10"))
1778 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1783 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1785 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1786 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1787 const char * rtype2
= elf_mips_reloc_type (type2
);
1788 const char * rtype3
= elf_mips_reloc_type (type3
);
1790 printf (" Type2: ");
1793 printf (_("unrecognized: %-7lx"),
1794 (unsigned long) type2
& 0xffffffff);
1796 printf ("%-17.17s", rtype2
);
1798 printf ("\n Type3: ");
1801 printf (_("unrecognized: %-7lx"),
1802 (unsigned long) type3
& 0xffffffff);
1804 printf ("%-17.17s", rtype3
);
1817 get_aarch64_dynamic_type (unsigned long type
)
1821 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1822 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1823 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1830 get_mips_dynamic_type (unsigned long type
)
1834 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1835 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1836 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1837 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1838 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1839 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1840 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1841 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1842 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1843 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1844 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1845 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1846 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1847 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1848 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1849 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1850 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1851 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1852 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1853 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1854 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1855 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1856 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1857 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1858 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1859 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1860 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1861 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1862 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1863 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1864 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1865 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1866 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1867 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1868 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1869 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1870 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1871 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1872 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1873 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1874 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1875 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1876 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1877 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1878 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1879 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1880 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1887 get_sparc64_dynamic_type (unsigned long type
)
1891 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1898 get_ppc_dynamic_type (unsigned long type
)
1902 case DT_PPC_GOT
: return "PPC_GOT";
1903 case DT_PPC_OPT
: return "PPC_OPT";
1910 get_ppc64_dynamic_type (unsigned long type
)
1914 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1915 case DT_PPC64_OPD
: return "PPC64_OPD";
1916 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1917 case DT_PPC64_OPT
: return "PPC64_OPT";
1924 get_parisc_dynamic_type (unsigned long type
)
1928 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1929 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1930 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1931 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1932 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1933 case DT_HP_PREINIT
: return "HP_PREINIT";
1934 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1935 case DT_HP_NEEDED
: return "HP_NEEDED";
1936 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1937 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1938 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1939 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1940 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1941 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1942 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1943 case DT_HP_FILTERED
: return "HP_FILTERED";
1944 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1945 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1946 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1947 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1948 case DT_PLT
: return "PLT";
1949 case DT_PLT_SIZE
: return "PLT_SIZE";
1950 case DT_DLT
: return "DLT";
1951 case DT_DLT_SIZE
: return "DLT_SIZE";
1958 get_ia64_dynamic_type (unsigned long type
)
1962 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1963 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1964 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1965 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1966 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1967 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1968 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1969 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1970 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1971 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1972 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1973 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1974 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1975 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1976 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1977 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1978 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1979 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1980 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1981 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1982 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1983 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1984 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1985 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1986 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1987 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1988 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1989 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1990 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1991 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1992 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1999 get_solaris_section_type (unsigned long type
)
2003 case 0x6fffffee: return "SUNW_ancillary";
2004 case 0x6fffffef: return "SUNW_capchain";
2005 case 0x6ffffff0: return "SUNW_capinfo";
2006 case 0x6ffffff1: return "SUNW_symsort";
2007 case 0x6ffffff2: return "SUNW_tlssort";
2008 case 0x6ffffff3: return "SUNW_LDYNSYM";
2009 case 0x6ffffff4: return "SUNW_dof";
2010 case 0x6ffffff5: return "SUNW_cap";
2011 case 0x6ffffff6: return "SUNW_SIGNATURE";
2012 case 0x6ffffff7: return "SUNW_ANNOTATE";
2013 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2014 case 0x6ffffff9: return "SUNW_DEBUG";
2015 case 0x6ffffffa: return "SUNW_move";
2016 case 0x6ffffffb: return "SUNW_COMDAT";
2017 case 0x6ffffffc: return "SUNW_syminfo";
2018 case 0x6ffffffd: return "SUNW_verdef";
2019 case 0x6ffffffe: return "SUNW_verneed";
2020 case 0x6fffffff: return "SUNW_versym";
2021 case 0x70000000: return "SPARC_GOTDATA";
2022 default: return NULL
;
2027 get_alpha_dynamic_type (unsigned long type
)
2031 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2032 default: return NULL
;
2037 get_score_dynamic_type (unsigned long type
)
2041 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2042 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2043 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2044 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2045 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2046 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2047 default: return NULL
;
2052 get_tic6x_dynamic_type (unsigned long type
)
2056 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2057 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2058 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2059 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2060 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2061 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2062 default: return NULL
;
2067 get_nios2_dynamic_type (unsigned long type
)
2071 case DT_NIOS2_GP
: return "NIOS2_GP";
2072 default: return NULL
;
2077 get_solaris_dynamic_type (unsigned long type
)
2081 case 0x6000000d: return "SUNW_AUXILIARY";
2082 case 0x6000000e: return "SUNW_RTLDINF";
2083 case 0x6000000f: return "SUNW_FILTER";
2084 case 0x60000010: return "SUNW_CAP";
2085 case 0x60000011: return "SUNW_SYMTAB";
2086 case 0x60000012: return "SUNW_SYMSZ";
2087 case 0x60000013: return "SUNW_SORTENT";
2088 case 0x60000014: return "SUNW_SYMSORT";
2089 case 0x60000015: return "SUNW_SYMSORTSZ";
2090 case 0x60000016: return "SUNW_TLSSORT";
2091 case 0x60000017: return "SUNW_TLSSORTSZ";
2092 case 0x60000018: return "SUNW_CAPINFO";
2093 case 0x60000019: return "SUNW_STRPAD";
2094 case 0x6000001a: return "SUNW_CAPCHAIN";
2095 case 0x6000001b: return "SUNW_LDMACH";
2096 case 0x6000001d: return "SUNW_CAPCHAINENT";
2097 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2098 case 0x60000021: return "SUNW_PARENT";
2099 case 0x60000023: return "SUNW_ASLR";
2100 case 0x60000025: return "SUNW_RELAX";
2101 case 0x60000029: return "SUNW_NXHEAP";
2102 case 0x6000002b: return "SUNW_NXSTACK";
2104 case 0x70000001: return "SPARC_REGISTER";
2105 case 0x7ffffffd: return "AUXILIARY";
2106 case 0x7ffffffe: return "USED";
2107 case 0x7fffffff: return "FILTER";
2109 default: return NULL
;
2114 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2116 static char buff
[64];
2120 case DT_NULL
: return "NULL";
2121 case DT_NEEDED
: return "NEEDED";
2122 case DT_PLTRELSZ
: return "PLTRELSZ";
2123 case DT_PLTGOT
: return "PLTGOT";
2124 case DT_HASH
: return "HASH";
2125 case DT_STRTAB
: return "STRTAB";
2126 case DT_SYMTAB
: return "SYMTAB";
2127 case DT_RELA
: return "RELA";
2128 case DT_RELASZ
: return "RELASZ";
2129 case DT_RELAENT
: return "RELAENT";
2130 case DT_STRSZ
: return "STRSZ";
2131 case DT_SYMENT
: return "SYMENT";
2132 case DT_INIT
: return "INIT";
2133 case DT_FINI
: return "FINI";
2134 case DT_SONAME
: return "SONAME";
2135 case DT_RPATH
: return "RPATH";
2136 case DT_SYMBOLIC
: return "SYMBOLIC";
2137 case DT_REL
: return "REL";
2138 case DT_RELSZ
: return "RELSZ";
2139 case DT_RELENT
: return "RELENT";
2140 case DT_PLTREL
: return "PLTREL";
2141 case DT_DEBUG
: return "DEBUG";
2142 case DT_TEXTREL
: return "TEXTREL";
2143 case DT_JMPREL
: return "JMPREL";
2144 case DT_BIND_NOW
: return "BIND_NOW";
2145 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2146 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2147 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2148 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2149 case DT_RUNPATH
: return "RUNPATH";
2150 case DT_FLAGS
: return "FLAGS";
2152 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2153 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2154 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2156 case DT_CHECKSUM
: return "CHECKSUM";
2157 case DT_PLTPADSZ
: return "PLTPADSZ";
2158 case DT_MOVEENT
: return "MOVEENT";
2159 case DT_MOVESZ
: return "MOVESZ";
2160 case DT_FEATURE
: return "FEATURE";
2161 case DT_POSFLAG_1
: return "POSFLAG_1";
2162 case DT_SYMINSZ
: return "SYMINSZ";
2163 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2165 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2166 case DT_CONFIG
: return "CONFIG";
2167 case DT_DEPAUDIT
: return "DEPAUDIT";
2168 case DT_AUDIT
: return "AUDIT";
2169 case DT_PLTPAD
: return "PLTPAD";
2170 case DT_MOVETAB
: return "MOVETAB";
2171 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2173 case DT_VERSYM
: return "VERSYM";
2175 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2176 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2177 case DT_RELACOUNT
: return "RELACOUNT";
2178 case DT_RELCOUNT
: return "RELCOUNT";
2179 case DT_FLAGS_1
: return "FLAGS_1";
2180 case DT_VERDEF
: return "VERDEF";
2181 case DT_VERDEFNUM
: return "VERDEFNUM";
2182 case DT_VERNEED
: return "VERNEED";
2183 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2185 case DT_AUXILIARY
: return "AUXILIARY";
2186 case DT_USED
: return "USED";
2187 case DT_FILTER
: return "FILTER";
2189 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2190 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2191 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2192 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2193 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2194 case DT_GNU_HASH
: return "GNU_HASH";
2197 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2199 const char * result
;
2201 switch (filedata
->file_header
.e_machine
)
2204 result
= get_aarch64_dynamic_type (type
);
2207 case EM_MIPS_RS3_LE
:
2208 result
= get_mips_dynamic_type (type
);
2211 result
= get_sparc64_dynamic_type (type
);
2214 result
= get_ppc_dynamic_type (type
);
2217 result
= get_ppc64_dynamic_type (type
);
2220 result
= get_ia64_dynamic_type (type
);
2223 result
= get_alpha_dynamic_type (type
);
2226 result
= get_score_dynamic_type (type
);
2229 result
= get_tic6x_dynamic_type (type
);
2231 case EM_ALTERA_NIOS2
:
2232 result
= get_nios2_dynamic_type (type
);
2235 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2236 result
= get_solaris_dynamic_type (type
);
2245 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2247 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2248 || (filedata
->file_header
.e_machine
== EM_PARISC
2249 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2251 const char * result
;
2253 switch (filedata
->file_header
.e_machine
)
2256 result
= get_parisc_dynamic_type (type
);
2259 result
= get_ia64_dynamic_type (type
);
2262 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2263 result
= get_solaris_dynamic_type (type
);
2272 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2276 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2283 get_file_type (unsigned e_type
)
2285 static char buff
[32];
2289 case ET_NONE
: return _("NONE (None)");
2290 case ET_REL
: return _("REL (Relocatable file)");
2291 case ET_EXEC
: return _("EXEC (Executable file)");
2292 case ET_DYN
: return _("DYN (Shared object file)");
2293 case ET_CORE
: return _("CORE (Core file)");
2296 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2297 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2298 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2299 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2301 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2307 get_machine_name (unsigned e_machine
)
2309 static char buff
[64]; /* XXX */
2313 /* Please keep this switch table sorted by increasing EM_ value. */
2315 case EM_NONE
: return _("None");
2316 case EM_M32
: return "WE32100";
2317 case EM_SPARC
: return "Sparc";
2318 case EM_386
: return "Intel 80386";
2319 case EM_68K
: return "MC68000";
2320 case EM_88K
: return "MC88000";
2321 case EM_IAMCU
: return "Intel MCU";
2322 case EM_860
: return "Intel 80860";
2323 case EM_MIPS
: return "MIPS R3000";
2324 case EM_S370
: return "IBM System/370";
2326 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2327 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2328 case EM_PARISC
: return "HPPA";
2329 case EM_VPP550
: return "Fujitsu VPP500";
2330 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2331 case EM_960
: return "Intel 80960";
2332 case EM_PPC
: return "PowerPC";
2334 case EM_PPC64
: return "PowerPC64";
2336 case EM_S390
: return "IBM S/390";
2337 case EM_SPU
: return "SPU";
2339 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2340 case EM_FR20
: return "Fujitsu FR20";
2341 case EM_RH32
: return "TRW RH32";
2342 case EM_MCORE
: return "MCORE";
2344 case EM_ARM
: return "ARM";
2345 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2346 case EM_SH
: return "Renesas / SuperH SH";
2347 case EM_SPARCV9
: return "Sparc v9";
2348 case EM_TRICORE
: return "Siemens Tricore";
2349 case EM_ARC
: return "ARC";
2350 case EM_H8_300
: return "Renesas H8/300";
2351 case EM_H8_300H
: return "Renesas H8/300H";
2352 case EM_H8S
: return "Renesas H8S";
2353 case EM_H8_500
: return "Renesas H8/500";
2355 case EM_IA_64
: return "Intel IA-64";
2356 case EM_MIPS_X
: return "Stanford MIPS-X";
2357 case EM_COLDFIRE
: return "Motorola Coldfire";
2358 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2359 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2360 case EM_PCP
: return "Siemens PCP";
2361 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2362 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2363 case EM_STARCORE
: return "Motorola Star*Core processor";
2364 case EM_ME16
: return "Toyota ME16 processor";
2366 case EM_ST100
: return "STMicroelectronics ST100 processor";
2367 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2368 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2369 case EM_PDSP
: return "Sony DSP processor";
2370 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2371 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2372 case EM_FX66
: return "Siemens FX66 microcontroller";
2373 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2374 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2375 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2377 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2378 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2379 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2380 case EM_SVX
: return "Silicon Graphics SVx";
2381 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2382 case EM_VAX
: return "Digital VAX";
2383 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2384 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2385 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2386 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2388 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2389 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2390 case EM_PRISM
: return "Vitesse Prism";
2392 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2393 case EM_CYGNUS_FR30
:
2394 case EM_FR30
: return "Fujitsu FR30";
2395 case EM_CYGNUS_D10V
:
2396 case EM_D10V
: return "d10v";
2397 case EM_CYGNUS_D30V
:
2398 case EM_D30V
: return "d30v";
2399 case EM_CYGNUS_V850
:
2400 case EM_V850
: return "Renesas V850";
2401 case EM_CYGNUS_M32R
:
2402 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2403 case EM_CYGNUS_MN10300
:
2404 case EM_MN10300
: return "mn10300";
2406 case EM_CYGNUS_MN10200
:
2407 case EM_MN10200
: return "mn10200";
2408 case EM_PJ
: return "picoJava";
2409 case EM_OR1K
: return "OpenRISC 1000";
2410 case EM_ARC_COMPACT
: return "ARCompact";
2412 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2413 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2414 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2415 case EM_NS32K
: return "National Semiconductor 32000 series";
2416 case EM_TPC
: return "Tenor Network TPC processor";
2417 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2419 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2421 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2422 case EM_MAX
: return "MAX Processor";
2423 case EM_CR
: return "National Semiconductor CompactRISC";
2424 case EM_F2MC16
: return "Fujitsu F2MC16";
2425 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2426 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2427 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2428 case EM_SEP
: return "Sharp embedded microprocessor";
2429 case EM_ARCA
: return "Arca RISC microprocessor";
2431 case EM_UNICORE
: return "Unicore";
2432 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2433 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2434 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2435 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2436 case EM_XGATE
: return "Motorola XGATE embedded processor";
2438 case EM_XC16X
: return "Infineon Technologies xc16x";
2439 case EM_M16C
: return "Renesas M16C series microprocessors";
2440 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2441 case EM_CE
: return "Freescale Communication Engine RISC core";
2443 case EM_M32C
: return "Renesas M32c";
2445 case EM_TSK3000
: return "Altium TSK3000 core";
2446 case EM_RS08
: return "Freescale RS08 embedded processor";
2447 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2448 case EM_SCORE
: return "SUNPLUS S+Core";
2449 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2450 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2451 case EM_LATTICEMICO32
: return "Lattice Mico32";
2452 case EM_SE_C17
: return "Seiko Epson C17 family";
2454 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2455 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2456 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2457 case EM_TI_PRU
: return "TI PRU I/O processor";
2459 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2460 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2461 case EM_R32C
: return "Renesas R32C series microprocessors";
2462 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2463 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2464 case EM_8051
: return "Intel 8051 and variants";
2465 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2466 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2467 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2468 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2470 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2471 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2472 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2473 case EM_RX
: return "Renesas RX";
2474 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2475 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2476 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2479 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2480 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2481 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2483 case EM_L1OM
: return "Intel L1OM";
2484 case EM_K1OM
: return "Intel K1OM";
2485 case EM_INTEL182
: return "Intel (reserved)";
2486 case EM_AARCH64
: return "AArch64";
2487 case EM_ARM184
: return "ARM (reserved)";
2488 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2489 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2490 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2491 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2493 case EM_CUDA
: return "NVIDIA CUDA architecture";
2494 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2495 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2496 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2497 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2498 case EM_ARC_COMPACT2
: return "ARCv2";
2499 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2500 case EM_RL78
: return "Renesas RL78";
2501 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2502 case EM_78K0R
: return "Renesas 78K0R";
2504 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2505 case EM_BA1
: return "Beyond BA1 CPU architecture";
2506 case EM_BA2
: return "Beyond BA2 CPU architecture";
2507 case EM_XCORE
: return "XMOS xCORE processor family";
2508 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2510 case EM_KM32
: return "KM211 KM32 32-bit processor";
2511 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2512 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2513 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2514 case EM_KVARC
: return "KM211 KVARC processor";
2515 case EM_CDP
: return "Paneve CDP architecture family";
2516 case EM_COGE
: return "Cognitive Smart Memory Processor";
2517 case EM_COOL
: return "Bluechip Systems CoolEngine";
2518 case EM_NORC
: return "Nanoradio Optimized RISC";
2519 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2521 case EM_Z80
: return "Zilog Z80";
2522 case EM_VISIUM
: return "CDS VISIUMcore processor";
2523 case EM_FT32
: return "FTDI Chip FT32";
2524 case EM_MOXIE
: return "Moxie";
2525 case EM_AMDGPU
: return "AMD GPU";
2526 case EM_RISCV
: return "RISC-V";
2527 case EM_LANAI
: return "Lanai 32-bit processor";
2528 case EM_BPF
: return "Linux BPF";
2529 case EM_NFP
: return "Netronome Flow Processor";
2531 /* Large numbers... */
2532 case EM_MT
: return "Morpho Techologies MT processor";
2533 case EM_ALPHA
: return "Alpha";
2534 case EM_WEBASSEMBLY
: return "Web Assembly";
2535 case EM_DLX
: return "OpenDLX";
2536 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2537 case EM_IQ2000
: return "Vitesse IQ2000";
2539 case EM_NIOS32
: return "Altera Nios";
2540 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2541 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2542 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2543 case EM_S12Z
: return "Freescale S12Z";
2544 case EM_CSKY
: return "C-SKY";
2547 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2553 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2555 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2556 other compilers don't a specific architecture type in the e_flags, and
2557 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2558 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2561 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2562 but also sets a specific architecture type in the e_flags field.
2564 However, when decoding the flags we don't worry if we see an
2565 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2566 ARCEM architecture type. */
2568 switch (e_flags
& EF_ARC_MACH_MSK
)
2570 /* We only expect these to occur for EM_ARC_COMPACT2. */
2571 case EF_ARC_CPU_ARCV2EM
:
2572 strcat (buf
, ", ARC EM");
2574 case EF_ARC_CPU_ARCV2HS
:
2575 strcat (buf
, ", ARC HS");
2578 /* We only expect these to occur for EM_ARC_COMPACT. */
2579 case E_ARC_MACH_ARC600
:
2580 strcat (buf
, ", ARC600");
2582 case E_ARC_MACH_ARC601
:
2583 strcat (buf
, ", ARC601");
2585 case E_ARC_MACH_ARC700
:
2586 strcat (buf
, ", ARC700");
2589 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2590 new ELF with new architecture being read by an old version of
2591 readelf, or (c) An ELF built with non-GNU compiler that does not
2592 set the architecture in the e_flags. */
2594 if (e_machine
== EM_ARC_COMPACT
)
2595 strcat (buf
, ", Unknown ARCompact");
2597 strcat (buf
, ", Unknown ARC");
2601 switch (e_flags
& EF_ARC_OSABI_MSK
)
2603 case E_ARC_OSABI_ORIG
:
2604 strcat (buf
, ", (ABI:legacy)");
2606 case E_ARC_OSABI_V2
:
2607 strcat (buf
, ", (ABI:v2)");
2609 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2610 case E_ARC_OSABI_V3
:
2611 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2613 case E_ARC_OSABI_V4
:
2614 strcat (buf
, ", v4 ABI");
2617 strcat (buf
, ", unrecognised ARC OSABI flag");
2623 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2626 bfd_boolean unknown
= FALSE
;
2628 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2629 e_flags
&= ~ EF_ARM_EABIMASK
;
2631 /* Handle "generic" ARM flags. */
2632 if (e_flags
& EF_ARM_RELEXEC
)
2634 strcat (buf
, ", relocatable executable");
2635 e_flags
&= ~ EF_ARM_RELEXEC
;
2638 if (e_flags
& EF_ARM_PIC
)
2640 strcat (buf
, ", position independent");
2641 e_flags
&= ~ EF_ARM_PIC
;
2644 /* Now handle EABI specific flags. */
2648 strcat (buf
, ", <unrecognized EABI>");
2653 case EF_ARM_EABI_VER1
:
2654 strcat (buf
, ", Version1 EABI");
2659 /* Process flags one bit at a time. */
2660 flag
= e_flags
& - e_flags
;
2665 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2666 strcat (buf
, ", sorted symbol tables");
2676 case EF_ARM_EABI_VER2
:
2677 strcat (buf
, ", Version2 EABI");
2682 /* Process flags one bit at a time. */
2683 flag
= e_flags
& - e_flags
;
2688 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2689 strcat (buf
, ", sorted symbol tables");
2692 case EF_ARM_DYNSYMSUSESEGIDX
:
2693 strcat (buf
, ", dynamic symbols use segment index");
2696 case EF_ARM_MAPSYMSFIRST
:
2697 strcat (buf
, ", mapping symbols precede others");
2707 case EF_ARM_EABI_VER3
:
2708 strcat (buf
, ", Version3 EABI");
2711 case EF_ARM_EABI_VER4
:
2712 strcat (buf
, ", Version4 EABI");
2717 /* Process flags one bit at a time. */
2718 flag
= e_flags
& - e_flags
;
2724 strcat (buf
, ", BE8");
2728 strcat (buf
, ", LE8");
2738 case EF_ARM_EABI_VER5
:
2739 strcat (buf
, ", Version5 EABI");
2744 /* Process flags one bit at a time. */
2745 flag
= e_flags
& - e_flags
;
2751 strcat (buf
, ", BE8");
2755 strcat (buf
, ", LE8");
2758 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2759 strcat (buf
, ", soft-float ABI");
2762 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2763 strcat (buf
, ", hard-float ABI");
2773 case EF_ARM_EABI_UNKNOWN
:
2774 strcat (buf
, ", GNU EABI");
2779 /* Process flags one bit at a time. */
2780 flag
= e_flags
& - e_flags
;
2785 case EF_ARM_INTERWORK
:
2786 strcat (buf
, ", interworking enabled");
2789 case EF_ARM_APCS_26
:
2790 strcat (buf
, ", uses APCS/26");
2793 case EF_ARM_APCS_FLOAT
:
2794 strcat (buf
, ", uses APCS/float");
2798 strcat (buf
, ", position independent");
2802 strcat (buf
, ", 8 bit structure alignment");
2805 case EF_ARM_NEW_ABI
:
2806 strcat (buf
, ", uses new ABI");
2809 case EF_ARM_OLD_ABI
:
2810 strcat (buf
, ", uses old ABI");
2813 case EF_ARM_SOFT_FLOAT
:
2814 strcat (buf
, ", software FP");
2817 case EF_ARM_VFP_FLOAT
:
2818 strcat (buf
, ", VFP");
2821 case EF_ARM_MAVERICK_FLOAT
:
2822 strcat (buf
, ", Maverick FP");
2833 strcat (buf
,_(", <unknown>"));
2837 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2839 --size
; /* Leave space for null terminator. */
2841 switch (e_flags
& EF_AVR_MACH
)
2843 case E_AVR_MACH_AVR1
:
2844 strncat (buf
, ", avr:1", size
);
2846 case E_AVR_MACH_AVR2
:
2847 strncat (buf
, ", avr:2", size
);
2849 case E_AVR_MACH_AVR25
:
2850 strncat (buf
, ", avr:25", size
);
2852 case E_AVR_MACH_AVR3
:
2853 strncat (buf
, ", avr:3", size
);
2855 case E_AVR_MACH_AVR31
:
2856 strncat (buf
, ", avr:31", size
);
2858 case E_AVR_MACH_AVR35
:
2859 strncat (buf
, ", avr:35", size
);
2861 case E_AVR_MACH_AVR4
:
2862 strncat (buf
, ", avr:4", size
);
2864 case E_AVR_MACH_AVR5
:
2865 strncat (buf
, ", avr:5", size
);
2867 case E_AVR_MACH_AVR51
:
2868 strncat (buf
, ", avr:51", size
);
2870 case E_AVR_MACH_AVR6
:
2871 strncat (buf
, ", avr:6", size
);
2873 case E_AVR_MACH_AVRTINY
:
2874 strncat (buf
, ", avr:100", size
);
2876 case E_AVR_MACH_XMEGA1
:
2877 strncat (buf
, ", avr:101", size
);
2879 case E_AVR_MACH_XMEGA2
:
2880 strncat (buf
, ", avr:102", size
);
2882 case E_AVR_MACH_XMEGA3
:
2883 strncat (buf
, ", avr:103", size
);
2885 case E_AVR_MACH_XMEGA4
:
2886 strncat (buf
, ", avr:104", size
);
2888 case E_AVR_MACH_XMEGA5
:
2889 strncat (buf
, ", avr:105", size
);
2891 case E_AVR_MACH_XMEGA6
:
2892 strncat (buf
, ", avr:106", size
);
2894 case E_AVR_MACH_XMEGA7
:
2895 strncat (buf
, ", avr:107", size
);
2898 strncat (buf
, ", avr:<unknown>", size
);
2902 size
-= strlen (buf
);
2903 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2904 strncat (buf
, ", link-relax", size
);
2908 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2914 bfd_boolean has_fpu
= FALSE
;
2917 static const char *ABI_STRINGS
[] =
2919 "ABI v0", /* use r5 as return register; only used in N1213HC */
2920 "ABI v1", /* use r0 as return register */
2921 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2922 "ABI v2fp", /* for FPU */
2926 static const char *VER_STRINGS
[] =
2928 "Andes ELF V1.3 or older",
2932 static const char *ARCH_STRINGS
[] =
2941 abi
= EF_NDS_ABI
& e_flags
;
2942 arch
= EF_NDS_ARCH
& e_flags
;
2943 config
= EF_NDS_INST
& e_flags
;
2944 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2946 memset (buf
, 0, size
);
2953 case E_NDS_ABI_V2FP
:
2954 case E_NDS_ABI_AABI
:
2955 case E_NDS_ABI_V2FP_PLUS
:
2956 /* In case there are holes in the array. */
2957 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2961 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2967 case E_NDS32_ELF_VER_1_2
:
2968 case E_NDS32_ELF_VER_1_3
:
2969 case E_NDS32_ELF_VER_1_4
:
2970 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2974 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2978 if (E_NDS_ABI_V0
== abi
)
2980 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2981 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2982 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2983 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2989 case E_NDS_ARCH_STAR_V1_0
:
2990 case E_NDS_ARCH_STAR_V2_0
:
2991 case E_NDS_ARCH_STAR_V3_0
:
2992 case E_NDS_ARCH_STAR_V3_M
:
2993 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2997 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2998 /* ARCH version determines how the e_flags are interpreted.
2999 If it is unknown, we cannot proceed. */
3003 /* Newer ABI; Now handle architecture specific flags. */
3004 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3006 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3009 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3010 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3012 if (config
& E_NDS32_HAS_DIV_INST
)
3013 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3015 if (config
& E_NDS32_HAS_16BIT_INST
)
3016 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3020 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3022 if (version
<= E_NDS32_ELF_VER_1_3
)
3023 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3025 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3028 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3031 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3032 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3034 if (config
& E_NDS32_HAS_16BIT_INST
)
3036 if (version
<= E_NDS32_ELF_VER_1_3
)
3037 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3039 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3043 if (config
& E_NDS32_HAS_EXT_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3046 if (config
& E_NDS32_HAS_EXT2_INST
)
3047 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3049 if (config
& E_NDS32_HAS_FPU_INST
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3055 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3058 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3061 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3064 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3069 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3071 case E_NDS32_FPU_REG_8SP_4DP
:
3072 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3074 case E_NDS32_FPU_REG_16SP_8DP
:
3075 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3077 case E_NDS32_FPU_REG_32SP_16DP
:
3078 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3080 case E_NDS32_FPU_REG_32SP_32DP
:
3081 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3086 if (config
& E_NDS32_HAS_AUDIO_INST
)
3087 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3089 if (config
& E_NDS32_HAS_STRING_INST
)
3090 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3092 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3093 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3095 if (config
& E_NDS32_HAS_VIDEO_INST
)
3097 if (version
<= E_NDS32_ELF_VER_1_3
)
3098 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3100 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3103 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3104 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3106 if (config
& E_NDS32_HAS_L2C_INST
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3111 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3113 static char buf
[1024];
3124 case EM_ARC_COMPACT2
:
3125 case EM_ARC_COMPACT
:
3126 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3130 decode_ARM_machine_flags (e_flags
, buf
);
3134 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3138 if (e_flags
& EF_BFIN_PIC
)
3139 strcat (buf
, ", PIC");
3141 if (e_flags
& EF_BFIN_FDPIC
)
3142 strcat (buf
, ", FDPIC");
3144 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3145 strcat (buf
, ", code in L1");
3147 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3148 strcat (buf
, ", data in L1");
3153 switch (e_flags
& EF_FRV_CPU_MASK
)
3155 case EF_FRV_CPU_GENERIC
:
3159 strcat (buf
, ", fr???");
3162 case EF_FRV_CPU_FR300
:
3163 strcat (buf
, ", fr300");
3166 case EF_FRV_CPU_FR400
:
3167 strcat (buf
, ", fr400");
3169 case EF_FRV_CPU_FR405
:
3170 strcat (buf
, ", fr405");
3173 case EF_FRV_CPU_FR450
:
3174 strcat (buf
, ", fr450");
3177 case EF_FRV_CPU_FR500
:
3178 strcat (buf
, ", fr500");
3180 case EF_FRV_CPU_FR550
:
3181 strcat (buf
, ", fr550");
3184 case EF_FRV_CPU_SIMPLE
:
3185 strcat (buf
, ", simple");
3187 case EF_FRV_CPU_TOMCAT
:
3188 strcat (buf
, ", tomcat");
3194 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3195 strcat (buf
, ", m68000");
3196 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3197 strcat (buf
, ", cpu32");
3198 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3199 strcat (buf
, ", fido_a");
3202 char const * isa
= _("unknown");
3203 char const * mac
= _("unknown mac");
3204 char const * additional
= NULL
;
3206 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3208 case EF_M68K_CF_ISA_A_NODIV
:
3210 additional
= ", nodiv";
3212 case EF_M68K_CF_ISA_A
:
3215 case EF_M68K_CF_ISA_A_PLUS
:
3218 case EF_M68K_CF_ISA_B_NOUSP
:
3220 additional
= ", nousp";
3222 case EF_M68K_CF_ISA_B
:
3225 case EF_M68K_CF_ISA_C
:
3228 case EF_M68K_CF_ISA_C_NODIV
:
3230 additional
= ", nodiv";
3233 strcat (buf
, ", cf, isa ");
3236 strcat (buf
, additional
);
3237 if (e_flags
& EF_M68K_CF_FLOAT
)
3238 strcat (buf
, ", float");
3239 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3244 case EF_M68K_CF_MAC
:
3247 case EF_M68K_CF_EMAC
:
3250 case EF_M68K_CF_EMAC_B
:
3263 switch (e_flags
& EF_MEP_CPU_MASK
)
3265 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3266 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3267 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3268 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3269 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3270 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3271 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3274 switch (e_flags
& EF_MEP_COP_MASK
)
3276 case EF_MEP_COP_NONE
: break;
3277 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3278 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3279 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3280 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3281 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3284 if (e_flags
& EF_MEP_LIBRARY
)
3285 strcat (buf
, ", Built for Library");
3287 if (e_flags
& EF_MEP_INDEX_MASK
)
3288 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3289 e_flags
& EF_MEP_INDEX_MASK
);
3291 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3292 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3293 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3297 if (e_flags
& EF_PPC_EMB
)
3298 strcat (buf
, ", emb");
3300 if (e_flags
& EF_PPC_RELOCATABLE
)
3301 strcat (buf
, _(", relocatable"));
3303 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3304 strcat (buf
, _(", relocatable-lib"));
3308 if (e_flags
& EF_PPC64_ABI
)
3310 char abi
[] = ", abiv0";
3312 abi
[6] += e_flags
& EF_PPC64_ABI
;
3318 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3319 strcat (buf
, ", RH850 ABI");
3321 if (e_flags
& EF_V800_850E3
)
3322 strcat (buf
, ", V3 architecture");
3324 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3325 strcat (buf
, ", FPU not used");
3327 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3328 strcat (buf
, ", regmode: COMMON");
3330 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3331 strcat (buf
, ", r4 not used");
3333 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3334 strcat (buf
, ", r30 not used");
3336 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3337 strcat (buf
, ", r5 not used");
3339 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3340 strcat (buf
, ", r2 not used");
3342 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3344 switch (e_flags
& - e_flags
)
3346 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3347 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3348 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3349 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3350 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3351 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3352 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3353 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3354 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3355 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3356 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3357 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3364 case EM_CYGNUS_V850
:
3365 switch (e_flags
& EF_V850_ARCH
)
3367 case E_V850E3V5_ARCH
:
3368 strcat (buf
, ", v850e3v5");
3370 case E_V850E2V3_ARCH
:
3371 strcat (buf
, ", v850e2v3");
3374 strcat (buf
, ", v850e2");
3377 strcat (buf
, ", v850e1");
3380 strcat (buf
, ", v850e");
3383 strcat (buf
, ", v850");
3386 strcat (buf
, _(", unknown v850 architecture variant"));
3392 case EM_CYGNUS_M32R
:
3393 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3394 strcat (buf
, ", m32r");
3398 case EM_MIPS_RS3_LE
:
3399 if (e_flags
& EF_MIPS_NOREORDER
)
3400 strcat (buf
, ", noreorder");
3402 if (e_flags
& EF_MIPS_PIC
)
3403 strcat (buf
, ", pic");
3405 if (e_flags
& EF_MIPS_CPIC
)
3406 strcat (buf
, ", cpic");
3408 if (e_flags
& EF_MIPS_UCODE
)
3409 strcat (buf
, ", ugen_reserved");
3411 if (e_flags
& EF_MIPS_ABI2
)
3412 strcat (buf
, ", abi2");
3414 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3415 strcat (buf
, ", odk first");
3417 if (e_flags
& EF_MIPS_32BITMODE
)
3418 strcat (buf
, ", 32bitmode");
3420 if (e_flags
& EF_MIPS_NAN2008
)
3421 strcat (buf
, ", nan2008");
3423 if (e_flags
& EF_MIPS_FP64
)
3424 strcat (buf
, ", fp64");
3426 switch ((e_flags
& EF_MIPS_MACH
))
3428 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3429 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3430 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3431 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3432 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3433 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3434 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3435 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3436 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3437 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3438 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3439 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3440 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3441 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3442 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3443 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3444 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3445 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3446 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3447 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3448 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3450 /* We simply ignore the field in this case to avoid confusion:
3451 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3454 default: strcat (buf
, _(", unknown CPU")); break;
3457 switch ((e_flags
& EF_MIPS_ABI
))
3459 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3460 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3461 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3462 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3464 /* We simply ignore the field in this case to avoid confusion:
3465 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3466 This means it is likely to be an o32 file, but not for
3469 default: strcat (buf
, _(", unknown ABI")); break;
3472 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3473 strcat (buf
, ", mdmx");
3475 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3476 strcat (buf
, ", mips16");
3478 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3479 strcat (buf
, ", micromips");
3481 switch ((e_flags
& EF_MIPS_ARCH
))
3483 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3484 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3485 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3486 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3487 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3488 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3489 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3490 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3491 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3492 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3493 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3494 default: strcat (buf
, _(", unknown ISA")); break;
3499 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3503 switch (EF_NFP_MACH (e_flags
))
3505 case E_NFP_MACH_3200
:
3506 strcat (buf
, ", NFP-32xx");
3508 case E_NFP_MACH_6000
:
3509 strcat (buf
, ", NFP-6xxx");
3515 if (e_flags
& EF_RISCV_RVC
)
3516 strcat (buf
, ", RVC");
3518 if (e_flags
& EF_RISCV_RVE
)
3519 strcat (buf
, ", RVE");
3521 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3523 case EF_RISCV_FLOAT_ABI_SOFT
:
3524 strcat (buf
, ", soft-float ABI");
3527 case EF_RISCV_FLOAT_ABI_SINGLE
:
3528 strcat (buf
, ", single-float ABI");
3531 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3532 strcat (buf
, ", double-float ABI");
3535 case EF_RISCV_FLOAT_ABI_QUAD
:
3536 strcat (buf
, ", quad-float ABI");
3542 switch ((e_flags
& EF_SH_MACH_MASK
))
3544 case EF_SH1
: strcat (buf
, ", sh1"); break;
3545 case EF_SH2
: strcat (buf
, ", sh2"); break;
3546 case EF_SH3
: strcat (buf
, ", sh3"); break;
3547 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3548 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3549 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3550 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3551 case EF_SH4
: strcat (buf
, ", sh4"); break;
3552 case EF_SH5
: strcat (buf
, ", sh5"); break;
3553 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3554 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3555 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3556 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3557 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3558 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3559 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3560 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3561 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3562 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3563 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3564 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3565 default: strcat (buf
, _(", unknown ISA")); break;
3568 if (e_flags
& EF_SH_PIC
)
3569 strcat (buf
, ", pic");
3571 if (e_flags
& EF_SH_FDPIC
)
3572 strcat (buf
, ", fdpic");
3576 if (e_flags
& EF_OR1K_NODELAY
)
3577 strcat (buf
, ", no delay");
3581 if (e_flags
& EF_SPARC_32PLUS
)
3582 strcat (buf
, ", v8+");
3584 if (e_flags
& EF_SPARC_SUN_US1
)
3585 strcat (buf
, ", ultrasparcI");
3587 if (e_flags
& EF_SPARC_SUN_US3
)
3588 strcat (buf
, ", ultrasparcIII");
3590 if (e_flags
& EF_SPARC_HAL_R1
)
3591 strcat (buf
, ", halr1");
3593 if (e_flags
& EF_SPARC_LEDATA
)
3594 strcat (buf
, ", ledata");
3596 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3597 strcat (buf
, ", tso");
3599 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3600 strcat (buf
, ", pso");
3602 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3603 strcat (buf
, ", rmo");
3607 switch (e_flags
& EF_PARISC_ARCH
)
3609 case EFA_PARISC_1_0
:
3610 strcpy (buf
, ", PA-RISC 1.0");
3612 case EFA_PARISC_1_1
:
3613 strcpy (buf
, ", PA-RISC 1.1");
3615 case EFA_PARISC_2_0
:
3616 strcpy (buf
, ", PA-RISC 2.0");
3621 if (e_flags
& EF_PARISC_TRAPNIL
)
3622 strcat (buf
, ", trapnil");
3623 if (e_flags
& EF_PARISC_EXT
)
3624 strcat (buf
, ", ext");
3625 if (e_flags
& EF_PARISC_LSB
)
3626 strcat (buf
, ", lsb");
3627 if (e_flags
& EF_PARISC_WIDE
)
3628 strcat (buf
, ", wide");
3629 if (e_flags
& EF_PARISC_NO_KABP
)
3630 strcat (buf
, ", no kabp");
3631 if (e_flags
& EF_PARISC_LAZYSWAP
)
3632 strcat (buf
, ", lazyswap");
3637 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3638 strcat (buf
, ", new calling convention");
3640 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3641 strcat (buf
, ", gnu calling convention");
3645 if ((e_flags
& EF_IA_64_ABI64
))
3646 strcat (buf
, ", 64-bit");
3648 strcat (buf
, ", 32-bit");
3649 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3650 strcat (buf
, ", reduced fp model");
3651 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3652 strcat (buf
, ", no function descriptors, constant gp");
3653 else if ((e_flags
& EF_IA_64_CONS_GP
))
3654 strcat (buf
, ", constant gp");
3655 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3656 strcat (buf
, ", absolute");
3657 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3659 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3660 strcat (buf
, ", vms_linkages");
3661 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3663 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3665 case EF_IA_64_VMS_COMCOD_WARNING
:
3666 strcat (buf
, ", warning");
3668 case EF_IA_64_VMS_COMCOD_ERROR
:
3669 strcat (buf
, ", error");
3671 case EF_IA_64_VMS_COMCOD_ABORT
:
3672 strcat (buf
, ", abort");
3675 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3676 e_flags
& EF_IA_64_VMS_COMCOD
);
3677 strcat (buf
, ", <unknown>");
3683 if ((e_flags
& EF_VAX_NONPIC
))
3684 strcat (buf
, ", non-PIC");
3685 if ((e_flags
& EF_VAX_DFLOAT
))
3686 strcat (buf
, ", D-Float");
3687 if ((e_flags
& EF_VAX_GFLOAT
))
3688 strcat (buf
, ", G-Float");
3692 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3693 strcat (buf
, ", mcm");
3694 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3695 strcat (buf
, ", mcm24");
3696 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3697 strcat (buf
, ", gr6");
3701 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3703 case E_FLAG_RL78_ANY_CPU
: break;
3704 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3705 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3706 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3708 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3709 strcat (buf
, ", 64-bit doubles");
3713 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3714 strcat (buf
, ", 64-bit doubles");
3715 if (e_flags
& E_FLAG_RX_DSP
)
3716 strcat (buf
, ", dsp");
3717 if (e_flags
& E_FLAG_RX_PID
)
3718 strcat (buf
, ", pid");
3719 if (e_flags
& E_FLAG_RX_ABI
)
3720 strcat (buf
, ", RX ABI");
3721 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3722 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3723 ? ", uses String instructions" : ", bans String instructions");
3724 if (e_flags
& E_FLAG_RX_V2
)
3725 strcat (buf
, ", V2");
3726 if (e_flags
& E_FLAG_RX_V3
)
3727 strcat (buf
, ", V3");
3731 if (e_flags
& EF_S390_HIGH_GPRS
)
3732 strcat (buf
, ", highgprs");
3736 if ((e_flags
& EF_C6000_REL
))
3737 strcat (buf
, ", relocatable module");
3741 strcat (buf
, _(": architecture variant: "));
3742 switch (e_flags
& EF_MSP430_MACH
)
3744 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3745 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3746 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3747 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3748 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3749 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3750 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3751 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3752 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3753 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3754 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3755 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3756 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3757 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3758 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3760 strcat (buf
, _(": unknown")); break;
3763 if (e_flags
& ~ EF_MSP430_MACH
)
3764 strcat (buf
, _(": unknown extra flag bits also present"));
3772 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3774 static char buff
[32];
3778 case ELFOSABI_NONE
: return "UNIX - System V";
3779 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3780 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3781 case ELFOSABI_GNU
: return "UNIX - GNU";
3782 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3783 case ELFOSABI_AIX
: return "UNIX - AIX";
3784 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3785 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3786 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3787 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3788 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3789 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3790 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3791 case ELFOSABI_AROS
: return "AROS";
3792 case ELFOSABI_FENIXOS
: return "FenixOS";
3793 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3794 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3797 switch (filedata
->file_header
.e_machine
)
3802 case ELFOSABI_ARM
: return "ARM";
3803 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3814 case ELFOSABI_STANDALONE
: return _("Standalone App");
3823 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3824 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3833 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3839 get_aarch64_segment_type (unsigned long type
)
3843 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3844 default: return NULL
;
3849 get_arm_segment_type (unsigned long type
)
3853 case PT_ARM_EXIDX
: return "EXIDX";
3854 default: return NULL
;
3859 get_s390_segment_type (unsigned long type
)
3863 case PT_S390_PGSTE
: return "S390_PGSTE";
3864 default: return NULL
;
3869 get_mips_segment_type (unsigned long type
)
3873 case PT_MIPS_REGINFO
: return "REGINFO";
3874 case PT_MIPS_RTPROC
: return "RTPROC";
3875 case PT_MIPS_OPTIONS
: return "OPTIONS";
3876 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3877 default: return NULL
;
3882 get_parisc_segment_type (unsigned long type
)
3886 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3887 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3888 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3889 default: return NULL
;
3894 get_ia64_segment_type (unsigned long type
)
3898 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3899 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3900 default: return NULL
;
3905 get_tic6x_segment_type (unsigned long type
)
3909 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3910 default: return NULL
;
3915 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3917 if (e_machine
== EM_PARISC
)
3920 case PT_HP_TLS
: return "HP_TLS";
3921 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3922 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3923 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3924 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3925 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3926 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3927 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3928 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3929 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3930 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3931 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3932 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3933 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3934 case PT_HP_STACK
: return "HP_STACK";
3935 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3936 default: return NULL
;
3939 if (e_machine
== EM_IA_64
)
3942 case PT_HP_TLS
: return "HP_TLS";
3943 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3944 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3945 case PT_IA_64_HP_STACK
: return "HP_STACK";
3946 default: return NULL
;
3953 get_solaris_segment_type (unsigned long type
)
3957 case 0x6464e550: return "PT_SUNW_UNWIND";
3958 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3959 case 0x6ffffff7: return "PT_LOSUNW";
3960 case 0x6ffffffa: return "PT_SUNWBSS";
3961 case 0x6ffffffb: return "PT_SUNWSTACK";
3962 case 0x6ffffffc: return "PT_SUNWDTRACE";
3963 case 0x6ffffffd: return "PT_SUNWCAP";
3964 case 0x6fffffff: return "PT_HISUNW";
3965 default: return NULL
;
3970 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3972 static char buff
[32];
3976 case PT_NULL
: return "NULL";
3977 case PT_LOAD
: return "LOAD";
3978 case PT_DYNAMIC
: return "DYNAMIC";
3979 case PT_INTERP
: return "INTERP";
3980 case PT_NOTE
: return "NOTE";
3981 case PT_SHLIB
: return "SHLIB";
3982 case PT_PHDR
: return "PHDR";
3983 case PT_TLS
: return "TLS";
3984 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3985 case PT_GNU_STACK
: return "GNU_STACK";
3986 case PT_GNU_RELRO
: return "GNU_RELRO";
3987 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3990 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3992 const char * result
;
3994 switch (filedata
->file_header
.e_machine
)
3997 result
= get_aarch64_segment_type (p_type
);
4000 result
= get_arm_segment_type (p_type
);
4003 case EM_MIPS_RS3_LE
:
4004 result
= get_mips_segment_type (p_type
);
4007 result
= get_parisc_segment_type (p_type
);
4010 result
= get_ia64_segment_type (p_type
);
4013 result
= get_tic6x_segment_type (p_type
);
4017 result
= get_s390_segment_type (p_type
);
4027 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4029 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4031 const char * result
= NULL
;
4033 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4036 case ELFOSABI_FREEBSD
:
4037 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4039 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4044 result
= get_hpux_segment_type (p_type
,
4045 filedata
->file_header
.e_machine
);
4047 case ELFOSABI_SOLARIS
:
4048 result
= get_solaris_segment_type (p_type
);
4056 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4059 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4066 get_arc_section_type_name (unsigned int sh_type
)
4070 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4078 get_mips_section_type_name (unsigned int sh_type
)
4082 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4083 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4084 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4085 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4086 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4087 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4088 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4089 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4090 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4091 case SHT_MIPS_RELD
: return "MIPS_RELD";
4092 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4093 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4094 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4095 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4096 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4097 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4098 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4099 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4100 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4101 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4102 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4103 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4104 case SHT_MIPS_LINE
: return "MIPS_LINE";
4105 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4106 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4107 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4108 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4109 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4110 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4111 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4112 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4113 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4114 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4115 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4116 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4117 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4118 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4119 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4120 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4121 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4122 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4130 get_parisc_section_type_name (unsigned int sh_type
)
4134 case SHT_PARISC_EXT
: return "PARISC_EXT";
4135 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4136 case SHT_PARISC_DOC
: return "PARISC_DOC";
4137 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4138 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4139 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4140 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4141 default: return NULL
;
4146 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4148 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4149 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4150 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4154 case SHT_IA_64_EXT
: return "IA_64_EXT";
4155 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4156 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4157 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4158 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4159 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4160 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4161 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4162 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4163 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4171 get_x86_64_section_type_name (unsigned int sh_type
)
4175 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4176 default: return NULL
;
4181 get_aarch64_section_type_name (unsigned int sh_type
)
4185 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4186 default: return NULL
;
4191 get_arm_section_type_name (unsigned int sh_type
)
4195 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4196 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4197 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4198 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4199 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4200 default: return NULL
;
4205 get_tic6x_section_type_name (unsigned int sh_type
)
4209 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4210 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4211 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4212 case SHT_TI_ICODE
: return "TI_ICODE";
4213 case SHT_TI_XREF
: return "TI_XREF";
4214 case SHT_TI_HANDLER
: return "TI_HANDLER";
4215 case SHT_TI_INITINFO
: return "TI_INITINFO";
4216 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4217 default: return NULL
;
4222 get_msp430x_section_type_name (unsigned int sh_type
)
4226 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4227 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4228 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4229 default: return NULL
;
4234 get_nfp_section_type_name (unsigned int sh_type
)
4238 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4239 case SHT_NFP_INITREG
: return "NFP_INITREG";
4240 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4241 default: return NULL
;
4246 get_v850_section_type_name (unsigned int sh_type
)
4250 case SHT_V850_SCOMMON
: return "V850 Small Common";
4251 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4252 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4253 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4254 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4255 default: return NULL
;
4260 get_riscv_section_type_name (unsigned int sh_type
)
4264 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4265 default: return NULL
;
4270 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4272 static char buff
[32];
4273 const char * result
;
4277 case SHT_NULL
: return "NULL";
4278 case SHT_PROGBITS
: return "PROGBITS";
4279 case SHT_SYMTAB
: return "SYMTAB";
4280 case SHT_STRTAB
: return "STRTAB";
4281 case SHT_RELA
: return "RELA";
4282 case SHT_HASH
: return "HASH";
4283 case SHT_DYNAMIC
: return "DYNAMIC";
4284 case SHT_NOTE
: return "NOTE";
4285 case SHT_NOBITS
: return "NOBITS";
4286 case SHT_REL
: return "REL";
4287 case SHT_SHLIB
: return "SHLIB";
4288 case SHT_DYNSYM
: return "DYNSYM";
4289 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4290 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4291 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4292 case SHT_GNU_HASH
: return "GNU_HASH";
4293 case SHT_GROUP
: return "GROUP";
4294 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4295 case SHT_GNU_verdef
: return "VERDEF";
4296 case SHT_GNU_verneed
: return "VERNEED";
4297 case SHT_GNU_versym
: return "VERSYM";
4298 case 0x6ffffff0: return "VERSYM";
4299 case 0x6ffffffc: return "VERDEF";
4300 case 0x7ffffffd: return "AUXILIARY";
4301 case 0x7fffffff: return "FILTER";
4302 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4305 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4307 switch (filedata
->file_header
.e_machine
)
4310 case EM_ARC_COMPACT
:
4311 case EM_ARC_COMPACT2
:
4312 result
= get_arc_section_type_name (sh_type
);
4315 case EM_MIPS_RS3_LE
:
4316 result
= get_mips_section_type_name (sh_type
);
4319 result
= get_parisc_section_type_name (sh_type
);
4322 result
= get_ia64_section_type_name (filedata
, sh_type
);
4327 result
= get_x86_64_section_type_name (sh_type
);
4330 result
= get_aarch64_section_type_name (sh_type
);
4333 result
= get_arm_section_type_name (sh_type
);
4336 result
= get_tic6x_section_type_name (sh_type
);
4339 result
= get_msp430x_section_type_name (sh_type
);
4342 result
= get_nfp_section_type_name (sh_type
);
4346 case EM_CYGNUS_V850
:
4347 result
= get_v850_section_type_name (sh_type
);
4350 result
= get_riscv_section_type_name (sh_type
);
4360 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4362 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4364 switch (filedata
->file_header
.e_machine
)
4367 result
= get_ia64_section_type_name (filedata
, sh_type
);
4370 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4371 result
= get_solaris_section_type (sh_type
);
4376 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4377 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4378 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4379 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4391 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4393 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4395 switch (filedata
->file_header
.e_machine
)
4399 case EM_CYGNUS_V850
:
4400 result
= get_v850_section_type_name (sh_type
);
4410 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4413 /* This message is probably going to be displayed in a 15
4414 character wide field, so put the hex value first. */
4415 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4421 #define OPTION_DEBUG_DUMP 512
4422 #define OPTION_DYN_SYMS 513
4423 #define OPTION_DWARF_DEPTH 514
4424 #define OPTION_DWARF_START 515
4425 #define OPTION_DWARF_CHECK 516
4426 #define OPTION_CTF_DUMP 517
4427 #define OPTION_CTF_PARENT 518
4428 #define OPTION_CTF_SYMBOLS 519
4429 #define OPTION_CTF_STRINGS 520
4431 static struct option options
[] =
4433 {"all", no_argument
, 0, 'a'},
4434 {"file-header", no_argument
, 0, 'h'},
4435 {"program-headers", no_argument
, 0, 'l'},
4436 {"headers", no_argument
, 0, 'e'},
4437 {"histogram", no_argument
, 0, 'I'},
4438 {"segments", no_argument
, 0, 'l'},
4439 {"sections", no_argument
, 0, 'S'},
4440 {"section-headers", no_argument
, 0, 'S'},
4441 {"section-groups", no_argument
, 0, 'g'},
4442 {"section-details", no_argument
, 0, 't'},
4443 {"full-section-name",no_argument
, 0, 'N'},
4444 {"symbols", no_argument
, 0, 's'},
4445 {"syms", no_argument
, 0, 's'},
4446 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4447 {"relocs", no_argument
, 0, 'r'},
4448 {"notes", no_argument
, 0, 'n'},
4449 {"dynamic", no_argument
, 0, 'd'},
4450 {"arch-specific", no_argument
, 0, 'A'},
4451 {"version-info", no_argument
, 0, 'V'},
4452 {"use-dynamic", no_argument
, 0, 'D'},
4453 {"unwind", no_argument
, 0, 'u'},
4454 {"archive-index", no_argument
, 0, 'c'},
4455 {"hex-dump", required_argument
, 0, 'x'},
4456 {"relocated-dump", required_argument
, 0, 'R'},
4457 {"string-dump", required_argument
, 0, 'p'},
4458 {"decompress", no_argument
, 0, 'z'},
4459 #ifdef SUPPORT_DISASSEMBLY
4460 {"instruction-dump", required_argument
, 0, 'i'},
4462 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4464 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4465 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4466 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4468 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4470 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4471 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4472 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4474 {"version", no_argument
, 0, 'v'},
4475 {"wide", no_argument
, 0, 'W'},
4476 {"help", no_argument
, 0, 'H'},
4477 {0, no_argument
, 0, 0}
4481 usage (FILE * stream
)
4483 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4484 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4485 fprintf (stream
, _(" Options are:\n\
4486 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4487 -h --file-header Display the ELF file header\n\
4488 -l --program-headers Display the program headers\n\
4489 --segments An alias for --program-headers\n\
4490 -S --section-headers Display the sections' header\n\
4491 --sections An alias for --section-headers\n\
4492 -g --section-groups Display the section groups\n\
4493 -t --section-details Display the section details\n\
4494 -e --headers Equivalent to: -h -l -S\n\
4495 -s --syms Display the symbol table\n\
4496 --symbols An alias for --syms\n\
4497 --dyn-syms Display the dynamic symbol table\n\
4498 -n --notes Display the core notes (if present)\n\
4499 -r --relocs Display the relocations (if present)\n\
4500 -u --unwind Display the unwind info (if present)\n\
4501 -d --dynamic Display the dynamic section (if present)\n\
4502 -V --version-info Display the version sections (if present)\n\
4503 -A --arch-specific Display architecture specific information (if any)\n\
4504 -c --archive-index Display the symbol/file index in an archive\n\
4505 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4506 -x --hex-dump=<number|name>\n\
4507 Dump the contents of section <number|name> as bytes\n\
4508 -p --string-dump=<number|name>\n\
4509 Dump the contents of section <number|name> as strings\n\
4510 -R --relocated-dump=<number|name>\n\
4511 Dump the contents of section <number|name> as relocated bytes\n\
4512 -z --decompress Decompress section before dumping it\n\
4513 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4514 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4515 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4516 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4517 =addr,=cu_index,=links,=follow-links]\n\
4518 Display the contents of DWARF debug sections\n"));
4519 fprintf (stream
, _("\
4520 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4521 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4523 fprintf (stream
, _("\
4524 --ctf=<number|name> Display CTF info from section <number|name>\n\
4525 --ctf-parent=<number|name>\n\
4526 Use section <number|name> as the CTF parent\n\n\
4527 --ctf-symbols=<number|name>\n\
4528 Use section <number|name> as the CTF external symtab\n\n\
4529 --ctf-strings=<number|name>\n\
4530 Use section <number|name> as the CTF external strtab\n\n"));
4532 #ifdef SUPPORT_DISASSEMBLY
4533 fprintf (stream
, _("\
4534 -i --instruction-dump=<number|name>\n\
4535 Disassemble the contents of section <number|name>\n"));
4537 fprintf (stream
, _("\
4538 -I --histogram Display histogram of bucket list lengths\n\
4539 -W --wide Allow output width to exceed 80 characters\n\
4540 @<file> Read options from <file>\n\
4541 -H --help Display this information\n\
4542 -v --version Display the version number of readelf\n"));
4544 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4545 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4547 exit (stream
== stdout
? 0 : 1);
4550 /* Record the fact that the user wants the contents of section number
4551 SECTION to be displayed using the method(s) encoded as flags bits
4552 in TYPE. Note, TYPE can be zero if we are creating the array for
4556 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4558 if (section
>= filedata
->num_dump_sects
)
4560 dump_type
* new_dump_sects
;
4562 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4563 sizeof (* new_dump_sects
));
4565 if (new_dump_sects
== NULL
)
4566 error (_("Out of memory allocating dump request table.\n"));
4569 if (filedata
->dump_sects
)
4571 /* Copy current flag settings. */
4572 memcpy (new_dump_sects
, filedata
->dump_sects
,
4573 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4575 free (filedata
->dump_sects
);
4578 filedata
->dump_sects
= new_dump_sects
;
4579 filedata
->num_dump_sects
= section
+ 1;
4583 if (filedata
->dump_sects
)
4584 filedata
->dump_sects
[section
] |= type
;
4587 /* Request a dump by section name. */
4590 request_dump_byname (const char * section
, dump_type type
)
4592 struct dump_list_entry
* new_request
;
4594 new_request
= (struct dump_list_entry
*)
4595 malloc (sizeof (struct dump_list_entry
));
4597 error (_("Out of memory allocating dump request table.\n"));
4599 new_request
->name
= strdup (section
);
4600 if (!new_request
->name
)
4601 error (_("Out of memory allocating dump request table.\n"));
4603 new_request
->type
= type
;
4605 new_request
->next
= dump_sects_byname
;
4606 dump_sects_byname
= new_request
;
4610 request_dump (Filedata
* filedata
, dump_type type
)
4616 section
= strtoul (optarg
, & cp
, 0);
4618 if (! *cp
&& section
>= 0)
4619 request_dump_bynumber (filedata
, section
, type
);
4621 request_dump_byname (optarg
, type
);
4625 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4632 while ((c
= getopt_long
4633 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4651 do_section_groups
= TRUE
;
4654 do_histogram
= TRUE
;
4659 do_section_groups
= TRUE
;
4664 do_section_details
= TRUE
;
4675 do_using_dynamic
= TRUE
;
4699 do_histogram
= TRUE
;
4705 do_archive_index
= TRUE
;
4708 request_dump (filedata
, HEX_DUMP
);
4711 request_dump (filedata
, STRING_DUMP
);
4714 request_dump (filedata
, RELOC_DUMP
);
4717 decompress_dumps
= TRUE
;
4723 do_debugging
= TRUE
;
4724 dwarf_select_sections_all ();
4728 do_debugging
= FALSE
;
4729 dwarf_select_sections_by_letters (optarg
);
4732 case OPTION_DEBUG_DUMP
:
4735 do_debugging
= TRUE
;
4738 do_debugging
= FALSE
;
4739 dwarf_select_sections_by_names (optarg
);
4742 case OPTION_DWARF_DEPTH
:
4746 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4749 case OPTION_DWARF_START
:
4753 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4756 case OPTION_DWARF_CHECK
:
4759 case OPTION_CTF_DUMP
:
4761 request_dump (filedata
, CTF_DUMP
);
4763 case OPTION_CTF_SYMBOLS
:
4764 dump_ctf_symtab_name
= strdup (optarg
);
4766 case OPTION_CTF_STRINGS
:
4767 dump_ctf_strtab_name
= strdup (optarg
);
4769 case OPTION_CTF_PARENT
:
4770 dump_ctf_parent_name
= strdup (optarg
);
4772 case OPTION_DYN_SYMS
:
4775 #ifdef SUPPORT_DISASSEMBLY
4777 request_dump (filedata
, DISASS_DUMP
);
4781 print_version (program_name
);
4790 /* xgettext:c-format */
4791 error (_("Invalid option '-%c'\n"), c
);
4798 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4799 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4800 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4801 && !do_section_groups
&& !do_archive_index
4807 get_elf_class (unsigned int elf_class
)
4809 static char buff
[32];
4813 case ELFCLASSNONE
: return _("none");
4814 case ELFCLASS32
: return "ELF32";
4815 case ELFCLASS64
: return "ELF64";
4817 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4823 get_data_encoding (unsigned int encoding
)
4825 static char buff
[32];
4829 case ELFDATANONE
: return _("none");
4830 case ELFDATA2LSB
: return _("2's complement, little endian");
4831 case ELFDATA2MSB
: return _("2's complement, big endian");
4833 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4838 /* Decode the data held in 'filedata->file_header'. */
4841 process_file_header (Filedata
* filedata
)
4843 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4845 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4846 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4847 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4848 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4851 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4855 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4861 printf (_("ELF Header:\n"));
4862 printf (_(" Magic: "));
4863 for (i
= 0; i
< EI_NIDENT
; i
++)
4864 printf ("%2.2x ", header
->e_ident
[i
]);
4866 printf (_(" Class: %s\n"),
4867 get_elf_class (header
->e_ident
[EI_CLASS
]));
4868 printf (_(" Data: %s\n"),
4869 get_data_encoding (header
->e_ident
[EI_DATA
]));
4870 printf (_(" Version: %d%s\n"),
4871 header
->e_ident
[EI_VERSION
],
4872 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4874 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4877 printf (_(" OS/ABI: %s\n"),
4878 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4879 printf (_(" ABI Version: %d\n"),
4880 header
->e_ident
[EI_ABIVERSION
]);
4881 printf (_(" Type: %s\n"),
4882 get_file_type (header
->e_type
));
4883 printf (_(" Machine: %s\n"),
4884 get_machine_name (header
->e_machine
));
4885 printf (_(" Version: 0x%lx\n"),
4888 printf (_(" Entry point address: "));
4889 print_vma (header
->e_entry
, PREFIX_HEX
);
4890 printf (_("\n Start of program headers: "));
4891 print_vma (header
->e_phoff
, DEC
);
4892 printf (_(" (bytes into file)\n Start of section headers: "));
4893 print_vma (header
->e_shoff
, DEC
);
4894 printf (_(" (bytes into file)\n"));
4896 printf (_(" Flags: 0x%lx%s\n"),
4898 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4899 printf (_(" Size of this header: %u (bytes)\n"),
4901 printf (_(" Size of program headers: %u (bytes)\n"),
4902 header
->e_phentsize
);
4903 printf (_(" Number of program headers: %u"),
4905 if (filedata
->section_headers
!= NULL
4906 && header
->e_phnum
== PN_XNUM
4907 && filedata
->section_headers
[0].sh_info
!= 0)
4909 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4910 printf (" (%u)", header
->e_phnum
);
4912 putc ('\n', stdout
);
4913 printf (_(" Size of section headers: %u (bytes)\n"),
4914 header
->e_shentsize
);
4915 printf (_(" Number of section headers: %u"),
4917 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4919 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4920 printf (" (%u)", header
->e_shnum
);
4922 putc ('\n', stdout
);
4923 printf (_(" Section header string table index: %u"),
4924 header
->e_shstrndx
);
4925 if (filedata
->section_headers
!= NULL
4926 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4928 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4929 printf (" (%u)", header
->e_shstrndx
);
4931 if (header
->e_shstrndx
!= SHN_UNDEF
4932 && header
->e_shstrndx
>= header
->e_shnum
)
4934 header
->e_shstrndx
= SHN_UNDEF
;
4935 printf (_(" <corrupt: out of range>"));
4937 putc ('\n', stdout
);
4940 if (filedata
->section_headers
!= NULL
)
4942 if (header
->e_phnum
== PN_XNUM
4943 && filedata
->section_headers
[0].sh_info
!= 0)
4944 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4945 if (header
->e_shnum
== SHN_UNDEF
)
4946 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4947 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4948 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4949 if (header
->e_shstrndx
>= header
->e_shnum
)
4950 header
->e_shstrndx
= SHN_UNDEF
;
4951 free (filedata
->section_headers
);
4952 filedata
->section_headers
= NULL
;
4958 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4959 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4962 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4964 Elf32_External_Phdr
* phdrs
;
4965 Elf32_External_Phdr
* external
;
4966 Elf_Internal_Phdr
* internal
;
4968 unsigned int size
= filedata
->file_header
.e_phentsize
;
4969 unsigned int num
= filedata
->file_header
.e_phnum
;
4971 /* PR binutils/17531: Cope with unexpected section header sizes. */
4972 if (size
== 0 || num
== 0)
4974 if (size
< sizeof * phdrs
)
4976 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4979 if (size
> sizeof * phdrs
)
4980 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4982 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4983 size
, num
, _("program headers"));
4987 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4988 i
< filedata
->file_header
.e_phnum
;
4989 i
++, internal
++, external
++)
4991 internal
->p_type
= BYTE_GET (external
->p_type
);
4992 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4993 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4994 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4995 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4996 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4997 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4998 internal
->p_align
= BYTE_GET (external
->p_align
);
5005 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5006 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5009 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5011 Elf64_External_Phdr
* phdrs
;
5012 Elf64_External_Phdr
* external
;
5013 Elf_Internal_Phdr
* internal
;
5015 unsigned int size
= filedata
->file_header
.e_phentsize
;
5016 unsigned int num
= filedata
->file_header
.e_phnum
;
5018 /* PR binutils/17531: Cope with unexpected section header sizes. */
5019 if (size
== 0 || num
== 0)
5021 if (size
< sizeof * phdrs
)
5023 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5026 if (size
> sizeof * phdrs
)
5027 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5029 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5030 size
, num
, _("program headers"));
5034 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5035 i
< filedata
->file_header
.e_phnum
;
5036 i
++, internal
++, external
++)
5038 internal
->p_type
= BYTE_GET (external
->p_type
);
5039 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5040 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5041 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5042 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5043 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5044 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5045 internal
->p_align
= BYTE_GET (external
->p_align
);
5052 /* Returns TRUE if the program headers were read into `program_headers'. */
5055 get_program_headers (Filedata
* filedata
)
5057 Elf_Internal_Phdr
* phdrs
;
5059 /* Check cache of prior read. */
5060 if (filedata
->program_headers
!= NULL
)
5063 /* Be kind to memory checkers by looking for
5064 e_phnum values which we know must be invalid. */
5065 if (filedata
->file_header
.e_phnum
5066 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5067 >= filedata
->file_size
)
5069 error (_("Too many program headers - %#x - the file is not that big\n"),
5070 filedata
->file_header
.e_phnum
);
5074 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5075 sizeof (Elf_Internal_Phdr
));
5078 error (_("Out of memory reading %u program headers\n"),
5079 filedata
->file_header
.e_phnum
);
5084 ? get_32bit_program_headers (filedata
, phdrs
)
5085 : get_64bit_program_headers (filedata
, phdrs
))
5087 filedata
->program_headers
= phdrs
;
5095 /* Returns TRUE if the program headers were loaded. */
5098 process_program_headers (Filedata
* filedata
)
5100 Elf_Internal_Phdr
* segment
;
5102 Elf_Internal_Phdr
* previous_load
= NULL
;
5107 if (filedata
->file_header
.e_phnum
== 0)
5109 /* PR binutils/12467. */
5110 if (filedata
->file_header
.e_phoff
!= 0)
5112 warn (_("possibly corrupt ELF header - it has a non-zero program"
5113 " header offset, but no program headers\n"));
5116 else if (do_segments
)
5117 printf (_("\nThere are no program headers in this file.\n"));
5121 if (do_segments
&& !do_header
)
5123 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5124 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5125 printf (ngettext ("There is %d program header, starting at offset %s\n",
5126 "There are %d program headers, starting at offset %s\n",
5127 filedata
->file_header
.e_phnum
),
5128 filedata
->file_header
.e_phnum
,
5129 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5132 if (! get_program_headers (filedata
))
5137 if (filedata
->file_header
.e_phnum
> 1)
5138 printf (_("\nProgram Headers:\n"));
5140 printf (_("\nProgram Headers:\n"));
5144 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5147 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5151 (_(" Type Offset VirtAddr PhysAddr\n"));
5153 (_(" FileSiz MemSiz Flags Align\n"));
5157 for (i
= 0, segment
= filedata
->program_headers
;
5158 i
< filedata
->file_header
.e_phnum
;
5163 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5167 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5168 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5169 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5170 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5171 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5173 (segment
->p_flags
& PF_R
? 'R' : ' '),
5174 (segment
->p_flags
& PF_W
? 'W' : ' '),
5175 (segment
->p_flags
& PF_X
? 'E' : ' '));
5176 printf ("%#lx", (unsigned long) segment
->p_align
);
5180 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5181 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5184 print_vma (segment
->p_offset
, FULL_HEX
);
5188 print_vma (segment
->p_vaddr
, FULL_HEX
);
5190 print_vma (segment
->p_paddr
, FULL_HEX
);
5193 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5194 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5197 print_vma (segment
->p_filesz
, FULL_HEX
);
5201 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5202 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5205 print_vma (segment
->p_memsz
, FULL_HEX
);
5209 (segment
->p_flags
& PF_R
? 'R' : ' '),
5210 (segment
->p_flags
& PF_W
? 'W' : ' '),
5211 (segment
->p_flags
& PF_X
? 'E' : ' '));
5213 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5214 printf ("%#lx", (unsigned long) segment
->p_align
);
5217 print_vma (segment
->p_align
, PREFIX_HEX
);
5222 print_vma (segment
->p_offset
, FULL_HEX
);
5224 print_vma (segment
->p_vaddr
, FULL_HEX
);
5226 print_vma (segment
->p_paddr
, FULL_HEX
);
5228 print_vma (segment
->p_filesz
, FULL_HEX
);
5230 print_vma (segment
->p_memsz
, FULL_HEX
);
5232 (segment
->p_flags
& PF_R
? 'R' : ' '),
5233 (segment
->p_flags
& PF_W
? 'W' : ' '),
5234 (segment
->p_flags
& PF_X
? 'E' : ' '));
5235 print_vma (segment
->p_align
, PREFIX_HEX
);
5238 putc ('\n', stdout
);
5241 switch (segment
->p_type
)
5244 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5245 required by the ELF standard, several programs, including the Linux
5246 kernel, make use of non-ordered segments. */
5248 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5249 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5251 if (segment
->p_memsz
< segment
->p_filesz
)
5252 error (_("the segment's file size is larger than its memory size\n"));
5253 previous_load
= segment
;
5257 /* PR 20815 - Verify that the program header is loaded into memory. */
5258 if (i
> 0 && previous_load
!= NULL
)
5259 error (_("the PHDR segment must occur before any LOAD segment\n"));
5260 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5264 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5266 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5267 if (load
->p_type
== PT_LOAD
5268 && load
->p_offset
<= segment
->p_offset
5269 && (load
->p_offset
+ load
->p_filesz
5270 >= segment
->p_offset
+ segment
->p_filesz
)
5271 && load
->p_vaddr
<= segment
->p_vaddr
5272 && (load
->p_vaddr
+ load
->p_filesz
5273 >= segment
->p_vaddr
+ segment
->p_filesz
))
5276 if (j
== filedata
->file_header
.e_phnum
)
5277 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5283 error (_("more than one dynamic segment\n"));
5285 /* By default, assume that the .dynamic section is the first
5286 section in the DYNAMIC segment. */
5287 dynamic_addr
= segment
->p_offset
;
5288 dynamic_size
= segment
->p_filesz
;
5290 /* Try to locate the .dynamic section. If there is
5291 a section header table, we can easily locate it. */
5292 if (filedata
->section_headers
!= NULL
)
5294 Elf_Internal_Shdr
* sec
;
5296 sec
= find_section (filedata
, ".dynamic");
5297 if (sec
== NULL
|| sec
->sh_size
== 0)
5299 /* A corresponding .dynamic section is expected, but on
5300 IA-64/OpenVMS it is OK for it to be missing. */
5301 if (!is_ia64_vms (filedata
))
5302 error (_("no .dynamic section in the dynamic segment\n"));
5306 if (sec
->sh_type
== SHT_NOBITS
)
5312 dynamic_addr
= sec
->sh_offset
;
5313 dynamic_size
= sec
->sh_size
;
5315 if (dynamic_addr
< segment
->p_offset
5316 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5317 warn (_("the .dynamic section is not contained"
5318 " within the dynamic segment\n"));
5319 else if (dynamic_addr
> segment
->p_offset
)
5320 warn (_("the .dynamic section is not the first section"
5321 " in the dynamic segment.\n"));
5324 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5325 segment. Check this after matching against the section headers
5326 so we don't warn on debuginfo file (which have NOBITS .dynamic
5328 if (dynamic_addr
> filedata
->file_size
5329 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5331 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5332 dynamic_addr
= dynamic_size
= 0;
5337 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5339 error (_("Unable to find program interpreter name\n"));
5343 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5345 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5346 error (_("Internal error: failed to create format string to display program interpreter\n"));
5348 program_interpreter
[0] = 0;
5349 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5350 error (_("Unable to read program interpreter name\n"));
5353 printf (_(" [Requesting program interpreter: %s]\n"),
5354 program_interpreter
);
5361 && filedata
->section_headers
!= NULL
5362 && filedata
->string_table
!= NULL
)
5364 printf (_("\n Section to Segment mapping:\n"));
5365 printf (_(" Segment Sections...\n"));
5367 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5370 Elf_Internal_Shdr
* section
;
5372 segment
= filedata
->program_headers
+ i
;
5373 section
= filedata
->section_headers
+ 1;
5375 printf (" %2.2d ", i
);
5377 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5379 if (!ELF_TBSS_SPECIAL (section
, segment
)
5380 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5381 printf ("%s ", printable_section_name (filedata
, section
));
5392 /* Find the file offset corresponding to VMA by using the program headers. */
5395 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5397 Elf_Internal_Phdr
* seg
;
5399 if (! get_program_headers (filedata
))
5401 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5405 for (seg
= filedata
->program_headers
;
5406 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5409 if (seg
->p_type
!= PT_LOAD
)
5412 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5413 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5414 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5417 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5418 (unsigned long) vma
);
5423 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5424 If PROBE is true, this is just a probe and we do not generate any error
5425 messages if the load fails. */
5428 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5430 Elf32_External_Shdr
* shdrs
;
5431 Elf_Internal_Shdr
* internal
;
5433 unsigned int size
= filedata
->file_header
.e_shentsize
;
5434 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5436 /* PR binutils/17531: Cope with unexpected section header sizes. */
5437 if (size
== 0 || num
== 0)
5439 if (size
< sizeof * shdrs
)
5442 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5445 if (!probe
&& size
> sizeof * shdrs
)
5446 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5448 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5450 probe
? NULL
: _("section headers"));
5454 free (filedata
->section_headers
);
5455 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5456 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5457 if (filedata
->section_headers
== NULL
)
5460 error (_("Out of memory reading %u section headers\n"), num
);
5465 for (i
= 0, internal
= filedata
->section_headers
;
5469 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5470 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5471 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5472 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5473 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5474 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5475 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5476 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5477 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5478 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5479 if (!probe
&& internal
->sh_link
> num
)
5480 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5481 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5482 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5489 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5492 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5494 Elf64_External_Shdr
* shdrs
;
5495 Elf_Internal_Shdr
* internal
;
5497 unsigned int size
= filedata
->file_header
.e_shentsize
;
5498 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5500 /* PR binutils/17531: Cope with unexpected section header sizes. */
5501 if (size
== 0 || num
== 0)
5504 if (size
< sizeof * shdrs
)
5507 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5511 if (! probe
&& size
> sizeof * shdrs
)
5512 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5514 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5515 filedata
->file_header
.e_shoff
,
5517 probe
? NULL
: _("section headers"));
5521 free (filedata
->section_headers
);
5522 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5523 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5524 if (filedata
->section_headers
== NULL
)
5527 error (_("Out of memory reading %u section headers\n"), num
);
5532 for (i
= 0, internal
= filedata
->section_headers
;
5536 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5537 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5538 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5539 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5540 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5541 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5542 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5543 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5544 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5545 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5546 if (!probe
&& internal
->sh_link
> num
)
5547 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5548 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5549 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5556 static Elf_Internal_Sym
*
5557 get_32bit_elf_symbols (Filedata
* filedata
,
5558 Elf_Internal_Shdr
* section
,
5559 unsigned long * num_syms_return
)
5561 unsigned long number
= 0;
5562 Elf32_External_Sym
* esyms
= NULL
;
5563 Elf_External_Sym_Shndx
* shndx
= NULL
;
5564 Elf_Internal_Sym
* isyms
= NULL
;
5565 Elf_Internal_Sym
* psym
;
5567 elf_section_list
* entry
;
5569 if (section
->sh_size
== 0)
5571 if (num_syms_return
!= NULL
)
5572 * num_syms_return
= 0;
5576 /* Run some sanity checks first. */
5577 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5579 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5580 printable_section_name (filedata
, section
),
5581 (unsigned long) section
->sh_entsize
);
5585 if (section
->sh_size
> filedata
->file_size
)
5587 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5588 printable_section_name (filedata
, section
),
5589 (unsigned long) section
->sh_size
);
5593 number
= section
->sh_size
/ section
->sh_entsize
;
5595 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5597 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5598 (unsigned long) section
->sh_size
,
5599 printable_section_name (filedata
, section
),
5600 (unsigned long) section
->sh_entsize
);
5604 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5605 section
->sh_size
, _("symbols"));
5610 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5612 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5617 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5621 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5622 entry
->hdr
->sh_offset
,
5623 1, entry
->hdr
->sh_size
,
5624 _("symbol table section indices"));
5628 /* PR17531: file: heap-buffer-overflow */
5629 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5631 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5632 printable_section_name (filedata
, entry
->hdr
),
5633 (unsigned long) entry
->hdr
->sh_size
,
5634 (unsigned long) section
->sh_size
);
5639 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5643 error (_("Out of memory reading %lu symbols\n"),
5644 (unsigned long) number
);
5648 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5650 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5651 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5652 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5653 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5654 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5656 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5657 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5658 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5659 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5660 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5667 if (num_syms_return
!= NULL
)
5668 * num_syms_return
= isyms
== NULL
? 0 : number
;
5673 static Elf_Internal_Sym
*
5674 get_64bit_elf_symbols (Filedata
* filedata
,
5675 Elf_Internal_Shdr
* section
,
5676 unsigned long * num_syms_return
)
5678 unsigned long number
= 0;
5679 Elf64_External_Sym
* esyms
= NULL
;
5680 Elf_External_Sym_Shndx
* shndx
= NULL
;
5681 Elf_Internal_Sym
* isyms
= NULL
;
5682 Elf_Internal_Sym
* psym
;
5684 elf_section_list
* entry
;
5686 if (section
->sh_size
== 0)
5688 if (num_syms_return
!= NULL
)
5689 * num_syms_return
= 0;
5693 /* Run some sanity checks first. */
5694 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5696 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5697 printable_section_name (filedata
, section
),
5698 (unsigned long) section
->sh_entsize
);
5702 if (section
->sh_size
> filedata
->file_size
)
5704 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5705 printable_section_name (filedata
, section
),
5706 (unsigned long) section
->sh_size
);
5710 number
= section
->sh_size
/ section
->sh_entsize
;
5712 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5714 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5715 (unsigned long) section
->sh_size
,
5716 printable_section_name (filedata
, section
),
5717 (unsigned long) section
->sh_entsize
);
5721 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5722 section
->sh_size
, _("symbols"));
5727 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5729 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5734 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5738 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5739 entry
->hdr
->sh_offset
,
5740 1, entry
->hdr
->sh_size
,
5741 _("symbol table section indices"));
5745 /* PR17531: file: heap-buffer-overflow */
5746 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5748 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5749 printable_section_name (filedata
, entry
->hdr
),
5750 (unsigned long) entry
->hdr
->sh_size
,
5751 (unsigned long) section
->sh_size
);
5756 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5760 error (_("Out of memory reading %lu symbols\n"),
5761 (unsigned long) number
);
5765 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5767 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5768 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5769 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5770 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5772 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5774 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5775 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5776 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5778 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5779 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5786 if (num_syms_return
!= NULL
)
5787 * num_syms_return
= isyms
== NULL
? 0 : number
;
5793 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5795 static char buff
[1024];
5797 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5799 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5800 bfd_vma os_flags
= 0;
5801 bfd_vma proc_flags
= 0;
5802 bfd_vma unknown_flags
= 0;
5810 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5811 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5812 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5813 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5814 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5815 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5816 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5817 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5818 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5819 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5820 /* IA-64 specific. */
5821 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5822 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5823 /* IA-64 OpenVMS specific. */
5824 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5825 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5826 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5827 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5828 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5829 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5831 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5832 /* SPARC specific. */
5833 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5834 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5836 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5837 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5838 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5840 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5842 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5845 if (do_section_details
)
5847 sprintf (buff
, "[%*.*lx]: ",
5848 field_size
, field_size
, (unsigned long) sh_flags
);
5849 p
+= field_size
+ 4;
5856 flag
= sh_flags
& - sh_flags
;
5859 if (do_section_details
)
5863 case SHF_WRITE
: sindex
= 0; break;
5864 case SHF_ALLOC
: sindex
= 1; break;
5865 case SHF_EXECINSTR
: sindex
= 2; break;
5866 case SHF_MERGE
: sindex
= 3; break;
5867 case SHF_STRINGS
: sindex
= 4; break;
5868 case SHF_INFO_LINK
: sindex
= 5; break;
5869 case SHF_LINK_ORDER
: sindex
= 6; break;
5870 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5871 case SHF_GROUP
: sindex
= 8; break;
5872 case SHF_TLS
: sindex
= 9; break;
5873 case SHF_EXCLUDE
: sindex
= 18; break;
5874 case SHF_COMPRESSED
: sindex
= 20; break;
5875 case SHF_GNU_MBIND
: sindex
= 24; break;
5879 switch (filedata
->file_header
.e_machine
)
5882 if (flag
== SHF_IA_64_SHORT
)
5884 else if (flag
== SHF_IA_64_NORECOV
)
5887 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5890 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5891 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5892 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5893 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5894 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5895 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5906 case EM_OLD_SPARCV9
:
5907 case EM_SPARC32PLUS
:
5910 if (flag
== SHF_ORDERED
)
5917 case SHF_ENTRYSECT
: sindex
= 21; break;
5918 case SHF_ARM_PURECODE
: sindex
= 22; break;
5919 case SHF_COMDEF
: sindex
= 23; break;
5924 if (flag
== SHF_PPC_VLE
)
5935 if (p
!= buff
+ field_size
+ 4)
5937 if (size
< (10 + 2))
5939 warn (_("Internal error: not enough buffer room for section flag info"));
5940 return _("<unknown>");
5947 size
-= flags
[sindex
].len
;
5948 p
= stpcpy (p
, flags
[sindex
].str
);
5950 else if (flag
& SHF_MASKOS
)
5952 else if (flag
& SHF_MASKPROC
)
5955 unknown_flags
|= flag
;
5961 case SHF_WRITE
: *p
= 'W'; break;
5962 case SHF_ALLOC
: *p
= 'A'; break;
5963 case SHF_EXECINSTR
: *p
= 'X'; break;
5964 case SHF_MERGE
: *p
= 'M'; break;
5965 case SHF_STRINGS
: *p
= 'S'; break;
5966 case SHF_INFO_LINK
: *p
= 'I'; break;
5967 case SHF_LINK_ORDER
: *p
= 'L'; break;
5968 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5969 case SHF_GROUP
: *p
= 'G'; break;
5970 case SHF_TLS
: *p
= 'T'; break;
5971 case SHF_EXCLUDE
: *p
= 'E'; break;
5972 case SHF_COMPRESSED
: *p
= 'C'; break;
5973 case SHF_GNU_MBIND
: *p
= 'D'; break;
5976 if ((filedata
->file_header
.e_machine
== EM_X86_64
5977 || filedata
->file_header
.e_machine
== EM_L1OM
5978 || filedata
->file_header
.e_machine
== EM_K1OM
)
5979 && flag
== SHF_X86_64_LARGE
)
5981 else if (filedata
->file_header
.e_machine
== EM_ARM
5982 && flag
== SHF_ARM_PURECODE
)
5984 else if (filedata
->file_header
.e_machine
== EM_PPC
5985 && flag
== SHF_PPC_VLE
)
5987 else if (flag
& SHF_MASKOS
)
5990 sh_flags
&= ~ SHF_MASKOS
;
5992 else if (flag
& SHF_MASKPROC
)
5995 sh_flags
&= ~ SHF_MASKPROC
;
6005 if (do_section_details
)
6009 size
-= 5 + field_size
;
6010 if (p
!= buff
+ field_size
+ 4)
6014 warn (_("Internal error: not enough buffer room for section flag info"));
6015 return _("<unknown>");
6021 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6022 (unsigned long) os_flags
);
6023 p
+= 5 + field_size
;
6027 size
-= 7 + field_size
;
6028 if (p
!= buff
+ field_size
+ 4)
6032 warn (_("Internal error: not enough buffer room for section flag info"));
6033 return _("<unknown>");
6039 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6040 (unsigned long) proc_flags
);
6041 p
+= 7 + field_size
;
6045 size
-= 10 + field_size
;
6046 if (p
!= buff
+ field_size
+ 4)
6050 warn (_("Internal error: not enough buffer room for section flag info"));
6051 return _("<unknown>");
6057 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6058 (unsigned long) unknown_flags
);
6059 p
+= 10 + field_size
;
6068 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6072 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6074 if (size
< sizeof (* echdr
))
6076 error (_("Compressed section is too small even for a compression header\n"));
6080 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6081 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6082 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6083 return sizeof (*echdr
);
6087 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6089 if (size
< sizeof (* echdr
))
6091 error (_("Compressed section is too small even for a compression header\n"));
6095 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6096 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6097 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6098 return sizeof (*echdr
);
6103 process_section_headers (Filedata
* filedata
)
6105 Elf_Internal_Shdr
* section
;
6108 filedata
->section_headers
= NULL
;
6110 if (filedata
->file_header
.e_shnum
== 0)
6112 /* PR binutils/12467. */
6113 if (filedata
->file_header
.e_shoff
!= 0)
6115 warn (_("possibly corrupt ELF file header - it has a non-zero"
6116 " section header offset, but no section headers\n"));
6119 else if (do_sections
)
6120 printf (_("\nThere are no sections in this file.\n"));
6125 if (do_sections
&& !do_header
)
6126 printf (ngettext ("There is %d section header, "
6127 "starting at offset 0x%lx:\n",
6128 "There are %d section headers, "
6129 "starting at offset 0x%lx:\n",
6130 filedata
->file_header
.e_shnum
),
6131 filedata
->file_header
.e_shnum
,
6132 (unsigned long) filedata
->file_header
.e_shoff
);
6136 if (! get_32bit_section_headers (filedata
, FALSE
))
6141 if (! get_64bit_section_headers (filedata
, FALSE
))
6145 /* Read in the string table, so that we have names to display. */
6146 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6147 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6149 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6151 if (section
->sh_size
!= 0)
6153 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6154 1, section
->sh_size
,
6157 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6161 /* Scan the sections for the dynamic symbol table
6162 and dynamic string table and debug sections. */
6163 dynamic_symbols
= NULL
;
6164 dynamic_strings
= NULL
;
6165 dynamic_syminfo
= NULL
;
6166 symtab_shndx_list
= NULL
;
6168 eh_addr_size
= is_32bit_elf
? 4 : 8;
6169 switch (filedata
->file_header
.e_machine
)
6172 case EM_MIPS_RS3_LE
:
6173 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6174 FDE addresses. However, the ABI also has a semi-official ILP32
6175 variant for which the normal FDE address size rules apply.
6177 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6178 section, where XX is the size of longs in bits. Unfortunately,
6179 earlier compilers provided no way of distinguishing ILP32 objects
6180 from LP64 objects, so if there's any doubt, we should assume that
6181 the official LP64 form is being used. */
6182 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6183 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6189 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6191 case E_H8_MACH_H8300
:
6192 case E_H8_MACH_H8300HN
:
6193 case E_H8_MACH_H8300SN
:
6194 case E_H8_MACH_H8300SXN
:
6197 case E_H8_MACH_H8300H
:
6198 case E_H8_MACH_H8300S
:
6199 case E_H8_MACH_H8300SX
:
6207 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6209 case EF_M32C_CPU_M16C
:
6216 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6219 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6220 if (section->sh_entsize != expected_entsize) \
6223 sprintf_vma (buf, section->sh_entsize); \
6224 /* Note: coded this way so that there is a single string for \
6226 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6227 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6228 (unsigned) expected_entsize); \
6229 section->sh_entsize = expected_entsize; \
6234 #define CHECK_ENTSIZE(section, i, type) \
6235 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6236 sizeof (Elf64_External_##type))
6238 for (i
= 0, section
= filedata
->section_headers
;
6239 i
< filedata
->file_header
.e_shnum
;
6242 char * name
= SECTION_NAME (section
);
6244 if (section
->sh_type
== SHT_DYNSYM
)
6246 if (dynamic_symbols
!= NULL
)
6248 error (_("File contains multiple dynamic symbol tables\n"));
6252 CHECK_ENTSIZE (section
, i
, Sym
);
6253 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6255 else if (section
->sh_type
== SHT_STRTAB
6256 && streq (name
, ".dynstr"))
6258 if (dynamic_strings
!= NULL
)
6260 error (_("File contains multiple dynamic string tables\n"));
6264 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6265 1, section
->sh_size
,
6266 _("dynamic strings"));
6267 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6269 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6271 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6273 entry
->hdr
= section
;
6274 entry
->next
= symtab_shndx_list
;
6275 symtab_shndx_list
= entry
;
6277 else if (section
->sh_type
== SHT_SYMTAB
)
6278 CHECK_ENTSIZE (section
, i
, Sym
);
6279 else if (section
->sh_type
== SHT_GROUP
)
6280 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6281 else if (section
->sh_type
== SHT_REL
)
6282 CHECK_ENTSIZE (section
, i
, Rel
);
6283 else if (section
->sh_type
== SHT_RELA
)
6284 CHECK_ENTSIZE (section
, i
, Rela
);
6285 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6286 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6287 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6288 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6289 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6290 && (const_strneq (name
, ".debug_")
6291 || const_strneq (name
, ".zdebug_")))
6294 name
+= sizeof (".zdebug_") - 1;
6296 name
+= sizeof (".debug_") - 1;
6299 || (do_debug_info
&& const_strneq (name
, "info"))
6300 || (do_debug_info
&& const_strneq (name
, "types"))
6301 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6302 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6303 || (do_debug_lines
&& const_strneq (name
, "line."))
6304 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6305 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6306 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6307 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6308 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6309 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6310 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6311 || (do_debug_frames
&& const_strneq (name
, "frame"))
6312 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6313 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6314 || (do_debug_str
&& const_strneq (name
, "str"))
6315 || (do_debug_loc
&& const_strneq (name
, "loc"))
6316 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6317 || (do_debug_addr
&& const_strneq (name
, "addr"))
6318 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6319 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6321 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6323 /* Linkonce section to be combined with .debug_info at link time. */
6324 else if ((do_debugging
|| do_debug_info
)
6325 && const_strneq (name
, ".gnu.linkonce.wi."))
6326 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6327 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6328 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6329 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6330 || streq (name
, ".debug_names")))
6331 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6332 /* Trace sections for Itanium VMS. */
6333 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6334 || do_trace_aranges
)
6335 && const_strneq (name
, ".trace_"))
6337 name
+= sizeof (".trace_") - 1;
6340 || (do_trace_info
&& streq (name
, "info"))
6341 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6342 || (do_trace_aranges
&& streq (name
, "aranges"))
6344 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6346 else if ((do_debugging
|| do_debug_links
)
6347 && (const_strneq (name
, ".gnu_debuglink")
6348 || const_strneq (name
, ".gnu_debugaltlink")))
6349 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6355 if (filedata
->file_header
.e_shnum
> 1)
6356 printf (_("\nSection Headers:\n"));
6358 printf (_("\nSection Header:\n"));
6362 if (do_section_details
)
6364 printf (_(" [Nr] Name\n"));
6365 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6369 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6373 if (do_section_details
)
6375 printf (_(" [Nr] Name\n"));
6376 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6380 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6384 if (do_section_details
)
6386 printf (_(" [Nr] Name\n"));
6387 printf (_(" Type Address Offset Link\n"));
6388 printf (_(" Size EntSize Info Align\n"));
6392 printf (_(" [Nr] Name Type Address Offset\n"));
6393 printf (_(" Size EntSize Flags Link Info Align\n"));
6397 if (do_section_details
)
6398 printf (_(" Flags\n"));
6400 for (i
= 0, section
= filedata
->section_headers
;
6401 i
< filedata
->file_header
.e_shnum
;
6404 /* Run some sanity checks on the section header. */
6406 /* Check the sh_link field. */
6407 switch (section
->sh_type
)
6411 if (section
->sh_link
== 0
6412 && (filedata
->file_header
.e_type
== ET_EXEC
6413 || filedata
->file_header
.e_type
== ET_DYN
))
6414 /* A dynamic relocation section where all entries use a
6415 zero symbol index need not specify a symtab section. */
6418 case SHT_SYMTAB_SHNDX
:
6422 case SHT_GNU_versym
:
6423 if (section
->sh_link
== 0
6424 || section
->sh_link
>= filedata
->file_header
.e_shnum
6425 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6426 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6427 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6428 i
, section
->sh_link
);
6434 case SHT_GNU_verneed
:
6435 case SHT_GNU_verdef
:
6436 case SHT_GNU_LIBLIST
:
6437 if (section
->sh_link
== 0
6438 || section
->sh_link
>= filedata
->file_header
.e_shnum
6439 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6440 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6441 i
, section
->sh_link
);
6444 case SHT_INIT_ARRAY
:
6445 case SHT_FINI_ARRAY
:
6446 case SHT_PREINIT_ARRAY
:
6447 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6448 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6449 i
, section
->sh_link
);
6453 /* FIXME: Add support for target specific section types. */
6454 #if 0 /* Currently we do not check other section types as there are too
6455 many special cases. Stab sections for example have a type
6456 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6458 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6459 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6460 i
, section
->sh_link
);
6465 /* Check the sh_info field. */
6466 switch (section
->sh_type
)
6470 if (section
->sh_info
== 0
6471 && (filedata
->file_header
.e_type
== ET_EXEC
6472 || filedata
->file_header
.e_type
== ET_DYN
))
6473 /* Dynamic relocations apply to segments, so they do not
6474 need to specify the section they relocate. */
6476 if (section
->sh_info
== 0
6477 || section
->sh_info
>= filedata
->file_header
.e_shnum
6478 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6479 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6480 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6481 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6482 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6483 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6484 /* FIXME: Are other section types valid ? */
6485 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6486 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6487 i
, section
->sh_info
);
6492 case SHT_SYMTAB_SHNDX
:
6493 case SHT_INIT_ARRAY
:
6494 case SHT_FINI_ARRAY
:
6495 case SHT_PREINIT_ARRAY
:
6496 if (section
->sh_info
!= 0)
6497 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6498 i
, section
->sh_info
);
6504 /* A symbol index - we assume that it is valid. */
6508 /* FIXME: Add support for target specific section types. */
6509 if (section
->sh_type
== SHT_NOBITS
)
6510 /* NOBITS section headers with non-zero sh_info fields can be
6511 created when a binary is stripped of everything but its debug
6512 information. The stripped sections have their headers
6513 preserved but their types set to SHT_NOBITS. So do not check
6514 this type of section. */
6516 else if (section
->sh_flags
& SHF_INFO_LINK
)
6518 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6519 warn (_("[%2u]: Expected link to another section in info field"), i
);
6521 else if (section
->sh_type
< SHT_LOOS
6522 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6523 && section
->sh_info
!= 0)
6524 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6525 i
, section
->sh_info
);
6529 /* Check the sh_size field. */
6530 if (section
->sh_size
> filedata
->file_size
6531 && section
->sh_type
!= SHT_NOBITS
6532 && section
->sh_type
!= SHT_NULL
6533 && section
->sh_type
< SHT_LOOS
)
6534 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6536 printf (" [%2u] ", i
);
6537 if (do_section_details
)
6538 printf ("%s\n ", printable_section_name (filedata
, section
));
6540 print_symbol (-17, SECTION_NAME (section
));
6542 printf (do_wide
? " %-15s " : " %-15.15s ",
6543 get_section_type_name (filedata
, section
->sh_type
));
6547 const char * link_too_big
= NULL
;
6549 print_vma (section
->sh_addr
, LONG_HEX
);
6551 printf ( " %6.6lx %6.6lx %2.2lx",
6552 (unsigned long) section
->sh_offset
,
6553 (unsigned long) section
->sh_size
,
6554 (unsigned long) section
->sh_entsize
);
6556 if (do_section_details
)
6557 fputs (" ", stdout
);
6559 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6561 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6564 /* The sh_link value is out of range. Normally this indicates
6565 an error but it can have special values in Solaris binaries. */
6566 switch (filedata
->file_header
.e_machine
)
6573 case EM_OLD_SPARCV9
:
6574 case EM_SPARC32PLUS
:
6577 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6578 link_too_big
= "BEFORE";
6579 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6580 link_too_big
= "AFTER";
6587 if (do_section_details
)
6589 if (link_too_big
!= NULL
&& * link_too_big
)
6590 printf ("<%s> ", link_too_big
);
6592 printf ("%2u ", section
->sh_link
);
6593 printf ("%3u %2lu\n", section
->sh_info
,
6594 (unsigned long) section
->sh_addralign
);
6597 printf ("%2u %3u %2lu\n",
6600 (unsigned long) section
->sh_addralign
);
6602 if (link_too_big
&& ! * link_too_big
)
6603 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6604 i
, section
->sh_link
);
6608 print_vma (section
->sh_addr
, LONG_HEX
);
6610 if ((long) section
->sh_offset
== section
->sh_offset
)
6611 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6615 print_vma (section
->sh_offset
, LONG_HEX
);
6618 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6619 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6623 print_vma (section
->sh_size
, LONG_HEX
);
6626 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6627 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6631 print_vma (section
->sh_entsize
, LONG_HEX
);
6634 if (do_section_details
)
6635 fputs (" ", stdout
);
6637 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6639 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6641 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6642 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6645 print_vma (section
->sh_addralign
, DEC
);
6649 else if (do_section_details
)
6652 print_vma (section
->sh_addr
, LONG_HEX
);
6653 if ((long) section
->sh_offset
== section
->sh_offset
)
6654 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6658 print_vma (section
->sh_offset
, LONG_HEX
);
6660 printf (" %u\n ", section
->sh_link
);
6661 print_vma (section
->sh_size
, LONG_HEX
);
6663 print_vma (section
->sh_entsize
, LONG_HEX
);
6665 printf (" %-16u %lu\n",
6667 (unsigned long) section
->sh_addralign
);
6672 print_vma (section
->sh_addr
, LONG_HEX
);
6673 if ((long) section
->sh_offset
== section
->sh_offset
)
6674 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6678 print_vma (section
->sh_offset
, LONG_HEX
);
6681 print_vma (section
->sh_size
, LONG_HEX
);
6683 print_vma (section
->sh_entsize
, LONG_HEX
);
6685 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6687 printf (" %2u %3u %lu\n",
6690 (unsigned long) section
->sh_addralign
);
6693 if (do_section_details
)
6695 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6696 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6698 /* Minimum section size is 12 bytes for 32-bit compression
6699 header + 12 bytes for compressed data header. */
6700 unsigned char buf
[24];
6702 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6703 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6704 sizeof (buf
), _("compression header")))
6706 Elf_Internal_Chdr chdr
;
6708 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6710 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6713 printf (_(" [<unknown>: 0x%x], "),
6715 print_vma (chdr
.ch_size
, LONG_HEX
);
6716 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6722 if (!do_section_details
)
6724 /* The ordering of the letters shown here matches the ordering of the
6725 corresponding SHF_xxx values, and hence the order in which these
6726 letters will be displayed to the user. */
6727 printf (_("Key to Flags:\n\
6728 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6729 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6730 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6731 if (filedata
->file_header
.e_machine
== EM_X86_64
6732 || filedata
->file_header
.e_machine
== EM_L1OM
6733 || filedata
->file_header
.e_machine
== EM_K1OM
)
6734 printf (_("l (large), "));
6735 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6736 printf (_("y (purecode), "));
6737 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6738 printf (_("v (VLE), "));
6739 printf ("p (processor specific)\n");
6746 get_group_flags (unsigned int flags
)
6748 static char buff
[128];
6752 else if (flags
== GRP_COMDAT
)
6755 snprintf (buff
, 14, _("[0x%x: "), flags
);
6757 flags
&= ~ GRP_COMDAT
;
6758 if (flags
& GRP_MASKOS
)
6760 strcat (buff
, "<OS specific>");
6761 flags
&= ~ GRP_MASKOS
;
6764 if (flags
& GRP_MASKPROC
)
6766 strcat (buff
, "<PROC specific>");
6767 flags
&= ~ GRP_MASKPROC
;
6771 strcat (buff
, "<unknown>");
6778 process_section_groups (Filedata
* filedata
)
6780 Elf_Internal_Shdr
* section
;
6782 struct group
* group
;
6783 Elf_Internal_Shdr
* symtab_sec
;
6784 Elf_Internal_Shdr
* strtab_sec
;
6785 Elf_Internal_Sym
* symtab
;
6786 unsigned long num_syms
;
6790 /* Don't process section groups unless needed. */
6791 if (!do_unwind
&& !do_section_groups
)
6794 if (filedata
->file_header
.e_shnum
== 0)
6796 if (do_section_groups
)
6797 printf (_("\nThere are no sections to group in this file.\n"));
6802 if (filedata
->section_headers
== NULL
)
6804 error (_("Section headers are not available!\n"));
6805 /* PR 13622: This can happen with a corrupt ELF header. */
6809 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6810 sizeof (struct group
*));
6812 if (section_headers_groups
== NULL
)
6814 error (_("Out of memory reading %u section group headers\n"),
6815 filedata
->file_header
.e_shnum
);
6819 /* Scan the sections for the group section. */
6821 for (i
= 0, section
= filedata
->section_headers
;
6822 i
< filedata
->file_header
.e_shnum
;
6824 if (section
->sh_type
== SHT_GROUP
)
6827 if (group_count
== 0)
6829 if (do_section_groups
)
6830 printf (_("\nThere are no section groups in this file.\n"));
6835 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6837 if (section_groups
== NULL
)
6839 error (_("Out of memory reading %lu groups\n"),
6840 (unsigned long) group_count
);
6850 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6851 i
< filedata
->file_header
.e_shnum
;
6854 if (section
->sh_type
== SHT_GROUP
)
6856 const char * name
= printable_section_name (filedata
, section
);
6857 const char * group_name
;
6858 unsigned char * start
;
6859 unsigned char * indices
;
6860 unsigned int entry
, j
, size
;
6861 Elf_Internal_Shdr
* sec
;
6862 Elf_Internal_Sym
* sym
;
6864 /* Get the symbol table. */
6865 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6866 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6869 error (_("Bad sh_link in group section `%s'\n"), name
);
6873 if (symtab_sec
!= sec
)
6878 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6883 error (_("Corrupt header in group section `%s'\n"), name
);
6887 if (section
->sh_info
>= num_syms
)
6889 error (_("Bad sh_info in group section `%s'\n"), name
);
6893 sym
= symtab
+ section
->sh_info
;
6895 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6897 if (sym
->st_shndx
== 0
6898 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6900 error (_("Bad sh_info in group section `%s'\n"), name
);
6904 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6913 /* Get the string table. */
6914 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6923 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6929 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6930 1, strtab_sec
->sh_size
,
6932 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6934 group_name
= sym
->st_name
< strtab_size
6935 ? strtab
+ sym
->st_name
: _("<corrupt>");
6938 /* PR 17531: file: loop. */
6939 if (section
->sh_entsize
> section
->sh_size
)
6941 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6942 printable_section_name (filedata
, section
),
6943 (unsigned long) section
->sh_entsize
,
6944 (unsigned long) section
->sh_size
);
6948 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6949 1, section
->sh_size
,
6955 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6956 entry
= byte_get (indices
, 4);
6959 if (do_section_groups
)
6961 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6962 get_group_flags (entry
), i
, name
, group_name
, size
);
6964 printf (_(" [Index] Name\n"));
6967 group
->group_index
= i
;
6969 for (j
= 0; j
< size
; j
++)
6971 struct group_list
* g
;
6973 entry
= byte_get (indices
, 4);
6976 if (entry
>= filedata
->file_header
.e_shnum
)
6978 static unsigned num_group_errors
= 0;
6980 if (num_group_errors
++ < 10)
6982 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6983 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6984 if (num_group_errors
== 10)
6985 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6990 if (section_headers_groups
[entry
] != NULL
)
6994 static unsigned num_errs
= 0;
6996 if (num_errs
++ < 10)
6998 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7000 section_headers_groups
[entry
]->group_index
);
7002 warn (_("Further error messages about already contained group sections suppressed\n"));
7008 /* Intel C/C++ compiler may put section 0 in a
7009 section group. We just warn it the first time
7010 and ignore it afterwards. */
7011 static bfd_boolean warned
= FALSE
;
7014 error (_("section 0 in group section [%5u]\n"),
7015 section_headers_groups
[entry
]->group_index
);
7021 section_headers_groups
[entry
] = group
;
7023 if (do_section_groups
)
7025 sec
= filedata
->section_headers
+ entry
;
7026 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7029 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7030 g
->section_index
= entry
;
7031 g
->next
= group
->root
;
7049 /* Data used to display dynamic fixups. */
7051 struct ia64_vms_dynfixup
7053 bfd_vma needed_ident
; /* Library ident number. */
7054 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7055 bfd_vma fixup_needed
; /* Index of the library. */
7056 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7057 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7060 /* Data used to display dynamic relocations. */
7062 struct ia64_vms_dynimgrela
7064 bfd_vma img_rela_cnt
; /* Number of relocations. */
7065 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7068 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7072 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7073 struct ia64_vms_dynfixup
* fixup
,
7074 const char * strtab
,
7075 unsigned int strtab_sz
)
7077 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7079 const char * lib_name
;
7081 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7082 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7083 _("dynamic section image fixups"));
7087 if (fixup
->needed
< strtab_sz
)
7088 lib_name
= strtab
+ fixup
->needed
;
7091 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7092 (unsigned long) fixup
->needed
);
7095 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7096 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7098 (_("Seg Offset Type SymVec DataType\n"));
7100 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7105 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7106 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7107 type
= BYTE_GET (imfs
[i
].type
);
7108 rtype
= elf_ia64_reloc_type (type
);
7110 printf (" 0x%08x ", type
);
7112 printf (" %-32s ", rtype
);
7113 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7114 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7121 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7124 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7126 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7129 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7130 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7131 _("dynamic section image relocations"));
7135 printf (_("\nImage relocs\n"));
7137 (_("Seg Offset Type Addend Seg Sym Off\n"));
7139 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7144 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7145 printf ("%08" BFD_VMA_FMT
"x ",
7146 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7147 type
= BYTE_GET (imrs
[i
].type
);
7148 rtype
= elf_ia64_reloc_type (type
);
7150 printf ("0x%08x ", type
);
7152 printf ("%-31s ", rtype
);
7153 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7154 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7155 printf ("%08" BFD_VMA_FMT
"x\n",
7156 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7163 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7166 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7168 struct ia64_vms_dynfixup fixup
;
7169 struct ia64_vms_dynimgrela imgrela
;
7170 Elf_Internal_Dyn
*entry
;
7171 bfd_vma strtab_off
= 0;
7172 bfd_vma strtab_sz
= 0;
7173 char *strtab
= NULL
;
7174 bfd_boolean res
= TRUE
;
7176 memset (&fixup
, 0, sizeof (fixup
));
7177 memset (&imgrela
, 0, sizeof (imgrela
));
7179 /* Note: the order of the entries is specified by the OpenVMS specs. */
7180 for (entry
= dynamic_section
;
7181 entry
< dynamic_section
+ dynamic_nent
;
7184 switch (entry
->d_tag
)
7186 case DT_IA_64_VMS_STRTAB_OFFSET
:
7187 strtab_off
= entry
->d_un
.d_val
;
7190 strtab_sz
= entry
->d_un
.d_val
;
7192 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7193 1, strtab_sz
, _("dynamic string section"));
7196 case DT_IA_64_VMS_NEEDED_IDENT
:
7197 fixup
.needed_ident
= entry
->d_un
.d_val
;
7200 fixup
.needed
= entry
->d_un
.d_val
;
7202 case DT_IA_64_VMS_FIXUP_NEEDED
:
7203 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7205 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7206 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7208 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7209 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7210 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7213 case DT_IA_64_VMS_IMG_RELA_CNT
:
7214 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7216 case DT_IA_64_VMS_IMG_RELA_OFF
:
7217 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7218 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7240 dynamic_relocations
[] =
7242 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7243 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7244 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7247 /* Process the reloc section. */
7250 process_relocs (Filedata
* filedata
)
7252 unsigned long rel_size
;
7253 unsigned long rel_offset
;
7258 if (do_using_dynamic
)
7262 bfd_boolean has_dynamic_reloc
;
7265 has_dynamic_reloc
= FALSE
;
7267 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7269 is_rela
= dynamic_relocations
[i
].rela
;
7270 name
= dynamic_relocations
[i
].name
;
7271 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7272 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7275 has_dynamic_reloc
= TRUE
;
7277 if (is_rela
== UNKNOWN
)
7279 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7280 switch (dynamic_info
[DT_PLTREL
])
7294 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7295 name
, rel_offset
, rel_size
);
7297 dump_relocations (filedata
,
7298 offset_from_vma (filedata
, rel_offset
, rel_size
),
7300 dynamic_symbols
, num_dynamic_syms
,
7301 dynamic_strings
, dynamic_strings_length
,
7302 is_rela
, TRUE
/* is_dynamic */);
7306 if (is_ia64_vms (filedata
))
7307 if (process_ia64_vms_dynamic_relocs (filedata
))
7308 has_dynamic_reloc
= TRUE
;
7310 if (! has_dynamic_reloc
)
7311 printf (_("\nThere are no dynamic relocations in this file.\n"));
7315 Elf_Internal_Shdr
* section
;
7317 bfd_boolean found
= FALSE
;
7319 for (i
= 0, section
= filedata
->section_headers
;
7320 i
< filedata
->file_header
.e_shnum
;
7323 if ( section
->sh_type
!= SHT_RELA
7324 && section
->sh_type
!= SHT_REL
)
7327 rel_offset
= section
->sh_offset
;
7328 rel_size
= section
->sh_size
;
7332 Elf_Internal_Shdr
* strsec
;
7334 unsigned long num_rela
;
7336 printf (_("\nRelocation section "));
7338 if (filedata
->string_table
== NULL
)
7339 printf ("%d", section
->sh_name
);
7341 printf ("'%s'", printable_section_name (filedata
, section
));
7343 num_rela
= rel_size
/ section
->sh_entsize
;
7344 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7345 " at offset 0x%lx contains %lu entries:\n",
7347 rel_offset
, num_rela
);
7349 is_rela
= section
->sh_type
== SHT_RELA
;
7351 if (section
->sh_link
!= 0
7352 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7354 Elf_Internal_Shdr
* symsec
;
7355 Elf_Internal_Sym
* symtab
;
7356 unsigned long nsyms
;
7357 unsigned long strtablen
= 0;
7358 char * strtab
= NULL
;
7360 symsec
= filedata
->section_headers
+ section
->sh_link
;
7361 if (symsec
->sh_type
!= SHT_SYMTAB
7362 && symsec
->sh_type
!= SHT_DYNSYM
)
7365 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7370 if (symsec
->sh_link
!= 0
7371 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7373 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7375 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7378 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7381 dump_relocations (filedata
, rel_offset
, rel_size
,
7382 symtab
, nsyms
, strtab
, strtablen
,
7384 symsec
->sh_type
== SHT_DYNSYM
);
7390 dump_relocations (filedata
, rel_offset
, rel_size
,
7391 NULL
, 0, NULL
, 0, is_rela
,
7392 FALSE
/* is_dynamic */);
7400 /* Users sometimes forget the -D option, so try to be helpful. */
7401 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7403 if (dynamic_info
[dynamic_relocations
[i
].size
])
7405 printf (_("\nThere are no static relocations in this file."));
7406 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7411 if (i
== ARRAY_SIZE (dynamic_relocations
))
7412 printf (_("\nThere are no relocations in this file.\n"));
7419 /* An absolute address consists of a section and an offset. If the
7420 section is NULL, the offset itself is the address, otherwise, the
7421 address equals to LOAD_ADDRESS(section) + offset. */
7425 unsigned short section
;
7429 /* Find the nearest symbol at or below ADDR. Returns the symbol
7430 name, if found, and the offset from the symbol to ADDR. */
7433 find_symbol_for_address (Filedata
* filedata
,
7434 Elf_Internal_Sym
* symtab
,
7435 unsigned long nsyms
,
7436 const char * strtab
,
7437 unsigned long strtab_size
,
7438 struct absaddr addr
,
7439 const char ** symname
,
7442 bfd_vma dist
= 0x100000;
7443 Elf_Internal_Sym
* sym
;
7444 Elf_Internal_Sym
* beg
;
7445 Elf_Internal_Sym
* end
;
7446 Elf_Internal_Sym
* best
= NULL
;
7448 REMOVE_ARCH_BITS (addr
.offset
);
7450 end
= symtab
+ nsyms
;
7456 sym
= beg
+ (end
- beg
) / 2;
7458 value
= sym
->st_value
;
7459 REMOVE_ARCH_BITS (value
);
7461 if (sym
->st_name
!= 0
7462 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7463 && addr
.offset
>= value
7464 && addr
.offset
- value
< dist
)
7467 dist
= addr
.offset
- value
;
7472 if (addr
.offset
< value
)
7480 *symname
= (best
->st_name
>= strtab_size
7481 ? _("<corrupt>") : strtab
+ best
->st_name
);
7487 *offset
= addr
.offset
;
7490 static /* signed */ int
7491 symcmp (const void *p
, const void *q
)
7493 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7494 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7496 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7499 /* Process the unwind section. */
7501 #include "unwind-ia64.h"
7503 struct ia64_unw_table_entry
7505 struct absaddr start
;
7507 struct absaddr info
;
7510 struct ia64_unw_aux_info
7512 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7513 unsigned long table_len
; /* Length of unwind table. */
7514 unsigned char * info
; /* Unwind info. */
7515 unsigned long info_size
; /* Size of unwind info. */
7516 bfd_vma info_addr
; /* Starting address of unwind info. */
7517 bfd_vma seg_base
; /* Starting address of segment. */
7518 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7519 unsigned long nsyms
; /* Number of symbols. */
7520 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7521 unsigned long nfuns
; /* Number of entries in funtab. */
7522 char * strtab
; /* The string table. */
7523 unsigned long strtab_size
; /* Size of string table. */
7527 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7529 struct ia64_unw_table_entry
* tp
;
7530 unsigned long j
, nfuns
;
7532 bfd_boolean res
= TRUE
;
7534 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7535 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7536 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7537 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7539 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7541 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7545 const unsigned char * dp
;
7546 const unsigned char * head
;
7547 const unsigned char * end
;
7548 const char * procname
;
7550 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7551 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7553 fputs ("\n<", stdout
);
7557 fputs (procname
, stdout
);
7560 printf ("+%lx", (unsigned long) offset
);
7563 fputs (">: [", stdout
);
7564 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7565 fputc ('-', stdout
);
7566 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7567 printf ("], info at +0x%lx\n",
7568 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7570 /* PR 17531: file: 86232b32. */
7571 if (aux
->info
== NULL
)
7574 offset
= tp
->info
.offset
;
7575 if (tp
->info
.section
)
7577 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7579 warn (_("Invalid section %u in table entry %ld\n"),
7580 tp
->info
.section
, (long) (tp
- aux
->table
));
7584 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7586 offset
-= aux
->info_addr
;
7587 /* PR 17531: file: 0997b4d1. */
7588 if (offset
>= aux
->info_size
7589 || aux
->info_size
- offset
< 8)
7591 warn (_("Invalid offset %lx in table entry %ld\n"),
7592 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7597 head
= aux
->info
+ offset
;
7598 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7600 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7601 (unsigned) UNW_VER (stamp
),
7602 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7603 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7604 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7605 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7607 if (UNW_VER (stamp
) != 1)
7609 printf (_("\tUnknown version.\n"));
7614 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7615 /* PR 17531: file: 16ceda89. */
7616 if (end
> aux
->info
+ aux
->info_size
)
7617 end
= aux
->info
+ aux
->info_size
;
7618 for (dp
= head
+ 8; dp
< end
;)
7619 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7628 slurp_ia64_unwind_table (Filedata
* filedata
,
7629 struct ia64_unw_aux_info
* aux
,
7630 Elf_Internal_Shdr
* sec
)
7632 unsigned long size
, nrelas
, i
;
7633 Elf_Internal_Phdr
* seg
;
7634 struct ia64_unw_table_entry
* tep
;
7635 Elf_Internal_Shdr
* relsec
;
7636 Elf_Internal_Rela
* rela
;
7637 Elf_Internal_Rela
* rp
;
7638 unsigned char * table
;
7640 Elf_Internal_Sym
* sym
;
7641 const char * relname
;
7645 /* First, find the starting address of the segment that includes
7648 if (filedata
->file_header
.e_phnum
)
7650 if (! get_program_headers (filedata
))
7653 for (seg
= filedata
->program_headers
;
7654 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7657 if (seg
->p_type
!= PT_LOAD
)
7660 if (sec
->sh_addr
>= seg
->p_vaddr
7661 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7663 aux
->seg_base
= seg
->p_vaddr
;
7669 /* Second, build the unwind table from the contents of the unwind section: */
7670 size
= sec
->sh_size
;
7671 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7676 aux
->table_len
= size
/ (3 * eh_addr_size
);
7677 aux
->table
= (struct ia64_unw_table_entry
*)
7678 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7681 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7683 tep
->start
.section
= SHN_UNDEF
;
7684 tep
->end
.section
= SHN_UNDEF
;
7685 tep
->info
.section
= SHN_UNDEF
;
7686 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7687 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7688 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7689 tep
->start
.offset
+= aux
->seg_base
;
7690 tep
->end
.offset
+= aux
->seg_base
;
7691 tep
->info
.offset
+= aux
->seg_base
;
7695 /* Third, apply any relocations to the unwind table: */
7696 for (relsec
= filedata
->section_headers
;
7697 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7700 if (relsec
->sh_type
!= SHT_RELA
7701 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7702 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7705 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7714 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7716 unsigned int sym_ndx
;
7717 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7718 relname
= elf_ia64_reloc_type (r_type
);
7720 /* PR 17531: file: 9fa67536. */
7721 if (relname
== NULL
)
7723 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7727 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7729 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7733 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7735 /* PR 17531: file: 5bc8d9bf. */
7736 if (i
>= aux
->table_len
)
7738 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7742 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7743 if (sym_ndx
>= aux
->nsyms
)
7745 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7749 sym
= aux
->symtab
+ sym_ndx
;
7751 switch (rp
->r_offset
/ eh_addr_size
% 3)
7754 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7755 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7758 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7759 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7762 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7763 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7777 ia64_process_unwind (Filedata
* filedata
)
7779 Elf_Internal_Shdr
* sec
;
7780 Elf_Internal_Shdr
* unwsec
= NULL
;
7781 Elf_Internal_Shdr
* strsec
;
7782 unsigned long i
, unwcount
= 0, unwstart
= 0;
7783 struct ia64_unw_aux_info aux
;
7784 bfd_boolean res
= TRUE
;
7786 memset (& aux
, 0, sizeof (aux
));
7788 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7790 if (sec
->sh_type
== SHT_SYMTAB
7791 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7793 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7795 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7796 if (aux
.strtab
!= NULL
)
7798 error (_("Multiple auxillary string tables encountered\n"));
7802 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7805 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7807 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7812 printf (_("\nThere are no unwind sections in this file.\n"));
7814 while (unwcount
-- > 0)
7819 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7820 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7821 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7826 /* We have already counted the number of SHT_IA64_UNWIND
7827 sections so the loop above should never fail. */
7828 assert (unwsec
!= NULL
);
7831 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7833 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7835 /* We need to find which section group it is in. */
7836 struct group_list
* g
;
7838 if (section_headers_groups
== NULL
7839 || section_headers_groups
[i
] == NULL
)
7840 i
= filedata
->file_header
.e_shnum
;
7843 g
= section_headers_groups
[i
]->root
;
7845 for (; g
!= NULL
; g
= g
->next
)
7847 sec
= filedata
->section_headers
+ g
->section_index
;
7849 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7854 i
= filedata
->file_header
.e_shnum
;
7857 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7859 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7860 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7861 suffix
= SECTION_NAME (unwsec
) + len
;
7862 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7864 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7865 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7870 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7871 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7872 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7873 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7875 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7876 suffix
= SECTION_NAME (unwsec
) + len
;
7877 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7879 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7880 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7884 if (i
== filedata
->file_header
.e_shnum
)
7886 printf (_("\nCould not find unwind info section for "));
7888 if (filedata
->string_table
== NULL
)
7889 printf ("%d", unwsec
->sh_name
);
7891 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7895 aux
.info_addr
= sec
->sh_addr
;
7896 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7899 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7901 printf (_("\nUnwind section "));
7903 if (filedata
->string_table
== NULL
)
7904 printf ("%d", unwsec
->sh_name
);
7906 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7908 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7909 (unsigned long) unwsec
->sh_offset
,
7910 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7912 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7913 && aux
.table_len
> 0)
7914 dump_ia64_unwind (filedata
, & aux
);
7917 free ((char *) aux
.table
);
7919 free ((char *) aux
.info
);
7928 free ((char *) aux
.strtab
);
7933 struct hppa_unw_table_entry
7935 struct absaddr start
;
7937 unsigned int Cannot_unwind
:1; /* 0 */
7938 unsigned int Millicode
:1; /* 1 */
7939 unsigned int Millicode_save_sr0
:1; /* 2 */
7940 unsigned int Region_description
:2; /* 3..4 */
7941 unsigned int reserved1
:1; /* 5 */
7942 unsigned int Entry_SR
:1; /* 6 */
7943 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7944 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7945 unsigned int Args_stored
:1; /* 16 */
7946 unsigned int Variable_Frame
:1; /* 17 */
7947 unsigned int Separate_Package_Body
:1; /* 18 */
7948 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7949 unsigned int Stack_Overflow_Check
:1; /* 20 */
7950 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7951 unsigned int Ada_Region
:1; /* 22 */
7952 unsigned int cxx_info
:1; /* 23 */
7953 unsigned int cxx_try_catch
:1; /* 24 */
7954 unsigned int sched_entry_seq
:1; /* 25 */
7955 unsigned int reserved2
:1; /* 26 */
7956 unsigned int Save_SP
:1; /* 27 */
7957 unsigned int Save_RP
:1; /* 28 */
7958 unsigned int Save_MRP_in_frame
:1; /* 29 */
7959 unsigned int extn_ptr_defined
:1; /* 30 */
7960 unsigned int Cleanup_defined
:1; /* 31 */
7962 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7963 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7964 unsigned int Large_frame
:1; /* 2 */
7965 unsigned int Pseudo_SP_Set
:1; /* 3 */
7966 unsigned int reserved4
:1; /* 4 */
7967 unsigned int Total_frame_size
:27; /* 5..31 */
7970 struct hppa_unw_aux_info
7972 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7973 unsigned long table_len
; /* Length of unwind table. */
7974 bfd_vma seg_base
; /* Starting address of segment. */
7975 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7976 unsigned long nsyms
; /* Number of symbols. */
7977 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7978 unsigned long nfuns
; /* Number of entries in funtab. */
7979 char * strtab
; /* The string table. */
7980 unsigned long strtab_size
; /* Size of string table. */
7984 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7986 struct hppa_unw_table_entry
* tp
;
7987 unsigned long j
, nfuns
;
7988 bfd_boolean res
= TRUE
;
7990 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7991 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7992 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7993 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7995 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7997 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8000 const char * procname
;
8002 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8003 aux
->strtab_size
, tp
->start
, &procname
,
8006 fputs ("\n<", stdout
);
8010 fputs (procname
, stdout
);
8013 printf ("+%lx", (unsigned long) offset
);
8016 fputs (">: [", stdout
);
8017 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8018 fputc ('-', stdout
);
8019 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8022 #define PF(_m) if (tp->_m) printf (#_m " ");
8023 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8026 PF(Millicode_save_sr0
);
8027 /* PV(Region_description); */
8033 PF(Separate_Package_Body
);
8034 PF(Frame_Extension_Millicode
);
8035 PF(Stack_Overflow_Check
);
8036 PF(Two_Instruction_SP_Increment
);
8040 PF(sched_entry_seq
);
8043 PF(Save_MRP_in_frame
);
8044 PF(extn_ptr_defined
);
8045 PF(Cleanup_defined
);
8046 PF(MPE_XL_interrupt_marker
);
8047 PF(HP_UX_interrupt_marker
);
8050 PV(Total_frame_size
);
8063 slurp_hppa_unwind_table (Filedata
* filedata
,
8064 struct hppa_unw_aux_info
* aux
,
8065 Elf_Internal_Shdr
* sec
)
8067 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8068 Elf_Internal_Phdr
* seg
;
8069 struct hppa_unw_table_entry
* tep
;
8070 Elf_Internal_Shdr
* relsec
;
8071 Elf_Internal_Rela
* rela
;
8072 Elf_Internal_Rela
* rp
;
8073 unsigned char * table
;
8075 Elf_Internal_Sym
* sym
;
8076 const char * relname
;
8078 /* First, find the starting address of the segment that includes
8080 if (filedata
->file_header
.e_phnum
)
8082 if (! get_program_headers (filedata
))
8085 for (seg
= filedata
->program_headers
;
8086 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8089 if (seg
->p_type
!= PT_LOAD
)
8092 if (sec
->sh_addr
>= seg
->p_vaddr
8093 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8095 aux
->seg_base
= seg
->p_vaddr
;
8101 /* Second, build the unwind table from the contents of the unwind
8103 size
= sec
->sh_size
;
8104 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8110 nentries
= size
/ unw_ent_size
;
8111 size
= unw_ent_size
* nentries
;
8113 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8114 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8116 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8118 unsigned int tmp1
, tmp2
;
8120 tep
->start
.section
= SHN_UNDEF
;
8121 tep
->end
.section
= SHN_UNDEF
;
8123 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8124 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8125 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8126 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8128 tep
->start
.offset
+= aux
->seg_base
;
8129 tep
->end
.offset
+= aux
->seg_base
;
8131 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8132 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8133 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8134 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8135 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8136 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8137 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8138 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8139 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8140 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8141 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8142 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8143 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8144 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8145 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8146 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8147 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8148 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8149 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8150 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8151 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8152 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8153 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8154 tep
->Cleanup_defined
= tmp1
& 0x1;
8156 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8157 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8158 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8159 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8160 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8161 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8165 /* Third, apply any relocations to the unwind table. */
8166 for (relsec
= filedata
->section_headers
;
8167 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8170 if (relsec
->sh_type
!= SHT_RELA
8171 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8172 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8175 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8179 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8181 unsigned int sym_ndx
;
8182 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8183 relname
= elf_hppa_reloc_type (r_type
);
8185 if (relname
== NULL
)
8187 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8191 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8192 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8194 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8198 i
= rp
->r_offset
/ unw_ent_size
;
8199 if (i
>= aux
->table_len
)
8201 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8205 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8206 if (sym_ndx
>= aux
->nsyms
)
8208 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8212 sym
= aux
->symtab
+ sym_ndx
;
8214 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8217 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8218 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8221 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8222 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8232 aux
->table_len
= nentries
;
8238 hppa_process_unwind (Filedata
* filedata
)
8240 struct hppa_unw_aux_info aux
;
8241 Elf_Internal_Shdr
* unwsec
= NULL
;
8242 Elf_Internal_Shdr
* strsec
;
8243 Elf_Internal_Shdr
* sec
;
8245 bfd_boolean res
= TRUE
;
8247 if (filedata
->string_table
== NULL
)
8250 memset (& aux
, 0, sizeof (aux
));
8252 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8254 if (sec
->sh_type
== SHT_SYMTAB
8255 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8257 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8259 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8260 if (aux
.strtab
!= NULL
)
8262 error (_("Multiple auxillary string tables encountered\n"));
8266 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8269 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8271 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8276 printf (_("\nThere are no unwind sections in this file.\n"));
8278 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8280 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8282 unsigned long num_unwind
= sec
->sh_size
/ 16;
8284 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8285 "contains %lu entry:\n",
8286 "\nUnwind section '%s' at offset 0x%lx "
8287 "contains %lu entries:\n",
8289 printable_section_name (filedata
, sec
),
8290 (unsigned long) sec
->sh_offset
,
8293 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8296 if (res
&& aux
.table_len
> 0)
8298 if (! dump_hppa_unwind (filedata
, &aux
))
8303 free ((char *) aux
.table
);
8311 free ((char *) aux
.strtab
);
8318 unsigned char * data
; /* The unwind data. */
8319 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8320 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8321 unsigned long nrelas
; /* The number of relocations. */
8322 unsigned int rel_type
; /* REL or RELA ? */
8323 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8326 struct arm_unw_aux_info
8328 Filedata
* filedata
; /* The file containing the unwind sections. */
8329 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8330 unsigned long nsyms
; /* Number of symbols. */
8331 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8332 unsigned long nfuns
; /* Number of these symbols. */
8333 char * strtab
; /* The file's string table. */
8334 unsigned long strtab_size
; /* Size of string table. */
8338 arm_print_vma_and_name (Filedata
* filedata
,
8339 struct arm_unw_aux_info
* aux
,
8341 struct absaddr addr
)
8343 const char *procname
;
8346 if (addr
.section
== SHN_UNDEF
)
8349 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8350 aux
->strtab_size
, addr
, &procname
,
8353 print_vma (fn
, PREFIX_HEX
);
8357 fputs (" <", stdout
);
8358 fputs (procname
, stdout
);
8361 printf ("+0x%lx", (unsigned long) sym_offset
);
8362 fputc ('>', stdout
);
8369 arm_free_section (struct arm_section
*arm_sec
)
8371 if (arm_sec
->data
!= NULL
)
8372 free (arm_sec
->data
);
8374 if (arm_sec
->rela
!= NULL
)
8375 free (arm_sec
->rela
);
8378 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8379 cached section and install SEC instead.
8380 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8381 and return its valued in * WORDP, relocating if necessary.
8382 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8383 relocation's offset in ADDR.
8384 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8385 into the string table of the symbol associated with the reloc. If no
8386 reloc was applied store -1 there.
8387 5) Return TRUE upon success, FALSE otherwise. */
8390 get_unwind_section_word (Filedata
* filedata
,
8391 struct arm_unw_aux_info
* aux
,
8392 struct arm_section
* arm_sec
,
8393 Elf_Internal_Shdr
* sec
,
8394 bfd_vma word_offset
,
8395 unsigned int * wordp
,
8396 struct absaddr
* addr
,
8399 Elf_Internal_Rela
*rp
;
8400 Elf_Internal_Sym
*sym
;
8401 const char * relname
;
8403 bfd_boolean wrapped
;
8405 if (sec
== NULL
|| arm_sec
== NULL
)
8408 addr
->section
= SHN_UNDEF
;
8411 if (sym_name
!= NULL
)
8412 *sym_name
= (bfd_vma
) -1;
8414 /* If necessary, update the section cache. */
8415 if (sec
!= arm_sec
->sec
)
8417 Elf_Internal_Shdr
*relsec
;
8419 arm_free_section (arm_sec
);
8422 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8423 sec
->sh_size
, _("unwind data"));
8424 arm_sec
->rela
= NULL
;
8425 arm_sec
->nrelas
= 0;
8427 for (relsec
= filedata
->section_headers
;
8428 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8431 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8432 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8433 /* PR 15745: Check the section type as well. */
8434 || (relsec
->sh_type
!= SHT_REL
8435 && relsec
->sh_type
!= SHT_RELA
))
8438 arm_sec
->rel_type
= relsec
->sh_type
;
8439 if (relsec
->sh_type
== SHT_REL
)
8441 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8443 & arm_sec
->rela
, & arm_sec
->nrelas
))
8446 else /* relsec->sh_type == SHT_RELA */
8448 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8450 & arm_sec
->rela
, & arm_sec
->nrelas
))
8456 arm_sec
->next_rela
= arm_sec
->rela
;
8459 /* If there is no unwind data we can do nothing. */
8460 if (arm_sec
->data
== NULL
)
8463 /* If the offset is invalid then fail. */
8464 if (/* PR 21343 *//* PR 18879 */
8466 || word_offset
> (sec
->sh_size
- 4)
8467 || ((bfd_signed_vma
) word_offset
) < 0)
8470 /* Get the word at the required offset. */
8471 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8473 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8474 if (arm_sec
->rela
== NULL
)
8480 /* Look through the relocs to find the one that applies to the provided offset. */
8482 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8484 bfd_vma prelval
, offset
;
8486 if (rp
->r_offset
> word_offset
&& !wrapped
)
8491 if (rp
->r_offset
> word_offset
)
8494 if (rp
->r_offset
& 3)
8496 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8497 (unsigned long) rp
->r_offset
);
8501 if (rp
->r_offset
< word_offset
)
8504 /* PR 17531: file: 027-161405-0.004 */
8505 if (aux
->symtab
== NULL
)
8508 if (arm_sec
->rel_type
== SHT_REL
)
8510 offset
= word
& 0x7fffffff;
8511 if (offset
& 0x40000000)
8512 offset
|= ~ (bfd_vma
) 0x7fffffff;
8514 else if (arm_sec
->rel_type
== SHT_RELA
)
8515 offset
= rp
->r_addend
;
8518 error (_("Unknown section relocation type %d encountered\n"),
8523 /* PR 17531 file: 027-1241568-0.004. */
8524 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8526 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8527 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8531 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8532 offset
+= sym
->st_value
;
8533 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8535 /* Check that we are processing the expected reloc type. */
8536 if (filedata
->file_header
.e_machine
== EM_ARM
)
8538 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8539 if (relname
== NULL
)
8541 warn (_("Skipping unknown ARM relocation type: %d\n"),
8542 (int) ELF32_R_TYPE (rp
->r_info
));
8546 if (streq (relname
, "R_ARM_NONE"))
8549 if (! streq (relname
, "R_ARM_PREL31"))
8551 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8555 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8557 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8558 if (relname
== NULL
)
8560 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8561 (int) ELF32_R_TYPE (rp
->r_info
));
8565 if (streq (relname
, "R_C6000_NONE"))
8568 if (! streq (relname
, "R_C6000_PREL31"))
8570 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8578 /* This function currently only supports ARM and TI unwinders. */
8579 warn (_("Only TI and ARM unwinders are currently supported\n"));
8583 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8584 addr
->section
= sym
->st_shndx
;
8585 addr
->offset
= offset
;
8588 * sym_name
= sym
->st_name
;
8593 arm_sec
->next_rela
= rp
;
8598 static const char *tic6x_unwind_regnames
[16] =
8600 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8601 "A14", "A13", "A12", "A11", "A10",
8602 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8606 decode_tic6x_unwind_regmask (unsigned int mask
)
8610 for (i
= 12; mask
; mask
>>= 1, i
--)
8614 fputs (tic6x_unwind_regnames
[i
], stdout
);
8616 fputs (", ", stdout
);
8622 if (remaining == 0 && more_words) \
8625 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8626 data_offset, & word, & addr, NULL)) \
8632 #define GET_OP(OP) \
8637 (OP) = word >> 24; \
8642 printf (_("[Truncated opcode]\n")); \
8645 printf ("0x%02x ", OP)
8648 decode_arm_unwind_bytecode (Filedata
* filedata
,
8649 struct arm_unw_aux_info
* aux
,
8651 unsigned int remaining
,
8652 unsigned int more_words
,
8653 bfd_vma data_offset
,
8654 Elf_Internal_Shdr
* data_sec
,
8655 struct arm_section
* data_arm_sec
)
8657 struct absaddr addr
;
8658 bfd_boolean res
= TRUE
;
8660 /* Decode the unwinding instructions. */
8663 unsigned int op
, op2
;
8672 printf (" 0x%02x ", op
);
8674 if ((op
& 0xc0) == 0x00)
8676 int offset
= ((op
& 0x3f) << 2) + 4;
8678 printf (" vsp = vsp + %d", offset
);
8680 else if ((op
& 0xc0) == 0x40)
8682 int offset
= ((op
& 0x3f) << 2) + 4;
8684 printf (" vsp = vsp - %d", offset
);
8686 else if ((op
& 0xf0) == 0x80)
8689 if (op
== 0x80 && op2
== 0)
8690 printf (_("Refuse to unwind"));
8693 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8694 bfd_boolean first
= TRUE
;
8698 for (i
= 0; i
< 12; i
++)
8699 if (mask
& (1 << i
))
8705 printf ("r%d", 4 + i
);
8710 else if ((op
& 0xf0) == 0x90)
8712 if (op
== 0x9d || op
== 0x9f)
8713 printf (_(" [Reserved]"));
8715 printf (" vsp = r%d", op
& 0x0f);
8717 else if ((op
& 0xf0) == 0xa0)
8719 int end
= 4 + (op
& 0x07);
8720 bfd_boolean first
= TRUE
;
8724 for (i
= 4; i
<= end
; i
++)
8740 else if (op
== 0xb0)
8741 printf (_(" finish"));
8742 else if (op
== 0xb1)
8745 if (op2
== 0 || (op2
& 0xf0) != 0)
8746 printf (_("[Spare]"));
8749 unsigned int mask
= op2
& 0x0f;
8750 bfd_boolean first
= TRUE
;
8754 for (i
= 0; i
< 12; i
++)
8755 if (mask
& (1 << i
))
8766 else if (op
== 0xb2)
8768 unsigned char buf
[9];
8769 unsigned int i
, len
;
8770 unsigned long offset
;
8772 for (i
= 0; i
< sizeof (buf
); i
++)
8775 if ((buf
[i
] & 0x80) == 0)
8778 if (i
== sizeof (buf
))
8780 error (_("corrupt change to vsp"));
8785 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8786 assert (len
== i
+ 1);
8787 offset
= offset
* 4 + 0x204;
8788 printf ("vsp = vsp + %ld", offset
);
8791 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8793 unsigned int first
, last
;
8800 printf ("pop {D%d", first
);
8802 printf ("-D%d", first
+ last
);
8805 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8807 unsigned int count
= op
& 0x07;
8811 printf ("-D%d", 8 + count
);
8814 else if (op
>= 0xc0 && op
<= 0xc5)
8816 unsigned int count
= op
& 0x07;
8818 printf (" pop {wR10");
8820 printf ("-wR%d", 10 + count
);
8823 else if (op
== 0xc6)
8825 unsigned int first
, last
;
8830 printf ("pop {wR%d", first
);
8832 printf ("-wR%d", first
+ last
);
8835 else if (op
== 0xc7)
8838 if (op2
== 0 || (op2
& 0xf0) != 0)
8839 printf (_("[Spare]"));
8842 unsigned int mask
= op2
& 0x0f;
8843 bfd_boolean first
= TRUE
;
8847 for (i
= 0; i
< 4; i
++)
8848 if (mask
& (1 << i
))
8854 printf ("wCGR%d", i
);
8861 printf (_(" [unsupported opcode]"));
8872 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8873 struct arm_unw_aux_info
* aux
,
8875 unsigned int remaining
,
8876 unsigned int more_words
,
8877 bfd_vma data_offset
,
8878 Elf_Internal_Shdr
* data_sec
,
8879 struct arm_section
* data_arm_sec
)
8881 struct absaddr addr
;
8883 /* Decode the unwinding instructions. */
8886 unsigned int op
, op2
;
8895 printf (" 0x%02x ", op
);
8897 if ((op
& 0xc0) == 0x00)
8899 int offset
= ((op
& 0x3f) << 3) + 8;
8900 printf (" sp = sp + %d", offset
);
8902 else if ((op
& 0xc0) == 0x80)
8905 if (op
== 0x80 && op2
== 0)
8906 printf (_("Refuse to unwind"));
8909 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8911 printf ("pop compact {");
8915 decode_tic6x_unwind_regmask (mask
);
8919 else if ((op
& 0xf0) == 0xc0)
8927 unsigned int offset
;
8931 /* Scan entire instruction first so that GET_OP output is not
8932 interleaved with disassembly. */
8934 for (i
= 0; nregs
< (op
& 0xf); i
++)
8940 regpos
[nregs
].offset
= i
* 2;
8941 regpos
[nregs
].reg
= reg
;
8948 regpos
[nregs
].offset
= i
* 2 + 1;
8949 regpos
[nregs
].reg
= reg
;
8954 printf (_("pop frame {"));
8957 printf (_("*corrupt* - no registers specified"));
8962 for (i
= i
* 2; i
> 0; i
--)
8964 if (regpos
[reg
].offset
== i
- 1)
8966 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8973 fputs (name
, stdout
);
8981 else if (op
== 0xd0)
8982 printf (" MOV FP, SP");
8983 else if (op
== 0xd1)
8984 printf (" __c6xabi_pop_rts");
8985 else if (op
== 0xd2)
8987 unsigned char buf
[9];
8988 unsigned int i
, len
;
8989 unsigned long offset
;
8991 for (i
= 0; i
< sizeof (buf
); i
++)
8994 if ((buf
[i
] & 0x80) == 0)
8997 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8998 if (i
== sizeof (buf
))
9000 warn (_("Corrupt stack pointer adjustment detected\n"));
9004 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
9005 assert (len
== i
+ 1);
9006 offset
= offset
* 8 + 0x408;
9007 printf (_("sp = sp + %ld"), offset
);
9009 else if ((op
& 0xf0) == 0xe0)
9011 if ((op
& 0x0f) == 7)
9014 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9018 printf (_(" [unsupported opcode]"));
9027 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9031 offset
= word
& 0x7fffffff;
9032 if (offset
& 0x40000000)
9033 offset
|= ~ (bfd_vma
) 0x7fffffff;
9035 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9038 return offset
+ where
;
9042 decode_arm_unwind (Filedata
* filedata
,
9043 struct arm_unw_aux_info
* aux
,
9045 unsigned int remaining
,
9046 bfd_vma data_offset
,
9047 Elf_Internal_Shdr
* data_sec
,
9048 struct arm_section
* data_arm_sec
)
9051 unsigned int more_words
= 0;
9052 struct absaddr addr
;
9053 bfd_vma sym_name
= (bfd_vma
) -1;
9054 bfd_boolean res
= TRUE
;
9058 /* Fetch the first word.
9059 Note - when decoding an object file the address extracted
9060 here will always be 0. So we also pass in the sym_name
9061 parameter so that we can find the symbol associated with
9062 the personality routine. */
9063 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9064 & word
, & addr
, & sym_name
))
9071 addr
.section
= SHN_UNDEF
;
9075 if ((word
& 0x80000000) == 0)
9077 /* Expand prel31 for personality routine. */
9079 const char *procname
;
9081 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9082 printf (_(" Personality routine: "));
9084 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9085 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9087 procname
= aux
->strtab
+ sym_name
;
9088 print_vma (fn
, PREFIX_HEX
);
9091 fputs (" <", stdout
);
9092 fputs (procname
, stdout
);
9093 fputc ('>', stdout
);
9097 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9098 fputc ('\n', stdout
);
9100 /* The GCC personality routines use the standard compact
9101 encoding, starting with one byte giving the number of
9103 if (procname
!= NULL
9104 && (const_strneq (procname
, "__gcc_personality_v0")
9105 || const_strneq (procname
, "__gxx_personality_v0")
9106 || const_strneq (procname
, "__gcj_personality_v0")
9107 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9114 printf (_(" [Truncated data]\n"));
9117 more_words
= word
>> 24;
9127 /* ARM EHABI Section 6.3:
9129 An exception-handling table entry for the compact model looks like:
9133 1 0 index Data for personalityRoutine[index] */
9135 if (filedata
->file_header
.e_machine
== EM_ARM
9136 && (word
& 0x70000000))
9138 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9142 per_index
= (word
>> 24) & 0x7f;
9143 printf (_(" Compact model index: %d\n"), per_index
);
9150 else if (per_index
< 3)
9152 more_words
= (word
>> 16) & 0xff;
9158 switch (filedata
->file_header
.e_machine
)
9163 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9164 data_offset
, data_sec
, data_arm_sec
))
9169 warn (_("Unknown ARM compact model index encountered\n"));
9170 printf (_(" [reserved]\n"));
9178 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9179 data_offset
, data_sec
, data_arm_sec
))
9182 else if (per_index
< 5)
9184 if (((word
>> 17) & 0x7f) == 0x7f)
9185 printf (_(" Restore stack from frame pointer\n"));
9187 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9188 printf (_(" Registers restored: "));
9190 printf (" (compact) ");
9191 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9193 printf (_(" Return register: %s\n"),
9194 tic6x_unwind_regnames
[word
& 0xf]);
9197 printf (_(" [reserved (%d)]\n"), per_index
);
9201 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9202 filedata
->file_header
.e_machine
);
9206 /* Decode the descriptors. Not implemented. */
9212 dump_arm_unwind (Filedata
* filedata
,
9213 struct arm_unw_aux_info
* aux
,
9214 Elf_Internal_Shdr
* exidx_sec
)
9216 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9217 unsigned int i
, exidx_len
;
9218 unsigned long j
, nfuns
;
9219 bfd_boolean res
= TRUE
;
9221 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9222 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9223 exidx_len
= exidx_sec
->sh_size
/ 8;
9225 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9226 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9227 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9228 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9230 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9232 for (i
= 0; i
< exidx_len
; i
++)
9234 unsigned int exidx_fn
, exidx_entry
;
9235 struct absaddr fn_addr
, entry_addr
;
9238 fputc ('\n', stdout
);
9240 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9241 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9242 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9243 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9246 arm_free_section (& exidx_arm_sec
);
9247 arm_free_section (& extab_arm_sec
);
9251 /* ARM EHABI, Section 5:
9252 An index table entry consists of 2 words.
9253 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9254 if (exidx_fn
& 0x80000000)
9256 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9260 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9262 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9263 fputs (": ", stdout
);
9265 if (exidx_entry
== 1)
9267 print_vma (exidx_entry
, PREFIX_HEX
);
9268 fputs (" [cantunwind]\n", stdout
);
9270 else if (exidx_entry
& 0x80000000)
9272 print_vma (exidx_entry
, PREFIX_HEX
);
9273 fputc ('\n', stdout
);
9274 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9278 bfd_vma table
, table_offset
= 0;
9279 Elf_Internal_Shdr
*table_sec
;
9281 fputs ("@", stdout
);
9282 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9283 print_vma (table
, PREFIX_HEX
);
9286 /* Locate the matching .ARM.extab. */
9287 if (entry_addr
.section
!= SHN_UNDEF
9288 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9290 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9291 table_offset
= entry_addr
.offset
;
9293 if (table_offset
> table_sec
->sh_size
9294 || ((bfd_signed_vma
) table_offset
) < 0)
9296 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9297 (unsigned long) table_offset
,
9298 printable_section_name (filedata
, table_sec
));
9305 table_sec
= find_section_by_address (filedata
, table
);
9306 if (table_sec
!= NULL
)
9307 table_offset
= table
- table_sec
->sh_addr
;
9310 if (table_sec
== NULL
)
9312 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9313 (unsigned long) table
);
9318 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9327 arm_free_section (&exidx_arm_sec
);
9328 arm_free_section (&extab_arm_sec
);
9333 /* Used for both ARM and C6X unwinding tables. */
9336 arm_process_unwind (Filedata
* filedata
)
9338 struct arm_unw_aux_info aux
;
9339 Elf_Internal_Shdr
*unwsec
= NULL
;
9340 Elf_Internal_Shdr
*strsec
;
9341 Elf_Internal_Shdr
*sec
;
9343 unsigned int sec_type
;
9344 bfd_boolean res
= TRUE
;
9346 switch (filedata
->file_header
.e_machine
)
9349 sec_type
= SHT_ARM_EXIDX
;
9353 sec_type
= SHT_C6000_UNWIND
;
9357 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9358 filedata
->file_header
.e_machine
);
9362 if (filedata
->string_table
== NULL
)
9365 memset (& aux
, 0, sizeof (aux
));
9366 aux
.filedata
= filedata
;
9368 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9370 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9372 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9374 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9376 /* PR binutils/17531 file: 011-12666-0.004. */
9377 if (aux
.strtab
!= NULL
)
9379 error (_("Multiple string tables found in file.\n"));
9383 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9384 1, strsec
->sh_size
, _("string table"));
9385 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9387 else if (sec
->sh_type
== sec_type
)
9392 printf (_("\nThere are no unwind sections in this file.\n"));
9394 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9396 if (sec
->sh_type
== sec_type
)
9398 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9399 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9400 "contains %lu entry:\n",
9401 "\nUnwind section '%s' at offset 0x%lx "
9402 "contains %lu entries:\n",
9404 printable_section_name (filedata
, sec
),
9405 (unsigned long) sec
->sh_offset
,
9408 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9416 free ((char *) aux
.strtab
);
9422 process_unwind (Filedata
* filedata
)
9424 struct unwind_handler
9426 unsigned int machtype
;
9427 bfd_boolean (* handler
)(Filedata
*);
9430 { EM_ARM
, arm_process_unwind
},
9431 { EM_IA_64
, ia64_process_unwind
},
9432 { EM_PARISC
, hppa_process_unwind
},
9433 { EM_TI_C6000
, arm_process_unwind
},
9441 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9442 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9443 return handlers
[i
].handler (filedata
);
9445 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9446 get_machine_name (filedata
->file_header
.e_machine
));
9451 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9453 switch (entry
->d_tag
)
9455 case DT_AARCH64_BTI_PLT
:
9456 case DT_AARCH64_PAC_PLT
:
9459 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9466 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9468 switch (entry
->d_tag
)
9471 if (entry
->d_un
.d_val
== 0)
9475 static const char * opts
[] =
9477 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9478 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9479 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9480 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9484 bfd_boolean first
= TRUE
;
9486 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9487 if (entry
->d_un
.d_val
& (1 << cnt
))
9489 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9495 case DT_MIPS_IVERSION
:
9496 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9497 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9501 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9502 /* Note: coded this way so that there is a single string for translation. */
9503 printf (_("<corrupt: %s>"), buf
);
9507 case DT_MIPS_TIME_STAMP
:
9511 time_t atime
= entry
->d_un
.d_val
;
9513 tmp
= gmtime (&atime
);
9514 /* PR 17531: file: 6accc532. */
9516 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9518 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9519 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9520 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9521 printf (_("Time Stamp: %s"), timebuf
);
9525 case DT_MIPS_RLD_VERSION
:
9526 case DT_MIPS_LOCAL_GOTNO
:
9527 case DT_MIPS_CONFLICTNO
:
9528 case DT_MIPS_LIBLISTNO
:
9529 case DT_MIPS_SYMTABNO
:
9530 case DT_MIPS_UNREFEXTNO
:
9531 case DT_MIPS_HIPAGENO
:
9532 case DT_MIPS_DELTA_CLASS_NO
:
9533 case DT_MIPS_DELTA_INSTANCE_NO
:
9534 case DT_MIPS_DELTA_RELOC_NO
:
9535 case DT_MIPS_DELTA_SYM_NO
:
9536 case DT_MIPS_DELTA_CLASSSYM_NO
:
9537 case DT_MIPS_COMPACT_SIZE
:
9538 print_vma (entry
->d_un
.d_val
, DEC
);
9542 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9543 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9544 /* Falls through. */
9547 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9553 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9555 switch (entry
->d_tag
)
9557 case DT_HP_DLD_FLAGS
:
9566 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9567 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9568 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9569 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9570 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9571 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9572 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9573 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9574 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9575 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9576 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9577 { DT_HP_GST
, "HP_GST" },
9578 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9579 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9580 { DT_HP_NODELETE
, "HP_NODELETE" },
9581 { DT_HP_GROUP
, "HP_GROUP" },
9582 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9584 bfd_boolean first
= TRUE
;
9586 bfd_vma val
= entry
->d_un
.d_val
;
9588 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9589 if (val
& flags
[cnt
].bit
)
9593 fputs (flags
[cnt
].str
, stdout
);
9595 val
^= flags
[cnt
].bit
;
9598 if (val
!= 0 || first
)
9602 print_vma (val
, HEX
);
9608 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9616 /* VMS vs Unix time offset and factor. */
9618 #define VMS_EPOCH_OFFSET 35067168000000000LL
9619 #define VMS_GRANULARITY_FACTOR 10000000
9621 /* Display a VMS time in a human readable format. */
9624 print_vms_time (bfd_int64_t vmstime
)
9629 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9630 tm
= gmtime (&unxtime
);
9631 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9632 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9633 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9638 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9640 switch (entry
->d_tag
)
9642 case DT_IA_64_PLT_RESERVE
:
9643 /* First 3 slots reserved. */
9644 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9646 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9649 case DT_IA_64_VMS_LINKTIME
:
9651 print_vms_time (entry
->d_un
.d_val
);
9655 case DT_IA_64_VMS_LNKFLAGS
:
9656 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9657 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9658 printf (" CALL_DEBUG");
9659 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9660 printf (" NOP0BUFS");
9661 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9662 printf (" P0IMAGE");
9663 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9664 printf (" MKTHREADS");
9665 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9666 printf (" UPCALLS");
9667 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9669 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9670 printf (" INITIALIZE");
9671 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9673 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9674 printf (" EXE_INIT");
9675 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9676 printf (" TBK_IN_IMG");
9677 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9678 printf (" DBG_IN_IMG");
9679 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9680 printf (" TBK_IN_DSF");
9681 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9682 printf (" DBG_IN_DSF");
9683 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9684 printf (" SIGNATURES");
9685 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9686 printf (" REL_SEG_OFF");
9690 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9697 get_32bit_dynamic_section (Filedata
* filedata
)
9699 Elf32_External_Dyn
* edyn
;
9700 Elf32_External_Dyn
* ext
;
9701 Elf_Internal_Dyn
* entry
;
9703 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9704 dynamic_size
, _("dynamic section"));
9708 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9709 might not have the luxury of section headers. Look for the DT_NULL
9710 terminator to determine the number of entries. */
9711 for (ext
= edyn
, dynamic_nent
= 0;
9712 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9716 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9720 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9722 if (dynamic_section
== NULL
)
9724 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9725 (unsigned long) dynamic_nent
);
9730 for (ext
= edyn
, entry
= dynamic_section
;
9731 entry
< dynamic_section
+ dynamic_nent
;
9734 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9735 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9744 get_64bit_dynamic_section (Filedata
* filedata
)
9746 Elf64_External_Dyn
* edyn
;
9747 Elf64_External_Dyn
* ext
;
9748 Elf_Internal_Dyn
* entry
;
9750 /* Read in the data. */
9751 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9752 dynamic_size
, _("dynamic section"));
9756 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9757 might not have the luxury of section headers. Look for the DT_NULL
9758 terminator to determine the number of entries. */
9759 for (ext
= edyn
, dynamic_nent
= 0;
9760 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9761 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9765 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9769 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9771 if (dynamic_section
== NULL
)
9773 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9774 (unsigned long) dynamic_nent
);
9779 /* Convert from external to internal formats. */
9780 for (ext
= edyn
, entry
= dynamic_section
;
9781 entry
< dynamic_section
+ dynamic_nent
;
9784 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9785 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9794 print_dynamic_flags (bfd_vma flags
)
9796 bfd_boolean first
= TRUE
;
9802 flag
= flags
& - flags
;
9812 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9813 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9814 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9815 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9816 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9817 default: fputs (_("unknown"), stdout
); break;
9823 /* Parse and display the contents of the dynamic section. */
9826 process_dynamic_section (Filedata
* filedata
)
9828 Elf_Internal_Dyn
* entry
;
9830 if (dynamic_size
== 0)
9833 printf (_("\nThere is no dynamic section in this file.\n"));
9840 if (! get_32bit_dynamic_section (filedata
))
9845 if (! get_64bit_dynamic_section (filedata
))
9849 /* Find the appropriate symbol table. */
9850 if (dynamic_symbols
== NULL
)
9852 for (entry
= dynamic_section
;
9853 entry
< dynamic_section
+ dynamic_nent
;
9856 Elf_Internal_Shdr section
;
9858 if (entry
->d_tag
!= DT_SYMTAB
)
9861 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9863 /* Since we do not know how big the symbol table is,
9864 we default to reading in the entire file (!) and
9865 processing that. This is overkill, I know, but it
9867 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9868 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9870 /* See PR 21379 for a reproducer. */
9871 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9875 if (archive_file_offset
!= 0)
9876 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9878 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9881 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9883 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9884 section
.sh_name
= filedata
->string_table_length
;
9886 if (dynamic_symbols
!= NULL
)
9888 error (_("Multiple dynamic symbol table sections found\n"));
9889 free (dynamic_symbols
);
9891 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9892 if (num_dynamic_syms
< 1)
9894 error (_("Unable to determine the number of symbols to load\n"));
9900 /* Similarly find a string table. */
9901 if (dynamic_strings
== NULL
)
9903 for (entry
= dynamic_section
;
9904 entry
< dynamic_section
+ dynamic_nent
;
9907 unsigned long offset
;
9910 if (entry
->d_tag
!= DT_STRTAB
)
9913 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9915 /* Since we do not know how big the string table is,
9916 we default to reading in the entire file (!) and
9917 processing that. This is overkill, I know, but it
9920 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9922 if (archive_file_offset
!= 0)
9923 str_tab_len
= archive_file_size
- offset
;
9925 str_tab_len
= filedata
->file_size
- offset
;
9927 if (str_tab_len
< 1)
9930 (_("Unable to determine the length of the dynamic string table\n"));
9934 if (dynamic_strings
!= NULL
)
9936 error (_("Multiple dynamic string tables found\n"));
9937 free (dynamic_strings
);
9940 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9942 _("dynamic string table"));
9943 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9947 /* And find the syminfo section if available. */
9948 if (dynamic_syminfo
== NULL
)
9950 unsigned long syminsz
= 0;
9952 for (entry
= dynamic_section
;
9953 entry
< dynamic_section
+ dynamic_nent
;
9956 if (entry
->d_tag
== DT_SYMINENT
)
9958 /* Note: these braces are necessary to avoid a syntax
9959 error from the SunOS4 C compiler. */
9960 /* PR binutils/17531: A corrupt file can trigger this test.
9961 So do not use an assert, instead generate an error message. */
9962 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9963 error (_("Bad value (%d) for SYMINENT entry\n"),
9964 (int) entry
->d_un
.d_val
);
9966 else if (entry
->d_tag
== DT_SYMINSZ
)
9967 syminsz
= entry
->d_un
.d_val
;
9968 else if (entry
->d_tag
== DT_SYMINFO
)
9969 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9973 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9975 Elf_External_Syminfo
* extsyminfo
;
9976 Elf_External_Syminfo
* extsym
;
9977 Elf_Internal_Syminfo
* syminfo
;
9979 /* There is a syminfo section. Read the data. */
9980 extsyminfo
= (Elf_External_Syminfo
*)
9981 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9982 _("symbol information"));
9986 if (dynamic_syminfo
!= NULL
)
9988 error (_("Multiple dynamic symbol information sections found\n"));
9989 free (dynamic_syminfo
);
9991 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9992 if (dynamic_syminfo
== NULL
)
9994 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9995 (unsigned long) syminsz
);
9999 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10000 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10001 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10002 ++syminfo
, ++extsym
)
10004 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10005 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10012 if (do_dynamic
&& dynamic_addr
)
10013 printf (ngettext ("\nDynamic section at offset 0x%lx "
10014 "contains %lu entry:\n",
10015 "\nDynamic section at offset 0x%lx "
10016 "contains %lu entries:\n",
10018 dynamic_addr
, (unsigned long) dynamic_nent
);
10020 printf (_(" Tag Type Name/Value\n"));
10022 for (entry
= dynamic_section
;
10023 entry
< dynamic_section
+ dynamic_nent
;
10028 const char * dtype
;
10031 print_vma (entry
->d_tag
, FULL_HEX
);
10032 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10033 printf (" (%s)%*s", dtype
,
10034 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10037 switch (entry
->d_tag
)
10041 print_dynamic_flags (entry
->d_un
.d_val
);
10051 switch (entry
->d_tag
)
10054 printf (_("Auxiliary library"));
10058 printf (_("Filter library"));
10062 printf (_("Configuration file"));
10066 printf (_("Dependency audit library"));
10070 printf (_("Audit library"));
10074 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10075 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10079 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10088 printf (_("Flags:"));
10090 if (entry
->d_un
.d_val
== 0)
10091 printf (_(" None\n"));
10094 unsigned long int val
= entry
->d_un
.d_val
;
10096 if (val
& DTF_1_PARINIT
)
10098 printf (" PARINIT");
10099 val
^= DTF_1_PARINIT
;
10101 if (val
& DTF_1_CONFEXP
)
10103 printf (" CONFEXP");
10104 val
^= DTF_1_CONFEXP
;
10107 printf (" %lx", val
);
10116 printf (_("Flags:"));
10118 if (entry
->d_un
.d_val
== 0)
10119 printf (_(" None\n"));
10122 unsigned long int val
= entry
->d_un
.d_val
;
10124 if (val
& DF_P1_LAZYLOAD
)
10126 printf (" LAZYLOAD");
10127 val
^= DF_P1_LAZYLOAD
;
10129 if (val
& DF_P1_GROUPPERM
)
10131 printf (" GROUPPERM");
10132 val
^= DF_P1_GROUPPERM
;
10135 printf (" %lx", val
);
10144 printf (_("Flags:"));
10145 if (entry
->d_un
.d_val
== 0)
10146 printf (_(" None\n"));
10149 unsigned long int val
= entry
->d_un
.d_val
;
10151 if (val
& DF_1_NOW
)
10156 if (val
& DF_1_GLOBAL
)
10158 printf (" GLOBAL");
10159 val
^= DF_1_GLOBAL
;
10161 if (val
& DF_1_GROUP
)
10166 if (val
& DF_1_NODELETE
)
10168 printf (" NODELETE");
10169 val
^= DF_1_NODELETE
;
10171 if (val
& DF_1_LOADFLTR
)
10173 printf (" LOADFLTR");
10174 val
^= DF_1_LOADFLTR
;
10176 if (val
& DF_1_INITFIRST
)
10178 printf (" INITFIRST");
10179 val
^= DF_1_INITFIRST
;
10181 if (val
& DF_1_NOOPEN
)
10183 printf (" NOOPEN");
10184 val
^= DF_1_NOOPEN
;
10186 if (val
& DF_1_ORIGIN
)
10188 printf (" ORIGIN");
10189 val
^= DF_1_ORIGIN
;
10191 if (val
& DF_1_DIRECT
)
10193 printf (" DIRECT");
10194 val
^= DF_1_DIRECT
;
10196 if (val
& DF_1_TRANS
)
10201 if (val
& DF_1_INTERPOSE
)
10203 printf (" INTERPOSE");
10204 val
^= DF_1_INTERPOSE
;
10206 if (val
& DF_1_NODEFLIB
)
10208 printf (" NODEFLIB");
10209 val
^= DF_1_NODEFLIB
;
10211 if (val
& DF_1_NODUMP
)
10213 printf (" NODUMP");
10214 val
^= DF_1_NODUMP
;
10216 if (val
& DF_1_CONFALT
)
10218 printf (" CONFALT");
10219 val
^= DF_1_CONFALT
;
10221 if (val
& DF_1_ENDFILTEE
)
10223 printf (" ENDFILTEE");
10224 val
^= DF_1_ENDFILTEE
;
10226 if (val
& DF_1_DISPRELDNE
)
10228 printf (" DISPRELDNE");
10229 val
^= DF_1_DISPRELDNE
;
10231 if (val
& DF_1_DISPRELPND
)
10233 printf (" DISPRELPND");
10234 val
^= DF_1_DISPRELPND
;
10236 if (val
& DF_1_NODIRECT
)
10238 printf (" NODIRECT");
10239 val
^= DF_1_NODIRECT
;
10241 if (val
& DF_1_IGNMULDEF
)
10243 printf (" IGNMULDEF");
10244 val
^= DF_1_IGNMULDEF
;
10246 if (val
& DF_1_NOKSYMS
)
10248 printf (" NOKSYMS");
10249 val
^= DF_1_NOKSYMS
;
10251 if (val
& DF_1_NOHDR
)
10256 if (val
& DF_1_EDITED
)
10258 printf (" EDITED");
10259 val
^= DF_1_EDITED
;
10261 if (val
& DF_1_NORELOC
)
10263 printf (" NORELOC");
10264 val
^= DF_1_NORELOC
;
10266 if (val
& DF_1_SYMINTPOSE
)
10268 printf (" SYMINTPOSE");
10269 val
^= DF_1_SYMINTPOSE
;
10271 if (val
& DF_1_GLOBAUDIT
)
10273 printf (" GLOBAUDIT");
10274 val
^= DF_1_GLOBAUDIT
;
10276 if (val
& DF_1_SINGLETON
)
10278 printf (" SINGLETON");
10279 val
^= DF_1_SINGLETON
;
10281 if (val
& DF_1_STUB
)
10286 if (val
& DF_1_PIE
)
10291 if (val
& DF_1_KMOD
)
10296 if (val
& DF_1_WEAKFILTER
)
10298 printf (" WEAKFILTER");
10299 val
^= DF_1_WEAKFILTER
;
10301 if (val
& DF_1_NOCOMMON
)
10303 printf (" NOCOMMON");
10304 val
^= DF_1_NOCOMMON
;
10307 printf (" %lx", val
);
10314 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10316 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10336 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10342 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10343 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10349 switch (entry
->d_tag
)
10352 printf (_("Shared library: [%s]"), name
);
10354 if (streq (name
, program_interpreter
))
10355 printf (_(" program interpreter"));
10359 printf (_("Library soname: [%s]"), name
);
10363 printf (_("Library rpath: [%s]"), name
);
10367 printf (_("Library runpath: [%s]"), name
);
10371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10376 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10389 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10390 /* Fall through. */
10394 case DT_INIT_ARRAYSZ
:
10395 case DT_FINI_ARRAYSZ
:
10396 case DT_GNU_CONFLICTSZ
:
10397 case DT_GNU_LIBLISTSZ
:
10400 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10401 printf (_(" (bytes)\n"));
10406 case DT_VERNEEDNUM
:
10411 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10420 case DT_INIT_ARRAY
:
10421 case DT_FINI_ARRAY
:
10424 if (entry
->d_tag
== DT_USED
10425 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10427 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10431 printf (_("Not needed object: [%s]\n"), name
);
10436 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10442 /* The value of this entry is ignored. */
10447 case DT_GNU_PRELINKED
:
10451 time_t atime
= entry
->d_un
.d_val
;
10453 tmp
= gmtime (&atime
);
10454 /* PR 17533 file: 041-1244816-0.004. */
10456 printf (_("<corrupt time val: %lx"),
10457 (unsigned long) atime
);
10459 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10460 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10461 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10467 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10470 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10476 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10477 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10482 switch (filedata
->file_header
.e_machine
)
10485 dynamic_section_aarch64_val (entry
);
10488 case EM_MIPS_RS3_LE
:
10489 dynamic_section_mips_val (entry
);
10492 dynamic_section_parisc_val (entry
);
10495 dynamic_section_ia64_val (entry
);
10498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10510 get_ver_flags (unsigned int flags
)
10512 static char buff
[128];
10519 if (flags
& VER_FLG_BASE
)
10520 strcat (buff
, "BASE");
10522 if (flags
& VER_FLG_WEAK
)
10524 if (flags
& VER_FLG_BASE
)
10525 strcat (buff
, " | ");
10527 strcat (buff
, "WEAK");
10530 if (flags
& VER_FLG_INFO
)
10532 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10533 strcat (buff
, " | ");
10535 strcat (buff
, "INFO");
10538 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10540 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10541 strcat (buff
, " | ");
10543 strcat (buff
, _("<unknown>"));
10549 /* Display the contents of the version sections. */
10552 process_version_sections (Filedata
* filedata
)
10554 Elf_Internal_Shdr
* section
;
10556 bfd_boolean found
= FALSE
;
10561 for (i
= 0, section
= filedata
->section_headers
;
10562 i
< filedata
->file_header
.e_shnum
;
10565 switch (section
->sh_type
)
10567 case SHT_GNU_verdef
:
10569 Elf_External_Verdef
* edefs
;
10576 printf (ngettext ("\nVersion definition section '%s' "
10577 "contains %u entry:\n",
10578 "\nVersion definition section '%s' "
10579 "contains %u entries:\n",
10581 printable_section_name (filedata
, section
),
10584 printf (_(" Addr: 0x"));
10585 printf_vma (section
->sh_addr
);
10586 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10587 (unsigned long) section
->sh_offset
, section
->sh_link
,
10588 printable_section_name_from_index (filedata
, section
->sh_link
));
10590 edefs
= (Elf_External_Verdef
*)
10591 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10592 _("version definition section"));
10595 endbuf
= (char *) edefs
+ section
->sh_size
;
10597 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10600 Elf_External_Verdef
* edef
;
10601 Elf_Internal_Verdef ent
;
10602 Elf_External_Verdaux
* eaux
;
10603 Elf_Internal_Verdaux aux
;
10604 unsigned long isum
;
10607 vstart
= ((char *) edefs
) + idx
;
10608 if (vstart
+ sizeof (*edef
) > endbuf
)
10611 edef
= (Elf_External_Verdef
*) vstart
;
10613 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10614 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10615 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10616 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10617 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10618 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10619 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10621 printf (_(" %#06lx: Rev: %d Flags: %s"),
10622 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10624 printf (_(" Index: %d Cnt: %d "),
10625 ent
.vd_ndx
, ent
.vd_cnt
);
10627 /* Check for overflow. */
10628 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10631 vstart
+= ent
.vd_aux
;
10633 if (vstart
+ sizeof (*eaux
) > endbuf
)
10635 eaux
= (Elf_External_Verdaux
*) vstart
;
10637 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10638 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10640 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10641 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10643 printf (_("Name index: %ld\n"), aux
.vda_name
);
10645 isum
= idx
+ ent
.vd_aux
;
10647 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10649 if (aux
.vda_next
< sizeof (*eaux
)
10650 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10652 warn (_("Invalid vda_next field of %lx\n"),
10657 /* Check for overflow. */
10658 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10661 isum
+= aux
.vda_next
;
10662 vstart
+= aux
.vda_next
;
10664 if (vstart
+ sizeof (*eaux
) > endbuf
)
10666 eaux
= (Elf_External_Verdaux
*) vstart
;
10668 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10669 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10671 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10672 printf (_(" %#06lx: Parent %d: %s\n"),
10673 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10675 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10676 isum
, j
, aux
.vda_name
);
10679 if (j
< ent
.vd_cnt
)
10680 printf (_(" Version def aux past end of section\n"));
10683 file: id:000001,src:000172+005151,op:splice,rep:2. */
10684 if (ent
.vd_next
< sizeof (*edef
)
10685 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10687 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10688 cnt
= section
->sh_info
;
10691 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10694 idx
+= ent
.vd_next
;
10697 if (cnt
< section
->sh_info
)
10698 printf (_(" Version definition past end of section\n"));
10704 case SHT_GNU_verneed
:
10706 Elf_External_Verneed
* eneed
;
10713 printf (ngettext ("\nVersion needs section '%s' "
10714 "contains %u entry:\n",
10715 "\nVersion needs section '%s' "
10716 "contains %u entries:\n",
10718 printable_section_name (filedata
, section
), section
->sh_info
);
10720 printf (_(" Addr: 0x"));
10721 printf_vma (section
->sh_addr
);
10722 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10723 (unsigned long) section
->sh_offset
, section
->sh_link
,
10724 printable_section_name_from_index (filedata
, section
->sh_link
));
10726 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10727 section
->sh_offset
, 1,
10729 _("Version Needs section"));
10732 endbuf
= (char *) eneed
+ section
->sh_size
;
10734 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10736 Elf_External_Verneed
* entry
;
10737 Elf_Internal_Verneed ent
;
10738 unsigned long isum
;
10742 vstart
= ((char *) eneed
) + idx
;
10743 if (vstart
+ sizeof (*entry
) > endbuf
)
10746 entry
= (Elf_External_Verneed
*) vstart
;
10748 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10749 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10750 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10751 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10752 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10754 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10756 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10757 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10759 printf (_(" File: %lx"), ent
.vn_file
);
10761 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10763 /* Check for overflow. */
10764 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10766 vstart
+= ent
.vn_aux
;
10768 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10770 Elf_External_Vernaux
* eaux
;
10771 Elf_Internal_Vernaux aux
;
10773 if (vstart
+ sizeof (*eaux
) > endbuf
)
10775 eaux
= (Elf_External_Vernaux
*) vstart
;
10777 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10778 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10779 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10780 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10781 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10783 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10784 printf (_(" %#06lx: Name: %s"),
10785 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10787 printf (_(" %#06lx: Name index: %lx"),
10788 isum
, aux
.vna_name
);
10790 printf (_(" Flags: %s Version: %d\n"),
10791 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10793 if (aux
.vna_next
< sizeof (*eaux
)
10794 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10796 warn (_("Invalid vna_next field of %lx\n"),
10801 /* Check for overflow. */
10802 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10804 isum
+= aux
.vna_next
;
10805 vstart
+= aux
.vna_next
;
10808 if (j
< ent
.vn_cnt
)
10809 warn (_("Missing Version Needs auxillary information\n"));
10811 if (ent
.vn_next
< sizeof (*entry
)
10812 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10814 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10815 cnt
= section
->sh_info
;
10818 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10820 idx
+= ent
.vn_next
;
10823 if (cnt
< section
->sh_info
)
10824 warn (_("Missing Version Needs information\n"));
10830 case SHT_GNU_versym
:
10832 Elf_Internal_Shdr
* link_section
;
10835 unsigned char * edata
;
10836 unsigned short * data
;
10838 Elf_Internal_Sym
* symbols
;
10839 Elf_Internal_Shdr
* string_sec
;
10840 unsigned long num_syms
;
10843 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10846 link_section
= filedata
->section_headers
+ section
->sh_link
;
10847 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10849 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10854 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10855 if (symbols
== NULL
)
10858 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10860 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10861 string_sec
->sh_size
,
10862 _("version string table"));
10869 printf (ngettext ("\nVersion symbols section '%s' "
10870 "contains %lu entry:\n",
10871 "\nVersion symbols section '%s' "
10872 "contains %lu entries:\n",
10874 printable_section_name (filedata
, section
), (unsigned long) total
);
10876 printf (_(" Addr: 0x"));
10877 printf_vma (section
->sh_addr
);
10878 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10879 (unsigned long) section
->sh_offset
, section
->sh_link
,
10880 printable_section_name (filedata
, link_section
));
10882 off
= offset_from_vma (filedata
,
10883 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10884 total
* sizeof (short));
10885 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10887 _("version symbol data"));
10895 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10897 for (cnt
= total
; cnt
--;)
10898 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10903 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10907 char *invalid
= _("*invalid*");
10909 printf (" %03x:", cnt
);
10911 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10912 switch (data
[cnt
+ j
])
10915 fputs (_(" 0 (*local*) "), stdout
);
10919 fputs (_(" 1 (*global*) "), stdout
);
10923 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10924 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10926 /* If this index value is greater than the size of the symbols
10927 array, break to avoid an out-of-bounds read. */
10928 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10930 warn (_("invalid index into symbol array\n"));
10935 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10937 Elf_Internal_Verneed ivn
;
10938 unsigned long offset
;
10940 offset
= offset_from_vma
10941 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10942 sizeof (Elf_External_Verneed
));
10946 Elf_Internal_Vernaux ivna
;
10947 Elf_External_Verneed evn
;
10948 Elf_External_Vernaux evna
;
10949 unsigned long a_off
;
10951 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10952 _("version need")) == NULL
)
10955 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10956 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10958 a_off
= offset
+ ivn
.vn_aux
;
10962 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10963 1, _("version need aux (2)")) == NULL
)
10966 ivna
.vna_other
= 0;
10970 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10971 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10974 a_off
+= ivna
.vna_next
;
10976 while (ivna
.vna_other
!= data
[cnt
+ j
]
10977 && ivna
.vna_next
!= 0);
10979 if (ivna
.vna_other
== data
[cnt
+ j
])
10981 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10983 if (ivna
.vna_name
>= string_sec
->sh_size
)
10986 name
= strtab
+ ivna
.vna_name
;
10990 offset
+= ivn
.vn_next
;
10992 while (ivn
.vn_next
);
10995 if (data
[cnt
+ j
] != 0x8001
10996 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10998 Elf_Internal_Verdef ivd
;
10999 Elf_External_Verdef evd
;
11000 unsigned long offset
;
11002 offset
= offset_from_vma
11003 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11008 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11009 _("version def")) == NULL
)
11012 /* PR 17531: file: 046-1082287-0.004. */
11013 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11018 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11019 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11022 offset
+= ivd
.vd_next
;
11024 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11025 && ivd
.vd_next
!= 0);
11027 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11029 Elf_External_Verdaux evda
;
11030 Elf_Internal_Verdaux ivda
;
11032 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11034 if (get_data (&evda
, filedata
,
11035 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11037 _("version def aux")) == NULL
)
11040 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11042 if (ivda
.vda_name
>= string_sec
->sh_size
)
11044 else if (name
!= NULL
&& name
!= invalid
)
11045 name
= _("*both*");
11047 name
= strtab
+ ivda
.vda_name
;
11051 nn
+= printf ("(%s%-*s",
11053 12 - (int) strlen (name
),
11057 printf ("%*c", 18 - nn
, ' ');
11075 printf (_("\nNo version information found in this file.\n"));
11080 static const char *
11081 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11083 static char buff
[32];
11087 case STB_LOCAL
: return "LOCAL";
11088 case STB_GLOBAL
: return "GLOBAL";
11089 case STB_WEAK
: return "WEAK";
11091 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11092 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11094 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11096 if (binding
== STB_GNU_UNIQUE
11097 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11099 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11102 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11107 static const char *
11108 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11110 static char buff
[32];
11114 case STT_NOTYPE
: return "NOTYPE";
11115 case STT_OBJECT
: return "OBJECT";
11116 case STT_FUNC
: return "FUNC";
11117 case STT_SECTION
: return "SECTION";
11118 case STT_FILE
: return "FILE";
11119 case STT_COMMON
: return "COMMON";
11120 case STT_TLS
: return "TLS";
11121 case STT_RELC
: return "RELC";
11122 case STT_SRELC
: return "SRELC";
11124 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11126 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11127 return "THUMB_FUNC";
11129 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11132 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11133 return "PARISC_MILLI";
11135 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11137 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11139 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11141 if (type
== STT_HP_OPAQUE
)
11142 return "HP_OPAQUE";
11143 if (type
== STT_HP_STUB
)
11147 if (type
== STT_GNU_IFUNC
11148 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11149 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11152 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11155 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11160 static const char *
11161 get_symbol_visibility (unsigned int visibility
)
11163 switch (visibility
)
11165 case STV_DEFAULT
: return "DEFAULT";
11166 case STV_INTERNAL
: return "INTERNAL";
11167 case STV_HIDDEN
: return "HIDDEN";
11168 case STV_PROTECTED
: return "PROTECTED";
11170 error (_("Unrecognized visibility value: %u"), visibility
);
11171 return _("<unknown>");
11175 static const char *
11176 get_alpha_symbol_other (unsigned int other
)
11180 case STO_ALPHA_NOPV
: return "NOPV";
11181 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11183 error (_("Unrecognized alpah specific other value: %u"), other
);
11184 return _("<unknown>");
11188 static const char *
11189 get_solaris_symbol_visibility (unsigned int visibility
)
11191 switch (visibility
)
11193 case 4: return "EXPORTED";
11194 case 5: return "SINGLETON";
11195 case 6: return "ELIMINATE";
11196 default: return get_symbol_visibility (visibility
);
11200 static const char *
11201 get_aarch64_symbol_other (unsigned int other
)
11203 static char buf
[32];
11205 if (other
& STO_AARCH64_VARIANT_PCS
)
11207 other
&= ~STO_AARCH64_VARIANT_PCS
;
11209 return "VARIANT_PCS";
11210 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11216 static const char *
11217 get_mips_symbol_other (unsigned int other
)
11221 case STO_OPTIONAL
: return "OPTIONAL";
11222 case STO_MIPS_PLT
: return "MIPS PLT";
11223 case STO_MIPS_PIC
: return "MIPS PIC";
11224 case STO_MICROMIPS
: return "MICROMIPS";
11225 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11226 case STO_MIPS16
: return "MIPS16";
11227 default: return NULL
;
11231 static const char *
11232 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11234 if (is_ia64_vms (filedata
))
11236 static char res
[32];
11240 /* Function types is for images and .STB files only. */
11241 switch (filedata
->file_header
.e_type
)
11245 switch (VMS_ST_FUNC_TYPE (other
))
11247 case VMS_SFT_CODE_ADDR
:
11248 strcat (res
, " CA");
11250 case VMS_SFT_SYMV_IDX
:
11251 strcat (res
, " VEC");
11254 strcat (res
, " FD");
11256 case VMS_SFT_RESERVE
:
11257 strcat (res
, " RSV");
11260 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11261 VMS_ST_FUNC_TYPE (other
));
11262 strcat (res
, " <unknown>");
11269 switch (VMS_ST_LINKAGE (other
))
11271 case VMS_STL_IGNORE
:
11272 strcat (res
, " IGN");
11274 case VMS_STL_RESERVE
:
11275 strcat (res
, " RSV");
11278 strcat (res
, " STD");
11281 strcat (res
, " LNK");
11284 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11285 VMS_ST_LINKAGE (other
));
11286 strcat (res
, " <unknown>");
11298 static const char *
11299 get_ppc64_symbol_other (unsigned int other
)
11301 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11304 other
>>= STO_PPC64_LOCAL_BIT
;
11307 static char buf
[32];
11309 other
= ppc64_decode_local_entry (other
);
11310 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11316 static const char *
11317 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11319 const char * result
= NULL
;
11320 static char buff
[32];
11325 switch (filedata
->file_header
.e_machine
)
11328 result
= get_alpha_symbol_other (other
);
11331 result
= get_aarch64_symbol_other (other
);
11334 result
= get_mips_symbol_other (other
);
11337 result
= get_ia64_symbol_other (filedata
, other
);
11340 result
= get_ppc64_symbol_other (other
);
11350 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11354 static const char *
11355 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11357 static char buff
[32];
11361 case SHN_UNDEF
: return "UND";
11362 case SHN_ABS
: return "ABS";
11363 case SHN_COMMON
: return "COM";
11365 if (type
== SHN_IA_64_ANSI_COMMON
11366 && filedata
->file_header
.e_machine
== EM_IA_64
11367 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11369 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11370 || filedata
->file_header
.e_machine
== EM_L1OM
11371 || filedata
->file_header
.e_machine
== EM_K1OM
)
11372 && type
== SHN_X86_64_LCOMMON
)
11373 return "LARGE_COM";
11374 else if ((type
== SHN_MIPS_SCOMMON
11375 && filedata
->file_header
.e_machine
== EM_MIPS
)
11376 || (type
== SHN_TIC6X_SCOMMON
11377 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11379 else if (type
== SHN_MIPS_SUNDEFINED
11380 && filedata
->file_header
.e_machine
== EM_MIPS
)
11382 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11383 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11384 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11385 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11386 else if (type
>= SHN_LORESERVE
)
11387 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11388 else if (type
>= filedata
->file_header
.e_shnum
)
11389 sprintf (buff
, _("bad section index[%3d]"), type
);
11391 sprintf (buff
, "%3d", type
);
11399 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11401 unsigned char * e_data
;
11404 /* If the size_t type is smaller than the bfd_size_type, eg because
11405 you are building a 32-bit tool on a 64-bit host, then make sure
11406 that when (number) is cast to (size_t) no information is lost. */
11407 if (sizeof (size_t) < sizeof (bfd_size_type
)
11408 && (bfd_size_type
) ((size_t) number
) != number
)
11410 error (_("Size truncation prevents reading %s elements of size %u\n"),
11411 bfd_vmatoa ("u", number
), ent_size
);
11415 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11416 attempting to allocate memory when the read is bound to fail. */
11417 if (ent_size
* number
> filedata
->file_size
)
11419 error (_("Invalid number of dynamic entries: %s\n"),
11420 bfd_vmatoa ("u", number
));
11424 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11425 if (e_data
== NULL
)
11427 error (_("Out of memory reading %s dynamic entries\n"),
11428 bfd_vmatoa ("u", number
));
11432 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11434 error (_("Unable to read in %s bytes of dynamic data\n"),
11435 bfd_vmatoa ("u", number
* ent_size
));
11440 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11441 if (i_data
== NULL
)
11443 error (_("Out of memory allocating space for %s dynamic entries\n"),
11444 bfd_vmatoa ("u", number
));
11450 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11458 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11460 Elf_Internal_Sym
* psym
;
11463 n
= print_vma (si
, DEC_5
);
11465 fputs (&" "[n
], stdout
);
11466 printf (" %3lu: ", hn
);
11468 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11470 printf (_("<No info available for dynamic symbol number %lu>\n"),
11471 (unsigned long) si
);
11475 psym
= dynamic_symbols
+ si
;
11476 print_vma (psym
->st_value
, LONG_HEX
);
11478 print_vma (psym
->st_size
, DEC_5
);
11480 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11481 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11483 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11484 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11487 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11489 printf (" %-7s", get_symbol_visibility (vis
));
11490 /* Check to see if any other bits in the st_other field are set.
11491 Note - displaying this information disrupts the layout of the
11492 table being generated, but for the moment this case is very
11494 if (psym
->st_other
^ vis
)
11495 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11498 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11499 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11500 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11502 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11506 static const char *
11507 get_symbol_version_string (Filedata
* filedata
,
11508 bfd_boolean is_dynsym
,
11509 const char * strtab
,
11510 unsigned long int strtab_size
,
11512 Elf_Internal_Sym
* psym
,
11513 enum versioned_symbol_info
* sym_info
,
11514 unsigned short * vna_other
)
11516 unsigned char data
[2];
11517 unsigned short vers_data
;
11518 unsigned long offset
;
11519 unsigned short max_vd_ndx
;
11522 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11525 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11526 sizeof data
+ si
* sizeof (vers_data
));
11528 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11529 sizeof (data
), 1, _("version data")) == NULL
)
11532 vers_data
= byte_get (data
, 2);
11534 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11537 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11540 /* Usually we'd only see verdef for defined symbols, and verneed for
11541 undefined symbols. However, symbols defined by the linker in
11542 .dynbss for variables copied from a shared library in order to
11543 avoid text relocations are defined yet have verneed. We could
11544 use a heuristic to detect the special case, for example, check
11545 for verneed first on symbols defined in SHT_NOBITS sections, but
11546 it is simpler and more reliable to just look for both verdef and
11547 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11549 if (psym
->st_shndx
!= SHN_UNDEF
11550 && vers_data
!= 0x8001
11551 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11553 Elf_Internal_Verdef ivd
;
11554 Elf_Internal_Verdaux ivda
;
11555 Elf_External_Verdaux evda
;
11558 off
= offset_from_vma (filedata
,
11559 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11560 sizeof (Elf_External_Verdef
));
11564 Elf_External_Verdef evd
;
11566 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11567 _("version def")) == NULL
)
11576 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11577 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11578 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11579 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11582 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11583 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11585 off
+= ivd
.vd_next
;
11587 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11589 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11591 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11594 off
-= ivd
.vd_next
;
11597 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11598 _("version def aux")) != NULL
)
11600 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11602 if (psym
->st_name
!= ivda
.vda_name
)
11603 return (ivda
.vda_name
< strtab_size
11604 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11609 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11611 Elf_External_Verneed evn
;
11612 Elf_Internal_Verneed ivn
;
11613 Elf_Internal_Vernaux ivna
;
11615 offset
= offset_from_vma (filedata
,
11616 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11620 unsigned long vna_off
;
11622 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11623 _("version need")) == NULL
)
11626 ivna
.vna_other
= 0;
11631 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11632 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11634 vna_off
= offset
+ ivn
.vn_aux
;
11638 Elf_External_Vernaux evna
;
11640 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11641 _("version need aux (3)")) == NULL
)
11644 ivna
.vna_other
= 0;
11649 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11650 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11651 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11654 vna_off
+= ivna
.vna_next
;
11656 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11658 if (ivna
.vna_other
== vers_data
)
11661 offset
+= ivn
.vn_next
;
11663 while (ivn
.vn_next
!= 0);
11665 if (ivna
.vna_other
== vers_data
)
11667 *sym_info
= symbol_undefined
;
11668 *vna_other
= ivna
.vna_other
;
11669 return (ivna
.vna_name
< strtab_size
11670 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11672 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11673 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11674 return _("<corrupt>");
11679 /* Dump the symbol table. */
11681 process_symbol_table (Filedata
* filedata
)
11683 Elf_Internal_Shdr
* section
;
11684 bfd_size_type nbuckets
= 0;
11685 bfd_size_type nchains
= 0;
11686 bfd_vma
* buckets
= NULL
;
11687 bfd_vma
* chains
= NULL
;
11688 bfd_vma ngnubuckets
= 0;
11689 bfd_vma
* gnubuckets
= NULL
;
11690 bfd_vma
* gnuchains
= NULL
;
11691 bfd_vma
* mipsxlat
= NULL
;
11692 bfd_vma gnusymidx
= 0;
11693 bfd_size_type ngnuchains
= 0;
11695 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11698 if (dynamic_info
[DT_HASH
]
11700 || (do_using_dynamic
11702 && dynamic_strings
!= NULL
)))
11704 unsigned char nb
[8];
11705 unsigned char nc
[8];
11706 unsigned int hash_ent_size
= 4;
11708 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11709 || filedata
->file_header
.e_machine
== EM_S390
11710 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11711 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11714 if (fseek (filedata
->handle
,
11715 (archive_file_offset
11716 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11717 sizeof nb
+ sizeof nc
)),
11720 error (_("Unable to seek to start of dynamic information\n"));
11724 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11726 error (_("Failed to read in number of buckets\n"));
11730 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11732 error (_("Failed to read in number of chains\n"));
11736 nbuckets
= byte_get (nb
, hash_ent_size
);
11737 nchains
= byte_get (nc
, hash_ent_size
);
11739 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11740 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11743 if (buckets
== NULL
|| chains
== NULL
)
11745 if (do_using_dynamic
)
11756 if (dynamic_info_DT_GNU_HASH
11758 || (do_using_dynamic
11760 && dynamic_strings
!= NULL
)))
11762 unsigned char nb
[16];
11763 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11764 bfd_vma buckets_vma
;
11766 if (fseek (filedata
->handle
,
11767 (archive_file_offset
11768 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11772 error (_("Unable to seek to start of dynamic information\n"));
11776 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11778 error (_("Failed to read in number of buckets\n"));
11782 ngnubuckets
= byte_get (nb
, 4);
11783 gnusymidx
= byte_get (nb
+ 4, 4);
11784 bitmaskwords
= byte_get (nb
+ 8, 4);
11785 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11787 buckets_vma
+= bitmaskwords
* 4;
11789 buckets_vma
+= bitmaskwords
* 8;
11791 if (fseek (filedata
->handle
,
11792 (archive_file_offset
11793 + offset_from_vma (filedata
, buckets_vma
, 4)),
11796 error (_("Unable to seek to start of dynamic information\n"));
11800 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11802 if (gnubuckets
== NULL
)
11805 for (i
= 0; i
< ngnubuckets
; i
++)
11806 if (gnubuckets
[i
] != 0)
11808 if (gnubuckets
[i
] < gnusymidx
)
11811 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11812 maxchain
= gnubuckets
[i
];
11815 if (maxchain
== 0xffffffff)
11818 maxchain
-= gnusymidx
;
11820 if (fseek (filedata
->handle
,
11821 (archive_file_offset
11822 + offset_from_vma (filedata
, buckets_vma
11823 + 4 * (ngnubuckets
+ maxchain
), 4)),
11826 error (_("Unable to seek to start of dynamic information\n"));
11832 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11834 error (_("Failed to determine last chain length\n"));
11838 if (maxchain
+ 1 == 0)
11843 while ((byte_get (nb
, 4) & 1) == 0);
11845 if (fseek (filedata
->handle
,
11846 (archive_file_offset
11847 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11850 error (_("Unable to seek to start of dynamic information\n"));
11854 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11855 ngnuchains
= maxchain
;
11857 if (gnuchains
== NULL
)
11860 if (dynamic_info_DT_MIPS_XHASH
)
11862 if (fseek (filedata
->handle
,
11863 (archive_file_offset
11864 + offset_from_vma (filedata
, (buckets_vma
11869 error (_("Unable to seek to start of dynamic information\n"));
11873 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11877 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11882 if (gnuchains
== NULL
)
11887 if (do_using_dynamic
)
11892 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11894 && do_using_dynamic
11895 && dynamic_strings
!= NULL
11896 && dynamic_symbols
!= NULL
)
11900 if (dynamic_info
[DT_HASH
])
11905 printf (_("\nSymbol table for image:\n"));
11907 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11909 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11911 visited
= xcmalloc (nchains
, 1);
11912 memset (visited
, 0, nchains
);
11913 for (hn
= 0; hn
< nbuckets
; hn
++)
11915 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11917 print_dynamic_symbol (filedata
, si
, hn
);
11918 if (si
>= nchains
|| visited
[si
])
11920 error (_("histogram chain is corrupt\n"));
11929 if (dynamic_info_DT_GNU_HASH
)
11931 printf (_("\nSymbol table of `%s' for image:\n"),
11932 GNU_HASH_SECTION_NAME
);
11934 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11936 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11938 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11939 if (gnubuckets
[hn
] != 0)
11941 bfd_vma si
= gnubuckets
[hn
];
11942 bfd_vma off
= si
- gnusymidx
;
11946 if (dynamic_info_DT_MIPS_XHASH
)
11947 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11949 print_dynamic_symbol (filedata
, si
, hn
);
11952 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11956 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11957 && filedata
->section_headers
!= NULL
)
11961 for (i
= 0, section
= filedata
->section_headers
;
11962 i
< filedata
->file_header
.e_shnum
;
11966 char * strtab
= NULL
;
11967 unsigned long int strtab_size
= 0;
11968 Elf_Internal_Sym
* symtab
;
11969 Elf_Internal_Sym
* psym
;
11970 unsigned long num_syms
;
11972 if ((section
->sh_type
!= SHT_SYMTAB
11973 && section
->sh_type
!= SHT_DYNSYM
)
11975 && section
->sh_type
== SHT_SYMTAB
))
11978 if (section
->sh_entsize
== 0)
11980 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11981 printable_section_name (filedata
, section
));
11985 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11986 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11987 "\nSymbol table '%s' contains %lu entries:\n",
11989 printable_section_name (filedata
, section
),
11993 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11995 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11997 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11998 if (symtab
== NULL
)
12001 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12003 strtab
= filedata
->string_table
;
12004 strtab_size
= filedata
->string_table_length
;
12006 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12008 Elf_Internal_Shdr
* string_sec
;
12010 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12012 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12013 1, string_sec
->sh_size
,
12014 _("string table"));
12015 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12018 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12020 const char *version_string
;
12021 enum versioned_symbol_info sym_info
;
12022 unsigned short vna_other
;
12024 printf ("%6d: ", si
);
12025 print_vma (psym
->st_value
, LONG_HEX
);
12027 print_vma (psym
->st_size
, DEC_5
);
12028 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12029 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12030 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12031 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12034 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12036 printf (" %-7s", get_symbol_visibility (vis
));
12037 /* Check to see if any other bits in the st_other field are set.
12038 Note - displaying this information disrupts the layout of the
12039 table being generated, but for the moment this case is very rare. */
12040 if (psym
->st_other
^ vis
)
12041 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12043 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12044 print_symbol (25, psym
->st_name
< strtab_size
12045 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12048 = get_symbol_version_string (filedata
,
12049 section
->sh_type
== SHT_DYNSYM
,
12050 strtab
, strtab_size
, si
,
12051 psym
, &sym_info
, &vna_other
);
12052 if (version_string
)
12054 if (sym_info
== symbol_undefined
)
12055 printf ("@%s (%d)", version_string
, vna_other
);
12057 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12063 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12064 && si
>= section
->sh_info
12065 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12066 && filedata
->file_header
.e_machine
!= EM_MIPS
12067 /* Solaris binaries have been found to violate this requirement as
12068 well. Not sure if this is a bug or an ABI requirement. */
12069 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12070 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12071 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12075 if (strtab
!= filedata
->string_table
)
12081 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12083 if (do_histogram
&& buckets
!= NULL
)
12085 unsigned long * lengths
;
12086 unsigned long * counts
;
12089 unsigned long maxlength
= 0;
12090 unsigned long nzero_counts
= 0;
12091 unsigned long nsyms
= 0;
12094 printf (ngettext ("\nHistogram for bucket list length "
12095 "(total of %lu bucket):\n",
12096 "\nHistogram for bucket list length "
12097 "(total of %lu buckets):\n",
12098 (unsigned long) nbuckets
),
12099 (unsigned long) nbuckets
);
12101 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12102 if (lengths
== NULL
)
12104 error (_("Out of memory allocating space for histogram buckets\n"));
12107 visited
= xcmalloc (nchains
, 1);
12108 memset (visited
, 0, nchains
);
12110 printf (_(" Length Number %% of total Coverage\n"));
12111 for (hn
= 0; hn
< nbuckets
; ++hn
)
12113 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12116 if (maxlength
< ++lengths
[hn
])
12118 if (si
>= nchains
|| visited
[si
])
12120 error (_("histogram chain is corrupt\n"));
12128 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12129 if (counts
== NULL
)
12132 error (_("Out of memory allocating space for histogram counts\n"));
12136 for (hn
= 0; hn
< nbuckets
; ++hn
)
12137 ++counts
[lengths
[hn
]];
12142 printf (" 0 %-10lu (%5.1f%%)\n",
12143 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12144 for (i
= 1; i
<= maxlength
; ++i
)
12146 nzero_counts
+= counts
[i
] * i
;
12147 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12148 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12149 (nzero_counts
* 100.0) / nsyms
);
12157 if (buckets
!= NULL
)
12163 if (do_histogram
&& gnubuckets
!= NULL
)
12165 unsigned long * lengths
;
12166 unsigned long * counts
;
12168 unsigned long maxlength
= 0;
12169 unsigned long nzero_counts
= 0;
12170 unsigned long nsyms
= 0;
12172 printf (ngettext ("\nHistogram for `%s' bucket list length "
12173 "(total of %lu bucket):\n",
12174 "\nHistogram for `%s' bucket list length "
12175 "(total of %lu buckets):\n",
12176 (unsigned long) ngnubuckets
),
12177 GNU_HASH_SECTION_NAME
,
12178 (unsigned long) ngnubuckets
);
12180 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12181 if (lengths
== NULL
)
12183 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12187 printf (_(" Length Number %% of total Coverage\n"));
12189 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12190 if (gnubuckets
[hn
] != 0)
12192 bfd_vma off
, length
= 1;
12194 for (off
= gnubuckets
[hn
] - gnusymidx
;
12195 /* PR 17531 file: 010-77222-0.004. */
12196 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12199 lengths
[hn
] = length
;
12200 if (length
> maxlength
)
12201 maxlength
= length
;
12205 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12206 if (counts
== NULL
)
12209 error (_("Out of memory allocating space for gnu histogram counts\n"));
12213 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12214 ++counts
[lengths
[hn
]];
12216 if (ngnubuckets
> 0)
12219 printf (" 0 %-10lu (%5.1f%%)\n",
12220 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12221 for (j
= 1; j
<= maxlength
; ++j
)
12223 nzero_counts
+= counts
[j
] * j
;
12224 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12225 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12226 (nzero_counts
* 100.0) / nsyms
);
12241 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12245 if (dynamic_syminfo
== NULL
12247 /* No syminfo, this is ok. */
12250 /* There better should be a dynamic symbol section. */
12251 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12255 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12256 "contains %d entry:\n",
12257 "\nDynamic info segment at offset 0x%lx "
12258 "contains %d entries:\n",
12259 dynamic_syminfo_nent
),
12260 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12262 printf (_(" Num: Name BoundTo Flags\n"));
12263 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12265 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12267 printf ("%4d: ", i
);
12268 if (i
>= num_dynamic_syms
)
12269 printf (_("<corrupt index>"));
12270 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12271 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12273 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12276 switch (dynamic_syminfo
[i
].si_boundto
)
12278 case SYMINFO_BT_SELF
:
12279 fputs ("SELF ", stdout
);
12281 case SYMINFO_BT_PARENT
:
12282 fputs ("PARENT ", stdout
);
12285 if (dynamic_syminfo
[i
].si_boundto
> 0
12286 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12287 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12289 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12293 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12297 if (flags
& SYMINFO_FLG_DIRECT
)
12298 printf (" DIRECT");
12299 if (flags
& SYMINFO_FLG_PASSTHRU
)
12300 printf (" PASSTHRU");
12301 if (flags
& SYMINFO_FLG_COPY
)
12303 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12304 printf (" LAZYLOAD");
12312 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12313 is contained by the region START .. END. The types of ADDR, START
12314 and END should all be the same. Note both ADDR + NELEM and END
12315 point to just beyond the end of the regions that are being tested. */
12316 #define IN_RANGE(START,END,ADDR,NELEM) \
12317 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12319 /* Check to see if the given reloc needs to be handled in a target specific
12320 manner. If so then process the reloc and return TRUE otherwise return
12323 If called with reloc == NULL, then this is a signal that reloc processing
12324 for the current section has finished, and any saved state should be
12328 target_specific_reloc_handling (Filedata
* filedata
,
12329 Elf_Internal_Rela
* reloc
,
12330 unsigned char * start
,
12331 unsigned char * end
,
12332 Elf_Internal_Sym
* symtab
,
12333 unsigned long num_syms
)
12335 unsigned int reloc_type
= 0;
12336 unsigned long sym_index
= 0;
12340 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12341 sym_index
= get_reloc_symindex (reloc
->r_info
);
12344 switch (filedata
->file_header
.e_machine
)
12347 case EM_MSP430_OLD
:
12349 static Elf_Internal_Sym
* saved_sym
= NULL
;
12357 switch (reloc_type
)
12359 case 10: /* R_MSP430_SYM_DIFF */
12360 if (uses_msp430x_relocs (filedata
))
12362 /* Fall through. */
12363 case 21: /* R_MSP430X_SYM_DIFF */
12365 if (sym_index
>= num_syms
)
12366 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12369 saved_sym
= symtab
+ sym_index
;
12372 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12373 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12374 goto handle_sym_diff
;
12376 case 5: /* R_MSP430_16_BYTE */
12377 case 9: /* R_MSP430_8 */
12378 if (uses_msp430x_relocs (filedata
))
12380 goto handle_sym_diff
;
12382 case 2: /* R_MSP430_ABS16 */
12383 case 15: /* R_MSP430X_ABS16 */
12384 if (! uses_msp430x_relocs (filedata
))
12386 goto handle_sym_diff
;
12389 if (saved_sym
!= NULL
)
12391 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12394 if (sym_index
>= num_syms
)
12395 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12399 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12400 - saved_sym
->st_value
);
12402 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12403 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12406 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12407 (long) reloc
->r_offset
);
12416 if (saved_sym
!= NULL
)
12417 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12424 case EM_CYGNUS_MN10300
:
12426 static Elf_Internal_Sym
* saved_sym
= NULL
;
12434 switch (reloc_type
)
12436 case 34: /* R_MN10300_ALIGN */
12438 case 33: /* R_MN10300_SYM_DIFF */
12439 if (sym_index
>= num_syms
)
12440 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12443 saved_sym
= symtab
+ sym_index
;
12446 case 1: /* R_MN10300_32 */
12447 case 2: /* R_MN10300_16 */
12448 if (saved_sym
!= NULL
)
12450 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12453 if (sym_index
>= num_syms
)
12454 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12458 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12459 - saved_sym
->st_value
);
12461 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12462 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12464 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12465 (long) reloc
->r_offset
);
12473 if (saved_sym
!= NULL
)
12474 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12482 static bfd_vma saved_sym1
= 0;
12483 static bfd_vma saved_sym2
= 0;
12484 static bfd_vma value
;
12488 saved_sym1
= saved_sym2
= 0;
12492 switch (reloc_type
)
12494 case 0x80: /* R_RL78_SYM. */
12495 saved_sym1
= saved_sym2
;
12496 if (sym_index
>= num_syms
)
12497 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12501 saved_sym2
= symtab
[sym_index
].st_value
;
12502 saved_sym2
+= reloc
->r_addend
;
12506 case 0x83: /* R_RL78_OPsub. */
12507 value
= saved_sym1
- saved_sym2
;
12508 saved_sym2
= saved_sym1
= 0;
12512 case 0x41: /* R_RL78_ABS32. */
12513 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12514 byte_put (start
+ reloc
->r_offset
, value
, 4);
12516 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12517 (long) reloc
->r_offset
);
12521 case 0x43: /* R_RL78_ABS16. */
12522 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12523 byte_put (start
+ reloc
->r_offset
, value
, 2);
12525 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12526 (long) reloc
->r_offset
);
12540 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12541 DWARF debug sections. This is a target specific test. Note - we do not
12542 go through the whole including-target-headers-multiple-times route, (as
12543 we have already done with <elf/h8.h>) because this would become very
12544 messy and even then this function would have to contain target specific
12545 information (the names of the relocs instead of their numeric values).
12546 FIXME: This is not the correct way to solve this problem. The proper way
12547 is to have target specific reloc sizing and typing functions created by
12548 the reloc-macros.h header, in the same way that it already creates the
12549 reloc naming functions. */
12552 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12554 /* Please keep this table alpha-sorted for ease of visual lookup. */
12555 switch (filedata
->file_header
.e_machine
)
12559 return reloc_type
== 1; /* R_386_32. */
12561 return reloc_type
== 1; /* R_68K_32. */
12563 return reloc_type
== 1; /* R_860_32. */
12565 return reloc_type
== 2; /* R_960_32. */
12567 return (reloc_type
== 258
12568 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12570 return reloc_type
== 11; /* R_BPF_DATA_32 */
12571 case EM_ADAPTEVA_EPIPHANY
:
12572 return reloc_type
== 3;
12574 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12576 return reloc_type
== 1; /* R_ARC_32. */
12577 case EM_ARC_COMPACT
:
12578 case EM_ARC_COMPACT2
:
12579 return reloc_type
== 4; /* R_ARC_32. */
12581 return reloc_type
== 2; /* R_ARM_ABS32 */
12584 return reloc_type
== 1;
12586 return reloc_type
== 0x12; /* R_byte4_data. */
12588 return reloc_type
== 3; /* R_CRIS_32. */
12590 return reloc_type
== 3; /* R_CR16_NUM32. */
12592 return reloc_type
== 15; /* R_CRX_NUM32. */
12594 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12595 case EM_CYGNUS_FRV
:
12596 return reloc_type
== 1;
12597 case EM_CYGNUS_D10V
:
12599 return reloc_type
== 6; /* R_D10V_32. */
12600 case EM_CYGNUS_D30V
:
12602 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12604 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12605 case EM_CYGNUS_FR30
:
12607 return reloc_type
== 3; /* R_FR30_32. */
12609 return reloc_type
== 1; /* R_FT32_32. */
12613 return reloc_type
== 1; /* R_H8_DIR32. */
12615 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12616 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12617 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12618 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12621 return reloc_type
== 2; /* R_IP2K_32. */
12623 return reloc_type
== 2; /* R_IQ2000_32. */
12624 case EM_LATTICEMICO32
:
12625 return reloc_type
== 3; /* R_LM32_32. */
12628 return reloc_type
== 3; /* R_M32C_32. */
12630 return reloc_type
== 34; /* R_M32R_32_RELA. */
12633 return reloc_type
== 6; /* R_M68HC11_32. */
12635 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12636 reloc_type
== 6; /* R_S12Z_CW32. */
12638 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12639 case EM_CYGNUS_MEP
:
12640 return reloc_type
== 4; /* R_MEP_32. */
12642 return reloc_type
== 2; /* R_METAG_ADDR32. */
12643 case EM_MICROBLAZE
:
12644 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12646 return reloc_type
== 2; /* R_MIPS_32. */
12648 return reloc_type
== 4; /* R_MMIX_32. */
12649 case EM_CYGNUS_MN10200
:
12651 return reloc_type
== 1; /* R_MN10200_32. */
12652 case EM_CYGNUS_MN10300
:
12654 return reloc_type
== 1; /* R_MN10300_32. */
12656 return reloc_type
== 1; /* R_MOXIE_32. */
12657 case EM_MSP430_OLD
:
12659 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12661 return reloc_type
== 2; /* R_MT_32. */
12663 return reloc_type
== 20; /* R_NDS32_RELA. */
12664 case EM_ALTERA_NIOS2
:
12665 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12667 return reloc_type
== 1; /* R_NIOS_32. */
12669 return reloc_type
== 1; /* R_OR1K_32. */
12671 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12672 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12673 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12676 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12678 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12680 return reloc_type
== 1; /* R_PPC_ADDR32. */
12682 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12684 return reloc_type
== 1; /* R_RISCV_32. */
12686 return reloc_type
== 1; /* R_RL78_DIR32. */
12688 return reloc_type
== 1; /* R_RX_DIR32. */
12690 return reloc_type
== 1; /* R_I370_ADDR31. */
12693 return reloc_type
== 4; /* R_S390_32. */
12695 return reloc_type
== 8; /* R_SCORE_ABS32. */
12697 return reloc_type
== 1; /* R_SH_DIR32. */
12698 case EM_SPARC32PLUS
:
12701 return reloc_type
== 3 /* R_SPARC_32. */
12702 || reloc_type
== 23; /* R_SPARC_UA32. */
12704 return reloc_type
== 6; /* R_SPU_ADDR32 */
12706 return reloc_type
== 1; /* R_C6000_ABS32. */
12708 return reloc_type
== 2; /* R_TILEGX_32. */
12710 return reloc_type
== 1; /* R_TILEPRO_32. */
12711 case EM_CYGNUS_V850
:
12713 return reloc_type
== 6; /* R_V850_ABS32. */
12715 return reloc_type
== 0x33; /* R_V810_WORD. */
12717 return reloc_type
== 1; /* R_VAX_32. */
12719 return reloc_type
== 3; /* R_VISIUM_32. */
12720 case EM_WEBASSEMBLY
:
12721 return reloc_type
== 1; /* R_WASM32_32. */
12725 return reloc_type
== 10; /* R_X86_64_32. */
12728 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12730 return reloc_type
== 4; /* R_XGATE_32. */
12732 return reloc_type
== 1; /* R_XSTROMY16_32. */
12733 case EM_XTENSA_OLD
:
12735 return reloc_type
== 1; /* R_XTENSA_32. */
12738 static unsigned int prev_warn
= 0;
12740 /* Avoid repeating the same warning multiple times. */
12741 if (prev_warn
!= filedata
->file_header
.e_machine
)
12742 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12743 filedata
->file_header
.e_machine
);
12744 prev_warn
= filedata
->file_header
.e_machine
;
12750 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12751 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12754 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12756 switch (filedata
->file_header
.e_machine
)
12757 /* Please keep this table alpha-sorted for ease of visual lookup. */
12761 return reloc_type
== 2; /* R_386_PC32. */
12763 return reloc_type
== 4; /* R_68K_PC32. */
12765 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12766 case EM_ADAPTEVA_EPIPHANY
:
12767 return reloc_type
== 6;
12769 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12770 case EM_ARC_COMPACT
:
12771 case EM_ARC_COMPACT2
:
12772 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12774 return reloc_type
== 3; /* R_ARM_REL32 */
12777 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12778 case EM_MICROBLAZE
:
12779 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12781 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12783 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12785 return reloc_type
== 26; /* R_PPC_REL32. */
12787 return reloc_type
== 26; /* R_PPC64_REL32. */
12789 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12792 return reloc_type
== 5; /* R_390_PC32. */
12794 return reloc_type
== 2; /* R_SH_REL32. */
12795 case EM_SPARC32PLUS
:
12798 return reloc_type
== 6; /* R_SPARC_DISP32. */
12800 return reloc_type
== 13; /* R_SPU_REL32. */
12802 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12804 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12806 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12810 return reloc_type
== 2; /* R_X86_64_PC32. */
12812 return reloc_type
== 4; /* R_VAX_PCREL32. */
12813 case EM_XTENSA_OLD
:
12815 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12817 /* Do not abort or issue an error message here. Not all targets use
12818 pc-relative 32-bit relocs in their DWARF debug information and we
12819 have already tested for target coverage in is_32bit_abs_reloc. A
12820 more helpful warning message will be generated by apply_relocations
12821 anyway, so just return. */
12826 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12827 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12830 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12832 switch (filedata
->file_header
.e_machine
)
12835 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12837 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12839 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12840 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12842 return reloc_type
== 80; /* R_PARISC_DIR64. */
12844 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12846 return reloc_type
== 2; /* R_RISCV_64. */
12847 case EM_SPARC32PLUS
:
12850 return reloc_type
== 32 /* R_SPARC_64. */
12851 || reloc_type
== 54; /* R_SPARC_UA64. */
12855 return reloc_type
== 1; /* R_X86_64_64. */
12858 return reloc_type
== 22; /* R_S390_64. */
12860 return reloc_type
== 1; /* R_TILEGX_64. */
12862 return reloc_type
== 18; /* R_MIPS_64. */
12868 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12869 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12872 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12874 switch (filedata
->file_header
.e_machine
)
12877 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12879 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12881 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12882 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12884 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12886 return reloc_type
== 44; /* R_PPC64_REL64. */
12887 case EM_SPARC32PLUS
:
12890 return reloc_type
== 46; /* R_SPARC_DISP64. */
12894 return reloc_type
== 24; /* R_X86_64_PC64. */
12897 return reloc_type
== 23; /* R_S390_PC64. */
12899 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12905 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12906 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12909 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12911 switch (filedata
->file_header
.e_machine
)
12913 case EM_CYGNUS_MN10200
:
12915 return reloc_type
== 4; /* R_MN10200_24. */
12917 return reloc_type
== 5; /* R_FT32_20. */
12923 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12924 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12927 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12929 /* Please keep this table alpha-sorted for ease of visual lookup. */
12930 switch (filedata
->file_header
.e_machine
)
12933 case EM_ARC_COMPACT
:
12934 case EM_ARC_COMPACT2
:
12935 return reloc_type
== 2; /* R_ARC_16. */
12936 case EM_ADAPTEVA_EPIPHANY
:
12937 return reloc_type
== 5;
12940 return reloc_type
== 4; /* R_AVR_16. */
12941 case EM_CYGNUS_D10V
:
12943 return reloc_type
== 3; /* R_D10V_16. */
12945 return reloc_type
== 2; /* R_FT32_16. */
12949 return reloc_type
== R_H8_DIR16
;
12952 return reloc_type
== 1; /* R_IP2K_16. */
12955 return reloc_type
== 1; /* R_M32C_16 */
12956 case EM_CYGNUS_MN10200
:
12958 return reloc_type
== 2; /* R_MN10200_16. */
12959 case EM_CYGNUS_MN10300
:
12961 return reloc_type
== 2; /* R_MN10300_16. */
12963 if (uses_msp430x_relocs (filedata
))
12964 return reloc_type
== 2; /* R_MSP430_ABS16. */
12965 /* Fall through. */
12966 case EM_MSP430_OLD
:
12967 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12969 return reloc_type
== 19; /* R_NDS32_RELA. */
12970 case EM_ALTERA_NIOS2
:
12971 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12973 return reloc_type
== 9; /* R_NIOS_16. */
12975 return reloc_type
== 2; /* R_OR1K_16. */
12977 return reloc_type
== 55; /* R_RISCV_SET16. */
12979 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12981 return reloc_type
== 2; /* R_C6000_ABS16. */
12983 return reloc_type
== 2; /* R_VISIUM_16. */
12986 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12988 return reloc_type
== 3; /* R_XGATE_16. */
12994 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12995 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12998 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13000 switch (filedata
->file_header
.e_machine
)
13003 return reloc_type
== 54; /* R_RISCV_SET8. */
13009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13013 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13015 switch (filedata
->file_header
.e_machine
)
13018 return reloc_type
== 53; /* R_RISCV_SET6. */
13024 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13025 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13028 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13030 /* Please keep this table alpha-sorted for ease of visual lookup. */
13031 switch (filedata
->file_header
.e_machine
)
13034 return reloc_type
== 35; /* R_RISCV_ADD32. */
13040 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13041 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13044 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13046 /* Please keep this table alpha-sorted for ease of visual lookup. */
13047 switch (filedata
->file_header
.e_machine
)
13050 return reloc_type
== 39; /* R_RISCV_SUB32. */
13056 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13057 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13060 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13062 /* Please keep this table alpha-sorted for ease of visual lookup. */
13063 switch (filedata
->file_header
.e_machine
)
13066 return reloc_type
== 36; /* R_RISCV_ADD64. */
13072 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13073 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13076 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13078 /* Please keep this table alpha-sorted for ease of visual lookup. */
13079 switch (filedata
->file_header
.e_machine
)
13082 return reloc_type
== 40; /* R_RISCV_SUB64. */
13088 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13089 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13092 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13094 /* Please keep this table alpha-sorted for ease of visual lookup. */
13095 switch (filedata
->file_header
.e_machine
)
13098 return reloc_type
== 34; /* R_RISCV_ADD16. */
13104 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13105 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13108 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13110 /* Please keep this table alpha-sorted for ease of visual lookup. */
13111 switch (filedata
->file_header
.e_machine
)
13114 return reloc_type
== 38; /* R_RISCV_SUB16. */
13120 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13121 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13124 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13126 /* Please keep this table alpha-sorted for ease of visual lookup. */
13127 switch (filedata
->file_header
.e_machine
)
13130 return reloc_type
== 33; /* R_RISCV_ADD8. */
13136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13137 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13140 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13142 /* Please keep this table alpha-sorted for ease of visual lookup. */
13143 switch (filedata
->file_header
.e_machine
)
13146 return reloc_type
== 37; /* R_RISCV_SUB8. */
13152 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13153 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13156 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13158 switch (filedata
->file_header
.e_machine
)
13161 return reloc_type
== 52; /* R_RISCV_SUB6. */
13167 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13168 relocation entries (possibly formerly used for SHT_GROUP sections). */
13171 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13173 switch (filedata
->file_header
.e_machine
)
13175 case EM_386
: /* R_386_NONE. */
13176 case EM_68K
: /* R_68K_NONE. */
13177 case EM_ADAPTEVA_EPIPHANY
:
13178 case EM_ALPHA
: /* R_ALPHA_NONE. */
13179 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13180 case EM_ARC
: /* R_ARC_NONE. */
13181 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13182 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13183 case EM_ARM
: /* R_ARM_NONE. */
13184 case EM_C166
: /* R_XC16X_NONE. */
13185 case EM_CRIS
: /* R_CRIS_NONE. */
13186 case EM_FT32
: /* R_FT32_NONE. */
13187 case EM_IA_64
: /* R_IA64_NONE. */
13188 case EM_K1OM
: /* R_X86_64_NONE. */
13189 case EM_L1OM
: /* R_X86_64_NONE. */
13190 case EM_M32R
: /* R_M32R_NONE. */
13191 case EM_MIPS
: /* R_MIPS_NONE. */
13192 case EM_MN10300
: /* R_MN10300_NONE. */
13193 case EM_MOXIE
: /* R_MOXIE_NONE. */
13194 case EM_NIOS32
: /* R_NIOS_NONE. */
13195 case EM_OR1K
: /* R_OR1K_NONE. */
13196 case EM_PARISC
: /* R_PARISC_NONE. */
13197 case EM_PPC64
: /* R_PPC64_NONE. */
13198 case EM_PPC
: /* R_PPC_NONE. */
13199 case EM_RISCV
: /* R_RISCV_NONE. */
13200 case EM_S390
: /* R_390_NONE. */
13202 case EM_SH
: /* R_SH_NONE. */
13203 case EM_SPARC32PLUS
:
13204 case EM_SPARC
: /* R_SPARC_NONE. */
13206 case EM_TILEGX
: /* R_TILEGX_NONE. */
13207 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13208 case EM_TI_C6000
:/* R_C6000_NONE. */
13209 case EM_X86_64
: /* R_X86_64_NONE. */
13211 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13212 return reloc_type
== 0;
13215 return reloc_type
== 0 || reloc_type
== 256;
13218 return (reloc_type
== 0 /* R_AVR_NONE. */
13219 || reloc_type
== 30 /* R_AVR_DIFF8. */
13220 || reloc_type
== 31 /* R_AVR_DIFF16. */
13221 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13223 return reloc_type
== 3; /* R_METAG_NONE. */
13225 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13226 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13227 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13228 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13229 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13231 return (reloc_type
== 0 /* R_PRU_NONE. */
13232 || reloc_type
== 65 /* R_PRU_DIFF8. */
13233 || reloc_type
== 66 /* R_PRU_DIFF16. */
13234 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13235 case EM_XTENSA_OLD
:
13237 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13238 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13239 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13240 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13245 /* Returns TRUE if there is a relocation against
13246 section NAME at OFFSET bytes. */
13249 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13251 Elf_Internal_Rela
* relocs
;
13252 Elf_Internal_Rela
* rp
;
13254 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13257 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13259 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13260 if (rp
->r_offset
== offset
)
13266 /* Apply relocations to a section.
13267 Returns TRUE upon success, FALSE otherwise.
13268 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13269 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13270 will be set to the number of relocs loaded.
13272 Note: So far support has been added only for those relocations
13273 which can be found in debug sections. FIXME: Add support for
13274 more relocations ? */
13277 apply_relocations (Filedata
* filedata
,
13278 const Elf_Internal_Shdr
* section
,
13279 unsigned char * start
,
13280 bfd_size_type size
,
13281 void ** relocs_return
,
13282 unsigned long * num_relocs_return
)
13284 Elf_Internal_Shdr
* relsec
;
13285 unsigned char * end
= start
+ size
;
13287 if (relocs_return
!= NULL
)
13289 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13290 * num_relocs_return
= 0;
13293 if (filedata
->file_header
.e_type
!= ET_REL
)
13294 /* No relocs to apply. */
13297 /* Find the reloc section associated with the section. */
13298 for (relsec
= filedata
->section_headers
;
13299 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13302 bfd_boolean is_rela
;
13303 unsigned long num_relocs
;
13304 Elf_Internal_Rela
* relocs
;
13305 Elf_Internal_Rela
* rp
;
13306 Elf_Internal_Shdr
* symsec
;
13307 Elf_Internal_Sym
* symtab
;
13308 unsigned long num_syms
;
13309 Elf_Internal_Sym
* sym
;
13311 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13312 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13313 || filedata
->section_headers
+ relsec
->sh_info
!= section
13314 || relsec
->sh_size
== 0
13315 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13318 is_rela
= relsec
->sh_type
== SHT_RELA
;
13322 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13323 relsec
->sh_size
, & relocs
, & num_relocs
))
13328 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13329 relsec
->sh_size
, & relocs
, & num_relocs
))
13333 /* SH uses RELA but uses in place value instead of the addend field. */
13334 if (filedata
->file_header
.e_machine
== EM_SH
)
13337 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13338 if (symsec
->sh_type
!= SHT_SYMTAB
13339 && symsec
->sh_type
!= SHT_DYNSYM
)
13341 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13343 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13346 unsigned int reloc_type
;
13347 unsigned int reloc_size
;
13348 bfd_boolean reloc_inplace
= FALSE
;
13349 bfd_boolean reloc_subtract
= FALSE
;
13350 unsigned char * rloc
;
13351 unsigned long sym_index
;
13353 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13355 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13357 else if (is_none_reloc (filedata
, reloc_type
))
13359 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13360 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13362 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13363 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13365 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13367 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13369 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13370 || is_6bit_abs_reloc (filedata
, reloc_type
))
13372 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13374 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13377 reloc_inplace
= TRUE
;
13379 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13381 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13384 reloc_inplace
= TRUE
;
13386 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13388 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13391 reloc_inplace
= TRUE
;
13393 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13395 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13398 reloc_inplace
= TRUE
;
13400 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13404 reloc_inplace
= TRUE
;
13408 static unsigned int prev_reloc
= 0;
13410 if (reloc_type
!= prev_reloc
)
13411 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13412 reloc_type
, printable_section_name (filedata
, section
));
13413 prev_reloc
= reloc_type
;
13417 rloc
= start
+ rp
->r_offset
;
13418 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13420 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13421 (unsigned long) rp
->r_offset
,
13422 printable_section_name (filedata
, section
));
13426 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13427 if (sym_index
>= num_syms
)
13429 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13430 sym_index
, printable_section_name (filedata
, section
));
13433 sym
= symtab
+ sym_index
;
13435 /* If the reloc has a symbol associated with it,
13436 make sure that it is of an appropriate type.
13438 Relocations against symbols without type can happen.
13439 Gcc -feliminate-dwarf2-dups may generate symbols
13440 without type for debug info.
13442 Icc generates relocations against function symbols
13443 instead of local labels.
13445 Relocations against object symbols can happen, eg when
13446 referencing a global array. For an example of this see
13447 the _clz.o binary in libgcc.a. */
13449 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13450 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13452 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13453 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13454 printable_section_name (filedata
, relsec
),
13455 (long int)(rp
- relocs
));
13461 addend
+= rp
->r_addend
;
13462 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13463 partial_inplace. */
13465 || (filedata
->file_header
.e_machine
== EM_XTENSA
13466 && reloc_type
== 1)
13467 || ((filedata
->file_header
.e_machine
== EM_PJ
13468 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13469 && reloc_type
== 1)
13470 || ((filedata
->file_header
.e_machine
== EM_D30V
13471 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13472 && reloc_type
== 12)
13475 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13476 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13478 addend
+= byte_get (rloc
, reloc_size
);
13481 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13482 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13484 /* On HPPA, all pc-relative relocations are biased by 8. */
13485 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13487 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13490 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13491 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13493 if (reloc_subtract
)
13494 addend
-= sym
->st_value
;
13496 addend
+= sym
->st_value
;
13497 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13498 byte_put (rloc
, addend
, reloc_size
);
13500 else if (reloc_subtract
)
13501 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13503 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13507 /* Let the target specific reloc processing code know that
13508 we have finished with these relocs. */
13509 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13513 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13514 * num_relocs_return
= num_relocs
;
13525 #ifdef SUPPORT_DISASSEMBLY
13527 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13529 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13531 /* FIXME: XXX -- to be done --- XXX */
13537 /* Reads in the contents of SECTION from FILE, returning a pointer
13538 to a malloc'ed buffer or NULL if something went wrong. */
13541 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13543 bfd_size_type num_bytes
= section
->sh_size
;
13545 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13547 printf (_("Section '%s' has no data to dump.\n"),
13548 printable_section_name (filedata
, section
));
13552 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13553 _("section contents"));
13556 /* Uncompresses a section that was compressed using zlib, in place. */
13559 uncompress_section_contents (unsigned char ** buffer
,
13560 dwarf_size_type uncompressed_size
,
13561 dwarf_size_type
* size
)
13563 dwarf_size_type compressed_size
= *size
;
13564 unsigned char * compressed_buffer
= *buffer
;
13565 unsigned char * uncompressed_buffer
;
13569 /* It is possible the section consists of several compressed
13570 buffers concatenated together, so we uncompress in a loop. */
13571 /* PR 18313: The state field in the z_stream structure is supposed
13572 to be invisible to the user (ie us), but some compilers will
13573 still complain about it being used without initialisation. So
13574 we first zero the entire z_stream structure and then set the fields
13576 memset (& strm
, 0, sizeof strm
);
13577 strm
.avail_in
= compressed_size
;
13578 strm
.next_in
= (Bytef
*) compressed_buffer
;
13579 strm
.avail_out
= uncompressed_size
;
13580 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13582 rc
= inflateInit (& strm
);
13583 while (strm
.avail_in
> 0)
13587 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13588 + (uncompressed_size
- strm
.avail_out
));
13589 rc
= inflate (&strm
, Z_FINISH
);
13590 if (rc
!= Z_STREAM_END
)
13592 rc
= inflateReset (& strm
);
13594 rc
= inflateEnd (& strm
);
13596 || strm
.avail_out
!= 0)
13599 *buffer
= uncompressed_buffer
;
13600 *size
= uncompressed_size
;
13604 free (uncompressed_buffer
);
13605 /* Indicate decompression failure. */
13611 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13613 Elf_Internal_Shdr
* relsec
;
13614 bfd_size_type num_bytes
;
13615 unsigned char * data
;
13616 unsigned char * end
;
13617 unsigned char * real_start
;
13618 unsigned char * start
;
13619 bfd_boolean some_strings_shown
;
13621 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13623 /* PR 21820: Do not fail if the section was empty. */
13624 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13626 num_bytes
= section
->sh_size
;
13628 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13630 if (decompress_dumps
)
13632 dwarf_size_type new_size
= num_bytes
;
13633 dwarf_size_type uncompressed_size
= 0;
13635 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13637 Elf_Internal_Chdr chdr
;
13638 unsigned int compression_header_size
13639 = get_compression_header (& chdr
, (unsigned char *) start
,
13642 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13644 warn (_("section '%s' has unsupported compress type: %d\n"),
13645 printable_section_name (filedata
, section
), chdr
.ch_type
);
13648 uncompressed_size
= chdr
.ch_size
;
13649 start
+= compression_header_size
;
13650 new_size
-= compression_header_size
;
13652 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13654 /* Read the zlib header. In this case, it should be "ZLIB"
13655 followed by the uncompressed section size, 8 bytes in
13656 big-endian order. */
13657 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13658 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13659 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13660 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13661 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13662 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13663 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13664 uncompressed_size
+= start
[11];
13669 if (uncompressed_size
)
13671 if (uncompress_section_contents (& start
,
13672 uncompressed_size
, & new_size
))
13673 num_bytes
= new_size
;
13676 error (_("Unable to decompress section %s\n"),
13677 printable_section_name (filedata
, section
));
13682 start
= real_start
;
13685 /* If the section being dumped has relocations against it the user might
13686 be expecting these relocations to have been applied. Check for this
13687 case and issue a warning message in order to avoid confusion.
13688 FIXME: Maybe we ought to have an option that dumps a section with
13689 relocs applied ? */
13690 for (relsec
= filedata
->section_headers
;
13691 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13694 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13695 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13696 || filedata
->section_headers
+ relsec
->sh_info
!= section
13697 || relsec
->sh_size
== 0
13698 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13701 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13706 end
= start
+ num_bytes
;
13707 some_strings_shown
= FALSE
;
13711 while (!ISPRINT (* data
))
13712 if (++ data
>= end
)
13717 size_t maxlen
= end
- data
;
13720 /* PR 11128: Use two separate invocations in order to work
13721 around bugs in the Solaris 8 implementation of printf. */
13722 printf (" [%6tx] ", data
- start
);
13724 printf (" [%6Ix] ", (size_t) (data
- start
));
13728 print_symbol ((int) maxlen
, (const char *) data
);
13730 data
+= strnlen ((const char *) data
, maxlen
);
13734 printf (_("<corrupt>\n"));
13737 some_strings_shown
= TRUE
;
13741 if (! some_strings_shown
)
13742 printf (_(" No strings found in this section."));
13751 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13752 Filedata
* filedata
,
13753 bfd_boolean relocate
)
13755 Elf_Internal_Shdr
* relsec
;
13756 bfd_size_type bytes
;
13757 bfd_size_type section_size
;
13759 unsigned char * data
;
13760 unsigned char * real_start
;
13761 unsigned char * start
;
13763 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13765 /* PR 21820: Do not fail if the section was empty. */
13766 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13768 section_size
= section
->sh_size
;
13770 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13772 if (decompress_dumps
)
13774 dwarf_size_type new_size
= section_size
;
13775 dwarf_size_type uncompressed_size
= 0;
13777 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13779 Elf_Internal_Chdr chdr
;
13780 unsigned int compression_header_size
13781 = get_compression_header (& chdr
, start
, section_size
);
13783 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13785 warn (_("section '%s' has unsupported compress type: %d\n"),
13786 printable_section_name (filedata
, section
), chdr
.ch_type
);
13789 uncompressed_size
= chdr
.ch_size
;
13790 start
+= compression_header_size
;
13791 new_size
-= compression_header_size
;
13793 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13795 /* Read the zlib header. In this case, it should be "ZLIB"
13796 followed by the uncompressed section size, 8 bytes in
13797 big-endian order. */
13798 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13799 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13800 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13801 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13802 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13803 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13804 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13805 uncompressed_size
+= start
[11];
13810 if (uncompressed_size
)
13812 if (uncompress_section_contents (& start
, uncompressed_size
,
13815 section_size
= new_size
;
13819 error (_("Unable to decompress section %s\n"),
13820 printable_section_name (filedata
, section
));
13821 /* FIXME: Print the section anyway ? */
13826 start
= real_start
;
13831 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13836 /* If the section being dumped has relocations against it the user might
13837 be expecting these relocations to have been applied. Check for this
13838 case and issue a warning message in order to avoid confusion.
13839 FIXME: Maybe we ought to have an option that dumps a section with
13840 relocs applied ? */
13841 for (relsec
= filedata
->section_headers
;
13842 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13845 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13846 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13847 || filedata
->section_headers
+ relsec
->sh_info
!= section
13848 || relsec
->sh_size
== 0
13849 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13852 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13857 addr
= section
->sh_addr
;
13858 bytes
= section_size
;
13867 lbytes
= (bytes
> 16 ? 16 : bytes
);
13869 printf (" 0x%8.8lx ", (unsigned long) addr
);
13871 for (j
= 0; j
< 16; j
++)
13874 printf ("%2.2x", data
[j
]);
13882 for (j
= 0; j
< lbytes
; j
++)
13885 if (k
>= ' ' && k
< 0x7f)
13904 static ctf_sect_t
*
13905 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13907 buf
->cts_name
= SECTION_NAME (shdr
);
13908 buf
->cts_size
= shdr
->sh_size
;
13909 buf
->cts_entsize
= shdr
->sh_entsize
;
13914 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13915 it is passed, or a pointer to newly-allocated storage, in which case
13916 dump_ctf() will free it when it no longer needs it. */
13918 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13919 char *s
, void *arg
)
13921 const char *blanks
= arg
;
13924 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13930 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13932 Elf_Internal_Shdr
* parent_sec
= NULL
;
13933 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13934 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13935 void * data
= NULL
;
13936 void * symdata
= NULL
;
13937 void * strdata
= NULL
;
13938 void * parentdata
= NULL
;
13939 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13940 ctf_sect_t
* symsectp
= NULL
;
13941 ctf_sect_t
* strsectp
= NULL
;
13942 ctf_file_t
* ctf
= NULL
;
13943 ctf_file_t
* parent
= NULL
;
13945 const char *things
[] = {"Header", "Labels", "Data objects",
13946 "Function objects", "Variables", "Types", "Strings",
13948 const char **thing
;
13950 bfd_boolean ret
= FALSE
;
13953 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13954 data
= get_section_contents (section
, filedata
);
13955 ctfsect
.cts_data
= data
;
13957 if (!dump_ctf_symtab_name
)
13958 dump_ctf_symtab_name
= strdup (".symtab");
13960 if (!dump_ctf_strtab_name
)
13961 dump_ctf_strtab_name
= strdup (".strtab");
13963 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
13965 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13967 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13970 if ((symdata
= (void *) get_data (NULL
, filedata
,
13971 symtab_sec
->sh_offset
, 1,
13972 symtab_sec
->sh_size
,
13973 _("symbols"))) == NULL
)
13975 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13976 symsect
.cts_data
= symdata
;
13978 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
13980 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
13982 error (_("No string table section named %s\n"),
13983 dump_ctf_strtab_name
);
13986 if ((strdata
= (void *) get_data (NULL
, filedata
,
13987 strtab_sec
->sh_offset
, 1,
13988 strtab_sec
->sh_size
,
13989 _("strings"))) == NULL
)
13991 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
13992 strsect
.cts_data
= strdata
;
13994 if (dump_ctf_parent_name
)
13996 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
13998 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14001 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14002 parent_sec
->sh_offset
, 1,
14003 parent_sec
->sh_size
,
14004 _("CTF parent"))) == NULL
)
14006 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14007 parentsect
.cts_data
= parentdata
;
14010 /* Load the CTF file and dump it. */
14012 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14014 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14020 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14022 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14026 ctf_import (ctf
, parent
);
14031 printf (_("\nDump of CTF section '%s':\n"),
14032 printable_section_name (filedata
, section
));
14034 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14036 ctf_dump_state_t
*s
= NULL
;
14039 printf ("\n %s:\n", *thing
);
14040 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14041 (void *) " ")) != NULL
)
14043 printf ("%s\n", item
);
14047 if (ctf_errno (ctf
))
14049 error (_("Iteration failed: %s, %s\n"), *thing
,
14050 ctf_errmsg (ctf_errno (ctf
)));
14056 ctf_file_close (ctf
);
14057 ctf_file_close (parent
);
14066 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14067 const Elf_Internal_Shdr
* sec
,
14070 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14072 Filedata
* filedata
= (Filedata
*) data
;
14074 if (section
->start
!= NULL
)
14076 /* If it is already loaded, do nothing. */
14077 if (streq (section
->filename
, filedata
->file_name
))
14079 free (section
->start
);
14082 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14083 section
->address
= sec
->sh_addr
;
14084 section
->user_data
= NULL
;
14085 section
->filename
= filedata
->file_name
;
14086 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14088 sec
->sh_size
, buf
);
14089 if (section
->start
== NULL
)
14093 unsigned char *start
= section
->start
;
14094 dwarf_size_type size
= sec
->sh_size
;
14095 dwarf_size_type uncompressed_size
= 0;
14097 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14099 Elf_Internal_Chdr chdr
;
14100 unsigned int compression_header_size
;
14102 if (size
< (is_32bit_elf
14103 ? sizeof (Elf32_External_Chdr
)
14104 : sizeof (Elf64_External_Chdr
)))
14106 warn (_("compressed section %s is too small to contain a compression header"),
14111 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14113 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14115 warn (_("section '%s' has unsupported compress type: %d\n"),
14116 section
->name
, chdr
.ch_type
);
14119 uncompressed_size
= chdr
.ch_size
;
14120 start
+= compression_header_size
;
14121 size
-= compression_header_size
;
14123 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14125 /* Read the zlib header. In this case, it should be "ZLIB"
14126 followed by the uncompressed section size, 8 bytes in
14127 big-endian order. */
14128 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14129 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14130 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14131 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14132 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14133 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14134 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14135 uncompressed_size
+= start
[11];
14140 if (uncompressed_size
)
14142 if (uncompress_section_contents (&start
, uncompressed_size
,
14145 /* Free the compressed buffer, update the section buffer
14146 and the section size if uncompress is successful. */
14147 free (section
->start
);
14148 section
->start
= start
;
14152 error (_("Unable to decompress section %s\n"),
14153 printable_section_name (filedata
, sec
));
14158 section
->size
= size
;
14161 if (section
->start
== NULL
)
14164 if (debug_displays
[debug
].relocate
)
14166 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14167 & section
->reloc_info
, & section
->num_relocs
))
14172 section
->reloc_info
= NULL
;
14173 section
->num_relocs
= 0;
14179 /* If this is not NULL, load_debug_section will only look for sections
14180 within the list of sections given here. */
14181 static unsigned int * section_subset
= NULL
;
14184 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14186 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14187 Elf_Internal_Shdr
* sec
;
14188 Filedata
* filedata
= (Filedata
*) data
;
14190 /* Without section headers we cannot find any sections. */
14191 if (filedata
->section_headers
== NULL
)
14194 if (filedata
->string_table
== NULL
14195 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14196 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14198 Elf_Internal_Shdr
* strs
;
14200 /* Read in the string table, so that we have section names to scan. */
14201 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14203 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14205 filedata
->string_table
14206 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14207 1, strs
->sh_size
, _("string table"));
14209 filedata
->string_table_length
14210 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14214 /* Locate the debug section. */
14215 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14217 section
->name
= section
->uncompressed_name
;
14220 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14222 section
->name
= section
->compressed_name
;
14227 /* If we're loading from a subset of sections, and we've loaded
14228 a section matching this name before, it's likely that it's a
14230 if (section_subset
!= NULL
)
14231 free_debug_section (debug
);
14233 return load_specific_debug_section (debug
, sec
, data
);
14237 free_debug_section (enum dwarf_section_display_enum debug
)
14239 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14241 if (section
->start
== NULL
)
14244 free ((char *) section
->start
);
14245 section
->start
= NULL
;
14246 section
->address
= 0;
14251 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14253 char * name
= SECTION_NAME (section
);
14254 const char * print_name
= printable_section_name (filedata
, section
);
14255 bfd_size_type length
;
14256 bfd_boolean result
= TRUE
;
14259 length
= section
->sh_size
;
14262 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14265 if (section
->sh_type
== SHT_NOBITS
)
14267 /* There is no point in dumping the contents of a debugging section
14268 which has the NOBITS type - the bits in the file will be random.
14269 This can happen when a file containing a .eh_frame section is
14270 stripped with the --only-keep-debug command line option. */
14271 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14276 if (const_strneq (name
, ".gnu.linkonce.wi."))
14277 name
= ".debug_info";
14279 /* See if we know how to display the contents of this section. */
14280 for (i
= 0; i
< max
; i
++)
14282 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14283 struct dwarf_section_display
* display
= debug_displays
+ i
;
14284 struct dwarf_section
* sec
= & display
->section
;
14286 if (streq (sec
->uncompressed_name
, name
)
14287 || (id
== line
&& const_strneq (name
, ".debug_line."))
14288 || streq (sec
->compressed_name
, name
))
14290 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14293 free_debug_section (id
);
14295 if (i
== line
&& const_strneq (name
, ".debug_line."))
14297 else if (streq (sec
->uncompressed_name
, name
))
14298 sec
->name
= sec
->uncompressed_name
;
14300 sec
->name
= sec
->compressed_name
;
14302 if (load_specific_debug_section (id
, section
, filedata
))
14304 /* If this debug section is part of a CU/TU set in a .dwp file,
14305 restrict load_debug_section to the sections in that set. */
14306 section_subset
= find_cu_tu_set (filedata
, shndx
);
14308 result
&= display
->display (sec
, filedata
);
14310 section_subset
= NULL
;
14312 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14313 free_debug_section (id
);
14321 printf (_("Unrecognized debug section: %s\n"), print_name
);
14328 /* Set DUMP_SECTS for all sections where dumps were requested
14329 based on section name. */
14332 initialise_dumps_byname (Filedata
* filedata
)
14334 struct dump_list_entry
* cur
;
14336 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14339 bfd_boolean any
= FALSE
;
14341 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14342 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14344 request_dump_bynumber (filedata
, i
, cur
->type
);
14349 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14355 process_section_contents (Filedata
* filedata
)
14357 Elf_Internal_Shdr
* section
;
14359 bfd_boolean res
= TRUE
;
14364 initialise_dumps_byname (filedata
);
14366 for (i
= 0, section
= filedata
->section_headers
;
14367 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14370 dump_type dump
= filedata
->dump_sects
[i
];
14372 #ifdef SUPPORT_DISASSEMBLY
14373 if (dump
& DISASS_DUMP
)
14375 if (! disassemble_section (section
, filedata
))
14379 if (dump
& HEX_DUMP
)
14381 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14385 if (dump
& RELOC_DUMP
)
14387 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14391 if (dump
& STRING_DUMP
)
14393 if (! dump_section_as_strings (section
, filedata
))
14397 if (dump
& DEBUG_DUMP
)
14399 if (! display_debug_section (i
, section
, filedata
))
14403 if (dump
& CTF_DUMP
)
14405 if (! dump_section_as_ctf (section
, filedata
))
14410 /* Check to see if the user requested a
14411 dump of a section that does not exist. */
14412 while (i
< filedata
->num_dump_sects
)
14414 if (filedata
->dump_sects
[i
])
14416 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14426 process_mips_fpe_exception (int mask
)
14430 bfd_boolean first
= TRUE
;
14432 if (mask
& OEX_FPU_INEX
)
14433 fputs ("INEX", stdout
), first
= FALSE
;
14434 if (mask
& OEX_FPU_UFLO
)
14435 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14436 if (mask
& OEX_FPU_OFLO
)
14437 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14438 if (mask
& OEX_FPU_DIV0
)
14439 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14440 if (mask
& OEX_FPU_INVAL
)
14441 printf ("%sINVAL", first
? "" : "|");
14444 fputs ("0", stdout
);
14447 /* Display's the value of TAG at location P. If TAG is
14448 greater than 0 it is assumed to be an unknown tag, and
14449 a message is printed to this effect. Otherwise it is
14450 assumed that a message has already been printed.
14452 If the bottom bit of TAG is set it assumed to have a
14453 string value, otherwise it is assumed to have an integer
14456 Returns an updated P pointing to the first unread byte
14457 beyond the end of TAG's value.
14459 Reads at or beyond END will not be made. */
14461 static unsigned char *
14462 display_tag_value (signed int tag
,
14464 const unsigned char * const end
)
14469 printf (" Tag_unknown_%d: ", tag
);
14473 warn (_("<corrupt tag>\n"));
14477 /* PR 17531 file: 027-19978-0.004. */
14478 size_t maxlen
= (end
- p
) - 1;
14483 print_symbol ((int) maxlen
, (const char *) p
);
14484 p
+= strnlen ((char *) p
, maxlen
) + 1;
14488 printf (_("<corrupt string tag>"));
14489 p
= (unsigned char *) end
;
14497 val
= read_uleb128 (p
, &len
, end
);
14499 printf ("%ld (0x%lx)\n", val
, val
);
14506 /* ARC ABI attributes section. */
14508 static unsigned char *
14509 display_arc_attribute (unsigned char * p
,
14510 const unsigned char * const end
)
14516 tag
= read_uleb128 (p
, &len
, end
);
14521 case Tag_ARC_PCS_config
:
14522 val
= read_uleb128 (p
, &len
, end
);
14524 printf (" Tag_ARC_PCS_config: ");
14528 printf (_("Absent/Non standard\n"));
14531 printf (_("Bare metal/mwdt\n"));
14534 printf (_("Bare metal/newlib\n"));
14537 printf (_("Linux/uclibc\n"));
14540 printf (_("Linux/glibc\n"));
14543 printf (_("Unknown\n"));
14548 case Tag_ARC_CPU_base
:
14549 val
= read_uleb128 (p
, &len
, end
);
14551 printf (" Tag_ARC_CPU_base: ");
14556 printf (_("Absent\n"));
14558 case TAG_CPU_ARC6xx
:
14559 printf ("ARC6xx\n");
14561 case TAG_CPU_ARC7xx
:
14562 printf ("ARC7xx\n");
14564 case TAG_CPU_ARCEM
:
14565 printf ("ARCEM\n");
14567 case TAG_CPU_ARCHS
:
14568 printf ("ARCHS\n");
14573 case Tag_ARC_CPU_variation
:
14574 val
= read_uleb128 (p
, &len
, end
);
14576 printf (" Tag_ARC_CPU_variation: ");
14580 if (val
> 0 && val
< 16)
14581 printf ("Core%d\n", val
);
14583 printf ("Unknown\n");
14587 printf (_("Absent\n"));
14592 case Tag_ARC_CPU_name
:
14593 printf (" Tag_ARC_CPU_name: ");
14594 p
= display_tag_value (-1, p
, end
);
14597 case Tag_ARC_ABI_rf16
:
14598 val
= read_uleb128 (p
, &len
, end
);
14600 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14603 case Tag_ARC_ABI_osver
:
14604 val
= read_uleb128 (p
, &len
, end
);
14606 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14609 case Tag_ARC_ABI_pic
:
14610 case Tag_ARC_ABI_sda
:
14611 val
= read_uleb128 (p
, &len
, end
);
14613 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14614 : " Tag_ARC_ABI_pic: ");
14618 printf (_("Absent\n"));
14627 printf (_("Unknown\n"));
14632 case Tag_ARC_ABI_tls
:
14633 val
= read_uleb128 (p
, &len
, end
);
14635 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14638 case Tag_ARC_ABI_enumsize
:
14639 val
= read_uleb128 (p
, &len
, end
);
14641 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14645 case Tag_ARC_ABI_exceptions
:
14646 val
= read_uleb128 (p
, &len
, end
);
14648 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14652 case Tag_ARC_ABI_double_size
:
14653 val
= read_uleb128 (p
, &len
, end
);
14655 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14658 case Tag_ARC_ISA_config
:
14659 printf (" Tag_ARC_ISA_config: ");
14660 p
= display_tag_value (-1, p
, end
);
14663 case Tag_ARC_ISA_apex
:
14664 printf (" Tag_ARC_ISA_apex: ");
14665 p
= display_tag_value (-1, p
, end
);
14668 case Tag_ARC_ISA_mpy_option
:
14669 val
= read_uleb128 (p
, &len
, end
);
14671 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14674 case Tag_ARC_ATR_version
:
14675 val
= read_uleb128 (p
, &len
, end
);
14677 printf (" Tag_ARC_ATR_version: %d\n", val
);
14681 return display_tag_value (tag
& 1, p
, end
);
14687 /* ARM EABI attributes section. */
14692 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14694 const char ** table
;
14695 } arm_attr_public_tag
;
14697 static const char * arm_attr_tag_CPU_arch
[] =
14698 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14699 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14700 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14701 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14702 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14703 {"No", "Thumb-1", "Thumb-2", "Yes"};
14704 static const char * arm_attr_tag_FP_arch
[] =
14705 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14706 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14707 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14708 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14709 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14710 "NEON for ARMv8.1"};
14711 static const char * arm_attr_tag_PCS_config
[] =
14712 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14713 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14714 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14715 {"V6", "SB", "TLS", "Unused"};
14716 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14717 {"Absolute", "PC-relative", "SB-relative", "None"};
14718 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14719 {"Absolute", "PC-relative", "None"};
14720 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14721 {"None", "direct", "GOT-indirect"};
14722 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14723 {"None", "??? 1", "2", "??? 3", "4"};
14724 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14725 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14726 {"Unused", "Needed", "Sign only"};
14727 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14728 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14729 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14730 {"Unused", "Finite", "RTABI", "IEEE 754"};
14731 static const char * arm_attr_tag_ABI_enum_size
[] =
14732 {"Unused", "small", "int", "forced to int"};
14733 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14734 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14735 static const char * arm_attr_tag_ABI_VFP_args
[] =
14736 {"AAPCS", "VFP registers", "custom", "compatible"};
14737 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14738 {"AAPCS", "WMMX registers", "custom"};
14739 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14740 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14741 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14742 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14743 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14744 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14745 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14746 static const char * arm_attr_tag_FP_HP_extension
[] =
14747 {"Not Allowed", "Allowed"};
14748 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14749 {"None", "IEEE 754", "Alternative Format"};
14750 static const char * arm_attr_tag_DSP_extension
[] =
14751 {"Follow architecture", "Allowed"};
14752 static const char * arm_attr_tag_MPextension_use
[] =
14753 {"Not Allowed", "Allowed"};
14754 static const char * arm_attr_tag_DIV_use
[] =
14755 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14756 "Allowed in v7-A with integer division extension"};
14757 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14758 static const char * arm_attr_tag_Virtualization_use
[] =
14759 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14760 "TrustZone and Virtualization Extensions"};
14761 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14762 {"Not Allowed", "Allowed"};
14764 static const char * arm_attr_tag_MVE_arch
[] =
14765 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14767 #define LOOKUP(id, name) \
14768 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14769 static arm_attr_public_tag arm_attr_public_tags
[] =
14771 {4, "CPU_raw_name", 1, NULL
},
14772 {5, "CPU_name", 1, NULL
},
14773 LOOKUP(6, CPU_arch
),
14774 {7, "CPU_arch_profile", 0, NULL
},
14775 LOOKUP(8, ARM_ISA_use
),
14776 LOOKUP(9, THUMB_ISA_use
),
14777 LOOKUP(10, FP_arch
),
14778 LOOKUP(11, WMMX_arch
),
14779 LOOKUP(12, Advanced_SIMD_arch
),
14780 LOOKUP(13, PCS_config
),
14781 LOOKUP(14, ABI_PCS_R9_use
),
14782 LOOKUP(15, ABI_PCS_RW_data
),
14783 LOOKUP(16, ABI_PCS_RO_data
),
14784 LOOKUP(17, ABI_PCS_GOT_use
),
14785 LOOKUP(18, ABI_PCS_wchar_t
),
14786 LOOKUP(19, ABI_FP_rounding
),
14787 LOOKUP(20, ABI_FP_denormal
),
14788 LOOKUP(21, ABI_FP_exceptions
),
14789 LOOKUP(22, ABI_FP_user_exceptions
),
14790 LOOKUP(23, ABI_FP_number_model
),
14791 {24, "ABI_align_needed", 0, NULL
},
14792 {25, "ABI_align_preserved", 0, NULL
},
14793 LOOKUP(26, ABI_enum_size
),
14794 LOOKUP(27, ABI_HardFP_use
),
14795 LOOKUP(28, ABI_VFP_args
),
14796 LOOKUP(29, ABI_WMMX_args
),
14797 LOOKUP(30, ABI_optimization_goals
),
14798 LOOKUP(31, ABI_FP_optimization_goals
),
14799 {32, "compatibility", 0, NULL
},
14800 LOOKUP(34, CPU_unaligned_access
),
14801 LOOKUP(36, FP_HP_extension
),
14802 LOOKUP(38, ABI_FP_16bit_format
),
14803 LOOKUP(42, MPextension_use
),
14804 LOOKUP(44, DIV_use
),
14805 LOOKUP(46, DSP_extension
),
14806 LOOKUP(48, MVE_arch
),
14807 {64, "nodefaults", 0, NULL
},
14808 {65, "also_compatible_with", 0, NULL
},
14809 LOOKUP(66, T2EE_use
),
14810 {67, "conformance", 1, NULL
},
14811 LOOKUP(68, Virtualization_use
),
14812 LOOKUP(70, MPextension_use_legacy
)
14816 static unsigned char *
14817 display_arm_attribute (unsigned char * p
,
14818 const unsigned char * const end
)
14823 arm_attr_public_tag
* attr
;
14827 tag
= read_uleb128 (p
, &len
, end
);
14830 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14832 if (arm_attr_public_tags
[i
].tag
== tag
)
14834 attr
= &arm_attr_public_tags
[i
];
14841 printf (" Tag_%s: ", attr
->name
);
14842 switch (attr
->type
)
14847 case 7: /* Tag_CPU_arch_profile. */
14848 val
= read_uleb128 (p
, &len
, end
);
14852 case 0: printf (_("None\n")); break;
14853 case 'A': printf (_("Application\n")); break;
14854 case 'R': printf (_("Realtime\n")); break;
14855 case 'M': printf (_("Microcontroller\n")); break;
14856 case 'S': printf (_("Application or Realtime\n")); break;
14857 default: printf ("??? (%d)\n", val
); break;
14861 case 24: /* Tag_align_needed. */
14862 val
= read_uleb128 (p
, &len
, end
);
14866 case 0: printf (_("None\n")); break;
14867 case 1: printf (_("8-byte\n")); break;
14868 case 2: printf (_("4-byte\n")); break;
14869 case 3: printf ("??? 3\n"); break;
14872 printf (_("8-byte and up to %d-byte extended\n"),
14875 printf ("??? (%d)\n", val
);
14880 case 25: /* Tag_align_preserved. */
14881 val
= read_uleb128 (p
, &len
, end
);
14885 case 0: printf (_("None\n")); break;
14886 case 1: printf (_("8-byte, except leaf SP\n")); break;
14887 case 2: printf (_("8-byte\n")); break;
14888 case 3: printf ("??? 3\n"); break;
14891 printf (_("8-byte and up to %d-byte extended\n"),
14894 printf ("??? (%d)\n", val
);
14899 case 32: /* Tag_compatibility. */
14901 val
= read_uleb128 (p
, &len
, end
);
14903 printf (_("flag = %d, vendor = "), val
);
14906 size_t maxlen
= (end
- p
) - 1;
14908 print_symbol ((int) maxlen
, (const char *) p
);
14909 p
+= strnlen ((char *) p
, maxlen
) + 1;
14913 printf (_("<corrupt>"));
14914 p
= (unsigned char *) end
;
14920 case 64: /* Tag_nodefaults. */
14921 /* PR 17531: file: 001-505008-0.01. */
14924 printf (_("True\n"));
14927 case 65: /* Tag_also_compatible_with. */
14928 val
= read_uleb128 (p
, &len
, end
);
14930 if (val
== 6 /* Tag_CPU_arch. */)
14932 val
= read_uleb128 (p
, &len
, end
);
14934 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14935 printf ("??? (%d)\n", val
);
14937 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14941 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14946 printf (_("<unknown: %d>\n"), tag
);
14952 return display_tag_value (-1, p
, end
);
14954 return display_tag_value (0, p
, end
);
14957 assert (attr
->type
& 0x80);
14958 val
= read_uleb128 (p
, &len
, end
);
14960 type
= attr
->type
& 0x7f;
14962 printf ("??? (%d)\n", val
);
14964 printf ("%s\n", attr
->table
[val
]);
14969 return display_tag_value (tag
, p
, end
);
14972 static unsigned char *
14973 display_gnu_attribute (unsigned char * p
,
14974 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14975 const unsigned char * const end
)
14981 tag
= read_uleb128 (p
, &len
, end
);
14984 /* Tag_compatibility is the only generic GNU attribute defined at
14988 val
= read_uleb128 (p
, &len
, end
);
14991 printf (_("flag = %d, vendor = "), val
);
14994 printf (_("<corrupt>\n"));
14995 warn (_("corrupt vendor attribute\n"));
15001 size_t maxlen
= (end
- p
) - 1;
15003 print_symbol ((int) maxlen
, (const char *) p
);
15004 p
+= strnlen ((char *) p
, maxlen
) + 1;
15008 printf (_("<corrupt>"));
15009 p
= (unsigned char *) end
;
15016 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15017 return display_proc_gnu_attribute (p
, tag
, end
);
15019 return display_tag_value (tag
, p
, end
);
15022 static unsigned char *
15023 display_power_gnu_attribute (unsigned char * p
,
15025 const unsigned char * const end
)
15030 if (tag
== Tag_GNU_Power_ABI_FP
)
15032 val
= read_uleb128 (p
, &len
, end
);
15034 printf (" Tag_GNU_Power_ABI_FP: ");
15037 printf (_("<corrupt>\n"));
15042 printf ("(%#x), ", val
);
15047 printf (_("unspecified hard/soft float, "));
15050 printf (_("hard float, "));
15053 printf (_("soft float, "));
15056 printf (_("single-precision hard float, "));
15063 printf (_("unspecified long double\n"));
15066 printf (_("128-bit IBM long double\n"));
15069 printf (_("64-bit long double\n"));
15072 printf (_("128-bit IEEE long double\n"));
15078 if (tag
== Tag_GNU_Power_ABI_Vector
)
15080 val
= read_uleb128 (p
, &len
, end
);
15082 printf (" Tag_GNU_Power_ABI_Vector: ");
15085 printf (_("<corrupt>\n"));
15090 printf ("(%#x), ", val
);
15095 printf (_("unspecified\n"));
15098 printf (_("generic\n"));
15101 printf ("AltiVec\n");
15110 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15112 val
= read_uleb128 (p
, &len
, end
);
15114 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15117 printf (_("<corrupt>\n"));
15122 printf ("(%#x), ", val
);
15127 printf (_("unspecified\n"));
15130 printf ("r3/r4\n");
15133 printf (_("memory\n"));
15142 return display_tag_value (tag
& 1, p
, end
);
15145 static unsigned char *
15146 display_s390_gnu_attribute (unsigned char * p
,
15148 const unsigned char * const end
)
15153 if (tag
== Tag_GNU_S390_ABI_Vector
)
15155 val
= read_uleb128 (p
, &len
, end
);
15157 printf (" Tag_GNU_S390_ABI_Vector: ");
15162 printf (_("any\n"));
15165 printf (_("software\n"));
15168 printf (_("hardware\n"));
15171 printf ("??? (%d)\n", val
);
15177 return display_tag_value (tag
& 1, p
, end
);
15181 display_sparc_hwcaps (unsigned int mask
)
15185 bfd_boolean first
= TRUE
;
15187 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15188 fputs ("mul32", stdout
), first
= FALSE
;
15189 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15190 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15191 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15192 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15193 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15194 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15195 if (mask
& ELF_SPARC_HWCAP_POPC
)
15196 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15197 if (mask
& ELF_SPARC_HWCAP_VIS
)
15198 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15199 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15200 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15201 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15202 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15203 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15204 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15205 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15206 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15207 if (mask
& ELF_SPARC_HWCAP_HPC
)
15208 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15209 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15210 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15211 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15212 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15213 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15214 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15215 if (mask
& ELF_SPARC_HWCAP_IMA
)
15216 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15217 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15218 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15221 fputc ('0', stdout
);
15222 fputc ('\n', stdout
);
15226 display_sparc_hwcaps2 (unsigned int mask
)
15230 bfd_boolean first
= TRUE
;
15232 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15233 fputs ("fjathplus", stdout
), first
= FALSE
;
15234 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15235 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15236 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15237 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15238 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15239 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15240 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15241 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15242 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15243 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15244 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15245 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15246 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15247 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15248 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15249 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15250 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15251 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15252 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15253 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15256 fputc ('0', stdout
);
15257 fputc ('\n', stdout
);
15260 static unsigned char *
15261 display_sparc_gnu_attribute (unsigned char * p
,
15263 const unsigned char * const end
)
15268 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15270 val
= read_uleb128 (p
, &len
, end
);
15272 printf (" Tag_GNU_Sparc_HWCAPS: ");
15273 display_sparc_hwcaps (val
);
15276 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15278 val
= read_uleb128 (p
, &len
, end
);
15280 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15281 display_sparc_hwcaps2 (val
);
15285 return display_tag_value (tag
, p
, end
);
15289 print_mips_fp_abi_value (unsigned int val
)
15293 case Val_GNU_MIPS_ABI_FP_ANY
:
15294 printf (_("Hard or soft float\n"));
15296 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15297 printf (_("Hard float (double precision)\n"));
15299 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15300 printf (_("Hard float (single precision)\n"));
15302 case Val_GNU_MIPS_ABI_FP_SOFT
:
15303 printf (_("Soft float\n"));
15305 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15306 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15308 case Val_GNU_MIPS_ABI_FP_XX
:
15309 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15311 case Val_GNU_MIPS_ABI_FP_64
:
15312 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15314 case Val_GNU_MIPS_ABI_FP_64A
:
15315 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15317 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15318 printf (_("NaN 2008 compatibility\n"));
15321 printf ("??? (%d)\n", val
);
15326 static unsigned char *
15327 display_mips_gnu_attribute (unsigned char * p
,
15329 const unsigned char * const end
)
15331 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15336 val
= read_uleb128 (p
, &len
, end
);
15338 printf (" Tag_GNU_MIPS_ABI_FP: ");
15340 print_mips_fp_abi_value (val
);
15345 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15350 val
= read_uleb128 (p
, &len
, end
);
15352 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15356 case Val_GNU_MIPS_ABI_MSA_ANY
:
15357 printf (_("Any MSA or not\n"));
15359 case Val_GNU_MIPS_ABI_MSA_128
:
15360 printf (_("128-bit MSA\n"));
15363 printf ("??? (%d)\n", val
);
15369 return display_tag_value (tag
& 1, p
, end
);
15372 static unsigned char *
15373 display_tic6x_attribute (unsigned char * p
,
15374 const unsigned char * const end
)
15380 tag
= read_uleb128 (p
, &len
, end
);
15386 val
= read_uleb128 (p
, &len
, end
);
15388 printf (" Tag_ISA: ");
15392 case C6XABI_Tag_ISA_none
:
15393 printf (_("None\n"));
15395 case C6XABI_Tag_ISA_C62X
:
15398 case C6XABI_Tag_ISA_C67X
:
15401 case C6XABI_Tag_ISA_C67XP
:
15402 printf ("C67x+\n");
15404 case C6XABI_Tag_ISA_C64X
:
15407 case C6XABI_Tag_ISA_C64XP
:
15408 printf ("C64x+\n");
15410 case C6XABI_Tag_ISA_C674X
:
15411 printf ("C674x\n");
15414 printf ("??? (%d)\n", val
);
15419 case Tag_ABI_wchar_t
:
15420 val
= read_uleb128 (p
, &len
, end
);
15422 printf (" Tag_ABI_wchar_t: ");
15426 printf (_("Not used\n"));
15429 printf (_("2 bytes\n"));
15432 printf (_("4 bytes\n"));
15435 printf ("??? (%d)\n", val
);
15440 case Tag_ABI_stack_align_needed
:
15441 val
= read_uleb128 (p
, &len
, end
);
15443 printf (" Tag_ABI_stack_align_needed: ");
15447 printf (_("8-byte\n"));
15450 printf (_("16-byte\n"));
15453 printf ("??? (%d)\n", val
);
15458 case Tag_ABI_stack_align_preserved
:
15459 val
= read_uleb128 (p
, &len
, end
);
15461 printf (" Tag_ABI_stack_align_preserved: ");
15465 printf (_("8-byte\n"));
15468 printf (_("16-byte\n"));
15471 printf ("??? (%d)\n", val
);
15477 val
= read_uleb128 (p
, &len
, end
);
15479 printf (" Tag_ABI_DSBT: ");
15483 printf (_("DSBT addressing not used\n"));
15486 printf (_("DSBT addressing used\n"));
15489 printf ("??? (%d)\n", val
);
15495 val
= read_uleb128 (p
, &len
, end
);
15497 printf (" Tag_ABI_PID: ");
15501 printf (_("Data addressing position-dependent\n"));
15504 printf (_("Data addressing position-independent, GOT near DP\n"));
15507 printf (_("Data addressing position-independent, GOT far from DP\n"));
15510 printf ("??? (%d)\n", val
);
15516 val
= read_uleb128 (p
, &len
, end
);
15518 printf (" Tag_ABI_PIC: ");
15522 printf (_("Code addressing position-dependent\n"));
15525 printf (_("Code addressing position-independent\n"));
15528 printf ("??? (%d)\n", val
);
15533 case Tag_ABI_array_object_alignment
:
15534 val
= read_uleb128 (p
, &len
, end
);
15536 printf (" Tag_ABI_array_object_alignment: ");
15540 printf (_("8-byte\n"));
15543 printf (_("4-byte\n"));
15546 printf (_("16-byte\n"));
15549 printf ("??? (%d)\n", val
);
15554 case Tag_ABI_array_object_align_expected
:
15555 val
= read_uleb128 (p
, &len
, end
);
15557 printf (" Tag_ABI_array_object_align_expected: ");
15561 printf (_("8-byte\n"));
15564 printf (_("4-byte\n"));
15567 printf (_("16-byte\n"));
15570 printf ("??? (%d)\n", val
);
15575 case Tag_ABI_compatibility
:
15577 val
= read_uleb128 (p
, &len
, end
);
15579 printf (" Tag_ABI_compatibility: ");
15580 printf (_("flag = %d, vendor = "), val
);
15583 size_t maxlen
= (end
- p
) - 1;
15585 print_symbol ((int) maxlen
, (const char *) p
);
15586 p
+= strnlen ((char *) p
, maxlen
) + 1;
15590 printf (_("<corrupt>"));
15591 p
= (unsigned char *) end
;
15597 case Tag_ABI_conformance
:
15599 printf (" Tag_ABI_conformance: \"");
15602 size_t maxlen
= (end
- p
) - 1;
15604 print_symbol ((int) maxlen
, (const char *) p
);
15605 p
+= strnlen ((char *) p
, maxlen
) + 1;
15609 printf (_("<corrupt>"));
15610 p
= (unsigned char *) end
;
15617 return display_tag_value (tag
, p
, end
);
15621 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15623 unsigned long addr
= 0;
15624 size_t bytes
= end
- p
;
15631 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15633 printf (" 0x%8.8lx ", addr
);
15635 for (j
= 0; j
< 16; j
++)
15638 printf ("%2.2x", p
[j
]);
15646 for (j
= 0; j
< lbytes
; j
++)
15649 if (k
>= ' ' && k
< 0x7f)
15665 static unsigned char *
15666 display_msp430x_attribute (unsigned char * p
,
15667 const unsigned char * const end
)
15673 tag
= read_uleb128 (p
, & len
, end
);
15678 case OFBA_MSPABI_Tag_ISA
:
15679 val
= read_uleb128 (p
, &len
, end
);
15681 printf (" Tag_ISA: ");
15684 case 0: printf (_("None\n")); break;
15685 case 1: printf (_("MSP430\n")); break;
15686 case 2: printf (_("MSP430X\n")); break;
15687 default: printf ("??? (%d)\n", val
); break;
15691 case OFBA_MSPABI_Tag_Code_Model
:
15692 val
= read_uleb128 (p
, &len
, end
);
15694 printf (" Tag_Code_Model: ");
15697 case 0: printf (_("None\n")); break;
15698 case 1: printf (_("Small\n")); break;
15699 case 2: printf (_("Large\n")); break;
15700 default: printf ("??? (%d)\n", val
); break;
15704 case OFBA_MSPABI_Tag_Data_Model
:
15705 val
= read_uleb128 (p
, &len
, end
);
15707 printf (" Tag_Data_Model: ");
15710 case 0: printf (_("None\n")); break;
15711 case 1: printf (_("Small\n")); break;
15712 case 2: printf (_("Large\n")); break;
15713 case 3: printf (_("Restricted Large\n")); break;
15714 default: printf ("??? (%d)\n", val
); break;
15719 printf (_(" <unknown tag %d>: "), tag
);
15726 size_t maxlen
= (end
- p
) - 1;
15728 print_symbol ((int) maxlen
, (const char *) p
);
15729 p
+= strnlen ((char *) p
, maxlen
) + 1;
15733 printf (_("<corrupt>"));
15734 p
= (unsigned char *) end
;
15740 val
= read_uleb128 (p
, &len
, end
);
15742 printf ("%d (0x%x)\n", val
, val
);
15751 static unsigned char *
15752 display_msp430_gnu_attribute (unsigned char * p
,
15754 const unsigned char * const end
)
15756 if (tag
== Tag_GNU_MSP430_Data_Region
)
15761 val
= read_uleb128 (p
, &len
, end
);
15763 printf (" Tag_GNU_MSP430_Data_Region: ");
15767 case Val_GNU_MSP430_Data_Region_Any
:
15768 printf (_("Any Region\n"));
15770 case Val_GNU_MSP430_Data_Region_Lower
:
15771 printf (_("Lower Region Only\n"));
15774 printf ("??? (%d)\n", val
);
15778 return display_tag_value (tag
& 1, p
, end
);
15781 struct riscv_attr_tag_t
{
15786 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15788 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15791 T(priv_spec_minor
),
15792 T(priv_spec_revision
),
15793 T(unaligned_access
),
15798 static unsigned char *
15799 display_riscv_attribute (unsigned char *p
,
15800 const unsigned char * const end
)
15805 struct riscv_attr_tag_t
*attr
= NULL
;
15808 tag
= read_uleb128 (p
, &len
, end
);
15811 /* Find the name of attribute. */
15812 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15814 if (riscv_attr_tag
[i
].tag
== tag
)
15816 attr
= &riscv_attr_tag
[i
];
15822 printf (" %s: ", attr
->name
);
15824 return display_tag_value (tag
, p
, end
);
15828 case Tag_RISCV_priv_spec
:
15829 case Tag_RISCV_priv_spec_minor
:
15830 case Tag_RISCV_priv_spec_revision
:
15831 val
= read_uleb128 (p
, &len
, end
);
15833 printf (_("%d\n"), val
);
15835 case Tag_RISCV_unaligned_access
:
15836 val
= read_uleb128 (p
, &len
, end
);
15841 printf (_("No unaligned access\n"));
15844 printf (_("Unaligned access\n"));
15848 case Tag_RISCV_stack_align
:
15849 val
= read_uleb128 (p
, &len
, end
);
15851 printf (_("%d-bytes\n"), val
);
15853 case Tag_RISCV_arch
:
15854 p
= display_tag_value (-1, p
, end
);
15857 return display_tag_value (tag
, p
, end
);
15864 process_attributes (Filedata
* filedata
,
15865 const char * public_name
,
15866 unsigned int proc_type
,
15867 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15868 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15870 Elf_Internal_Shdr
* sect
;
15872 bfd_boolean res
= TRUE
;
15874 /* Find the section header so that we get the size. */
15875 for (i
= 0, sect
= filedata
->section_headers
;
15876 i
< filedata
->file_header
.e_shnum
;
15879 unsigned char * contents
;
15882 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15885 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15886 sect
->sh_size
, _("attributes"));
15887 if (contents
== NULL
)
15894 /* The first character is the version of the attributes.
15895 Currently only version 1, (aka 'A') is recognised here. */
15898 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15903 bfd_vma section_len
;
15905 section_len
= sect
->sh_size
- 1;
15908 while (section_len
> 0)
15911 unsigned int namelen
;
15912 bfd_boolean public_section
;
15913 bfd_boolean gnu_section
;
15915 if (section_len
<= 4)
15917 error (_("Tag section ends prematurely\n"));
15921 attr_len
= byte_get (p
, 4);
15924 if (attr_len
> section_len
)
15926 error (_("Bad attribute length (%u > %u)\n"),
15927 (unsigned) attr_len
, (unsigned) section_len
);
15928 attr_len
= section_len
;
15931 /* PR 17531: file: 001-101425-0.004 */
15932 else if (attr_len
< 5)
15934 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15939 section_len
-= attr_len
;
15942 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15943 if (namelen
== 0 || namelen
>= attr_len
)
15945 error (_("Corrupt attribute section name\n"));
15950 printf (_("Attribute Section: "));
15951 print_symbol (INT_MAX
, (const char *) p
);
15954 if (public_name
&& streq ((char *) p
, public_name
))
15955 public_section
= TRUE
;
15957 public_section
= FALSE
;
15959 if (streq ((char *) p
, "gnu"))
15960 gnu_section
= TRUE
;
15962 gnu_section
= FALSE
;
15965 attr_len
-= namelen
;
15967 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15972 unsigned char * end
;
15974 /* PR binutils/17531: Safe handling of corrupt files. */
15977 error (_("Unused bytes at end of section\n"));
15984 size
= byte_get (p
, 4);
15985 if (size
> attr_len
)
15987 error (_("Bad subsection length (%u > %u)\n"),
15988 (unsigned) size
, (unsigned) attr_len
);
15992 /* PR binutils/17531: Safe handling of corrupt files. */
15995 error (_("Bad subsection length (%u < 6)\n"),
16003 end
= p
+ size
- 1;
16004 assert (end
<= contents
+ sect
->sh_size
);
16010 printf (_("File Attributes\n"));
16013 printf (_("Section Attributes:"));
16016 printf (_("Symbol Attributes:"));
16017 /* Fall through. */
16023 val
= read_uleb128 (p
, &j
, end
);
16027 printf (" %d", val
);
16032 printf (_("Unknown tag: %d\n"), tag
);
16033 public_section
= FALSE
;
16037 if (public_section
&& display_pub_attribute
!= NULL
)
16040 p
= display_pub_attribute (p
, end
);
16043 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16046 p
= display_gnu_attribute (p
,
16047 display_proc_gnu_attribute
,
16053 printf (_(" Unknown attribute:\n"));
16054 display_raw_attribute (p
, end
);
16069 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16070 Print the Address, Access and Initial fields of an entry at VMA ADDR
16071 and return the VMA of the next entry, or -1 if there was a problem.
16072 Does not read from DATA_END or beyond. */
16075 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16076 unsigned char * data_end
)
16079 print_vma (addr
, LONG_HEX
);
16081 if (addr
< pltgot
+ 0xfff0)
16082 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16084 printf ("%10s", "");
16087 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16091 unsigned char * from
= data
+ addr
- pltgot
;
16093 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16095 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16096 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16097 return (bfd_vma
) -1;
16101 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16102 print_vma (entry
, LONG_HEX
);
16105 return addr
+ (is_32bit_elf
? 4 : 8);
16108 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16109 PLTGOT. Print the Address and Initial fields of an entry at VMA
16110 ADDR and return the VMA of the next entry. */
16113 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16116 print_vma (addr
, LONG_HEX
);
16119 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16124 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16125 print_vma (entry
, LONG_HEX
);
16127 return addr
+ (is_32bit_elf
? 4 : 8);
16131 print_mips_ases (unsigned int mask
)
16133 if (mask
& AFL_ASE_DSP
)
16134 fputs ("\n\tDSP ASE", stdout
);
16135 if (mask
& AFL_ASE_DSPR2
)
16136 fputs ("\n\tDSP R2 ASE", stdout
);
16137 if (mask
& AFL_ASE_DSPR3
)
16138 fputs ("\n\tDSP R3 ASE", stdout
);
16139 if (mask
& AFL_ASE_EVA
)
16140 fputs ("\n\tEnhanced VA Scheme", stdout
);
16141 if (mask
& AFL_ASE_MCU
)
16142 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16143 if (mask
& AFL_ASE_MDMX
)
16144 fputs ("\n\tMDMX ASE", stdout
);
16145 if (mask
& AFL_ASE_MIPS3D
)
16146 fputs ("\n\tMIPS-3D ASE", stdout
);
16147 if (mask
& AFL_ASE_MT
)
16148 fputs ("\n\tMT ASE", stdout
);
16149 if (mask
& AFL_ASE_SMARTMIPS
)
16150 fputs ("\n\tSmartMIPS ASE", stdout
);
16151 if (mask
& AFL_ASE_VIRT
)
16152 fputs ("\n\tVZ ASE", stdout
);
16153 if (mask
& AFL_ASE_MSA
)
16154 fputs ("\n\tMSA ASE", stdout
);
16155 if (mask
& AFL_ASE_MIPS16
)
16156 fputs ("\n\tMIPS16 ASE", stdout
);
16157 if (mask
& AFL_ASE_MICROMIPS
)
16158 fputs ("\n\tMICROMIPS ASE", stdout
);
16159 if (mask
& AFL_ASE_XPA
)
16160 fputs ("\n\tXPA ASE", stdout
);
16161 if (mask
& AFL_ASE_MIPS16E2
)
16162 fputs ("\n\tMIPS16e2 ASE", stdout
);
16163 if (mask
& AFL_ASE_CRC
)
16164 fputs ("\n\tCRC ASE", stdout
);
16165 if (mask
& AFL_ASE_GINV
)
16166 fputs ("\n\tGINV ASE", stdout
);
16167 if (mask
& AFL_ASE_LOONGSON_MMI
)
16168 fputs ("\n\tLoongson MMI ASE", stdout
);
16169 if (mask
& AFL_ASE_LOONGSON_CAM
)
16170 fputs ("\n\tLoongson CAM ASE", stdout
);
16171 if (mask
& AFL_ASE_LOONGSON_EXT
)
16172 fputs ("\n\tLoongson EXT ASE", stdout
);
16173 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16174 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16176 fprintf (stdout
, "\n\t%s", _("None"));
16177 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16178 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16182 print_mips_isa_ext (unsigned int isa_ext
)
16187 fputs (_("None"), stdout
);
16190 fputs ("RMI XLR", stdout
);
16192 case AFL_EXT_OCTEON3
:
16193 fputs ("Cavium Networks Octeon3", stdout
);
16195 case AFL_EXT_OCTEON2
:
16196 fputs ("Cavium Networks Octeon2", stdout
);
16198 case AFL_EXT_OCTEONP
:
16199 fputs ("Cavium Networks OcteonP", stdout
);
16201 case AFL_EXT_OCTEON
:
16202 fputs ("Cavium Networks Octeon", stdout
);
16205 fputs ("Toshiba R5900", stdout
);
16208 fputs ("MIPS R4650", stdout
);
16211 fputs ("LSI R4010", stdout
);
16214 fputs ("NEC VR4100", stdout
);
16217 fputs ("Toshiba R3900", stdout
);
16219 case AFL_EXT_10000
:
16220 fputs ("MIPS R10000", stdout
);
16223 fputs ("Broadcom SB-1", stdout
);
16226 fputs ("NEC VR4111/VR4181", stdout
);
16229 fputs ("NEC VR4120", stdout
);
16232 fputs ("NEC VR5400", stdout
);
16235 fputs ("NEC VR5500", stdout
);
16237 case AFL_EXT_LOONGSON_2E
:
16238 fputs ("ST Microelectronics Loongson 2E", stdout
);
16240 case AFL_EXT_LOONGSON_2F
:
16241 fputs ("ST Microelectronics Loongson 2F", stdout
);
16243 case AFL_EXT_INTERAPTIV_MR2
:
16244 fputs ("Imagination interAptiv MR2", stdout
);
16247 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16252 get_mips_reg_size (int reg_size
)
16254 return (reg_size
== AFL_REG_NONE
) ? 0
16255 : (reg_size
== AFL_REG_32
) ? 32
16256 : (reg_size
== AFL_REG_64
) ? 64
16257 : (reg_size
== AFL_REG_128
) ? 128
16262 process_mips_specific (Filedata
* filedata
)
16264 Elf_Internal_Dyn
* entry
;
16265 Elf_Internal_Shdr
*sect
= NULL
;
16266 size_t liblist_offset
= 0;
16267 size_t liblistno
= 0;
16268 size_t conflictsno
= 0;
16269 size_t options_offset
= 0;
16270 size_t conflicts_offset
= 0;
16271 size_t pltrelsz
= 0;
16273 bfd_vma pltgot
= 0;
16274 bfd_vma mips_pltgot
= 0;
16275 bfd_vma jmprel
= 0;
16276 bfd_vma local_gotno
= 0;
16277 bfd_vma gotsym
= 0;
16278 bfd_vma symtabno
= 0;
16279 bfd_boolean res
= TRUE
;
16281 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16282 display_mips_gnu_attribute
))
16285 sect
= find_section (filedata
, ".MIPS.abiflags");
16289 Elf_External_ABIFlags_v0
*abiflags_ext
;
16290 Elf_Internal_ABIFlags_v0 abiflags_in
;
16292 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16294 error (_("Corrupt MIPS ABI Flags section.\n"));
16299 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16300 sect
->sh_size
, _("MIPS ABI Flags section"));
16303 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16304 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16305 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16306 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16307 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16308 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16309 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16310 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16311 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16312 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16313 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16315 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16316 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16317 if (abiflags_in
.isa_rev
> 1)
16318 printf ("r%d", abiflags_in
.isa_rev
);
16319 printf ("\nGPR size: %d",
16320 get_mips_reg_size (abiflags_in
.gpr_size
));
16321 printf ("\nCPR1 size: %d",
16322 get_mips_reg_size (abiflags_in
.cpr1_size
));
16323 printf ("\nCPR2 size: %d",
16324 get_mips_reg_size (abiflags_in
.cpr2_size
));
16325 fputs ("\nFP ABI: ", stdout
);
16326 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16327 fputs ("ISA Extension: ", stdout
);
16328 print_mips_isa_ext (abiflags_in
.isa_ext
);
16329 fputs ("\nASEs:", stdout
);
16330 print_mips_ases (abiflags_in
.ases
);
16331 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16332 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16333 fputc ('\n', stdout
);
16334 free (abiflags_ext
);
16339 /* We have a lot of special sections. Thanks SGI! */
16340 if (dynamic_section
== NULL
)
16342 /* No dynamic information available. See if there is static GOT. */
16343 sect
= find_section (filedata
, ".got");
16346 unsigned char *data_end
;
16347 unsigned char *data
;
16351 pltgot
= sect
->sh_addr
;
16354 addr_size
= (is_32bit_elf
? 4 : 8);
16355 end
= pltgot
+ sect
->sh_size
;
16357 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16359 _("Global Offset Table data"));
16360 /* PR 12855: Null data is handled gracefully throughout. */
16361 data_end
= data
+ (end
- pltgot
);
16363 printf (_("\nStatic GOT:\n"));
16364 printf (_(" Canonical gp value: "));
16365 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16368 /* In a dynamic binary GOT[0] is reserved for the dynamic
16369 loader to store the lazy resolver pointer, however in
16370 a static binary it may well have been omitted and GOT
16371 reduced to a table of addresses.
16372 PR 21344: Check for the entry being fully available
16373 before fetching it. */
16375 && data
+ ent
- pltgot
+ addr_size
<= data_end
16376 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16378 printf (_(" Reserved entries:\n"));
16379 printf (_(" %*s %10s %*s\n"),
16380 addr_size
* 2, _("Address"), _("Access"),
16381 addr_size
* 2, _("Value"));
16382 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16384 if (ent
== (bfd_vma
) -1)
16385 goto sgot_print_fail
;
16387 /* Check for the MSB of GOT[1] being set, identifying a
16388 GNU object. This entry will be used by some runtime
16389 loaders, to store the module pointer. Otherwise this
16390 is an ordinary local entry.
16391 PR 21344: Check for the entry being fully available
16392 before fetching it. */
16394 && data
+ ent
- pltgot
+ addr_size
<= data_end
16395 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16396 >> (addr_size
* 8 - 1)) != 0)
16398 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16400 if (ent
== (bfd_vma
) -1)
16401 goto sgot_print_fail
;
16406 if (data
!= NULL
&& ent
< end
)
16408 printf (_(" Local entries:\n"));
16409 printf (" %*s %10s %*s\n",
16410 addr_size
* 2, _("Address"), _("Access"),
16411 addr_size
* 2, _("Value"));
16414 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16416 if (ent
== (bfd_vma
) -1)
16417 goto sgot_print_fail
;
16429 for (entry
= dynamic_section
;
16430 /* PR 17531 file: 012-50589-0.004. */
16431 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16433 switch (entry
->d_tag
)
16435 case DT_MIPS_LIBLIST
:
16437 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16438 liblistno
* sizeof (Elf32_External_Lib
));
16440 case DT_MIPS_LIBLISTNO
:
16441 liblistno
= entry
->d_un
.d_val
;
16443 case DT_MIPS_OPTIONS
:
16444 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16446 case DT_MIPS_CONFLICT
:
16448 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16449 conflictsno
* sizeof (Elf32_External_Conflict
));
16451 case DT_MIPS_CONFLICTNO
:
16452 conflictsno
= entry
->d_un
.d_val
;
16455 pltgot
= entry
->d_un
.d_ptr
;
16457 case DT_MIPS_LOCAL_GOTNO
:
16458 local_gotno
= entry
->d_un
.d_val
;
16460 case DT_MIPS_GOTSYM
:
16461 gotsym
= entry
->d_un
.d_val
;
16463 case DT_MIPS_SYMTABNO
:
16464 symtabno
= entry
->d_un
.d_val
;
16466 case DT_MIPS_PLTGOT
:
16467 mips_pltgot
= entry
->d_un
.d_ptr
;
16470 pltrel
= entry
->d_un
.d_val
;
16473 pltrelsz
= entry
->d_un
.d_val
;
16476 jmprel
= entry
->d_un
.d_ptr
;
16482 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16484 Elf32_External_Lib
* elib
;
16487 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16489 sizeof (Elf32_External_Lib
),
16490 _("liblist section data"));
16493 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16494 "\nSection '.liblist' contains %lu entries:\n",
16495 (unsigned long) liblistno
),
16496 (unsigned long) liblistno
);
16497 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16500 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16507 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16508 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16509 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16510 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16511 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16513 tmp
= gmtime (&atime
);
16514 snprintf (timebuf
, sizeof (timebuf
),
16515 "%04u-%02u-%02uT%02u:%02u:%02u",
16516 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16517 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16519 printf ("%3lu: ", (unsigned long) cnt
);
16520 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16521 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16523 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16524 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16525 liblist
.l_version
);
16527 if (liblist
.l_flags
== 0)
16531 static const struct
16538 { " EXACT_MATCH", LL_EXACT_MATCH
},
16539 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16540 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16541 { " EXPORTS", LL_EXPORTS
},
16542 { " DELAY_LOAD", LL_DELAY_LOAD
},
16543 { " DELTA", LL_DELTA
}
16545 int flags
= liblist
.l_flags
;
16548 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16549 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16551 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16552 flags
^= l_flags_vals
[fcnt
].bit
;
16555 printf (" %#x", (unsigned int) flags
);
16567 if (options_offset
!= 0)
16569 Elf_External_Options
* eopt
;
16572 sect
= filedata
->section_headers
;
16574 /* Find the section header so that we get the size. */
16575 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16576 /* PR 17533 file: 012-277276-0.004. */
16579 error (_("No MIPS_OPTIONS header found\n"));
16583 if (sect
->sh_size
< sizeof (* eopt
))
16585 error (_("The MIPS options section is too small.\n"));
16589 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16590 sect
->sh_size
, _("options"));
16593 Elf_Internal_Options
* iopt
;
16594 Elf_Internal_Options
* option
;
16595 Elf_Internal_Options
* iopt_end
;
16597 iopt
= (Elf_Internal_Options
*)
16598 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16601 error (_("Out of memory allocating space for MIPS options\n"));
16607 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16609 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16611 Elf_External_Options
* eoption
;
16613 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16615 option
->kind
= BYTE_GET (eoption
->kind
);
16616 option
->size
= BYTE_GET (eoption
->size
);
16617 option
->section
= BYTE_GET (eoption
->section
);
16618 option
->info
= BYTE_GET (eoption
->info
);
16620 /* PR 17531: file: ffa0fa3b. */
16621 if (option
->size
< sizeof (* eopt
)
16622 || offset
+ option
->size
> sect
->sh_size
)
16624 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16627 offset
+= option
->size
;
16633 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16634 "\nSection '%s' contains %d entries:\n",
16636 printable_section_name (filedata
, sect
), cnt
);
16645 switch (option
->kind
)
16648 /* This shouldn't happen. */
16649 printf (" NULL %d %lx", option
->section
, option
->info
);
16653 printf (" REGINFO ");
16654 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16656 Elf32_External_RegInfo
* ereg
;
16657 Elf32_RegInfo reginfo
;
16660 if (option
+ 2 > iopt_end
)
16662 printf (_("<corrupt>\n"));
16663 error (_("Truncated MIPS REGINFO option\n"));
16668 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16670 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16671 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16672 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16673 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16674 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16675 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16677 printf ("GPR %08lx GP 0x%lx\n",
16678 reginfo
.ri_gprmask
,
16679 (unsigned long) reginfo
.ri_gp_value
);
16680 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16681 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16682 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16687 Elf64_External_RegInfo
* ereg
;
16688 Elf64_Internal_RegInfo reginfo
;
16690 if (option
+ 2 > iopt_end
)
16692 printf (_("<corrupt>\n"));
16693 error (_("Truncated MIPS REGINFO option\n"));
16698 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16699 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16700 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16701 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16702 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16703 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16704 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16706 printf ("GPR %08lx GP 0x",
16707 reginfo
.ri_gprmask
);
16708 printf_vma (reginfo
.ri_gp_value
);
16711 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16712 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16713 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16718 case ODK_EXCEPTIONS
:
16719 fputs (" EXCEPTIONS fpe_min(", stdout
);
16720 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16721 fputs (") fpe_max(", stdout
);
16722 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16723 fputs (")", stdout
);
16725 if (option
->info
& OEX_PAGE0
)
16726 fputs (" PAGE0", stdout
);
16727 if (option
->info
& OEX_SMM
)
16728 fputs (" SMM", stdout
);
16729 if (option
->info
& OEX_FPDBUG
)
16730 fputs (" FPDBUG", stdout
);
16731 if (option
->info
& OEX_DISMISS
)
16732 fputs (" DISMISS", stdout
);
16736 fputs (" PAD ", stdout
);
16737 if (option
->info
& OPAD_PREFIX
)
16738 fputs (" PREFIX", stdout
);
16739 if (option
->info
& OPAD_POSTFIX
)
16740 fputs (" POSTFIX", stdout
);
16741 if (option
->info
& OPAD_SYMBOL
)
16742 fputs (" SYMBOL", stdout
);
16746 fputs (" HWPATCH ", stdout
);
16747 if (option
->info
& OHW_R4KEOP
)
16748 fputs (" R4KEOP", stdout
);
16749 if (option
->info
& OHW_R8KPFETCH
)
16750 fputs (" R8KPFETCH", stdout
);
16751 if (option
->info
& OHW_R5KEOP
)
16752 fputs (" R5KEOP", stdout
);
16753 if (option
->info
& OHW_R5KCVTL
)
16754 fputs (" R5KCVTL", stdout
);
16758 fputs (" FILL ", stdout
);
16759 /* XXX Print content of info word? */
16763 fputs (" TAGS ", stdout
);
16764 /* XXX Print content of info word? */
16768 fputs (" HWAND ", stdout
);
16769 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16770 fputs (" R4KEOP_CHECKED", stdout
);
16771 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16772 fputs (" R4KEOP_CLEAN", stdout
);
16776 fputs (" HWOR ", stdout
);
16777 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16778 fputs (" R4KEOP_CHECKED", stdout
);
16779 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16780 fputs (" R4KEOP_CLEAN", stdout
);
16784 printf (" GP_GROUP %#06lx self-contained %#06lx",
16785 option
->info
& OGP_GROUP
,
16786 (option
->info
& OGP_SELF
) >> 16);
16790 printf (" IDENT %#06lx self-contained %#06lx",
16791 option
->info
& OGP_GROUP
,
16792 (option
->info
& OGP_SELF
) >> 16);
16796 /* This shouldn't happen. */
16797 printf (" %3d ??? %d %lx",
16798 option
->kind
, option
->section
, option
->info
);
16802 len
= sizeof (* eopt
);
16803 while (len
< option
->size
)
16805 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16807 if (ISPRINT (datum
))
16808 printf ("%c", datum
);
16810 printf ("\\%03o", datum
);
16813 fputs ("\n", stdout
);
16815 offset
+= option
->size
;
16825 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16827 Elf32_Conflict
* iconf
;
16830 if (dynamic_symbols
== NULL
)
16832 error (_("conflict list found without a dynamic symbol table\n"));
16836 /* PR 21345 - print a slightly more helpful error message
16837 if we are sure that the cmalloc will fail. */
16838 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16840 error (_("Overlarge number of conflicts detected: %lx\n"),
16841 (long) conflictsno
);
16845 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16848 error (_("Out of memory allocating space for dynamic conflicts\n"));
16854 Elf32_External_Conflict
* econf32
;
16856 econf32
= (Elf32_External_Conflict
*)
16857 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16858 sizeof (* econf32
), _("conflict"));
16862 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16863 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16869 Elf64_External_Conflict
* econf64
;
16871 econf64
= (Elf64_External_Conflict
*)
16872 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16873 sizeof (* econf64
), _("conflict"));
16877 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16878 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16883 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16884 "\nSection '.conflict' contains %lu entries:\n",
16885 (unsigned long) conflictsno
),
16886 (unsigned long) conflictsno
);
16887 puts (_(" Num: Index Value Name"));
16889 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16891 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16893 if (iconf
[cnt
] >= num_dynamic_syms
)
16894 printf (_("<corrupt symbol index>"));
16897 Elf_Internal_Sym
* psym
;
16899 psym
= & dynamic_symbols
[iconf
[cnt
]];
16900 print_vma (psym
->st_value
, FULL_HEX
);
16902 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16903 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16905 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16913 if (pltgot
!= 0 && local_gotno
!= 0)
16915 bfd_vma ent
, local_end
, global_end
;
16917 unsigned char * data
;
16918 unsigned char * data_end
;
16922 addr_size
= (is_32bit_elf
? 4 : 8);
16923 local_end
= pltgot
+ local_gotno
* addr_size
;
16925 /* PR binutils/17533 file: 012-111227-0.004 */
16926 if (symtabno
< gotsym
)
16928 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16929 (unsigned long) gotsym
, (unsigned long) symtabno
);
16933 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16934 /* PR 17531: file: 54c91a34. */
16935 if (global_end
< local_end
)
16937 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16941 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16942 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16943 global_end
- pltgot
, 1,
16944 _("Global Offset Table data"));
16945 /* PR 12855: Null data is handled gracefully throughout. */
16946 data_end
= data
+ (global_end
- pltgot
);
16948 printf (_("\nPrimary GOT:\n"));
16949 printf (_(" Canonical gp value: "));
16950 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16953 printf (_(" Reserved entries:\n"));
16954 printf (_(" %*s %10s %*s Purpose\n"),
16955 addr_size
* 2, _("Address"), _("Access"),
16956 addr_size
* 2, _("Initial"));
16957 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16958 printf (_(" Lazy resolver\n"));
16959 if (ent
== (bfd_vma
) -1)
16960 goto got_print_fail
;
16962 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16963 This entry will be used by some runtime loaders, to store the
16964 module pointer. Otherwise this is an ordinary local entry.
16965 PR 21344: Check for the entry being fully available before
16968 && data
+ ent
- pltgot
+ addr_size
<= data_end
16969 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16970 >> (addr_size
* 8 - 1)) != 0)
16972 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16973 printf (_(" Module pointer (GNU extension)\n"));
16974 if (ent
== (bfd_vma
) -1)
16975 goto got_print_fail
;
16979 if (data
!= NULL
&& ent
< local_end
)
16981 printf (_(" Local entries:\n"));
16982 printf (" %*s %10s %*s\n",
16983 addr_size
* 2, _("Address"), _("Access"),
16984 addr_size
* 2, _("Initial"));
16985 while (ent
< local_end
)
16987 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16989 if (ent
== (bfd_vma
) -1)
16990 goto got_print_fail
;
16995 if (data
!= NULL
&& gotsym
< symtabno
)
16999 printf (_(" Global entries:\n"));
17000 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17001 addr_size
* 2, _("Address"),
17003 addr_size
* 2, _("Initial"),
17004 addr_size
* 2, _("Sym.Val."),
17006 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17007 _("Ndx"), _("Name"));
17009 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17011 for (i
= gotsym
; i
< symtabno
; i
++)
17013 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17016 if (dynamic_symbols
== NULL
)
17017 printf (_("<no dynamic symbols>"));
17018 else if (i
< num_dynamic_syms
)
17020 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17022 print_vma (psym
->st_value
, LONG_HEX
);
17023 printf (" %-7s %3s ",
17024 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17025 get_symbol_index_type (filedata
, psym
->st_shndx
));
17027 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17028 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17030 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17033 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17034 (unsigned long) i
);
17037 if (ent
== (bfd_vma
) -1)
17048 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17051 size_t offset
, rel_offset
;
17052 unsigned long count
, i
;
17053 unsigned char * data
;
17054 int addr_size
, sym_width
;
17055 Elf_Internal_Rela
* rels
;
17057 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17058 if (pltrel
== DT_RELA
)
17060 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17065 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17070 addr_size
= (is_32bit_elf
? 4 : 8);
17071 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17073 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17074 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17075 1, _("Procedure Linkage Table data"));
17079 printf ("\nPLT GOT:\n\n");
17080 printf (_(" Reserved entries:\n"));
17081 printf (_(" %*s %*s Purpose\n"),
17082 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17083 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17084 printf (_(" PLT lazy resolver\n"));
17085 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17086 printf (_(" Module pointer\n"));
17089 printf (_(" Entries:\n"));
17090 printf (" %*s %*s %*s %-7s %3s %s\n",
17091 addr_size
* 2, _("Address"),
17092 addr_size
* 2, _("Initial"),
17093 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17094 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17095 for (i
= 0; i
< count
; i
++)
17097 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17099 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17102 if (idx
>= num_dynamic_syms
)
17103 printf (_("<corrupt symbol index: %lu>"), idx
);
17106 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17108 print_vma (psym
->st_value
, LONG_HEX
);
17109 printf (" %-7s %3s ",
17110 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17111 get_symbol_index_type (filedata
, psym
->st_shndx
));
17112 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17113 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17115 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17130 process_nds32_specific (Filedata
* filedata
)
17132 Elf_Internal_Shdr
*sect
= NULL
;
17134 sect
= find_section (filedata
, ".nds32_e_flags");
17137 unsigned int *flag
;
17139 printf ("\nNDS32 elf flags section:\n");
17140 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17141 sect
->sh_size
, _("NDS32 elf flags section"));
17146 switch ((*flag
) & 0x3)
17149 printf ("(VEC_SIZE):\tNo entry.\n");
17152 printf ("(VEC_SIZE):\t4 bytes\n");
17155 printf ("(VEC_SIZE):\t16 bytes\n");
17158 printf ("(VEC_SIZE):\treserved\n");
17167 process_gnu_liblist (Filedata
* filedata
)
17169 Elf_Internal_Shdr
* section
;
17170 Elf_Internal_Shdr
* string_sec
;
17171 Elf32_External_Lib
* elib
;
17173 size_t strtab_size
;
17175 unsigned long num_liblist
;
17177 bfd_boolean res
= TRUE
;
17182 for (i
= 0, section
= filedata
->section_headers
;
17183 i
< filedata
->file_header
.e_shnum
;
17186 switch (section
->sh_type
)
17188 case SHT_GNU_LIBLIST
:
17189 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17192 elib
= (Elf32_External_Lib
*)
17193 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17194 _("liblist section data"));
17202 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17203 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17204 string_sec
->sh_size
,
17205 _("liblist string table"));
17207 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17214 strtab_size
= string_sec
->sh_size
;
17216 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17217 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17218 "\nLibrary list section '%s' contains %lu entries:\n",
17220 printable_section_name (filedata
, section
),
17223 puts (_(" Library Time Stamp Checksum Version Flags"));
17225 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17233 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17234 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17235 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17236 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17237 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17239 tmp
= gmtime (&atime
);
17240 snprintf (timebuf
, sizeof (timebuf
),
17241 "%04u-%02u-%02uT%02u:%02u:%02u",
17242 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17243 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17245 printf ("%3lu: ", (unsigned long) cnt
);
17247 printf ("%-20s", liblist
.l_name
< strtab_size
17248 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17250 printf ("%-20.20s", liblist
.l_name
< strtab_size
17251 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17252 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17253 liblist
.l_version
, liblist
.l_flags
);
17264 static const char *
17265 get_note_type (Filedata
* filedata
, unsigned e_type
)
17267 static char buff
[64];
17269 if (filedata
->file_header
.e_type
== ET_CORE
)
17273 return _("NT_AUXV (auxiliary vector)");
17275 return _("NT_PRSTATUS (prstatus structure)");
17277 return _("NT_FPREGSET (floating point registers)");
17279 return _("NT_PRPSINFO (prpsinfo structure)");
17280 case NT_TASKSTRUCT
:
17281 return _("NT_TASKSTRUCT (task structure)");
17283 return _("NT_PRXFPREG (user_xfpregs structure)");
17285 return _("NT_PPC_VMX (ppc Altivec registers)");
17287 return _("NT_PPC_VSX (ppc VSX registers)");
17289 return _("NT_PPC_TAR (ppc TAR register)");
17291 return _("NT_PPC_PPR (ppc PPR register)");
17293 return _("NT_PPC_DSCR (ppc DSCR register)");
17295 return _("NT_PPC_EBB (ppc EBB registers)");
17297 return _("NT_PPC_PMU (ppc PMU registers)");
17298 case NT_PPC_TM_CGPR
:
17299 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17300 case NT_PPC_TM_CFPR
:
17301 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17302 case NT_PPC_TM_CVMX
:
17303 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17304 case NT_PPC_TM_CVSX
:
17305 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17306 case NT_PPC_TM_SPR
:
17307 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17308 case NT_PPC_TM_CTAR
:
17309 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17310 case NT_PPC_TM_CPPR
:
17311 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17312 case NT_PPC_TM_CDSCR
:
17313 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17315 return _("NT_386_TLS (x86 TLS information)");
17316 case NT_386_IOPERM
:
17317 return _("NT_386_IOPERM (x86 I/O permissions)");
17318 case NT_X86_XSTATE
:
17319 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17320 case NT_S390_HIGH_GPRS
:
17321 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17322 case NT_S390_TIMER
:
17323 return _("NT_S390_TIMER (s390 timer register)");
17324 case NT_S390_TODCMP
:
17325 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17326 case NT_S390_TODPREG
:
17327 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17329 return _("NT_S390_CTRS (s390 control registers)");
17330 case NT_S390_PREFIX
:
17331 return _("NT_S390_PREFIX (s390 prefix register)");
17332 case NT_S390_LAST_BREAK
:
17333 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17334 case NT_S390_SYSTEM_CALL
:
17335 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17337 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17338 case NT_S390_VXRS_LOW
:
17339 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17340 case NT_S390_VXRS_HIGH
:
17341 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17342 case NT_S390_GS_CB
:
17343 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17344 case NT_S390_GS_BC
:
17345 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17347 return _("NT_ARM_VFP (arm VFP registers)");
17349 return _("NT_ARM_TLS (AArch TLS registers)");
17350 case NT_ARM_HW_BREAK
:
17351 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17352 case NT_ARM_HW_WATCH
:
17353 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17355 return _("NT_PSTATUS (pstatus structure)");
17357 return _("NT_FPREGS (floating point registers)");
17359 return _("NT_PSINFO (psinfo structure)");
17361 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17363 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17364 case NT_WIN32PSTATUS
:
17365 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17367 return _("NT_SIGINFO (siginfo_t data)");
17369 return _("NT_FILE (mapped files)");
17377 return _("NT_VERSION (version)");
17379 return _("NT_ARCH (architecture)");
17380 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17382 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17388 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17393 print_core_note (Elf_Internal_Note
*pnote
)
17395 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17396 bfd_vma count
, page_size
;
17397 unsigned char *descdata
, *filenames
, *descend
;
17399 if (pnote
->type
!= NT_FILE
)
17409 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17410 /* Still "successful". */
17415 if (pnote
->descsz
< 2 * addr_size
)
17417 error (_(" Malformed note - too short for header\n"));
17421 descdata
= (unsigned char *) pnote
->descdata
;
17422 descend
= descdata
+ pnote
->descsz
;
17424 if (descdata
[pnote
->descsz
- 1] != '\0')
17426 error (_(" Malformed note - does not end with \\0\n"));
17430 count
= byte_get (descdata
, addr_size
);
17431 descdata
+= addr_size
;
17433 page_size
= byte_get (descdata
, addr_size
);
17434 descdata
+= addr_size
;
17436 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17437 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17439 error (_(" Malformed note - too short for supplied file count\n"));
17443 printf (_(" Page size: "));
17444 print_vma (page_size
, DEC
);
17447 printf (_(" %*s%*s%*s\n"),
17448 (int) (2 + 2 * addr_size
), _("Start"),
17449 (int) (4 + 2 * addr_size
), _("End"),
17450 (int) (4 + 2 * addr_size
), _("Page Offset"));
17451 filenames
= descdata
+ count
* 3 * addr_size
;
17452 while (count
-- > 0)
17454 bfd_vma start
, end
, file_ofs
;
17456 if (filenames
== descend
)
17458 error (_(" Malformed note - filenames end too early\n"));
17462 start
= byte_get (descdata
, addr_size
);
17463 descdata
+= addr_size
;
17464 end
= byte_get (descdata
, addr_size
);
17465 descdata
+= addr_size
;
17466 file_ofs
= byte_get (descdata
, addr_size
);
17467 descdata
+= addr_size
;
17470 print_vma (start
, FULL_HEX
);
17472 print_vma (end
, FULL_HEX
);
17474 print_vma (file_ofs
, FULL_HEX
);
17475 printf ("\n %s\n", filenames
);
17477 filenames
+= 1 + strlen ((char *) filenames
);
17483 static const char *
17484 get_gnu_elf_note_type (unsigned e_type
)
17486 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17489 case NT_GNU_ABI_TAG
:
17490 return _("NT_GNU_ABI_TAG (ABI version tag)");
17492 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17493 case NT_GNU_BUILD_ID
:
17494 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17495 case NT_GNU_GOLD_VERSION
:
17496 return _("NT_GNU_GOLD_VERSION (gold version)");
17497 case NT_GNU_PROPERTY_TYPE_0
:
17498 return _("NT_GNU_PROPERTY_TYPE_0");
17499 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17500 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17501 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17502 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17505 static char buff
[64];
17507 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17514 decode_x86_compat_isa (unsigned int bitmask
)
17518 unsigned int bit
= bitmask
& (- bitmask
);
17523 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17526 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17529 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17532 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17535 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17538 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17541 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17544 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17547 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17550 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17553 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17556 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17557 printf ("AVX512F");
17559 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17560 printf ("AVX512CD");
17562 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17563 printf ("AVX512ER");
17565 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17566 printf ("AVX512PF");
17568 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17569 printf ("AVX512VL");
17571 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17572 printf ("AVX512DQ");
17574 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17575 printf ("AVX512BW");
17578 printf (_("<unknown: %x>"), bit
);
17587 decode_x86_isa (unsigned int bitmask
)
17591 printf (_("<None>"));
17597 unsigned int bit
= bitmask
& (- bitmask
);
17602 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17605 case GNU_PROPERTY_X86_ISA_1_SSE
:
17608 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17611 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17614 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17617 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17620 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17623 case GNU_PROPERTY_X86_ISA_1_AVX
:
17626 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17629 case GNU_PROPERTY_X86_ISA_1_FMA
:
17632 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17633 printf ("AVX512F");
17635 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17636 printf ("AVX512CD");
17638 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17639 printf ("AVX512ER");
17641 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17642 printf ("AVX512PF");
17644 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17645 printf ("AVX512VL");
17647 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17648 printf ("AVX512DQ");
17650 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17651 printf ("AVX512BW");
17653 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17654 printf ("AVX512_4FMAPS");
17656 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17657 printf ("AVX512_4VNNIW");
17659 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17660 printf ("AVX512_BITALG");
17662 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17663 printf ("AVX512_IFMA");
17665 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17666 printf ("AVX512_VBMI");
17668 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17669 printf ("AVX512_VBMI2");
17671 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17672 printf ("AVX512_VNNI");
17674 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17675 printf ("AVX512_BF16");
17678 printf (_("<unknown: %x>"), bit
);
17687 decode_x86_feature_1 (unsigned int bitmask
)
17691 printf (_("<None>"));
17697 unsigned int bit
= bitmask
& (- bitmask
);
17702 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17705 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17709 printf (_("<unknown: %x>"), bit
);
17718 decode_x86_feature_2 (unsigned int bitmask
)
17722 printf (_("<None>"));
17728 unsigned int bit
= bitmask
& (- bitmask
);
17733 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17736 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17739 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17742 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17745 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17748 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17751 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17754 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17757 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17758 printf ("XSAVEOPT");
17760 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17764 printf (_("<unknown: %x>"), bit
);
17773 decode_aarch64_feature_1_and (unsigned int bitmask
)
17777 unsigned int bit
= bitmask
& (- bitmask
);
17782 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17786 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17791 printf (_("<unknown: %x>"), bit
);
17800 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17802 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17803 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17804 unsigned int size
= is_32bit_elf
? 4 : 8;
17806 printf (_(" Properties: "));
17808 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17810 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17814 while (ptr
< ptr_end
)
17818 unsigned int datasz
;
17820 if ((size_t) (ptr_end
- ptr
) < 8)
17822 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17826 type
= byte_get (ptr
, 4);
17827 datasz
= byte_get (ptr
+ 4, 4);
17831 if (datasz
> (size_t) (ptr_end
- ptr
))
17833 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17838 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17840 if (filedata
->file_header
.e_machine
== EM_X86_64
17841 || filedata
->file_header
.e_machine
== EM_IAMCU
17842 || filedata
->file_header
.e_machine
== EM_386
)
17844 unsigned int bitmask
;
17847 bitmask
= byte_get (ptr
, 4);
17853 case GNU_PROPERTY_X86_ISA_1_USED
:
17855 printf (_("x86 ISA used: <corrupt length: %#x> "),
17859 printf ("x86 ISA used: ");
17860 decode_x86_isa (bitmask
);
17864 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17866 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17870 printf ("x86 ISA needed: ");
17871 decode_x86_isa (bitmask
);
17875 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17877 printf (_("x86 feature: <corrupt length: %#x> "),
17881 printf ("x86 feature: ");
17882 decode_x86_feature_1 (bitmask
);
17886 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17888 printf (_("x86 feature used: <corrupt length: %#x> "),
17892 printf ("x86 feature used: ");
17893 decode_x86_feature_2 (bitmask
);
17897 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17899 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17902 printf ("x86 feature needed: ");
17903 decode_x86_feature_2 (bitmask
);
17907 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17909 printf (_("x86 ISA used: <corrupt length: %#x> "),
17913 printf ("x86 ISA used: ");
17914 decode_x86_compat_isa (bitmask
);
17918 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17920 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17924 printf ("x86 ISA needed: ");
17925 decode_x86_compat_isa (bitmask
);
17933 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
17935 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
17937 printf ("AArch64 feature: ");
17939 printf (_("<corrupt length: %#x> "), datasz
);
17941 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
17950 case GNU_PROPERTY_STACK_SIZE
:
17951 printf (_("stack size: "));
17952 if (datasz
!= size
)
17953 printf (_("<corrupt length: %#x> "), datasz
);
17955 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17958 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17959 printf ("no copy on protected ");
17961 printf (_("<corrupt length: %#x> "), datasz
);
17969 if (type
< GNU_PROPERTY_LOPROC
)
17970 printf (_("<unknown type %#x data: "), type
);
17971 else if (type
< GNU_PROPERTY_LOUSER
)
17972 printf (_("<procesor-specific type %#x data: "), type
);
17974 printf (_("<application-specific type %#x data: "), type
);
17975 for (j
= 0; j
< datasz
; ++j
)
17976 printf ("%02x ", ptr
[j
] & 0xff);
17980 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17981 if (ptr
== ptr_end
)
17994 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17996 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17997 switch (pnote
->type
)
17999 case NT_GNU_BUILD_ID
:
18003 printf (_(" Build ID: "));
18004 for (i
= 0; i
< pnote
->descsz
; ++i
)
18005 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18010 case NT_GNU_ABI_TAG
:
18012 unsigned long os
, major
, minor
, subminor
;
18013 const char *osname
;
18015 /* PR 17531: file: 030-599401-0.004. */
18016 if (pnote
->descsz
< 16)
18018 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18022 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18023 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18024 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18025 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18029 case GNU_ABI_TAG_LINUX
:
18032 case GNU_ABI_TAG_HURD
:
18035 case GNU_ABI_TAG_SOLARIS
:
18036 osname
= "Solaris";
18038 case GNU_ABI_TAG_FREEBSD
:
18039 osname
= "FreeBSD";
18041 case GNU_ABI_TAG_NETBSD
:
18044 case GNU_ABI_TAG_SYLLABLE
:
18045 osname
= "Syllable";
18047 case GNU_ABI_TAG_NACL
:
18051 osname
= "Unknown";
18055 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18056 major
, minor
, subminor
);
18060 case NT_GNU_GOLD_VERSION
:
18064 printf (_(" Version: "));
18065 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18066 printf ("%c", pnote
->descdata
[i
]);
18073 unsigned long num_entries
, mask
;
18075 /* Hardware capabilities information. Word 0 is the number of entries.
18076 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18077 is a series of entries, where each entry is a single byte followed
18078 by a nul terminated string. The byte gives the bit number to test
18079 if enabled in the bitmask. */
18080 printf (_(" Hardware Capabilities: "));
18081 if (pnote
->descsz
< 8)
18083 error (_("<corrupt GNU_HWCAP>\n"));
18086 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18087 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18088 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18089 /* FIXME: Add code to display the entries... */
18093 case NT_GNU_PROPERTY_TYPE_0
:
18094 print_gnu_property_note (filedata
, pnote
);
18098 /* Handle unrecognised types. An error message should have already been
18099 created by get_gnu_elf_note_type(), so all that we need to do is to
18100 display the data. */
18104 printf (_(" Description data: "));
18105 for (i
= 0; i
< pnote
->descsz
; ++i
)
18106 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18115 static const char *
18116 get_v850_elf_note_type (enum v850_notes n_type
)
18118 static char buff
[64];
18122 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18123 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18124 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18125 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18126 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18127 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18129 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18135 print_v850_note (Elf_Internal_Note
* pnote
)
18139 if (pnote
->descsz
!= 4)
18142 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18146 printf (_("not set\n"));
18150 switch (pnote
->type
)
18152 case V850_NOTE_ALIGNMENT
:
18155 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18156 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18160 case V850_NOTE_DATA_SIZE
:
18163 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18164 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18168 case V850_NOTE_FPU_INFO
:
18171 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18172 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18176 case V850_NOTE_MMU_INFO
:
18177 case V850_NOTE_CACHE_INFO
:
18178 case V850_NOTE_SIMD_INFO
:
18179 if (val
== EF_RH850_SIMD
)
18181 printf (_("yes\n"));
18187 /* An 'unknown note type' message will already have been displayed. */
18191 printf (_("unknown value: %x\n"), val
);
18196 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18198 unsigned int version
;
18200 switch (pnote
->type
)
18202 case NT_NETBSD_IDENT
:
18203 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18204 if ((version
/ 10000) % 100)
18205 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18206 version
, version
/ 100000000, (version
/ 1000000) % 100,
18207 (version
/ 10000) % 100 > 26 ? "Z" : "",
18208 'A' + (version
/ 10000) % 26);
18210 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18211 version
, version
/ 100000000, (version
/ 1000000) % 100,
18212 (version
/ 100) % 100);
18215 case NT_NETBSD_MARCH
:
18216 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18220 #ifdef NT_NETBSD_PAX
18221 case NT_NETBSD_PAX
:
18222 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18223 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18224 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18225 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18226 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18227 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18228 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18229 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18234 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18240 static const char *
18241 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18245 case NT_FREEBSD_THRMISC
:
18246 return _("NT_THRMISC (thrmisc structure)");
18247 case NT_FREEBSD_PROCSTAT_PROC
:
18248 return _("NT_PROCSTAT_PROC (proc data)");
18249 case NT_FREEBSD_PROCSTAT_FILES
:
18250 return _("NT_PROCSTAT_FILES (files data)");
18251 case NT_FREEBSD_PROCSTAT_VMMAP
:
18252 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18253 case NT_FREEBSD_PROCSTAT_GROUPS
:
18254 return _("NT_PROCSTAT_GROUPS (groups data)");
18255 case NT_FREEBSD_PROCSTAT_UMASK
:
18256 return _("NT_PROCSTAT_UMASK (umask data)");
18257 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18258 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18259 case NT_FREEBSD_PROCSTAT_OSREL
:
18260 return _("NT_PROCSTAT_OSREL (osreldate data)");
18261 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18262 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18263 case NT_FREEBSD_PROCSTAT_AUXV
:
18264 return _("NT_PROCSTAT_AUXV (auxv data)");
18265 case NT_FREEBSD_PTLWPINFO
:
18266 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18268 return get_note_type (filedata
, e_type
);
18271 static const char *
18272 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18274 static char buff
[64];
18278 case NT_NETBSDCORE_PROCINFO
:
18279 /* NetBSD core "procinfo" structure. */
18280 return _("NetBSD procinfo structure");
18282 #ifdef NT_NETBSDCORE_AUXV
18283 case NT_NETBSDCORE_AUXV
:
18284 return _("NetBSD ELF auxiliary vector data");
18288 /* As of Jan 2002 there are no other machine-independent notes
18289 defined for NetBSD core files. If the note type is less
18290 than the start of the machine-dependent note types, we don't
18293 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18295 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18301 switch (filedata
->file_header
.e_machine
)
18303 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18304 and PT_GETFPREGS == mach+2. */
18309 case EM_SPARC32PLUS
:
18313 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18314 return _("PT_GETREGS (reg structure)");
18315 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18316 return _("PT_GETFPREGS (fpreg structure)");
18322 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18323 There's also old PT___GETREGS40 == mach + 1 for old reg
18324 structure which lacks GBR. */
18328 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18329 return _("PT___GETREGS40 (old reg structure)");
18330 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18331 return _("PT_GETREGS (reg structure)");
18332 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18333 return _("PT_GETFPREGS (fpreg structure)");
18339 /* On all other arch's, PT_GETREGS == mach+1 and
18340 PT_GETFPREGS == mach+3. */
18344 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18345 return _("PT_GETREGS (reg structure)");
18346 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18347 return _("PT_GETFPREGS (fpreg structure)");
18353 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18354 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18358 static const char *
18359 get_stapsdt_note_type (unsigned e_type
)
18361 static char buff
[64];
18366 return _("NT_STAPSDT (SystemTap probe descriptors)");
18372 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18377 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18379 size_t len
, maxlen
;
18380 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18381 char *data
= pnote
->descdata
;
18382 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18383 bfd_vma pc
, base_addr
, semaphore
;
18384 char *provider
, *probe
, *arg_fmt
;
18386 if (pnote
->descsz
< (addr_size
* 3))
18387 goto stapdt_note_too_small
;
18389 pc
= byte_get ((unsigned char *) data
, addr_size
);
18392 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18395 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18398 if (data
>= data_end
)
18399 goto stapdt_note_too_small
;
18400 maxlen
= data_end
- data
;
18401 len
= strnlen (data
, maxlen
);
18408 goto stapdt_note_too_small
;
18410 if (data
>= data_end
)
18411 goto stapdt_note_too_small
;
18412 maxlen
= data_end
- data
;
18413 len
= strnlen (data
, maxlen
);
18420 goto stapdt_note_too_small
;
18422 if (data
>= data_end
)
18423 goto stapdt_note_too_small
;
18424 maxlen
= data_end
- data
;
18425 len
= strnlen (data
, maxlen
);
18432 goto stapdt_note_too_small
;
18434 printf (_(" Provider: %s\n"), provider
);
18435 printf (_(" Name: %s\n"), probe
);
18436 printf (_(" Location: "));
18437 print_vma (pc
, FULL_HEX
);
18438 printf (_(", Base: "));
18439 print_vma (base_addr
, FULL_HEX
);
18440 printf (_(", Semaphore: "));
18441 print_vma (semaphore
, FULL_HEX
);
18443 printf (_(" Arguments: %s\n"), arg_fmt
);
18445 return data
== data_end
;
18447 stapdt_note_too_small
:
18448 printf (_(" <corrupt - note is too small>\n"));
18449 error (_("corrupt stapdt note - the data size is too small\n"));
18453 static const char *
18454 get_ia64_vms_note_type (unsigned e_type
)
18456 static char buff
[64];
18461 return _("NT_VMS_MHD (module header)");
18463 return _("NT_VMS_LNM (language name)");
18465 return _("NT_VMS_SRC (source files)");
18467 return "NT_VMS_TITLE";
18469 return _("NT_VMS_EIDC (consistency check)");
18470 case NT_VMS_FPMODE
:
18471 return _("NT_VMS_FPMODE (FP mode)");
18472 case NT_VMS_LINKTIME
:
18473 return "NT_VMS_LINKTIME";
18474 case NT_VMS_IMGNAM
:
18475 return _("NT_VMS_IMGNAM (image name)");
18477 return _("NT_VMS_IMGID (image id)");
18478 case NT_VMS_LINKID
:
18479 return _("NT_VMS_LINKID (link id)");
18480 case NT_VMS_IMGBID
:
18481 return _("NT_VMS_IMGBID (build id)");
18482 case NT_VMS_GSTNAM
:
18483 return _("NT_VMS_GSTNAM (sym table name)");
18484 case NT_VMS_ORIG_DYN
:
18485 return "NT_VMS_ORIG_DYN";
18486 case NT_VMS_PATCHTIME
:
18487 return "NT_VMS_PATCHTIME";
18489 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18495 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18497 int maxlen
= pnote
->descsz
;
18499 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18500 goto desc_size_fail
;
18502 switch (pnote
->type
)
18506 goto desc_size_fail
;
18508 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18510 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18511 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18512 if (l
+ 34 < maxlen
)
18514 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18515 if (l
+ 35 < maxlen
)
18516 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18518 printf (_(" Module version : <missing>\n"));
18522 printf (_(" Module name : <missing>\n"));
18523 printf (_(" Module version : <missing>\n"));
18528 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18532 case NT_VMS_FPMODE
:
18533 printf (_(" Floating Point mode: "));
18535 goto desc_size_fail
;
18536 /* FIXME: Generate an error if descsz > 8 ? */
18538 printf ("0x%016" BFD_VMA_FMT
"x\n",
18539 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18542 case NT_VMS_LINKTIME
:
18543 printf (_(" Link time: "));
18545 goto desc_size_fail
;
18546 /* FIXME: Generate an error if descsz > 8 ? */
18549 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18553 case NT_VMS_PATCHTIME
:
18554 printf (_(" Patch time: "));
18556 goto desc_size_fail
;
18557 /* FIXME: Generate an error if descsz > 8 ? */
18560 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18564 case NT_VMS_ORIG_DYN
:
18566 goto desc_size_fail
;
18568 printf (_(" Major id: %u, minor id: %u\n"),
18569 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18570 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18571 printf (_(" Last modified : "));
18573 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18574 printf (_("\n Link flags : "));
18575 printf ("0x%016" BFD_VMA_FMT
"x\n",
18576 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18577 printf (_(" Header flags: 0x%08x\n"),
18578 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18579 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18583 case NT_VMS_IMGNAM
:
18584 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18587 case NT_VMS_GSTNAM
:
18588 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18592 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18595 case NT_VMS_LINKID
:
18596 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18606 printf (_(" <corrupt - data size is too small>\n"));
18607 error (_("corrupt IA64 note: data size is too small\n"));
18611 /* Find the symbol associated with a build attribute that is attached
18612 to address OFFSET. If PNAME is non-NULL then store the name of
18613 the symbol (if found) in the provided pointer, Returns NULL if a
18614 symbol could not be found. */
18616 static Elf_Internal_Sym
*
18617 get_symbol_for_build_attribute (Filedata
* filedata
,
18618 unsigned long offset
,
18619 bfd_boolean is_open_attr
,
18620 const char ** pname
)
18622 static Filedata
* saved_filedata
= NULL
;
18623 static char * strtab
;
18624 static unsigned long strtablen
;
18625 static Elf_Internal_Sym
* symtab
;
18626 static unsigned long nsyms
;
18627 Elf_Internal_Sym
* saved_sym
= NULL
;
18628 Elf_Internal_Sym
* sym
;
18630 if (filedata
->section_headers
!= NULL
18631 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18633 Elf_Internal_Shdr
* symsec
;
18635 /* Load the symbol and string sections. */
18636 for (symsec
= filedata
->section_headers
;
18637 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18640 if (symsec
->sh_type
== SHT_SYMTAB
)
18642 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18644 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18646 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18648 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18649 1, strtab_sec
->sh_size
,
18650 _("string table"));
18651 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18655 saved_filedata
= filedata
;
18658 if (symtab
== NULL
|| strtab
== NULL
)
18661 /* Find a symbol whose value matches offset. */
18662 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18663 if (sym
->st_value
== offset
)
18665 if (sym
->st_name
>= strtablen
)
18666 /* Huh ? This should not happen. */
18669 if (strtab
[sym
->st_name
] == 0)
18672 /* The AArch64 and ARM architectures define mapping symbols
18673 (eg $d, $x, $t) which we want to ignore. */
18674 if (strtab
[sym
->st_name
] == '$'
18675 && strtab
[sym
->st_name
+ 1] != 0
18676 && strtab
[sym
->st_name
+ 2] == 0)
18681 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18682 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18683 FUNC symbols entirely. */
18684 switch (ELF_ST_TYPE (sym
->st_info
))
18691 /* If the symbol has a size associated
18692 with it then we can stop searching. */
18693 sym
= symtab
+ nsyms
;
18698 /* Ignore function symbols. */
18705 switch (ELF_ST_BIND (sym
->st_info
))
18708 if (saved_sym
== NULL
18709 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18714 if (saved_sym
== NULL
)
18724 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18732 if (saved_sym
&& pname
)
18733 * pname
= strtab
+ saved_sym
->st_name
;
18738 /* Returns true iff addr1 and addr2 are in the same section. */
18741 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18743 Elf_Internal_Shdr
* a1
;
18744 Elf_Internal_Shdr
* a2
;
18746 a1
= find_section_by_address (filedata
, addr1
);
18747 a2
= find_section_by_address (filedata
, addr2
);
18749 return a1
== a2
&& a1
!= NULL
;
18753 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18754 Filedata
* filedata
)
18756 static unsigned long global_offset
= 0;
18757 static unsigned long global_end
= 0;
18758 static unsigned long func_offset
= 0;
18759 static unsigned long func_end
= 0;
18761 Elf_Internal_Sym
* sym
;
18763 unsigned long start
;
18765 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18767 switch (pnote
->descsz
)
18770 /* A zero-length description means that the range of
18771 the previous note of the same type should be used. */
18774 if (global_end
> global_offset
)
18775 printf (_(" Applies to region from %#lx to %#lx\n"),
18776 global_offset
, global_end
);
18778 printf (_(" Applies to region from %#lx\n"), global_offset
);
18782 if (func_end
> func_offset
)
18783 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18785 printf (_(" Applies to region from %#lx\n"), func_offset
);
18790 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18797 /* FIXME: We should check that version 3+ notes are being used here... */
18798 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18799 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18803 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18809 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18810 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18814 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18815 printf (_(" <invalid descsz>"));
18820 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18821 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18822 in order to avoid them being confused with the start address of the
18823 first function in the file... */
18824 if (sym
== NULL
&& is_open_attr
)
18825 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18828 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18829 end
= start
+ sym
->st_size
;
18833 /* FIXME: Need to properly allow for section alignment.
18834 16 is just the alignment used on x86_64. */
18836 && start
> BFD_ALIGN (global_end
, 16)
18837 /* Build notes are not guaranteed to be organised in order of
18838 increasing address, but we should find the all of the notes
18839 for one section in the same place. */
18840 && same_section (filedata
, start
, global_end
))
18841 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18842 global_end
+ 1, start
- 1);
18844 printf (_(" Applies to region from %#lx"), start
);
18845 global_offset
= start
;
18849 printf (_(" to %#lx"), end
);
18855 printf (_(" Applies to region from %#lx"), start
);
18856 func_offset
= start
;
18860 printf (_(" to %#lx"), end
);
18866 printf (_(" (%s)"), name
);
18873 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18875 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18876 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18877 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18879 char name_attribute
;
18880 const char * expected_types
;
18881 const char * name
= pnote
->namedata
;
18885 if (name
== NULL
|| pnote
->namesz
< 2)
18887 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18888 print_symbol (-20, _(" <corrupt name>"));
18897 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18898 if (name
[0] == 'G' && name
[1] == 'A')
18900 if (pnote
->namesz
< 4)
18902 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18903 print_symbol (-20, _(" <corrupt name>"));
18912 switch ((name_type
= * name
))
18914 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18915 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18916 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18917 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18918 printf ("%c", * name
);
18922 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18923 print_symbol (-20, _("<unknown name type>"));
18930 switch ((name_attribute
= * name
))
18932 case GNU_BUILD_ATTRIBUTE_VERSION
:
18933 text
= _("<version>");
18934 expected_types
= string_expected
;
18937 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18938 text
= _("<stack prot>");
18939 expected_types
= "!+*";
18942 case GNU_BUILD_ATTRIBUTE_RELRO
:
18943 text
= _("<relro>");
18944 expected_types
= bool_expected
;
18947 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18948 text
= _("<stack size>");
18949 expected_types
= number_expected
;
18952 case GNU_BUILD_ATTRIBUTE_TOOL
:
18953 text
= _("<tool>");
18954 expected_types
= string_expected
;
18957 case GNU_BUILD_ATTRIBUTE_ABI
:
18959 expected_types
= "$*";
18962 case GNU_BUILD_ATTRIBUTE_PIC
:
18964 expected_types
= number_expected
;
18967 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18968 text
= _("<short enum>");
18969 expected_types
= bool_expected
;
18973 if (ISPRINT (* name
))
18975 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18977 if (len
> left
&& ! do_wide
)
18979 printf ("%.*s:", len
, name
);
18985 static char tmpbuf
[128];
18987 error (_("unrecognised byte in name field: %d\n"), * name
);
18988 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18992 expected_types
= "*$!+";
18997 left
-= printf ("%s", text
);
18999 if (strchr (expected_types
, name_type
) == NULL
)
19000 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19002 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19004 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19005 (unsigned long) pnote
->namesz
,
19006 (long) (name
- pnote
->namedata
));
19010 if (left
< 1 && ! do_wide
)
19015 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19017 unsigned int bytes
;
19018 unsigned long long val
= 0;
19019 unsigned int shift
= 0;
19020 char * decoded
= NULL
;
19022 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19024 /* The -1 is because the name field is always 0 terminated, and we
19025 want to be able to ensure that the shift in the while loop below
19026 will not overflow. */
19029 if (bytes
> sizeof (val
))
19031 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19033 bytes
= sizeof (val
);
19035 /* We do not bother to warn if bytes == 0 as this can
19036 happen with some early versions of the gcc plugin. */
19040 unsigned long byte
= (* name
++) & 0xff;
19042 val
|= byte
<< shift
;
19046 switch (name_attribute
)
19048 case GNU_BUILD_ATTRIBUTE_PIC
:
19051 case 0: decoded
= "static"; break;
19052 case 1: decoded
= "pic"; break;
19053 case 2: decoded
= "PIC"; break;
19054 case 3: decoded
= "pie"; break;
19055 case 4: decoded
= "PIE"; break;
19059 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19062 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19063 case 0: decoded
= "off"; break;
19064 case 1: decoded
= "on"; break;
19065 case 2: decoded
= "all"; break;
19066 case 3: decoded
= "strong"; break;
19067 case 4: decoded
= "explicit"; break;
19075 if (decoded
!= NULL
)
19077 print_symbol (-left
, decoded
);
19088 left
-= printf ("0x%llx", val
);
19090 left
-= printf ("0x%-.*llx", left
, val
);
19094 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19095 left
-= print_symbol (- left
, name
);
19097 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19098 left
-= print_symbol (- left
, "true");
19100 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19101 left
-= print_symbol (- left
, "false");
19105 if (do_wide
&& left
> 0)
19106 printf ("%-*s", left
, " ");
19111 /* Note that by the ELF standard, the name field is already null byte
19112 terminated, and namesz includes the terminating null byte.
19113 I.E. the value of namesz for the name "FSF" is 4.
19115 If the value of namesz is zero, there is no name present. */
19118 process_note (Elf_Internal_Note
* pnote
,
19119 Filedata
* filedata
)
19121 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19124 if (pnote
->namesz
== 0)
19125 /* If there is no note name, then use the default set of
19126 note type strings. */
19127 nt
= get_note_type (filedata
, pnote
->type
);
19129 else if (const_strneq (pnote
->namedata
, "GNU"))
19130 /* GNU-specific object file notes. */
19131 nt
= get_gnu_elf_note_type (pnote
->type
);
19133 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19134 /* FreeBSD-specific core file notes. */
19135 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19137 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19138 /* NetBSD-specific core file notes. */
19139 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19141 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19142 /* NetBSD-specific core file notes. */
19143 return process_netbsd_elf_note (pnote
);
19145 else if (const_strneq (pnote
->namedata
, "PaX"))
19146 /* NetBSD-specific core file notes. */
19147 return process_netbsd_elf_note (pnote
);
19149 else if (strneq (pnote
->namedata
, "SPU/", 4))
19151 /* SPU-specific core file notes. */
19152 nt
= pnote
->namedata
+ 4;
19156 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19157 /* VMS/ia64-specific file notes. */
19158 nt
= get_ia64_vms_note_type (pnote
->type
);
19160 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19161 nt
= get_stapsdt_note_type (pnote
->type
);
19164 /* Don't recognize this note name; just use the default set of
19165 note type strings. */
19166 nt
= get_note_type (filedata
, pnote
->type
);
19170 if (((const_strneq (pnote
->namedata
, "GA")
19171 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19172 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19173 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19174 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19175 print_gnu_build_attribute_name (pnote
);
19177 print_symbol (-20, name
);
19180 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19182 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19184 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19185 return print_ia64_vms_note (pnote
);
19186 else if (const_strneq (pnote
->namedata
, "GNU"))
19187 return print_gnu_note (filedata
, pnote
);
19188 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19189 return print_stapsdt_note (pnote
);
19190 else if (const_strneq (pnote
->namedata
, "CORE"))
19191 return print_core_note (pnote
);
19192 else if (((const_strneq (pnote
->namedata
, "GA")
19193 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19194 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19195 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19196 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19197 return print_gnu_build_attribute_description (pnote
, filedata
);
19203 printf (_(" description data: "));
19204 for (i
= 0; i
< pnote
->descsz
; i
++)
19205 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19217 process_notes_at (Filedata
* filedata
,
19218 Elf_Internal_Shdr
* section
,
19223 Elf_External_Note
* pnotes
;
19224 Elf_External_Note
* external
;
19226 bfd_boolean res
= TRUE
;
19233 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19236 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19241 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19244 if (pnotes
== NULL
)
19250 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19252 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19253 (unsigned long) offset
, (unsigned long) length
);
19255 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19256 specifies that notes should be aligned to 4 bytes in 32-bit
19257 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19258 we also support 4 byte alignment in 64-bit objects. If section
19259 alignment is less than 4, we treate alignment as 4 bytes. */
19262 else if (align
!= 4 && align
!= 8)
19264 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19269 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19271 end
= (char *) pnotes
+ length
;
19272 while ((char *) external
< end
)
19274 Elf_Internal_Note inote
;
19277 char * temp
= NULL
;
19278 size_t data_remaining
= end
- (char *) external
;
19280 if (!is_ia64_vms (filedata
))
19282 /* PR binutils/15191
19283 Make sure that there is enough data to read. */
19284 min_notesz
= offsetof (Elf_External_Note
, name
);
19285 if (data_remaining
< min_notesz
)
19287 warn (ngettext ("Corrupt note: only %ld byte remains, "
19288 "not enough for a full note\n",
19289 "Corrupt note: only %ld bytes remain, "
19290 "not enough for a full note\n",
19292 (long) data_remaining
);
19295 data_remaining
-= min_notesz
;
19297 inote
.type
= BYTE_GET (external
->type
);
19298 inote
.namesz
= BYTE_GET (external
->namesz
);
19299 inote
.namedata
= external
->name
;
19300 inote
.descsz
= BYTE_GET (external
->descsz
);
19301 inote
.descdata
= ((char *) external
19302 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19303 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19304 next
= ((char *) external
19305 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19309 Elf64_External_VMS_Note
*vms_external
;
19311 /* PR binutils/15191
19312 Make sure that there is enough data to read. */
19313 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19314 if (data_remaining
< min_notesz
)
19316 warn (ngettext ("Corrupt note: only %ld byte remains, "
19317 "not enough for a full note\n",
19318 "Corrupt note: only %ld bytes remain, "
19319 "not enough for a full note\n",
19321 (long) data_remaining
);
19324 data_remaining
-= min_notesz
;
19326 vms_external
= (Elf64_External_VMS_Note
*) external
;
19327 inote
.type
= BYTE_GET (vms_external
->type
);
19328 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19329 inote
.namedata
= vms_external
->name
;
19330 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19331 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19332 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19333 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19336 /* PR 17531: file: 3443835e. */
19337 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19338 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19339 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19340 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19341 || ((size_t) (next
- inote
.descdata
)
19342 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19344 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19345 (unsigned long) ((char *) external
- (char *) pnotes
));
19346 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19347 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19351 external
= (Elf_External_Note
*) next
;
19353 /* Verify that name is null terminated. It appears that at least
19354 one version of Linux (RedHat 6.0) generates corefiles that don't
19355 comply with the ELF spec by failing to include the null byte in
19357 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19359 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19361 temp
= (char *) malloc (inote
.namesz
+ 1);
19364 error (_("Out of memory allocating space for inote name\n"));
19369 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19370 inote
.namedata
= temp
;
19372 inote
.namedata
[inote
.namesz
] = 0;
19375 if (! process_note (& inote
, filedata
))
19391 process_corefile_note_segments (Filedata
* filedata
)
19393 Elf_Internal_Phdr
* segment
;
19395 bfd_boolean res
= TRUE
;
19397 if (! get_program_headers (filedata
))
19400 for (i
= 0, segment
= filedata
->program_headers
;
19401 i
< filedata
->file_header
.e_phnum
;
19404 if (segment
->p_type
== PT_NOTE
)
19405 if (! process_notes_at (filedata
, NULL
,
19406 (bfd_vma
) segment
->p_offset
,
19407 (bfd_vma
) segment
->p_filesz
,
19408 (bfd_vma
) segment
->p_align
))
19416 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19418 Elf_External_Note
* pnotes
;
19419 Elf_External_Note
* external
;
19421 bfd_boolean res
= TRUE
;
19426 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19428 if (pnotes
== NULL
)
19432 end
= (char*) pnotes
+ length
;
19434 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19435 (unsigned long) offset
, (unsigned long) length
);
19437 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19439 Elf_External_Note
* next
;
19440 Elf_Internal_Note inote
;
19442 inote
.type
= BYTE_GET (external
->type
);
19443 inote
.namesz
= BYTE_GET (external
->namesz
);
19444 inote
.namedata
= external
->name
;
19445 inote
.descsz
= BYTE_GET (external
->descsz
);
19446 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19447 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19449 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19451 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19452 inote
.descdata
= inote
.namedata
;
19456 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19458 if ( ((char *) next
> end
)
19459 || ((char *) next
< (char *) pnotes
))
19461 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19462 (unsigned long) ((char *) external
- (char *) pnotes
));
19463 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19464 inote
.type
, inote
.namesz
, inote
.descsz
);
19470 /* Prevent out-of-bounds indexing. */
19471 if ( inote
.namedata
+ inote
.namesz
> end
19472 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19474 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19475 (unsigned long) ((char *) external
- (char *) pnotes
));
19476 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19477 inote
.type
, inote
.namesz
, inote
.descsz
);
19481 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19483 if (! print_v850_note (& inote
))
19486 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19487 inote
.namesz
, inote
.descsz
);
19497 process_note_sections (Filedata
* filedata
)
19499 Elf_Internal_Shdr
* section
;
19501 unsigned int n
= 0;
19502 bfd_boolean res
= TRUE
;
19504 for (i
= 0, section
= filedata
->section_headers
;
19505 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19508 if (section
->sh_type
== SHT_NOTE
)
19510 if (! process_notes_at (filedata
, section
,
19511 (bfd_vma
) section
->sh_offset
,
19512 (bfd_vma
) section
->sh_size
,
19513 (bfd_vma
) section
->sh_addralign
))
19518 if (( filedata
->file_header
.e_machine
== EM_V800
19519 || filedata
->file_header
.e_machine
== EM_V850
19520 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19521 && section
->sh_type
== SHT_RENESAS_INFO
)
19523 if (! process_v850_notes (filedata
,
19524 (bfd_vma
) section
->sh_offset
,
19525 (bfd_vma
) section
->sh_size
))
19532 /* Try processing NOTE segments instead. */
19533 return process_corefile_note_segments (filedata
);
19539 process_notes (Filedata
* filedata
)
19541 /* If we have not been asked to display the notes then do nothing. */
19545 if (filedata
->file_header
.e_type
!= ET_CORE
)
19546 return process_note_sections (filedata
);
19548 /* No program headers means no NOTE segment. */
19549 if (filedata
->file_header
.e_phnum
> 0)
19550 return process_corefile_note_segments (filedata
);
19552 printf (_("No note segments present in the core file.\n"));
19556 static unsigned char *
19557 display_public_gnu_attributes (unsigned char * start
,
19558 const unsigned char * const end
)
19560 printf (_(" Unknown GNU attribute: %s\n"), start
);
19562 start
+= strnlen ((char *) start
, end
- start
);
19563 display_raw_attribute (start
, end
);
19565 return (unsigned char *) end
;
19568 static unsigned char *
19569 display_generic_attribute (unsigned char * start
,
19571 const unsigned char * const end
)
19574 return (unsigned char *) end
;
19576 return display_tag_value (tag
, start
, end
);
19580 process_arch_specific (Filedata
* filedata
)
19585 switch (filedata
->file_header
.e_machine
)
19588 case EM_ARC_COMPACT
:
19589 case EM_ARC_COMPACT2
:
19590 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19591 display_arc_attribute
,
19592 display_generic_attribute
);
19594 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19595 display_arm_attribute
,
19596 display_generic_attribute
);
19599 case EM_MIPS_RS3_LE
:
19600 return process_mips_specific (filedata
);
19603 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19604 display_msp430x_attribute
,
19605 display_msp430_gnu_attribute
);
19608 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19609 display_riscv_attribute
,
19610 display_generic_attribute
);
19613 return process_nds32_specific (filedata
);
19617 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19618 display_power_gnu_attribute
);
19622 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19623 display_s390_gnu_attribute
);
19626 case EM_SPARC32PLUS
:
19628 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19629 display_sparc_gnu_attribute
);
19632 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19633 display_tic6x_attribute
,
19634 display_generic_attribute
);
19637 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19638 display_public_gnu_attributes
,
19639 display_generic_attribute
);
19644 get_file_header (Filedata
* filedata
)
19646 /* Read in the identity array. */
19647 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19650 /* Determine how to read the rest of the header. */
19651 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19656 byte_get
= byte_get_little_endian
;
19657 byte_put
= byte_put_little_endian
;
19660 byte_get
= byte_get_big_endian
;
19661 byte_put
= byte_put_big_endian
;
19665 /* For now we only support 32 bit and 64 bit ELF files. */
19666 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19668 /* Read in the rest of the header. */
19671 Elf32_External_Ehdr ehdr32
;
19673 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19676 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19677 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19678 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19679 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19680 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19681 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19682 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19683 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19684 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19685 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19686 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19687 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19688 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19692 Elf64_External_Ehdr ehdr64
;
19694 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19695 we will not be able to cope with the 64bit data found in
19696 64 ELF files. Detect this now and abort before we start
19697 overwriting things. */
19698 if (sizeof (bfd_vma
) < 8)
19700 error (_("This instance of readelf has been built without support for a\n\
19701 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19705 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19708 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19709 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19710 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19711 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19712 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19713 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19714 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19715 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19716 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19717 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19718 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19719 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19720 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19723 if (filedata
->file_header
.e_shoff
)
19725 /* There may be some extensions in the first section header. Don't
19726 bomb if we can't read it. */
19728 get_32bit_section_headers (filedata
, TRUE
);
19730 get_64bit_section_headers (filedata
, TRUE
);
19737 close_file (Filedata
* filedata
)
19741 if (filedata
->handle
)
19742 fclose (filedata
->handle
);
19748 close_debug_file (void * data
)
19750 close_file ((Filedata
*) data
);
19754 open_file (const char * pathname
)
19756 struct stat statbuf
;
19757 Filedata
* filedata
= NULL
;
19759 if (stat (pathname
, & statbuf
) < 0
19760 || ! S_ISREG (statbuf
.st_mode
))
19763 filedata
= calloc (1, sizeof * filedata
);
19764 if (filedata
== NULL
)
19767 filedata
->handle
= fopen (pathname
, "rb");
19768 if (filedata
->handle
== NULL
)
19771 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19772 filedata
->file_name
= pathname
;
19774 if (! get_file_header (filedata
))
19777 if (filedata
->file_header
.e_shoff
)
19781 /* Read the section headers again, this time for real. */
19783 res
= get_32bit_section_headers (filedata
, FALSE
);
19785 res
= get_64bit_section_headers (filedata
, FALSE
);
19796 if (filedata
->handle
)
19797 fclose (filedata
->handle
);
19804 open_debug_file (const char * pathname
)
19806 return open_file (pathname
);
19809 /* Process one ELF object file according to the command line options.
19810 This file may actually be stored in an archive. The file is
19811 positioned at the start of the ELF object. Returns TRUE if no
19812 problems were encountered, FALSE otherwise. */
19815 process_object (Filedata
* filedata
)
19817 bfd_boolean have_separate_files
;
19819 bfd_boolean res
= TRUE
;
19821 if (! get_file_header (filedata
))
19823 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19827 /* Initialise per file variables. */
19828 for (i
= ARRAY_SIZE (version_info
); i
--;)
19829 version_info
[i
] = 0;
19831 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19832 dynamic_info
[i
] = 0;
19833 dynamic_info_DT_GNU_HASH
= 0;
19834 dynamic_info_DT_MIPS_XHASH
= 0;
19836 /* Process the file. */
19838 printf (_("\nFile: %s\n"), filedata
->file_name
);
19840 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19841 Note we do this even if cmdline_dump_sects is empty because we
19842 must make sure that the dump_sets array is zeroed out before each
19843 object file is processed. */
19844 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19845 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19847 if (cmdline
.num_dump_sects
> 0)
19849 if (filedata
->num_dump_sects
== 0)
19850 /* A sneaky way of allocating the dump_sects array. */
19851 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19853 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19854 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19855 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19858 if (! process_file_header (filedata
))
19861 if (! process_section_headers (filedata
))
19863 /* Without loaded section headers we cannot process lots of things. */
19864 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19866 if (! do_using_dynamic
)
19867 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19870 if (! process_section_groups (filedata
))
19871 /* Without loaded section groups we cannot process unwind. */
19874 if (process_program_headers (filedata
))
19875 process_dynamic_section (filedata
);
19879 if (! process_relocs (filedata
))
19882 if (! process_unwind (filedata
))
19885 if (! process_symbol_table (filedata
))
19888 if (! process_syminfo (filedata
))
19891 if (! process_version_sections (filedata
))
19894 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19895 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19897 have_separate_files
= FALSE
;
19899 if (! process_section_contents (filedata
))
19902 if (have_separate_files
)
19906 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19908 if (! process_section_headers (d
->handle
))
19910 else if (! process_section_contents (d
->handle
))
19914 /* The file handles are closed by the call to free_debug_memory() below. */
19917 if (! process_notes (filedata
))
19920 if (! process_gnu_liblist (filedata
))
19923 if (! process_arch_specific (filedata
))
19926 free (filedata
->program_headers
);
19927 filedata
->program_headers
= NULL
;
19929 free (filedata
->section_headers
);
19930 filedata
->section_headers
= NULL
;
19932 free (filedata
->string_table
);
19933 filedata
->string_table
= NULL
;
19934 filedata
->string_table_length
= 0;
19936 if (dynamic_strings
)
19938 free (dynamic_strings
);
19939 dynamic_strings
= NULL
;
19940 dynamic_strings_length
= 0;
19943 if (dynamic_symbols
)
19945 free (dynamic_symbols
);
19946 dynamic_symbols
= NULL
;
19947 num_dynamic_syms
= 0;
19950 if (dynamic_syminfo
)
19952 free (dynamic_syminfo
);
19953 dynamic_syminfo
= NULL
;
19956 if (dynamic_section
)
19958 free (dynamic_section
);
19959 dynamic_section
= NULL
;
19962 if (section_headers_groups
)
19964 free (section_headers_groups
);
19965 section_headers_groups
= NULL
;
19968 if (section_groups
)
19970 struct group_list
* g
;
19971 struct group_list
* next
;
19973 for (i
= 0; i
< group_count
; i
++)
19975 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19982 free (section_groups
);
19983 section_groups
= NULL
;
19986 free_debug_memory ();
19991 /* Process an ELF archive.
19992 On entry the file is positioned just after the ARMAG string.
19993 Returns TRUE upon success, FALSE otherwise. */
19996 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19998 struct archive_info arch
;
19999 struct archive_info nested_arch
;
20001 bfd_boolean ret
= TRUE
;
20005 /* The ARCH structure is used to hold information about this archive. */
20006 arch
.file_name
= NULL
;
20008 arch
.index_array
= NULL
;
20009 arch
.sym_table
= NULL
;
20010 arch
.longnames
= NULL
;
20012 /* The NESTED_ARCH structure is used as a single-item cache of information
20013 about a nested archive (when members of a thin archive reside within
20014 another regular archive file). */
20015 nested_arch
.file_name
= NULL
;
20016 nested_arch
.file
= NULL
;
20017 nested_arch
.index_array
= NULL
;
20018 nested_arch
.sym_table
= NULL
;
20019 nested_arch
.longnames
= NULL
;
20021 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20022 is_thin_archive
, do_archive_index
) != 0)
20028 if (do_archive_index
)
20030 if (arch
.sym_table
== NULL
)
20031 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20034 unsigned long i
, l
;
20035 unsigned long current_pos
;
20037 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20038 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20040 current_pos
= ftell (filedata
->handle
);
20042 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20044 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20046 char * member_name
;
20048 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20050 if (member_name
!= NULL
)
20052 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20054 if (qualified_name
!= NULL
)
20056 printf (_("Contents of binary %s at offset "), qualified_name
);
20057 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20059 free (qualified_name
);
20064 if (l
>= arch
.sym_size
)
20066 error (_("%s: end of the symbol table reached before the end of the index\n"),
20067 filedata
->file_name
);
20071 /* PR 17531: file: 0b6630b2. */
20072 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20073 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20076 if (arch
.uses_64bit_indices
)
20081 if (l
< arch
.sym_size
)
20083 error (ngettext ("%s: %ld byte remains in the symbol table, "
20084 "but without corresponding entries in "
20085 "the index table\n",
20086 "%s: %ld bytes remain in the symbol table, "
20087 "but without corresponding entries in "
20088 "the index table\n",
20089 arch
.sym_size
- l
),
20090 filedata
->file_name
, arch
.sym_size
- l
);
20094 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20096 error (_("%s: failed to seek back to start of object files in the archive\n"),
20097 filedata
->file_name
);
20103 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20104 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20105 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20106 && !do_section_groups
&& !do_dyn_syms
)
20108 ret
= TRUE
; /* Archive index only. */
20117 char * qualified_name
;
20119 /* Read the next archive header. */
20120 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20122 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20125 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20126 if (got
!= sizeof arch
.arhdr
)
20130 /* PR 24049 - we cannot use filedata->file_name as this will
20131 have already been freed. */
20132 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20137 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20139 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20144 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20146 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20147 if (archive_file_size
& 01)
20148 ++archive_file_size
;
20150 name
= get_archive_member_name (&arch
, &nested_arch
);
20153 error (_("%s: bad archive file name\n"), arch
.file_name
);
20157 namelen
= strlen (name
);
20159 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20160 if (qualified_name
== NULL
)
20162 error (_("%s: bad archive file name\n"), arch
.file_name
);
20167 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20169 /* This is a proxy for an external member of a thin archive. */
20170 Filedata
* member_filedata
;
20171 char * member_file_name
= adjust_relative_path
20172 (filedata
->file_name
, name
, namelen
);
20174 if (member_file_name
== NULL
)
20180 member_filedata
= open_file (member_file_name
);
20181 if (member_filedata
== NULL
)
20183 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20184 free (member_file_name
);
20189 archive_file_offset
= arch
.nested_member_origin
;
20190 member_filedata
->file_name
= qualified_name
;
20192 if (! process_object (member_filedata
))
20195 close_file (member_filedata
);
20196 free (member_file_name
);
20198 else if (is_thin_archive
)
20200 Filedata thin_filedata
;
20202 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20204 /* PR 15140: Allow for corrupt thin archives. */
20205 if (nested_arch
.file
== NULL
)
20207 error (_("%s: contains corrupt thin archive: %s\n"),
20208 qualified_name
, name
);
20213 /* This is a proxy for a member of a nested archive. */
20214 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20216 /* The nested archive file will have been opened and setup by
20217 get_archive_member_name. */
20218 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20220 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20225 thin_filedata
.handle
= nested_arch
.file
;
20226 thin_filedata
.file_name
= qualified_name
;
20228 if (! process_object (& thin_filedata
))
20233 archive_file_offset
= arch
.next_arhdr_offset
;
20234 arch
.next_arhdr_offset
+= archive_file_size
;
20236 filedata
->file_name
= qualified_name
;
20237 if (! process_object (filedata
))
20241 if (filedata
->dump_sects
!= NULL
)
20243 free (filedata
->dump_sects
);
20244 filedata
->dump_sects
= NULL
;
20245 filedata
->num_dump_sects
= 0;
20248 free (qualified_name
);
20252 if (nested_arch
.file
!= NULL
)
20253 fclose (nested_arch
.file
);
20254 release_archive (&nested_arch
);
20255 release_archive (&arch
);
20261 process_file (char * file_name
)
20263 Filedata
* filedata
= NULL
;
20264 struct stat statbuf
;
20265 char armag
[SARMAG
];
20266 bfd_boolean ret
= TRUE
;
20268 if (stat (file_name
, &statbuf
) < 0)
20270 if (errno
== ENOENT
)
20271 error (_("'%s': No such file\n"), file_name
);
20273 error (_("Could not locate '%s'. System error message: %s\n"),
20274 file_name
, strerror (errno
));
20278 if (! S_ISREG (statbuf
.st_mode
))
20280 error (_("'%s' is not an ordinary file\n"), file_name
);
20284 filedata
= calloc (1, sizeof * filedata
);
20285 if (filedata
== NULL
)
20287 error (_("Out of memory allocating file data structure\n"));
20291 filedata
->file_name
= file_name
;
20292 filedata
->handle
= fopen (file_name
, "rb");
20293 if (filedata
->handle
== NULL
)
20295 error (_("Input file '%s' is not readable.\n"), file_name
);
20300 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20302 error (_("%s: Failed to read file's magic number\n"), file_name
);
20303 fclose (filedata
->handle
);
20308 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20310 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20312 if (! process_archive (filedata
, FALSE
))
20315 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20317 if ( ! process_archive (filedata
, TRUE
))
20322 if (do_archive_index
)
20323 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20326 rewind (filedata
->handle
);
20327 archive_file_size
= archive_file_offset
= 0;
20329 if (! process_object (filedata
))
20333 fclose (filedata
->handle
);
20339 #ifdef SUPPORT_DISASSEMBLY
20340 /* Needed by the i386 disassembler. For extra credit, someone could
20341 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20345 print_address (unsigned int addr
, FILE * outfile
)
20347 fprintf (outfile
,"0x%8.8x", addr
);
20350 /* Needed by the i386 disassembler. */
20353 db_task_printsym (unsigned int addr
)
20355 print_address (addr
, stderr
);
20360 main (int argc
, char ** argv
)
20364 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20365 setlocale (LC_MESSAGES
, "");
20367 #if defined (HAVE_SETLOCALE)
20368 setlocale (LC_CTYPE
, "");
20370 bindtextdomain (PACKAGE
, LOCALEDIR
);
20371 textdomain (PACKAGE
);
20373 expandargv (&argc
, &argv
);
20375 cmdline
.file_name
= "<cmdline>";
20376 parse_args (& cmdline
, argc
, argv
);
20378 if (optind
< (argc
- 1))
20380 else if (optind
>= argc
)
20382 warn (_("Nothing to do.\n"));
20387 while (optind
< argc
)
20388 if (! process_file (argv
[optind
++]))
20391 if (cmdline
.dump_sects
!= NULL
)
20392 free (cmdline
.dump_sects
);
20394 free (dump_ctf_symtab_name
);
20395 free (dump_ctf_strtab_name
);
20396 free (dump_ctf_parent_name
);
20398 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;