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 (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
++)
5265 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5266 && (filedata
->program_headers
[j
].p_vaddr
5267 + filedata
->program_headers
[j
].p_memsz
)
5268 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5270 if (j
== filedata
->file_header
.e_phnum
)
5271 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5277 error (_("more than one dynamic segment\n"));
5279 /* By default, assume that the .dynamic section is the first
5280 section in the DYNAMIC segment. */
5281 dynamic_addr
= segment
->p_offset
;
5282 dynamic_size
= segment
->p_filesz
;
5284 /* Try to locate the .dynamic section. If there is
5285 a section header table, we can easily locate it. */
5286 if (filedata
->section_headers
!= NULL
)
5288 Elf_Internal_Shdr
* sec
;
5290 sec
= find_section (filedata
, ".dynamic");
5291 if (sec
== NULL
|| sec
->sh_size
== 0)
5293 /* A corresponding .dynamic section is expected, but on
5294 IA-64/OpenVMS it is OK for it to be missing. */
5295 if (!is_ia64_vms (filedata
))
5296 error (_("no .dynamic section in the dynamic segment\n"));
5300 if (sec
->sh_type
== SHT_NOBITS
)
5306 dynamic_addr
= sec
->sh_offset
;
5307 dynamic_size
= sec
->sh_size
;
5309 if (dynamic_addr
< segment
->p_offset
5310 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5311 warn (_("the .dynamic section is not contained"
5312 " within the dynamic segment\n"));
5313 else if (dynamic_addr
> segment
->p_offset
)
5314 warn (_("the .dynamic section is not the first section"
5315 " in the dynamic segment.\n"));
5318 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5319 segment. Check this after matching against the section headers
5320 so we don't warn on debuginfo file (which have NOBITS .dynamic
5322 if (dynamic_addr
> filedata
->file_size
5323 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5325 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5326 dynamic_addr
= dynamic_size
= 0;
5331 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5333 error (_("Unable to find program interpreter name\n"));
5337 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5339 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5340 error (_("Internal error: failed to create format string to display program interpreter\n"));
5342 program_interpreter
[0] = 0;
5343 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5344 error (_("Unable to read program interpreter name\n"));
5347 printf (_(" [Requesting program interpreter: %s]\n"),
5348 program_interpreter
);
5355 && filedata
->section_headers
!= NULL
5356 && filedata
->string_table
!= NULL
)
5358 printf (_("\n Section to Segment mapping:\n"));
5359 printf (_(" Segment Sections...\n"));
5361 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5364 Elf_Internal_Shdr
* section
;
5366 segment
= filedata
->program_headers
+ i
;
5367 section
= filedata
->section_headers
+ 1;
5369 printf (" %2.2d ", i
);
5371 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5373 if (!ELF_TBSS_SPECIAL (section
, segment
)
5374 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5375 printf ("%s ", printable_section_name (filedata
, section
));
5386 /* Find the file offset corresponding to VMA by using the program headers. */
5389 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5391 Elf_Internal_Phdr
* seg
;
5393 if (! get_program_headers (filedata
))
5395 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5399 for (seg
= filedata
->program_headers
;
5400 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5403 if (seg
->p_type
!= PT_LOAD
)
5406 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5407 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5408 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5411 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5412 (unsigned long) vma
);
5417 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5418 If PROBE is true, this is just a probe and we do not generate any error
5419 messages if the load fails. */
5422 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5424 Elf32_External_Shdr
* shdrs
;
5425 Elf_Internal_Shdr
* internal
;
5427 unsigned int size
= filedata
->file_header
.e_shentsize
;
5428 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5430 /* PR binutils/17531: Cope with unexpected section header sizes. */
5431 if (size
== 0 || num
== 0)
5433 if (size
< sizeof * shdrs
)
5436 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5439 if (!probe
&& size
> sizeof * shdrs
)
5440 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5442 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5444 probe
? NULL
: _("section headers"));
5448 free (filedata
->section_headers
);
5449 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5450 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5451 if (filedata
->section_headers
== NULL
)
5454 error (_("Out of memory reading %u section headers\n"), num
);
5459 for (i
= 0, internal
= filedata
->section_headers
;
5463 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5464 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5465 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5466 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5467 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5468 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5469 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5470 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5471 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5472 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5473 if (!probe
&& internal
->sh_link
> num
)
5474 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5475 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5476 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5483 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5486 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5488 Elf64_External_Shdr
* shdrs
;
5489 Elf_Internal_Shdr
* internal
;
5491 unsigned int size
= filedata
->file_header
.e_shentsize
;
5492 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5494 /* PR binutils/17531: Cope with unexpected section header sizes. */
5495 if (size
== 0 || num
== 0)
5498 if (size
< sizeof * shdrs
)
5501 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5505 if (! probe
&& size
> sizeof * shdrs
)
5506 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5508 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5509 filedata
->file_header
.e_shoff
,
5511 probe
? NULL
: _("section headers"));
5515 free (filedata
->section_headers
);
5516 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5517 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5518 if (filedata
->section_headers
== NULL
)
5521 error (_("Out of memory reading %u section headers\n"), num
);
5526 for (i
= 0, internal
= filedata
->section_headers
;
5530 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5531 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5532 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5533 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5534 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5535 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5536 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5537 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5538 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5539 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5540 if (!probe
&& internal
->sh_link
> num
)
5541 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5542 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5543 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5550 static Elf_Internal_Sym
*
5551 get_32bit_elf_symbols (Filedata
* filedata
,
5552 Elf_Internal_Shdr
* section
,
5553 unsigned long * num_syms_return
)
5555 unsigned long number
= 0;
5556 Elf32_External_Sym
* esyms
= NULL
;
5557 Elf_External_Sym_Shndx
* shndx
= NULL
;
5558 Elf_Internal_Sym
* isyms
= NULL
;
5559 Elf_Internal_Sym
* psym
;
5561 elf_section_list
* entry
;
5563 if (section
->sh_size
== 0)
5565 if (num_syms_return
!= NULL
)
5566 * num_syms_return
= 0;
5570 /* Run some sanity checks first. */
5571 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5573 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5574 printable_section_name (filedata
, section
),
5575 (unsigned long) section
->sh_entsize
);
5579 if (section
->sh_size
> filedata
->file_size
)
5581 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5582 printable_section_name (filedata
, section
),
5583 (unsigned long) section
->sh_size
);
5587 number
= section
->sh_size
/ section
->sh_entsize
;
5589 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5591 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5592 (unsigned long) section
->sh_size
,
5593 printable_section_name (filedata
, section
),
5594 (unsigned long) section
->sh_entsize
);
5598 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5599 section
->sh_size
, _("symbols"));
5604 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5606 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5611 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5615 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5616 entry
->hdr
->sh_offset
,
5617 1, entry
->hdr
->sh_size
,
5618 _("symbol table section indices"));
5622 /* PR17531: file: heap-buffer-overflow */
5623 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5625 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5626 printable_section_name (filedata
, entry
->hdr
),
5627 (unsigned long) entry
->hdr
->sh_size
,
5628 (unsigned long) section
->sh_size
);
5633 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5637 error (_("Out of memory reading %lu symbols\n"),
5638 (unsigned long) number
);
5642 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5644 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5645 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5646 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5647 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5648 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5650 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5651 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5652 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5653 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5654 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5661 if (num_syms_return
!= NULL
)
5662 * num_syms_return
= isyms
== NULL
? 0 : number
;
5667 static Elf_Internal_Sym
*
5668 get_64bit_elf_symbols (Filedata
* filedata
,
5669 Elf_Internal_Shdr
* section
,
5670 unsigned long * num_syms_return
)
5672 unsigned long number
= 0;
5673 Elf64_External_Sym
* esyms
= NULL
;
5674 Elf_External_Sym_Shndx
* shndx
= NULL
;
5675 Elf_Internal_Sym
* isyms
= NULL
;
5676 Elf_Internal_Sym
* psym
;
5678 elf_section_list
* entry
;
5680 if (section
->sh_size
== 0)
5682 if (num_syms_return
!= NULL
)
5683 * num_syms_return
= 0;
5687 /* Run some sanity checks first. */
5688 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5690 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5691 printable_section_name (filedata
, section
),
5692 (unsigned long) section
->sh_entsize
);
5696 if (section
->sh_size
> filedata
->file_size
)
5698 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5699 printable_section_name (filedata
, section
),
5700 (unsigned long) section
->sh_size
);
5704 number
= section
->sh_size
/ section
->sh_entsize
;
5706 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5708 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5709 (unsigned long) section
->sh_size
,
5710 printable_section_name (filedata
, section
),
5711 (unsigned long) section
->sh_entsize
);
5715 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5716 section
->sh_size
, _("symbols"));
5721 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5723 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5728 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5732 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5733 entry
->hdr
->sh_offset
,
5734 1, entry
->hdr
->sh_size
,
5735 _("symbol table section indices"));
5739 /* PR17531: file: heap-buffer-overflow */
5740 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5742 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5743 printable_section_name (filedata
, entry
->hdr
),
5744 (unsigned long) entry
->hdr
->sh_size
,
5745 (unsigned long) section
->sh_size
);
5750 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5754 error (_("Out of memory reading %lu symbols\n"),
5755 (unsigned long) number
);
5759 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5761 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5762 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5763 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5764 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5766 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5768 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5769 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5770 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5772 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5773 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5780 if (num_syms_return
!= NULL
)
5781 * num_syms_return
= isyms
== NULL
? 0 : number
;
5787 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5789 static char buff
[1024];
5791 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5793 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5794 bfd_vma os_flags
= 0;
5795 bfd_vma proc_flags
= 0;
5796 bfd_vma unknown_flags
= 0;
5804 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5805 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5806 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5807 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5808 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5809 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5810 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5811 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5812 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5813 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5814 /* IA-64 specific. */
5815 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5816 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5817 /* IA-64 OpenVMS specific. */
5818 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5819 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5820 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5821 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5822 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5823 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5825 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5826 /* SPARC specific. */
5827 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5828 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5830 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5831 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5832 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5834 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5836 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5839 if (do_section_details
)
5841 sprintf (buff
, "[%*.*lx]: ",
5842 field_size
, field_size
, (unsigned long) sh_flags
);
5843 p
+= field_size
+ 4;
5850 flag
= sh_flags
& - sh_flags
;
5853 if (do_section_details
)
5857 case SHF_WRITE
: sindex
= 0; break;
5858 case SHF_ALLOC
: sindex
= 1; break;
5859 case SHF_EXECINSTR
: sindex
= 2; break;
5860 case SHF_MERGE
: sindex
= 3; break;
5861 case SHF_STRINGS
: sindex
= 4; break;
5862 case SHF_INFO_LINK
: sindex
= 5; break;
5863 case SHF_LINK_ORDER
: sindex
= 6; break;
5864 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5865 case SHF_GROUP
: sindex
= 8; break;
5866 case SHF_TLS
: sindex
= 9; break;
5867 case SHF_EXCLUDE
: sindex
= 18; break;
5868 case SHF_COMPRESSED
: sindex
= 20; break;
5869 case SHF_GNU_MBIND
: sindex
= 24; break;
5873 switch (filedata
->file_header
.e_machine
)
5876 if (flag
== SHF_IA_64_SHORT
)
5878 else if (flag
== SHF_IA_64_NORECOV
)
5881 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5884 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5885 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5886 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5887 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5888 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5889 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5900 case EM_OLD_SPARCV9
:
5901 case EM_SPARC32PLUS
:
5904 if (flag
== SHF_ORDERED
)
5911 case SHF_ENTRYSECT
: sindex
= 21; break;
5912 case SHF_ARM_PURECODE
: sindex
= 22; break;
5913 case SHF_COMDEF
: sindex
= 23; break;
5918 if (flag
== SHF_PPC_VLE
)
5929 if (p
!= buff
+ field_size
+ 4)
5931 if (size
< (10 + 2))
5933 warn (_("Internal error: not enough buffer room for section flag info"));
5934 return _("<unknown>");
5941 size
-= flags
[sindex
].len
;
5942 p
= stpcpy (p
, flags
[sindex
].str
);
5944 else if (flag
& SHF_MASKOS
)
5946 else if (flag
& SHF_MASKPROC
)
5949 unknown_flags
|= flag
;
5955 case SHF_WRITE
: *p
= 'W'; break;
5956 case SHF_ALLOC
: *p
= 'A'; break;
5957 case SHF_EXECINSTR
: *p
= 'X'; break;
5958 case SHF_MERGE
: *p
= 'M'; break;
5959 case SHF_STRINGS
: *p
= 'S'; break;
5960 case SHF_INFO_LINK
: *p
= 'I'; break;
5961 case SHF_LINK_ORDER
: *p
= 'L'; break;
5962 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5963 case SHF_GROUP
: *p
= 'G'; break;
5964 case SHF_TLS
: *p
= 'T'; break;
5965 case SHF_EXCLUDE
: *p
= 'E'; break;
5966 case SHF_COMPRESSED
: *p
= 'C'; break;
5967 case SHF_GNU_MBIND
: *p
= 'D'; break;
5970 if ((filedata
->file_header
.e_machine
== EM_X86_64
5971 || filedata
->file_header
.e_machine
== EM_L1OM
5972 || filedata
->file_header
.e_machine
== EM_K1OM
)
5973 && flag
== SHF_X86_64_LARGE
)
5975 else if (filedata
->file_header
.e_machine
== EM_ARM
5976 && flag
== SHF_ARM_PURECODE
)
5978 else if (filedata
->file_header
.e_machine
== EM_PPC
5979 && flag
== SHF_PPC_VLE
)
5981 else if (flag
& SHF_MASKOS
)
5984 sh_flags
&= ~ SHF_MASKOS
;
5986 else if (flag
& SHF_MASKPROC
)
5989 sh_flags
&= ~ SHF_MASKPROC
;
5999 if (do_section_details
)
6003 size
-= 5 + field_size
;
6004 if (p
!= buff
+ field_size
+ 4)
6008 warn (_("Internal error: not enough buffer room for section flag info"));
6009 return _("<unknown>");
6015 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6016 (unsigned long) os_flags
);
6017 p
+= 5 + field_size
;
6021 size
-= 7 + field_size
;
6022 if (p
!= buff
+ field_size
+ 4)
6026 warn (_("Internal error: not enough buffer room for section flag info"));
6027 return _("<unknown>");
6033 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6034 (unsigned long) proc_flags
);
6035 p
+= 7 + field_size
;
6039 size
-= 10 + field_size
;
6040 if (p
!= buff
+ field_size
+ 4)
6044 warn (_("Internal error: not enough buffer room for section flag info"));
6045 return _("<unknown>");
6051 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6052 (unsigned long) unknown_flags
);
6053 p
+= 10 + field_size
;
6062 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6066 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6068 if (size
< sizeof (* echdr
))
6070 error (_("Compressed section is too small even for a compression header\n"));
6074 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6075 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6076 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6077 return sizeof (*echdr
);
6081 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6083 if (size
< sizeof (* echdr
))
6085 error (_("Compressed section is too small even for a compression header\n"));
6089 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6090 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6091 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6092 return sizeof (*echdr
);
6097 process_section_headers (Filedata
* filedata
)
6099 Elf_Internal_Shdr
* section
;
6102 filedata
->section_headers
= NULL
;
6104 if (filedata
->file_header
.e_shnum
== 0)
6106 /* PR binutils/12467. */
6107 if (filedata
->file_header
.e_shoff
!= 0)
6109 warn (_("possibly corrupt ELF file header - it has a non-zero"
6110 " section header offset, but no section headers\n"));
6113 else if (do_sections
)
6114 printf (_("\nThere are no sections in this file.\n"));
6119 if (do_sections
&& !do_header
)
6120 printf (ngettext ("There is %d section header, "
6121 "starting at offset 0x%lx:\n",
6122 "There are %d section headers, "
6123 "starting at offset 0x%lx:\n",
6124 filedata
->file_header
.e_shnum
),
6125 filedata
->file_header
.e_shnum
,
6126 (unsigned long) filedata
->file_header
.e_shoff
);
6130 if (! get_32bit_section_headers (filedata
, FALSE
))
6135 if (! get_64bit_section_headers (filedata
, FALSE
))
6139 /* Read in the string table, so that we have names to display. */
6140 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6141 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6143 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6145 if (section
->sh_size
!= 0)
6147 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6148 1, section
->sh_size
,
6151 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6155 /* Scan the sections for the dynamic symbol table
6156 and dynamic string table and debug sections. */
6157 dynamic_symbols
= NULL
;
6158 dynamic_strings
= NULL
;
6159 dynamic_syminfo
= NULL
;
6160 symtab_shndx_list
= NULL
;
6162 eh_addr_size
= is_32bit_elf
? 4 : 8;
6163 switch (filedata
->file_header
.e_machine
)
6166 case EM_MIPS_RS3_LE
:
6167 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6168 FDE addresses. However, the ABI also has a semi-official ILP32
6169 variant for which the normal FDE address size rules apply.
6171 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6172 section, where XX is the size of longs in bits. Unfortunately,
6173 earlier compilers provided no way of distinguishing ILP32 objects
6174 from LP64 objects, so if there's any doubt, we should assume that
6175 the official LP64 form is being used. */
6176 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6177 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6183 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6185 case E_H8_MACH_H8300
:
6186 case E_H8_MACH_H8300HN
:
6187 case E_H8_MACH_H8300SN
:
6188 case E_H8_MACH_H8300SXN
:
6191 case E_H8_MACH_H8300H
:
6192 case E_H8_MACH_H8300S
:
6193 case E_H8_MACH_H8300SX
:
6201 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6203 case EF_M32C_CPU_M16C
:
6210 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6213 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6214 if (section->sh_entsize != expected_entsize) \
6217 sprintf_vma (buf, section->sh_entsize); \
6218 /* Note: coded this way so that there is a single string for \
6220 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6221 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6222 (unsigned) expected_entsize); \
6223 section->sh_entsize = expected_entsize; \
6228 #define CHECK_ENTSIZE(section, i, type) \
6229 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6230 sizeof (Elf64_External_##type))
6232 for (i
= 0, section
= filedata
->section_headers
;
6233 i
< filedata
->file_header
.e_shnum
;
6236 char * name
= SECTION_NAME (section
);
6238 if (section
->sh_type
== SHT_DYNSYM
)
6240 if (dynamic_symbols
!= NULL
)
6242 error (_("File contains multiple dynamic symbol tables\n"));
6246 CHECK_ENTSIZE (section
, i
, Sym
);
6247 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6249 else if (section
->sh_type
== SHT_STRTAB
6250 && streq (name
, ".dynstr"))
6252 if (dynamic_strings
!= NULL
)
6254 error (_("File contains multiple dynamic string tables\n"));
6258 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6259 1, section
->sh_size
,
6260 _("dynamic strings"));
6261 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6263 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6265 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6267 entry
->hdr
= section
;
6268 entry
->next
= symtab_shndx_list
;
6269 symtab_shndx_list
= entry
;
6271 else if (section
->sh_type
== SHT_SYMTAB
)
6272 CHECK_ENTSIZE (section
, i
, Sym
);
6273 else if (section
->sh_type
== SHT_GROUP
)
6274 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6275 else if (section
->sh_type
== SHT_REL
)
6276 CHECK_ENTSIZE (section
, i
, Rel
);
6277 else if (section
->sh_type
== SHT_RELA
)
6278 CHECK_ENTSIZE (section
, i
, Rela
);
6279 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6280 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6281 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6282 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6283 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6284 && (const_strneq (name
, ".debug_")
6285 || const_strneq (name
, ".zdebug_")))
6288 name
+= sizeof (".zdebug_") - 1;
6290 name
+= sizeof (".debug_") - 1;
6293 || (do_debug_info
&& const_strneq (name
, "info"))
6294 || (do_debug_info
&& const_strneq (name
, "types"))
6295 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6296 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6297 || (do_debug_lines
&& const_strneq (name
, "line."))
6298 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6299 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6300 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6301 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6302 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6303 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6304 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6305 || (do_debug_frames
&& const_strneq (name
, "frame"))
6306 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6307 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6308 || (do_debug_str
&& const_strneq (name
, "str"))
6309 || (do_debug_loc
&& const_strneq (name
, "loc"))
6310 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6311 || (do_debug_addr
&& const_strneq (name
, "addr"))
6312 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6313 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6315 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6317 /* Linkonce section to be combined with .debug_info at link time. */
6318 else if ((do_debugging
|| do_debug_info
)
6319 && const_strneq (name
, ".gnu.linkonce.wi."))
6320 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6321 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6322 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6323 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6324 || streq (name
, ".debug_names")))
6325 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6326 /* Trace sections for Itanium VMS. */
6327 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6328 || do_trace_aranges
)
6329 && const_strneq (name
, ".trace_"))
6331 name
+= sizeof (".trace_") - 1;
6334 || (do_trace_info
&& streq (name
, "info"))
6335 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6336 || (do_trace_aranges
&& streq (name
, "aranges"))
6338 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6340 else if ((do_debugging
|| do_debug_links
)
6341 && (const_strneq (name
, ".gnu_debuglink")
6342 || const_strneq (name
, ".gnu_debugaltlink")))
6343 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6349 if (filedata
->file_header
.e_shnum
> 1)
6350 printf (_("\nSection Headers:\n"));
6352 printf (_("\nSection Header:\n"));
6356 if (do_section_details
)
6358 printf (_(" [Nr] Name\n"));
6359 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6363 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6367 if (do_section_details
)
6369 printf (_(" [Nr] Name\n"));
6370 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6374 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6378 if (do_section_details
)
6380 printf (_(" [Nr] Name\n"));
6381 printf (_(" Type Address Offset Link\n"));
6382 printf (_(" Size EntSize Info Align\n"));
6386 printf (_(" [Nr] Name Type Address Offset\n"));
6387 printf (_(" Size EntSize Flags Link Info Align\n"));
6391 if (do_section_details
)
6392 printf (_(" Flags\n"));
6394 for (i
= 0, section
= filedata
->section_headers
;
6395 i
< filedata
->file_header
.e_shnum
;
6398 /* Run some sanity checks on the section header. */
6400 /* Check the sh_link field. */
6401 switch (section
->sh_type
)
6405 if (section
->sh_link
== 0
6406 && (filedata
->file_header
.e_type
== ET_EXEC
6407 || filedata
->file_header
.e_type
== ET_DYN
))
6408 /* A dynamic relocation section where all entries use a
6409 zero symbol index need not specify a symtab section. */
6412 case SHT_SYMTAB_SHNDX
:
6416 case SHT_GNU_versym
:
6417 if (section
->sh_link
== 0
6418 || section
->sh_link
>= filedata
->file_header
.e_shnum
6419 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6420 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6421 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6422 i
, section
->sh_link
);
6428 case SHT_GNU_verneed
:
6429 case SHT_GNU_verdef
:
6430 case SHT_GNU_LIBLIST
:
6431 if (section
->sh_link
== 0
6432 || section
->sh_link
>= filedata
->file_header
.e_shnum
6433 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6434 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6435 i
, section
->sh_link
);
6438 case SHT_INIT_ARRAY
:
6439 case SHT_FINI_ARRAY
:
6440 case SHT_PREINIT_ARRAY
:
6441 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6442 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6443 i
, section
->sh_link
);
6447 /* FIXME: Add support for target specific section types. */
6448 #if 0 /* Currently we do not check other section types as there are too
6449 many special cases. Stab sections for example have a type
6450 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6452 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6453 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6454 i
, section
->sh_link
);
6459 /* Check the sh_info field. */
6460 switch (section
->sh_type
)
6464 if (section
->sh_info
== 0
6465 && (filedata
->file_header
.e_type
== ET_EXEC
6466 || filedata
->file_header
.e_type
== ET_DYN
))
6467 /* Dynamic relocations apply to segments, so they do not
6468 need to specify the section they relocate. */
6470 if (section
->sh_info
== 0
6471 || section
->sh_info
>= filedata
->file_header
.e_shnum
6472 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6473 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6474 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6475 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6476 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6477 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6478 /* FIXME: Are other section types valid ? */
6479 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6480 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6481 i
, section
->sh_info
);
6486 case SHT_SYMTAB_SHNDX
:
6487 case SHT_INIT_ARRAY
:
6488 case SHT_FINI_ARRAY
:
6489 case SHT_PREINIT_ARRAY
:
6490 if (section
->sh_info
!= 0)
6491 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6492 i
, section
->sh_info
);
6498 /* A symbol index - we assume that it is valid. */
6502 /* FIXME: Add support for target specific section types. */
6503 if (section
->sh_type
== SHT_NOBITS
)
6504 /* NOBITS section headers with non-zero sh_info fields can be
6505 created when a binary is stripped of everything but its debug
6506 information. The stripped sections have their headers
6507 preserved but their types set to SHT_NOBITS. So do not check
6508 this type of section. */
6510 else if (section
->sh_flags
& SHF_INFO_LINK
)
6512 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6513 warn (_("[%2u]: Expected link to another section in info field"), i
);
6515 else if (section
->sh_type
< SHT_LOOS
6516 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6517 && section
->sh_info
!= 0)
6518 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6519 i
, section
->sh_info
);
6523 /* Check the sh_size field. */
6524 if (section
->sh_size
> filedata
->file_size
6525 && section
->sh_type
!= SHT_NOBITS
6526 && section
->sh_type
!= SHT_NULL
6527 && section
->sh_type
< SHT_LOOS
)
6528 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6530 printf (" [%2u] ", i
);
6531 if (do_section_details
)
6532 printf ("%s\n ", printable_section_name (filedata
, section
));
6534 print_symbol (-17, SECTION_NAME (section
));
6536 printf (do_wide
? " %-15s " : " %-15.15s ",
6537 get_section_type_name (filedata
, section
->sh_type
));
6541 const char * link_too_big
= NULL
;
6543 print_vma (section
->sh_addr
, LONG_HEX
);
6545 printf ( " %6.6lx %6.6lx %2.2lx",
6546 (unsigned long) section
->sh_offset
,
6547 (unsigned long) section
->sh_size
,
6548 (unsigned long) section
->sh_entsize
);
6550 if (do_section_details
)
6551 fputs (" ", stdout
);
6553 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6555 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6558 /* The sh_link value is out of range. Normally this indicates
6559 an error but it can have special values in Solaris binaries. */
6560 switch (filedata
->file_header
.e_machine
)
6567 case EM_OLD_SPARCV9
:
6568 case EM_SPARC32PLUS
:
6571 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6572 link_too_big
= "BEFORE";
6573 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6574 link_too_big
= "AFTER";
6581 if (do_section_details
)
6583 if (link_too_big
!= NULL
&& * link_too_big
)
6584 printf ("<%s> ", link_too_big
);
6586 printf ("%2u ", section
->sh_link
);
6587 printf ("%3u %2lu\n", section
->sh_info
,
6588 (unsigned long) section
->sh_addralign
);
6591 printf ("%2u %3u %2lu\n",
6594 (unsigned long) section
->sh_addralign
);
6596 if (link_too_big
&& ! * link_too_big
)
6597 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6598 i
, section
->sh_link
);
6602 print_vma (section
->sh_addr
, LONG_HEX
);
6604 if ((long) section
->sh_offset
== section
->sh_offset
)
6605 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6609 print_vma (section
->sh_offset
, LONG_HEX
);
6612 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6613 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6617 print_vma (section
->sh_size
, LONG_HEX
);
6620 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6621 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6625 print_vma (section
->sh_entsize
, LONG_HEX
);
6628 if (do_section_details
)
6629 fputs (" ", stdout
);
6631 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6633 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6635 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6636 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6639 print_vma (section
->sh_addralign
, DEC
);
6643 else if (do_section_details
)
6646 print_vma (section
->sh_addr
, LONG_HEX
);
6647 if ((long) section
->sh_offset
== section
->sh_offset
)
6648 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6652 print_vma (section
->sh_offset
, LONG_HEX
);
6654 printf (" %u\n ", section
->sh_link
);
6655 print_vma (section
->sh_size
, LONG_HEX
);
6657 print_vma (section
->sh_entsize
, LONG_HEX
);
6659 printf (" %-16u %lu\n",
6661 (unsigned long) section
->sh_addralign
);
6666 print_vma (section
->sh_addr
, LONG_HEX
);
6667 if ((long) section
->sh_offset
== section
->sh_offset
)
6668 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6672 print_vma (section
->sh_offset
, LONG_HEX
);
6675 print_vma (section
->sh_size
, LONG_HEX
);
6677 print_vma (section
->sh_entsize
, LONG_HEX
);
6679 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6681 printf (" %2u %3u %lu\n",
6684 (unsigned long) section
->sh_addralign
);
6687 if (do_section_details
)
6689 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6690 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6692 /* Minimum section size is 12 bytes for 32-bit compression
6693 header + 12 bytes for compressed data header. */
6694 unsigned char buf
[24];
6696 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6697 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6698 sizeof (buf
), _("compression header")))
6700 Elf_Internal_Chdr chdr
;
6702 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6704 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6707 printf (_(" [<unknown>: 0x%x], "),
6709 print_vma (chdr
.ch_size
, LONG_HEX
);
6710 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6716 if (!do_section_details
)
6718 /* The ordering of the letters shown here matches the ordering of the
6719 corresponding SHF_xxx values, and hence the order in which these
6720 letters will be displayed to the user. */
6721 printf (_("Key to Flags:\n\
6722 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6723 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6724 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6725 if (filedata
->file_header
.e_machine
== EM_X86_64
6726 || filedata
->file_header
.e_machine
== EM_L1OM
6727 || filedata
->file_header
.e_machine
== EM_K1OM
)
6728 printf (_("l (large), "));
6729 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6730 printf (_("y (purecode), "));
6731 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6732 printf (_("v (VLE), "));
6733 printf ("p (processor specific)\n");
6740 get_group_flags (unsigned int flags
)
6742 static char buff
[128];
6746 else if (flags
== GRP_COMDAT
)
6749 snprintf (buff
, 14, _("[0x%x: "), flags
);
6751 flags
&= ~ GRP_COMDAT
;
6752 if (flags
& GRP_MASKOS
)
6754 strcat (buff
, "<OS specific>");
6755 flags
&= ~ GRP_MASKOS
;
6758 if (flags
& GRP_MASKPROC
)
6760 strcat (buff
, "<PROC specific>");
6761 flags
&= ~ GRP_MASKPROC
;
6765 strcat (buff
, "<unknown>");
6772 process_section_groups (Filedata
* filedata
)
6774 Elf_Internal_Shdr
* section
;
6776 struct group
* group
;
6777 Elf_Internal_Shdr
* symtab_sec
;
6778 Elf_Internal_Shdr
* strtab_sec
;
6779 Elf_Internal_Sym
* symtab
;
6780 unsigned long num_syms
;
6784 /* Don't process section groups unless needed. */
6785 if (!do_unwind
&& !do_section_groups
)
6788 if (filedata
->file_header
.e_shnum
== 0)
6790 if (do_section_groups
)
6791 printf (_("\nThere are no sections to group in this file.\n"));
6796 if (filedata
->section_headers
== NULL
)
6798 error (_("Section headers are not available!\n"));
6799 /* PR 13622: This can happen with a corrupt ELF header. */
6803 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6804 sizeof (struct group
*));
6806 if (section_headers_groups
== NULL
)
6808 error (_("Out of memory reading %u section group headers\n"),
6809 filedata
->file_header
.e_shnum
);
6813 /* Scan the sections for the group section. */
6815 for (i
= 0, section
= filedata
->section_headers
;
6816 i
< filedata
->file_header
.e_shnum
;
6818 if (section
->sh_type
== SHT_GROUP
)
6821 if (group_count
== 0)
6823 if (do_section_groups
)
6824 printf (_("\nThere are no section groups in this file.\n"));
6829 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6831 if (section_groups
== NULL
)
6833 error (_("Out of memory reading %lu groups\n"),
6834 (unsigned long) group_count
);
6844 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6845 i
< filedata
->file_header
.e_shnum
;
6848 if (section
->sh_type
== SHT_GROUP
)
6850 const char * name
= printable_section_name (filedata
, section
);
6851 const char * group_name
;
6852 unsigned char * start
;
6853 unsigned char * indices
;
6854 unsigned int entry
, j
, size
;
6855 Elf_Internal_Shdr
* sec
;
6856 Elf_Internal_Sym
* sym
;
6858 /* Get the symbol table. */
6859 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6860 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6863 error (_("Bad sh_link in group section `%s'\n"), name
);
6867 if (symtab_sec
!= sec
)
6872 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6877 error (_("Corrupt header in group section `%s'\n"), name
);
6881 if (section
->sh_info
>= num_syms
)
6883 error (_("Bad sh_info in group section `%s'\n"), name
);
6887 sym
= symtab
+ section
->sh_info
;
6889 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6891 if (sym
->st_shndx
== 0
6892 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6894 error (_("Bad sh_info in group section `%s'\n"), name
);
6898 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6907 /* Get the string table. */
6908 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6917 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6923 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6924 1, strtab_sec
->sh_size
,
6926 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6928 group_name
= sym
->st_name
< strtab_size
6929 ? strtab
+ sym
->st_name
: _("<corrupt>");
6932 /* PR 17531: file: loop. */
6933 if (section
->sh_entsize
> section
->sh_size
)
6935 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6936 printable_section_name (filedata
, section
),
6937 (unsigned long) section
->sh_entsize
,
6938 (unsigned long) section
->sh_size
);
6942 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6943 1, section
->sh_size
,
6949 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6950 entry
= byte_get (indices
, 4);
6953 if (do_section_groups
)
6955 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6956 get_group_flags (entry
), i
, name
, group_name
, size
);
6958 printf (_(" [Index] Name\n"));
6961 group
->group_index
= i
;
6963 for (j
= 0; j
< size
; j
++)
6965 struct group_list
* g
;
6967 entry
= byte_get (indices
, 4);
6970 if (entry
>= filedata
->file_header
.e_shnum
)
6972 static unsigned num_group_errors
= 0;
6974 if (num_group_errors
++ < 10)
6976 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6977 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6978 if (num_group_errors
== 10)
6979 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6984 if (section_headers_groups
[entry
] != NULL
)
6988 static unsigned num_errs
= 0;
6990 if (num_errs
++ < 10)
6992 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6994 section_headers_groups
[entry
]->group_index
);
6996 warn (_("Further error messages about already contained group sections suppressed\n"));
7002 /* Intel C/C++ compiler may put section 0 in a
7003 section group. We just warn it the first time
7004 and ignore it afterwards. */
7005 static bfd_boolean warned
= FALSE
;
7008 error (_("section 0 in group section [%5u]\n"),
7009 section_headers_groups
[entry
]->group_index
);
7015 section_headers_groups
[entry
] = group
;
7017 if (do_section_groups
)
7019 sec
= filedata
->section_headers
+ entry
;
7020 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7023 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7024 g
->section_index
= entry
;
7025 g
->next
= group
->root
;
7043 /* Data used to display dynamic fixups. */
7045 struct ia64_vms_dynfixup
7047 bfd_vma needed_ident
; /* Library ident number. */
7048 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7049 bfd_vma fixup_needed
; /* Index of the library. */
7050 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7051 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7054 /* Data used to display dynamic relocations. */
7056 struct ia64_vms_dynimgrela
7058 bfd_vma img_rela_cnt
; /* Number of relocations. */
7059 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7062 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7066 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7067 struct ia64_vms_dynfixup
* fixup
,
7068 const char * strtab
,
7069 unsigned int strtab_sz
)
7071 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7073 const char * lib_name
;
7075 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7076 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7077 _("dynamic section image fixups"));
7081 if (fixup
->needed
< strtab_sz
)
7082 lib_name
= strtab
+ fixup
->needed
;
7085 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7086 (unsigned long) fixup
->needed
);
7089 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7090 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7092 (_("Seg Offset Type SymVec DataType\n"));
7094 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7099 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7100 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7101 type
= BYTE_GET (imfs
[i
].type
);
7102 rtype
= elf_ia64_reloc_type (type
);
7104 printf (" 0x%08x ", type
);
7106 printf (" %-32s ", rtype
);
7107 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7108 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7115 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7118 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7120 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7123 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7124 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7125 _("dynamic section image relocations"));
7129 printf (_("\nImage relocs\n"));
7131 (_("Seg Offset Type Addend Seg Sym Off\n"));
7133 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7138 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7139 printf ("%08" BFD_VMA_FMT
"x ",
7140 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7141 type
= BYTE_GET (imrs
[i
].type
);
7142 rtype
= elf_ia64_reloc_type (type
);
7144 printf ("0x%08x ", type
);
7146 printf ("%-31s ", rtype
);
7147 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7148 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7149 printf ("%08" BFD_VMA_FMT
"x\n",
7150 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7157 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7160 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7162 struct ia64_vms_dynfixup fixup
;
7163 struct ia64_vms_dynimgrela imgrela
;
7164 Elf_Internal_Dyn
*entry
;
7165 bfd_vma strtab_off
= 0;
7166 bfd_vma strtab_sz
= 0;
7167 char *strtab
= NULL
;
7168 bfd_boolean res
= TRUE
;
7170 memset (&fixup
, 0, sizeof (fixup
));
7171 memset (&imgrela
, 0, sizeof (imgrela
));
7173 /* Note: the order of the entries is specified by the OpenVMS specs. */
7174 for (entry
= dynamic_section
;
7175 entry
< dynamic_section
+ dynamic_nent
;
7178 switch (entry
->d_tag
)
7180 case DT_IA_64_VMS_STRTAB_OFFSET
:
7181 strtab_off
= entry
->d_un
.d_val
;
7184 strtab_sz
= entry
->d_un
.d_val
;
7186 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7187 1, strtab_sz
, _("dynamic string section"));
7190 case DT_IA_64_VMS_NEEDED_IDENT
:
7191 fixup
.needed_ident
= entry
->d_un
.d_val
;
7194 fixup
.needed
= entry
->d_un
.d_val
;
7196 case DT_IA_64_VMS_FIXUP_NEEDED
:
7197 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7199 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7200 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7202 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7203 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7204 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7207 case DT_IA_64_VMS_IMG_RELA_CNT
:
7208 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7210 case DT_IA_64_VMS_IMG_RELA_OFF
:
7211 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7212 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7234 dynamic_relocations
[] =
7236 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7237 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7238 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7241 /* Process the reloc section. */
7244 process_relocs (Filedata
* filedata
)
7246 unsigned long rel_size
;
7247 unsigned long rel_offset
;
7252 if (do_using_dynamic
)
7256 bfd_boolean has_dynamic_reloc
;
7259 has_dynamic_reloc
= FALSE
;
7261 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7263 is_rela
= dynamic_relocations
[i
].rela
;
7264 name
= dynamic_relocations
[i
].name
;
7265 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7266 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7269 has_dynamic_reloc
= TRUE
;
7271 if (is_rela
== UNKNOWN
)
7273 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7274 switch (dynamic_info
[DT_PLTREL
])
7288 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7289 name
, rel_offset
, rel_size
);
7291 dump_relocations (filedata
,
7292 offset_from_vma (filedata
, rel_offset
, rel_size
),
7294 dynamic_symbols
, num_dynamic_syms
,
7295 dynamic_strings
, dynamic_strings_length
,
7296 is_rela
, TRUE
/* is_dynamic */);
7300 if (is_ia64_vms (filedata
))
7301 if (process_ia64_vms_dynamic_relocs (filedata
))
7302 has_dynamic_reloc
= TRUE
;
7304 if (! has_dynamic_reloc
)
7305 printf (_("\nThere are no dynamic relocations in this file.\n"));
7309 Elf_Internal_Shdr
* section
;
7311 bfd_boolean found
= FALSE
;
7313 for (i
= 0, section
= filedata
->section_headers
;
7314 i
< filedata
->file_header
.e_shnum
;
7317 if ( section
->sh_type
!= SHT_RELA
7318 && section
->sh_type
!= SHT_REL
)
7321 rel_offset
= section
->sh_offset
;
7322 rel_size
= section
->sh_size
;
7326 Elf_Internal_Shdr
* strsec
;
7328 unsigned long num_rela
;
7330 printf (_("\nRelocation section "));
7332 if (filedata
->string_table
== NULL
)
7333 printf ("%d", section
->sh_name
);
7335 printf ("'%s'", printable_section_name (filedata
, section
));
7337 num_rela
= rel_size
/ section
->sh_entsize
;
7338 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7339 " at offset 0x%lx contains %lu entries:\n",
7341 rel_offset
, num_rela
);
7343 is_rela
= section
->sh_type
== SHT_RELA
;
7345 if (section
->sh_link
!= 0
7346 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7348 Elf_Internal_Shdr
* symsec
;
7349 Elf_Internal_Sym
* symtab
;
7350 unsigned long nsyms
;
7351 unsigned long strtablen
= 0;
7352 char * strtab
= NULL
;
7354 symsec
= filedata
->section_headers
+ section
->sh_link
;
7355 if (symsec
->sh_type
!= SHT_SYMTAB
7356 && symsec
->sh_type
!= SHT_DYNSYM
)
7359 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7364 if (symsec
->sh_link
!= 0
7365 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7367 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7369 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7372 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7375 dump_relocations (filedata
, rel_offset
, rel_size
,
7376 symtab
, nsyms
, strtab
, strtablen
,
7378 symsec
->sh_type
== SHT_DYNSYM
);
7384 dump_relocations (filedata
, rel_offset
, rel_size
,
7385 NULL
, 0, NULL
, 0, is_rela
,
7386 FALSE
/* is_dynamic */);
7394 /* Users sometimes forget the -D option, so try to be helpful. */
7395 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7397 if (dynamic_info
[dynamic_relocations
[i
].size
])
7399 printf (_("\nThere are no static relocations in this file."));
7400 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7405 if (i
== ARRAY_SIZE (dynamic_relocations
))
7406 printf (_("\nThere are no relocations in this file.\n"));
7413 /* An absolute address consists of a section and an offset. If the
7414 section is NULL, the offset itself is the address, otherwise, the
7415 address equals to LOAD_ADDRESS(section) + offset. */
7419 unsigned short section
;
7423 /* Find the nearest symbol at or below ADDR. Returns the symbol
7424 name, if found, and the offset from the symbol to ADDR. */
7427 find_symbol_for_address (Filedata
* filedata
,
7428 Elf_Internal_Sym
* symtab
,
7429 unsigned long nsyms
,
7430 const char * strtab
,
7431 unsigned long strtab_size
,
7432 struct absaddr addr
,
7433 const char ** symname
,
7436 bfd_vma dist
= 0x100000;
7437 Elf_Internal_Sym
* sym
;
7438 Elf_Internal_Sym
* beg
;
7439 Elf_Internal_Sym
* end
;
7440 Elf_Internal_Sym
* best
= NULL
;
7442 REMOVE_ARCH_BITS (addr
.offset
);
7444 end
= symtab
+ nsyms
;
7450 sym
= beg
+ (end
- beg
) / 2;
7452 value
= sym
->st_value
;
7453 REMOVE_ARCH_BITS (value
);
7455 if (sym
->st_name
!= 0
7456 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7457 && addr
.offset
>= value
7458 && addr
.offset
- value
< dist
)
7461 dist
= addr
.offset
- value
;
7466 if (addr
.offset
< value
)
7474 *symname
= (best
->st_name
>= strtab_size
7475 ? _("<corrupt>") : strtab
+ best
->st_name
);
7481 *offset
= addr
.offset
;
7484 static /* signed */ int
7485 symcmp (const void *p
, const void *q
)
7487 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7488 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7490 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7493 /* Process the unwind section. */
7495 #include "unwind-ia64.h"
7497 struct ia64_unw_table_entry
7499 struct absaddr start
;
7501 struct absaddr info
;
7504 struct ia64_unw_aux_info
7506 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7507 unsigned long table_len
; /* Length of unwind table. */
7508 unsigned char * info
; /* Unwind info. */
7509 unsigned long info_size
; /* Size of unwind info. */
7510 bfd_vma info_addr
; /* Starting address of unwind info. */
7511 bfd_vma seg_base
; /* Starting address of segment. */
7512 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7513 unsigned long nsyms
; /* Number of symbols. */
7514 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7515 unsigned long nfuns
; /* Number of entries in funtab. */
7516 char * strtab
; /* The string table. */
7517 unsigned long strtab_size
; /* Size of string table. */
7521 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7523 struct ia64_unw_table_entry
* tp
;
7524 unsigned long j
, nfuns
;
7526 bfd_boolean res
= TRUE
;
7528 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7529 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7530 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7531 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7533 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7535 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7539 const unsigned char * dp
;
7540 const unsigned char * head
;
7541 const unsigned char * end
;
7542 const char * procname
;
7544 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7545 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7547 fputs ("\n<", stdout
);
7551 fputs (procname
, stdout
);
7554 printf ("+%lx", (unsigned long) offset
);
7557 fputs (">: [", stdout
);
7558 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7559 fputc ('-', stdout
);
7560 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7561 printf ("], info at +0x%lx\n",
7562 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7564 /* PR 17531: file: 86232b32. */
7565 if (aux
->info
== NULL
)
7568 offset
= tp
->info
.offset
;
7569 if (tp
->info
.section
)
7571 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7573 warn (_("Invalid section %u in table entry %ld\n"),
7574 tp
->info
.section
, (long) (tp
- aux
->table
));
7578 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7580 offset
-= aux
->info_addr
;
7581 /* PR 17531: file: 0997b4d1. */
7582 if (offset
>= aux
->info_size
7583 || aux
->info_size
- offset
< 8)
7585 warn (_("Invalid offset %lx in table entry %ld\n"),
7586 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7591 head
= aux
->info
+ offset
;
7592 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7594 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7595 (unsigned) UNW_VER (stamp
),
7596 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7597 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7598 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7599 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7601 if (UNW_VER (stamp
) != 1)
7603 printf (_("\tUnknown version.\n"));
7608 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7609 /* PR 17531: file: 16ceda89. */
7610 if (end
> aux
->info
+ aux
->info_size
)
7611 end
= aux
->info
+ aux
->info_size
;
7612 for (dp
= head
+ 8; dp
< end
;)
7613 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7622 slurp_ia64_unwind_table (Filedata
* filedata
,
7623 struct ia64_unw_aux_info
* aux
,
7624 Elf_Internal_Shdr
* sec
)
7626 unsigned long size
, nrelas
, i
;
7627 Elf_Internal_Phdr
* seg
;
7628 struct ia64_unw_table_entry
* tep
;
7629 Elf_Internal_Shdr
* relsec
;
7630 Elf_Internal_Rela
* rela
;
7631 Elf_Internal_Rela
* rp
;
7632 unsigned char * table
;
7634 Elf_Internal_Sym
* sym
;
7635 const char * relname
;
7639 /* First, find the starting address of the segment that includes
7642 if (filedata
->file_header
.e_phnum
)
7644 if (! get_program_headers (filedata
))
7647 for (seg
= filedata
->program_headers
;
7648 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7651 if (seg
->p_type
!= PT_LOAD
)
7654 if (sec
->sh_addr
>= seg
->p_vaddr
7655 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7657 aux
->seg_base
= seg
->p_vaddr
;
7663 /* Second, build the unwind table from the contents of the unwind section: */
7664 size
= sec
->sh_size
;
7665 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7670 aux
->table_len
= size
/ (3 * eh_addr_size
);
7671 aux
->table
= (struct ia64_unw_table_entry
*)
7672 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7675 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7677 tep
->start
.section
= SHN_UNDEF
;
7678 tep
->end
.section
= SHN_UNDEF
;
7679 tep
->info
.section
= SHN_UNDEF
;
7680 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7681 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7682 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7683 tep
->start
.offset
+= aux
->seg_base
;
7684 tep
->end
.offset
+= aux
->seg_base
;
7685 tep
->info
.offset
+= aux
->seg_base
;
7689 /* Third, apply any relocations to the unwind table: */
7690 for (relsec
= filedata
->section_headers
;
7691 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7694 if (relsec
->sh_type
!= SHT_RELA
7695 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7696 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7699 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7708 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7710 unsigned int sym_ndx
;
7711 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7712 relname
= elf_ia64_reloc_type (r_type
);
7714 /* PR 17531: file: 9fa67536. */
7715 if (relname
== NULL
)
7717 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7721 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7723 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7727 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7729 /* PR 17531: file: 5bc8d9bf. */
7730 if (i
>= aux
->table_len
)
7732 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7736 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7737 if (sym_ndx
>= aux
->nsyms
)
7739 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7743 sym
= aux
->symtab
+ sym_ndx
;
7745 switch (rp
->r_offset
/ eh_addr_size
% 3)
7748 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7749 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7752 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7753 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7756 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7757 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7771 ia64_process_unwind (Filedata
* filedata
)
7773 Elf_Internal_Shdr
* sec
;
7774 Elf_Internal_Shdr
* unwsec
= NULL
;
7775 Elf_Internal_Shdr
* strsec
;
7776 unsigned long i
, unwcount
= 0, unwstart
= 0;
7777 struct ia64_unw_aux_info aux
;
7778 bfd_boolean res
= TRUE
;
7780 memset (& aux
, 0, sizeof (aux
));
7782 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7784 if (sec
->sh_type
== SHT_SYMTAB
7785 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7787 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7789 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7790 if (aux
.strtab
!= NULL
)
7792 error (_("Multiple auxillary string tables encountered\n"));
7796 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7799 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7801 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7806 printf (_("\nThere are no unwind sections in this file.\n"));
7808 while (unwcount
-- > 0)
7813 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7814 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7815 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7820 /* We have already counted the number of SHT_IA64_UNWIND
7821 sections so the loop above should never fail. */
7822 assert (unwsec
!= NULL
);
7825 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7827 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7829 /* We need to find which section group it is in. */
7830 struct group_list
* g
;
7832 if (section_headers_groups
== NULL
7833 || section_headers_groups
[i
] == NULL
)
7834 i
= filedata
->file_header
.e_shnum
;
7837 g
= section_headers_groups
[i
]->root
;
7839 for (; g
!= NULL
; g
= g
->next
)
7841 sec
= filedata
->section_headers
+ g
->section_index
;
7843 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7848 i
= filedata
->file_header
.e_shnum
;
7851 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7853 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7854 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7855 suffix
= SECTION_NAME (unwsec
) + len
;
7856 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7858 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7859 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7864 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7865 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7866 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7867 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7869 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7870 suffix
= SECTION_NAME (unwsec
) + len
;
7871 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7873 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7874 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7878 if (i
== filedata
->file_header
.e_shnum
)
7880 printf (_("\nCould not find unwind info section for "));
7882 if (filedata
->string_table
== NULL
)
7883 printf ("%d", unwsec
->sh_name
);
7885 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7889 aux
.info_addr
= sec
->sh_addr
;
7890 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7893 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7895 printf (_("\nUnwind section "));
7897 if (filedata
->string_table
== NULL
)
7898 printf ("%d", unwsec
->sh_name
);
7900 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7902 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7903 (unsigned long) unwsec
->sh_offset
,
7904 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7906 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7907 && aux
.table_len
> 0)
7908 dump_ia64_unwind (filedata
, & aux
);
7911 free ((char *) aux
.table
);
7913 free ((char *) aux
.info
);
7922 free ((char *) aux
.strtab
);
7927 struct hppa_unw_table_entry
7929 struct absaddr start
;
7931 unsigned int Cannot_unwind
:1; /* 0 */
7932 unsigned int Millicode
:1; /* 1 */
7933 unsigned int Millicode_save_sr0
:1; /* 2 */
7934 unsigned int Region_description
:2; /* 3..4 */
7935 unsigned int reserved1
:1; /* 5 */
7936 unsigned int Entry_SR
:1; /* 6 */
7937 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7938 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7939 unsigned int Args_stored
:1; /* 16 */
7940 unsigned int Variable_Frame
:1; /* 17 */
7941 unsigned int Separate_Package_Body
:1; /* 18 */
7942 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7943 unsigned int Stack_Overflow_Check
:1; /* 20 */
7944 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7945 unsigned int Ada_Region
:1; /* 22 */
7946 unsigned int cxx_info
:1; /* 23 */
7947 unsigned int cxx_try_catch
:1; /* 24 */
7948 unsigned int sched_entry_seq
:1; /* 25 */
7949 unsigned int reserved2
:1; /* 26 */
7950 unsigned int Save_SP
:1; /* 27 */
7951 unsigned int Save_RP
:1; /* 28 */
7952 unsigned int Save_MRP_in_frame
:1; /* 29 */
7953 unsigned int extn_ptr_defined
:1; /* 30 */
7954 unsigned int Cleanup_defined
:1; /* 31 */
7956 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7957 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7958 unsigned int Large_frame
:1; /* 2 */
7959 unsigned int Pseudo_SP_Set
:1; /* 3 */
7960 unsigned int reserved4
:1; /* 4 */
7961 unsigned int Total_frame_size
:27; /* 5..31 */
7964 struct hppa_unw_aux_info
7966 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7967 unsigned long table_len
; /* Length of unwind table. */
7968 bfd_vma seg_base
; /* Starting address of segment. */
7969 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7970 unsigned long nsyms
; /* Number of symbols. */
7971 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7972 unsigned long nfuns
; /* Number of entries in funtab. */
7973 char * strtab
; /* The string table. */
7974 unsigned long strtab_size
; /* Size of string table. */
7978 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7980 struct hppa_unw_table_entry
* tp
;
7981 unsigned long j
, nfuns
;
7982 bfd_boolean res
= TRUE
;
7984 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7985 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7986 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7987 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7989 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7991 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7994 const char * procname
;
7996 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7997 aux
->strtab_size
, tp
->start
, &procname
,
8000 fputs ("\n<", stdout
);
8004 fputs (procname
, stdout
);
8007 printf ("+%lx", (unsigned long) offset
);
8010 fputs (">: [", stdout
);
8011 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8012 fputc ('-', stdout
);
8013 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8016 #define PF(_m) if (tp->_m) printf (#_m " ");
8017 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8020 PF(Millicode_save_sr0
);
8021 /* PV(Region_description); */
8027 PF(Separate_Package_Body
);
8028 PF(Frame_Extension_Millicode
);
8029 PF(Stack_Overflow_Check
);
8030 PF(Two_Instruction_SP_Increment
);
8034 PF(sched_entry_seq
);
8037 PF(Save_MRP_in_frame
);
8038 PF(extn_ptr_defined
);
8039 PF(Cleanup_defined
);
8040 PF(MPE_XL_interrupt_marker
);
8041 PF(HP_UX_interrupt_marker
);
8044 PV(Total_frame_size
);
8057 slurp_hppa_unwind_table (Filedata
* filedata
,
8058 struct hppa_unw_aux_info
* aux
,
8059 Elf_Internal_Shdr
* sec
)
8061 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8062 Elf_Internal_Phdr
* seg
;
8063 struct hppa_unw_table_entry
* tep
;
8064 Elf_Internal_Shdr
* relsec
;
8065 Elf_Internal_Rela
* rela
;
8066 Elf_Internal_Rela
* rp
;
8067 unsigned char * table
;
8069 Elf_Internal_Sym
* sym
;
8070 const char * relname
;
8072 /* First, find the starting address of the segment that includes
8074 if (filedata
->file_header
.e_phnum
)
8076 if (! get_program_headers (filedata
))
8079 for (seg
= filedata
->program_headers
;
8080 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8083 if (seg
->p_type
!= PT_LOAD
)
8086 if (sec
->sh_addr
>= seg
->p_vaddr
8087 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8089 aux
->seg_base
= seg
->p_vaddr
;
8095 /* Second, build the unwind table from the contents of the unwind
8097 size
= sec
->sh_size
;
8098 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8104 nentries
= size
/ unw_ent_size
;
8105 size
= unw_ent_size
* nentries
;
8107 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8108 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8110 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8112 unsigned int tmp1
, tmp2
;
8114 tep
->start
.section
= SHN_UNDEF
;
8115 tep
->end
.section
= SHN_UNDEF
;
8117 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8118 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8119 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8120 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8122 tep
->start
.offset
+= aux
->seg_base
;
8123 tep
->end
.offset
+= aux
->seg_base
;
8125 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8126 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8127 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8128 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8129 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8130 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8131 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8132 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8133 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8134 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8135 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8136 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8137 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8138 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8139 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8140 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8141 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8142 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8143 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8144 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8145 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8146 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8147 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8148 tep
->Cleanup_defined
= tmp1
& 0x1;
8150 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8151 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8152 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8153 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8154 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8155 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8159 /* Third, apply any relocations to the unwind table. */
8160 for (relsec
= filedata
->section_headers
;
8161 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8164 if (relsec
->sh_type
!= SHT_RELA
8165 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8166 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8169 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8173 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8175 unsigned int sym_ndx
;
8176 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8177 relname
= elf_hppa_reloc_type (r_type
);
8179 if (relname
== NULL
)
8181 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8185 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8186 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8188 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8192 i
= rp
->r_offset
/ unw_ent_size
;
8193 if (i
>= aux
->table_len
)
8195 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8199 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8200 if (sym_ndx
>= aux
->nsyms
)
8202 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8206 sym
= aux
->symtab
+ sym_ndx
;
8208 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8211 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8212 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8215 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8216 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8226 aux
->table_len
= nentries
;
8232 hppa_process_unwind (Filedata
* filedata
)
8234 struct hppa_unw_aux_info aux
;
8235 Elf_Internal_Shdr
* unwsec
= NULL
;
8236 Elf_Internal_Shdr
* strsec
;
8237 Elf_Internal_Shdr
* sec
;
8239 bfd_boolean res
= TRUE
;
8241 if (filedata
->string_table
== NULL
)
8244 memset (& aux
, 0, sizeof (aux
));
8246 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8248 if (sec
->sh_type
== SHT_SYMTAB
8249 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8251 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8253 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8254 if (aux
.strtab
!= NULL
)
8256 error (_("Multiple auxillary string tables encountered\n"));
8260 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8263 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8265 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8270 printf (_("\nThere are no unwind sections in this file.\n"));
8272 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8274 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8276 unsigned long num_unwind
= sec
->sh_size
/ 16;
8278 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8279 "contains %lu entry:\n",
8280 "\nUnwind section '%s' at offset 0x%lx "
8281 "contains %lu entries:\n",
8283 printable_section_name (filedata
, sec
),
8284 (unsigned long) sec
->sh_offset
,
8287 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8290 if (res
&& aux
.table_len
> 0)
8292 if (! dump_hppa_unwind (filedata
, &aux
))
8297 free ((char *) aux
.table
);
8305 free ((char *) aux
.strtab
);
8312 unsigned char * data
; /* The unwind data. */
8313 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8314 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8315 unsigned long nrelas
; /* The number of relocations. */
8316 unsigned int rel_type
; /* REL or RELA ? */
8317 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8320 struct arm_unw_aux_info
8322 Filedata
* filedata
; /* The file containing the unwind sections. */
8323 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8324 unsigned long nsyms
; /* Number of symbols. */
8325 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8326 unsigned long nfuns
; /* Number of these symbols. */
8327 char * strtab
; /* The file's string table. */
8328 unsigned long strtab_size
; /* Size of string table. */
8332 arm_print_vma_and_name (Filedata
* filedata
,
8333 struct arm_unw_aux_info
* aux
,
8335 struct absaddr addr
)
8337 const char *procname
;
8340 if (addr
.section
== SHN_UNDEF
)
8343 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8344 aux
->strtab_size
, addr
, &procname
,
8347 print_vma (fn
, PREFIX_HEX
);
8351 fputs (" <", stdout
);
8352 fputs (procname
, stdout
);
8355 printf ("+0x%lx", (unsigned long) sym_offset
);
8356 fputc ('>', stdout
);
8363 arm_free_section (struct arm_section
*arm_sec
)
8365 if (arm_sec
->data
!= NULL
)
8366 free (arm_sec
->data
);
8368 if (arm_sec
->rela
!= NULL
)
8369 free (arm_sec
->rela
);
8372 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8373 cached section and install SEC instead.
8374 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8375 and return its valued in * WORDP, relocating if necessary.
8376 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8377 relocation's offset in ADDR.
8378 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8379 into the string table of the symbol associated with the reloc. If no
8380 reloc was applied store -1 there.
8381 5) Return TRUE upon success, FALSE otherwise. */
8384 get_unwind_section_word (Filedata
* filedata
,
8385 struct arm_unw_aux_info
* aux
,
8386 struct arm_section
* arm_sec
,
8387 Elf_Internal_Shdr
* sec
,
8388 bfd_vma word_offset
,
8389 unsigned int * wordp
,
8390 struct absaddr
* addr
,
8393 Elf_Internal_Rela
*rp
;
8394 Elf_Internal_Sym
*sym
;
8395 const char * relname
;
8397 bfd_boolean wrapped
;
8399 if (sec
== NULL
|| arm_sec
== NULL
)
8402 addr
->section
= SHN_UNDEF
;
8405 if (sym_name
!= NULL
)
8406 *sym_name
= (bfd_vma
) -1;
8408 /* If necessary, update the section cache. */
8409 if (sec
!= arm_sec
->sec
)
8411 Elf_Internal_Shdr
*relsec
;
8413 arm_free_section (arm_sec
);
8416 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8417 sec
->sh_size
, _("unwind data"));
8418 arm_sec
->rela
= NULL
;
8419 arm_sec
->nrelas
= 0;
8421 for (relsec
= filedata
->section_headers
;
8422 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8425 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8426 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8427 /* PR 15745: Check the section type as well. */
8428 || (relsec
->sh_type
!= SHT_REL
8429 && relsec
->sh_type
!= SHT_RELA
))
8432 arm_sec
->rel_type
= relsec
->sh_type
;
8433 if (relsec
->sh_type
== SHT_REL
)
8435 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8437 & arm_sec
->rela
, & arm_sec
->nrelas
))
8440 else /* relsec->sh_type == SHT_RELA */
8442 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8444 & arm_sec
->rela
, & arm_sec
->nrelas
))
8450 arm_sec
->next_rela
= arm_sec
->rela
;
8453 /* If there is no unwind data we can do nothing. */
8454 if (arm_sec
->data
== NULL
)
8457 /* If the offset is invalid then fail. */
8458 if (/* PR 21343 *//* PR 18879 */
8460 || word_offset
> (sec
->sh_size
- 4)
8461 || ((bfd_signed_vma
) word_offset
) < 0)
8464 /* Get the word at the required offset. */
8465 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8467 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8468 if (arm_sec
->rela
== NULL
)
8474 /* Look through the relocs to find the one that applies to the provided offset. */
8476 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8478 bfd_vma prelval
, offset
;
8480 if (rp
->r_offset
> word_offset
&& !wrapped
)
8485 if (rp
->r_offset
> word_offset
)
8488 if (rp
->r_offset
& 3)
8490 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8491 (unsigned long) rp
->r_offset
);
8495 if (rp
->r_offset
< word_offset
)
8498 /* PR 17531: file: 027-161405-0.004 */
8499 if (aux
->symtab
== NULL
)
8502 if (arm_sec
->rel_type
== SHT_REL
)
8504 offset
= word
& 0x7fffffff;
8505 if (offset
& 0x40000000)
8506 offset
|= ~ (bfd_vma
) 0x7fffffff;
8508 else if (arm_sec
->rel_type
== SHT_RELA
)
8509 offset
= rp
->r_addend
;
8512 error (_("Unknown section relocation type %d encountered\n"),
8517 /* PR 17531 file: 027-1241568-0.004. */
8518 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8520 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8521 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8525 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8526 offset
+= sym
->st_value
;
8527 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8529 /* Check that we are processing the expected reloc type. */
8530 if (filedata
->file_header
.e_machine
== EM_ARM
)
8532 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8533 if (relname
== NULL
)
8535 warn (_("Skipping unknown ARM relocation type: %d\n"),
8536 (int) ELF32_R_TYPE (rp
->r_info
));
8540 if (streq (relname
, "R_ARM_NONE"))
8543 if (! streq (relname
, "R_ARM_PREL31"))
8545 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8549 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8551 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8552 if (relname
== NULL
)
8554 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8555 (int) ELF32_R_TYPE (rp
->r_info
));
8559 if (streq (relname
, "R_C6000_NONE"))
8562 if (! streq (relname
, "R_C6000_PREL31"))
8564 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8572 /* This function currently only supports ARM and TI unwinders. */
8573 warn (_("Only TI and ARM unwinders are currently supported\n"));
8577 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8578 addr
->section
= sym
->st_shndx
;
8579 addr
->offset
= offset
;
8582 * sym_name
= sym
->st_name
;
8587 arm_sec
->next_rela
= rp
;
8592 static const char *tic6x_unwind_regnames
[16] =
8594 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8595 "A14", "A13", "A12", "A11", "A10",
8596 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8600 decode_tic6x_unwind_regmask (unsigned int mask
)
8604 for (i
= 12; mask
; mask
>>= 1, i
--)
8608 fputs (tic6x_unwind_regnames
[i
], stdout
);
8610 fputs (", ", stdout
);
8616 if (remaining == 0 && more_words) \
8619 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8620 data_offset, & word, & addr, NULL)) \
8626 #define GET_OP(OP) \
8631 (OP) = word >> 24; \
8636 printf (_("[Truncated opcode]\n")); \
8639 printf ("0x%02x ", OP)
8642 decode_arm_unwind_bytecode (Filedata
* filedata
,
8643 struct arm_unw_aux_info
* aux
,
8645 unsigned int remaining
,
8646 unsigned int more_words
,
8647 bfd_vma data_offset
,
8648 Elf_Internal_Shdr
* data_sec
,
8649 struct arm_section
* data_arm_sec
)
8651 struct absaddr addr
;
8652 bfd_boolean res
= TRUE
;
8654 /* Decode the unwinding instructions. */
8657 unsigned int op
, op2
;
8666 printf (" 0x%02x ", op
);
8668 if ((op
& 0xc0) == 0x00)
8670 int offset
= ((op
& 0x3f) << 2) + 4;
8672 printf (" vsp = vsp + %d", offset
);
8674 else if ((op
& 0xc0) == 0x40)
8676 int offset
= ((op
& 0x3f) << 2) + 4;
8678 printf (" vsp = vsp - %d", offset
);
8680 else if ((op
& 0xf0) == 0x80)
8683 if (op
== 0x80 && op2
== 0)
8684 printf (_("Refuse to unwind"));
8687 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8688 bfd_boolean first
= TRUE
;
8692 for (i
= 0; i
< 12; i
++)
8693 if (mask
& (1 << i
))
8699 printf ("r%d", 4 + i
);
8704 else if ((op
& 0xf0) == 0x90)
8706 if (op
== 0x9d || op
== 0x9f)
8707 printf (_(" [Reserved]"));
8709 printf (" vsp = r%d", op
& 0x0f);
8711 else if ((op
& 0xf0) == 0xa0)
8713 int end
= 4 + (op
& 0x07);
8714 bfd_boolean first
= TRUE
;
8718 for (i
= 4; i
<= end
; i
++)
8734 else if (op
== 0xb0)
8735 printf (_(" finish"));
8736 else if (op
== 0xb1)
8739 if (op2
== 0 || (op2
& 0xf0) != 0)
8740 printf (_("[Spare]"));
8743 unsigned int mask
= op2
& 0x0f;
8744 bfd_boolean first
= TRUE
;
8748 for (i
= 0; i
< 12; i
++)
8749 if (mask
& (1 << i
))
8760 else if (op
== 0xb2)
8762 unsigned char buf
[9];
8763 unsigned int i
, len
;
8764 unsigned long offset
;
8766 for (i
= 0; i
< sizeof (buf
); i
++)
8769 if ((buf
[i
] & 0x80) == 0)
8772 if (i
== sizeof (buf
))
8774 error (_("corrupt change to vsp"));
8779 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8780 assert (len
== i
+ 1);
8781 offset
= offset
* 4 + 0x204;
8782 printf ("vsp = vsp + %ld", offset
);
8785 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8787 unsigned int first
, last
;
8794 printf ("pop {D%d", first
);
8796 printf ("-D%d", first
+ last
);
8799 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8801 unsigned int count
= op
& 0x07;
8805 printf ("-D%d", 8 + count
);
8808 else if (op
>= 0xc0 && op
<= 0xc5)
8810 unsigned int count
= op
& 0x07;
8812 printf (" pop {wR10");
8814 printf ("-wR%d", 10 + count
);
8817 else if (op
== 0xc6)
8819 unsigned int first
, last
;
8824 printf ("pop {wR%d", first
);
8826 printf ("-wR%d", first
+ last
);
8829 else if (op
== 0xc7)
8832 if (op2
== 0 || (op2
& 0xf0) != 0)
8833 printf (_("[Spare]"));
8836 unsigned int mask
= op2
& 0x0f;
8837 bfd_boolean first
= TRUE
;
8841 for (i
= 0; i
< 4; i
++)
8842 if (mask
& (1 << i
))
8848 printf ("wCGR%d", i
);
8855 printf (_(" [unsupported opcode]"));
8866 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8867 struct arm_unw_aux_info
* aux
,
8869 unsigned int remaining
,
8870 unsigned int more_words
,
8871 bfd_vma data_offset
,
8872 Elf_Internal_Shdr
* data_sec
,
8873 struct arm_section
* data_arm_sec
)
8875 struct absaddr addr
;
8877 /* Decode the unwinding instructions. */
8880 unsigned int op
, op2
;
8889 printf (" 0x%02x ", op
);
8891 if ((op
& 0xc0) == 0x00)
8893 int offset
= ((op
& 0x3f) << 3) + 8;
8894 printf (" sp = sp + %d", offset
);
8896 else if ((op
& 0xc0) == 0x80)
8899 if (op
== 0x80 && op2
== 0)
8900 printf (_("Refuse to unwind"));
8903 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8905 printf ("pop compact {");
8909 decode_tic6x_unwind_regmask (mask
);
8913 else if ((op
& 0xf0) == 0xc0)
8921 unsigned int offset
;
8925 /* Scan entire instruction first so that GET_OP output is not
8926 interleaved with disassembly. */
8928 for (i
= 0; nregs
< (op
& 0xf); i
++)
8934 regpos
[nregs
].offset
= i
* 2;
8935 regpos
[nregs
].reg
= reg
;
8942 regpos
[nregs
].offset
= i
* 2 + 1;
8943 regpos
[nregs
].reg
= reg
;
8948 printf (_("pop frame {"));
8951 printf (_("*corrupt* - no registers specified"));
8956 for (i
= i
* 2; i
> 0; i
--)
8958 if (regpos
[reg
].offset
== i
- 1)
8960 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8967 fputs (name
, stdout
);
8975 else if (op
== 0xd0)
8976 printf (" MOV FP, SP");
8977 else if (op
== 0xd1)
8978 printf (" __c6xabi_pop_rts");
8979 else if (op
== 0xd2)
8981 unsigned char buf
[9];
8982 unsigned int i
, len
;
8983 unsigned long offset
;
8985 for (i
= 0; i
< sizeof (buf
); i
++)
8988 if ((buf
[i
] & 0x80) == 0)
8991 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8992 if (i
== sizeof (buf
))
8994 warn (_("Corrupt stack pointer adjustment detected\n"));
8998 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8999 assert (len
== i
+ 1);
9000 offset
= offset
* 8 + 0x408;
9001 printf (_("sp = sp + %ld"), offset
);
9003 else if ((op
& 0xf0) == 0xe0)
9005 if ((op
& 0x0f) == 7)
9008 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9012 printf (_(" [unsupported opcode]"));
9021 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9025 offset
= word
& 0x7fffffff;
9026 if (offset
& 0x40000000)
9027 offset
|= ~ (bfd_vma
) 0x7fffffff;
9029 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9032 return offset
+ where
;
9036 decode_arm_unwind (Filedata
* filedata
,
9037 struct arm_unw_aux_info
* aux
,
9039 unsigned int remaining
,
9040 bfd_vma data_offset
,
9041 Elf_Internal_Shdr
* data_sec
,
9042 struct arm_section
* data_arm_sec
)
9045 unsigned int more_words
= 0;
9046 struct absaddr addr
;
9047 bfd_vma sym_name
= (bfd_vma
) -1;
9048 bfd_boolean res
= TRUE
;
9052 /* Fetch the first word.
9053 Note - when decoding an object file the address extracted
9054 here will always be 0. So we also pass in the sym_name
9055 parameter so that we can find the symbol associated with
9056 the personality routine. */
9057 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9058 & word
, & addr
, & sym_name
))
9065 addr
.section
= SHN_UNDEF
;
9069 if ((word
& 0x80000000) == 0)
9071 /* Expand prel31 for personality routine. */
9073 const char *procname
;
9075 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9076 printf (_(" Personality routine: "));
9078 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9079 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9081 procname
= aux
->strtab
+ sym_name
;
9082 print_vma (fn
, PREFIX_HEX
);
9085 fputs (" <", stdout
);
9086 fputs (procname
, stdout
);
9087 fputc ('>', stdout
);
9091 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9092 fputc ('\n', stdout
);
9094 /* The GCC personality routines use the standard compact
9095 encoding, starting with one byte giving the number of
9097 if (procname
!= NULL
9098 && (const_strneq (procname
, "__gcc_personality_v0")
9099 || const_strneq (procname
, "__gxx_personality_v0")
9100 || const_strneq (procname
, "__gcj_personality_v0")
9101 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9108 printf (_(" [Truncated data]\n"));
9111 more_words
= word
>> 24;
9121 /* ARM EHABI Section 6.3:
9123 An exception-handling table entry for the compact model looks like:
9127 1 0 index Data for personalityRoutine[index] */
9129 if (filedata
->file_header
.e_machine
== EM_ARM
9130 && (word
& 0x70000000))
9132 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9136 per_index
= (word
>> 24) & 0x7f;
9137 printf (_(" Compact model index: %d\n"), per_index
);
9144 else if (per_index
< 3)
9146 more_words
= (word
>> 16) & 0xff;
9152 switch (filedata
->file_header
.e_machine
)
9157 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9158 data_offset
, data_sec
, data_arm_sec
))
9163 warn (_("Unknown ARM compact model index encountered\n"));
9164 printf (_(" [reserved]\n"));
9172 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9173 data_offset
, data_sec
, data_arm_sec
))
9176 else if (per_index
< 5)
9178 if (((word
>> 17) & 0x7f) == 0x7f)
9179 printf (_(" Restore stack from frame pointer\n"));
9181 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9182 printf (_(" Registers restored: "));
9184 printf (" (compact) ");
9185 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9187 printf (_(" Return register: %s\n"),
9188 tic6x_unwind_regnames
[word
& 0xf]);
9191 printf (_(" [reserved (%d)]\n"), per_index
);
9195 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9196 filedata
->file_header
.e_machine
);
9200 /* Decode the descriptors. Not implemented. */
9206 dump_arm_unwind (Filedata
* filedata
,
9207 struct arm_unw_aux_info
* aux
,
9208 Elf_Internal_Shdr
* exidx_sec
)
9210 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9211 unsigned int i
, exidx_len
;
9212 unsigned long j
, nfuns
;
9213 bfd_boolean res
= TRUE
;
9215 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9216 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9217 exidx_len
= exidx_sec
->sh_size
/ 8;
9219 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9220 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9221 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9222 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9224 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9226 for (i
= 0; i
< exidx_len
; i
++)
9228 unsigned int exidx_fn
, exidx_entry
;
9229 struct absaddr fn_addr
, entry_addr
;
9232 fputc ('\n', stdout
);
9234 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9235 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9236 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9237 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9240 arm_free_section (& exidx_arm_sec
);
9241 arm_free_section (& extab_arm_sec
);
9245 /* ARM EHABI, Section 5:
9246 An index table entry consists of 2 words.
9247 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9248 if (exidx_fn
& 0x80000000)
9250 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9254 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9256 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9257 fputs (": ", stdout
);
9259 if (exidx_entry
== 1)
9261 print_vma (exidx_entry
, PREFIX_HEX
);
9262 fputs (" [cantunwind]\n", stdout
);
9264 else if (exidx_entry
& 0x80000000)
9266 print_vma (exidx_entry
, PREFIX_HEX
);
9267 fputc ('\n', stdout
);
9268 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9272 bfd_vma table
, table_offset
= 0;
9273 Elf_Internal_Shdr
*table_sec
;
9275 fputs ("@", stdout
);
9276 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9277 print_vma (table
, PREFIX_HEX
);
9280 /* Locate the matching .ARM.extab. */
9281 if (entry_addr
.section
!= SHN_UNDEF
9282 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9284 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9285 table_offset
= entry_addr
.offset
;
9287 if (table_offset
> table_sec
->sh_size
9288 || ((bfd_signed_vma
) table_offset
) < 0)
9290 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9291 (unsigned long) table_offset
,
9292 printable_section_name (filedata
, table_sec
));
9299 table_sec
= find_section_by_address (filedata
, table
);
9300 if (table_sec
!= NULL
)
9301 table_offset
= table
- table_sec
->sh_addr
;
9304 if (table_sec
== NULL
)
9306 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9307 (unsigned long) table
);
9312 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9321 arm_free_section (&exidx_arm_sec
);
9322 arm_free_section (&extab_arm_sec
);
9327 /* Used for both ARM and C6X unwinding tables. */
9330 arm_process_unwind (Filedata
* filedata
)
9332 struct arm_unw_aux_info aux
;
9333 Elf_Internal_Shdr
*unwsec
= NULL
;
9334 Elf_Internal_Shdr
*strsec
;
9335 Elf_Internal_Shdr
*sec
;
9337 unsigned int sec_type
;
9338 bfd_boolean res
= TRUE
;
9340 switch (filedata
->file_header
.e_machine
)
9343 sec_type
= SHT_ARM_EXIDX
;
9347 sec_type
= SHT_C6000_UNWIND
;
9351 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9352 filedata
->file_header
.e_machine
);
9356 if (filedata
->string_table
== NULL
)
9359 memset (& aux
, 0, sizeof (aux
));
9360 aux
.filedata
= filedata
;
9362 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9364 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9366 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9368 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9370 /* PR binutils/17531 file: 011-12666-0.004. */
9371 if (aux
.strtab
!= NULL
)
9373 error (_("Multiple string tables found in file.\n"));
9377 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9378 1, strsec
->sh_size
, _("string table"));
9379 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9381 else if (sec
->sh_type
== sec_type
)
9386 printf (_("\nThere are no unwind sections in this file.\n"));
9388 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9390 if (sec
->sh_type
== sec_type
)
9392 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9393 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9394 "contains %lu entry:\n",
9395 "\nUnwind section '%s' at offset 0x%lx "
9396 "contains %lu entries:\n",
9398 printable_section_name (filedata
, sec
),
9399 (unsigned long) sec
->sh_offset
,
9402 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9410 free ((char *) aux
.strtab
);
9416 process_unwind (Filedata
* filedata
)
9418 struct unwind_handler
9420 unsigned int machtype
;
9421 bfd_boolean (* handler
)(Filedata
*);
9424 { EM_ARM
, arm_process_unwind
},
9425 { EM_IA_64
, ia64_process_unwind
},
9426 { EM_PARISC
, hppa_process_unwind
},
9427 { EM_TI_C6000
, arm_process_unwind
},
9435 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9436 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9437 return handlers
[i
].handler (filedata
);
9439 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9440 get_machine_name (filedata
->file_header
.e_machine
));
9445 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9447 switch (entry
->d_tag
)
9449 case DT_AARCH64_BTI_PLT
:
9450 case DT_AARCH64_PAC_PLT
:
9453 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9460 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9462 switch (entry
->d_tag
)
9465 if (entry
->d_un
.d_val
== 0)
9469 static const char * opts
[] =
9471 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9472 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9473 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9474 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9478 bfd_boolean first
= TRUE
;
9480 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9481 if (entry
->d_un
.d_val
& (1 << cnt
))
9483 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9489 case DT_MIPS_IVERSION
:
9490 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9491 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9495 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9496 /* Note: coded this way so that there is a single string for translation. */
9497 printf (_("<corrupt: %s>"), buf
);
9501 case DT_MIPS_TIME_STAMP
:
9505 time_t atime
= entry
->d_un
.d_val
;
9507 tmp
= gmtime (&atime
);
9508 /* PR 17531: file: 6accc532. */
9510 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9512 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9513 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9514 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9515 printf (_("Time Stamp: %s"), timebuf
);
9519 case DT_MIPS_RLD_VERSION
:
9520 case DT_MIPS_LOCAL_GOTNO
:
9521 case DT_MIPS_CONFLICTNO
:
9522 case DT_MIPS_LIBLISTNO
:
9523 case DT_MIPS_SYMTABNO
:
9524 case DT_MIPS_UNREFEXTNO
:
9525 case DT_MIPS_HIPAGENO
:
9526 case DT_MIPS_DELTA_CLASS_NO
:
9527 case DT_MIPS_DELTA_INSTANCE_NO
:
9528 case DT_MIPS_DELTA_RELOC_NO
:
9529 case DT_MIPS_DELTA_SYM_NO
:
9530 case DT_MIPS_DELTA_CLASSSYM_NO
:
9531 case DT_MIPS_COMPACT_SIZE
:
9532 print_vma (entry
->d_un
.d_val
, DEC
);
9536 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9537 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9538 /* Falls through. */
9541 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9547 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9549 switch (entry
->d_tag
)
9551 case DT_HP_DLD_FLAGS
:
9560 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9561 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9562 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9563 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9564 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9565 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9566 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9567 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9568 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9569 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9570 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9571 { DT_HP_GST
, "HP_GST" },
9572 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9573 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9574 { DT_HP_NODELETE
, "HP_NODELETE" },
9575 { DT_HP_GROUP
, "HP_GROUP" },
9576 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9578 bfd_boolean first
= TRUE
;
9580 bfd_vma val
= entry
->d_un
.d_val
;
9582 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9583 if (val
& flags
[cnt
].bit
)
9587 fputs (flags
[cnt
].str
, stdout
);
9589 val
^= flags
[cnt
].bit
;
9592 if (val
!= 0 || first
)
9596 print_vma (val
, HEX
);
9602 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9610 /* VMS vs Unix time offset and factor. */
9612 #define VMS_EPOCH_OFFSET 35067168000000000LL
9613 #define VMS_GRANULARITY_FACTOR 10000000
9615 /* Display a VMS time in a human readable format. */
9618 print_vms_time (bfd_int64_t vmstime
)
9623 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9624 tm
= gmtime (&unxtime
);
9625 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9626 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9627 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9632 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9634 switch (entry
->d_tag
)
9636 case DT_IA_64_PLT_RESERVE
:
9637 /* First 3 slots reserved. */
9638 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9640 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9643 case DT_IA_64_VMS_LINKTIME
:
9645 print_vms_time (entry
->d_un
.d_val
);
9649 case DT_IA_64_VMS_LNKFLAGS
:
9650 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9651 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9652 printf (" CALL_DEBUG");
9653 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9654 printf (" NOP0BUFS");
9655 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9656 printf (" P0IMAGE");
9657 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9658 printf (" MKTHREADS");
9659 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9660 printf (" UPCALLS");
9661 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9663 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9664 printf (" INITIALIZE");
9665 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9667 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9668 printf (" EXE_INIT");
9669 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9670 printf (" TBK_IN_IMG");
9671 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9672 printf (" DBG_IN_IMG");
9673 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9674 printf (" TBK_IN_DSF");
9675 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9676 printf (" DBG_IN_DSF");
9677 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9678 printf (" SIGNATURES");
9679 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9680 printf (" REL_SEG_OFF");
9684 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9691 get_32bit_dynamic_section (Filedata
* filedata
)
9693 Elf32_External_Dyn
* edyn
;
9694 Elf32_External_Dyn
* ext
;
9695 Elf_Internal_Dyn
* entry
;
9697 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9698 dynamic_size
, _("dynamic section"));
9702 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9703 might not have the luxury of section headers. Look for the DT_NULL
9704 terminator to determine the number of entries. */
9705 for (ext
= edyn
, dynamic_nent
= 0;
9706 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9710 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9714 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9716 if (dynamic_section
== NULL
)
9718 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9719 (unsigned long) dynamic_nent
);
9724 for (ext
= edyn
, entry
= dynamic_section
;
9725 entry
< dynamic_section
+ dynamic_nent
;
9728 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9729 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9738 get_64bit_dynamic_section (Filedata
* filedata
)
9740 Elf64_External_Dyn
* edyn
;
9741 Elf64_External_Dyn
* ext
;
9742 Elf_Internal_Dyn
* entry
;
9744 /* Read in the data. */
9745 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9746 dynamic_size
, _("dynamic section"));
9750 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9751 might not have the luxury of section headers. Look for the DT_NULL
9752 terminator to determine the number of entries. */
9753 for (ext
= edyn
, dynamic_nent
= 0;
9754 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9755 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9759 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9763 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9765 if (dynamic_section
== NULL
)
9767 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9768 (unsigned long) dynamic_nent
);
9773 /* Convert from external to internal formats. */
9774 for (ext
= edyn
, entry
= dynamic_section
;
9775 entry
< dynamic_section
+ dynamic_nent
;
9778 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9779 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9788 print_dynamic_flags (bfd_vma flags
)
9790 bfd_boolean first
= TRUE
;
9796 flag
= flags
& - flags
;
9806 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9807 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9808 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9809 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9810 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9811 default: fputs (_("unknown"), stdout
); break;
9817 /* Parse and display the contents of the dynamic section. */
9820 process_dynamic_section (Filedata
* filedata
)
9822 Elf_Internal_Dyn
* entry
;
9824 if (dynamic_size
== 0)
9827 printf (_("\nThere is no dynamic section in this file.\n"));
9834 if (! get_32bit_dynamic_section (filedata
))
9839 if (! get_64bit_dynamic_section (filedata
))
9843 /* Find the appropriate symbol table. */
9844 if (dynamic_symbols
== NULL
)
9846 for (entry
= dynamic_section
;
9847 entry
< dynamic_section
+ dynamic_nent
;
9850 Elf_Internal_Shdr section
;
9852 if (entry
->d_tag
!= DT_SYMTAB
)
9855 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9857 /* Since we do not know how big the symbol table is,
9858 we default to reading in the entire file (!) and
9859 processing that. This is overkill, I know, but it
9861 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9862 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9864 /* See PR 21379 for a reproducer. */
9865 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9869 if (archive_file_offset
!= 0)
9870 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9872 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9875 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9877 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9878 section
.sh_name
= filedata
->string_table_length
;
9880 if (dynamic_symbols
!= NULL
)
9882 error (_("Multiple dynamic symbol table sections found\n"));
9883 free (dynamic_symbols
);
9885 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9886 if (num_dynamic_syms
< 1)
9888 error (_("Unable to determine the number of symbols to load\n"));
9894 /* Similarly find a string table. */
9895 if (dynamic_strings
== NULL
)
9897 for (entry
= dynamic_section
;
9898 entry
< dynamic_section
+ dynamic_nent
;
9901 unsigned long offset
;
9904 if (entry
->d_tag
!= DT_STRTAB
)
9907 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9909 /* Since we do not know how big the string table is,
9910 we default to reading in the entire file (!) and
9911 processing that. This is overkill, I know, but it
9914 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9916 if (archive_file_offset
!= 0)
9917 str_tab_len
= archive_file_size
- offset
;
9919 str_tab_len
= filedata
->file_size
- offset
;
9921 if (str_tab_len
< 1)
9924 (_("Unable to determine the length of the dynamic string table\n"));
9928 if (dynamic_strings
!= NULL
)
9930 error (_("Multiple dynamic string tables found\n"));
9931 free (dynamic_strings
);
9934 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9936 _("dynamic string table"));
9937 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9941 /* And find the syminfo section if available. */
9942 if (dynamic_syminfo
== NULL
)
9944 unsigned long syminsz
= 0;
9946 for (entry
= dynamic_section
;
9947 entry
< dynamic_section
+ dynamic_nent
;
9950 if (entry
->d_tag
== DT_SYMINENT
)
9952 /* Note: these braces are necessary to avoid a syntax
9953 error from the SunOS4 C compiler. */
9954 /* PR binutils/17531: A corrupt file can trigger this test.
9955 So do not use an assert, instead generate an error message. */
9956 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9957 error (_("Bad value (%d) for SYMINENT entry\n"),
9958 (int) entry
->d_un
.d_val
);
9960 else if (entry
->d_tag
== DT_SYMINSZ
)
9961 syminsz
= entry
->d_un
.d_val
;
9962 else if (entry
->d_tag
== DT_SYMINFO
)
9963 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9967 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9969 Elf_External_Syminfo
* extsyminfo
;
9970 Elf_External_Syminfo
* extsym
;
9971 Elf_Internal_Syminfo
* syminfo
;
9973 /* There is a syminfo section. Read the data. */
9974 extsyminfo
= (Elf_External_Syminfo
*)
9975 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9976 _("symbol information"));
9980 if (dynamic_syminfo
!= NULL
)
9982 error (_("Multiple dynamic symbol information sections found\n"));
9983 free (dynamic_syminfo
);
9985 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9986 if (dynamic_syminfo
== NULL
)
9988 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9989 (unsigned long) syminsz
);
9993 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9994 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9995 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9996 ++syminfo
, ++extsym
)
9998 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9999 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10006 if (do_dynamic
&& dynamic_addr
)
10007 printf (ngettext ("\nDynamic section at offset 0x%lx "
10008 "contains %lu entry:\n",
10009 "\nDynamic section at offset 0x%lx "
10010 "contains %lu entries:\n",
10012 dynamic_addr
, (unsigned long) dynamic_nent
);
10014 printf (_(" Tag Type Name/Value\n"));
10016 for (entry
= dynamic_section
;
10017 entry
< dynamic_section
+ dynamic_nent
;
10022 const char * dtype
;
10025 print_vma (entry
->d_tag
, FULL_HEX
);
10026 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10027 printf (" (%s)%*s", dtype
,
10028 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10031 switch (entry
->d_tag
)
10035 print_dynamic_flags (entry
->d_un
.d_val
);
10045 switch (entry
->d_tag
)
10048 printf (_("Auxiliary library"));
10052 printf (_("Filter library"));
10056 printf (_("Configuration file"));
10060 printf (_("Dependency audit library"));
10064 printf (_("Audit library"));
10068 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10069 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10073 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10082 printf (_("Flags:"));
10084 if (entry
->d_un
.d_val
== 0)
10085 printf (_(" None\n"));
10088 unsigned long int val
= entry
->d_un
.d_val
;
10090 if (val
& DTF_1_PARINIT
)
10092 printf (" PARINIT");
10093 val
^= DTF_1_PARINIT
;
10095 if (val
& DTF_1_CONFEXP
)
10097 printf (" CONFEXP");
10098 val
^= DTF_1_CONFEXP
;
10101 printf (" %lx", val
);
10110 printf (_("Flags:"));
10112 if (entry
->d_un
.d_val
== 0)
10113 printf (_(" None\n"));
10116 unsigned long int val
= entry
->d_un
.d_val
;
10118 if (val
& DF_P1_LAZYLOAD
)
10120 printf (" LAZYLOAD");
10121 val
^= DF_P1_LAZYLOAD
;
10123 if (val
& DF_P1_GROUPPERM
)
10125 printf (" GROUPPERM");
10126 val
^= DF_P1_GROUPPERM
;
10129 printf (" %lx", val
);
10138 printf (_("Flags:"));
10139 if (entry
->d_un
.d_val
== 0)
10140 printf (_(" None\n"));
10143 unsigned long int val
= entry
->d_un
.d_val
;
10145 if (val
& DF_1_NOW
)
10150 if (val
& DF_1_GLOBAL
)
10152 printf (" GLOBAL");
10153 val
^= DF_1_GLOBAL
;
10155 if (val
& DF_1_GROUP
)
10160 if (val
& DF_1_NODELETE
)
10162 printf (" NODELETE");
10163 val
^= DF_1_NODELETE
;
10165 if (val
& DF_1_LOADFLTR
)
10167 printf (" LOADFLTR");
10168 val
^= DF_1_LOADFLTR
;
10170 if (val
& DF_1_INITFIRST
)
10172 printf (" INITFIRST");
10173 val
^= DF_1_INITFIRST
;
10175 if (val
& DF_1_NOOPEN
)
10177 printf (" NOOPEN");
10178 val
^= DF_1_NOOPEN
;
10180 if (val
& DF_1_ORIGIN
)
10182 printf (" ORIGIN");
10183 val
^= DF_1_ORIGIN
;
10185 if (val
& DF_1_DIRECT
)
10187 printf (" DIRECT");
10188 val
^= DF_1_DIRECT
;
10190 if (val
& DF_1_TRANS
)
10195 if (val
& DF_1_INTERPOSE
)
10197 printf (" INTERPOSE");
10198 val
^= DF_1_INTERPOSE
;
10200 if (val
& DF_1_NODEFLIB
)
10202 printf (" NODEFLIB");
10203 val
^= DF_1_NODEFLIB
;
10205 if (val
& DF_1_NODUMP
)
10207 printf (" NODUMP");
10208 val
^= DF_1_NODUMP
;
10210 if (val
& DF_1_CONFALT
)
10212 printf (" CONFALT");
10213 val
^= DF_1_CONFALT
;
10215 if (val
& DF_1_ENDFILTEE
)
10217 printf (" ENDFILTEE");
10218 val
^= DF_1_ENDFILTEE
;
10220 if (val
& DF_1_DISPRELDNE
)
10222 printf (" DISPRELDNE");
10223 val
^= DF_1_DISPRELDNE
;
10225 if (val
& DF_1_DISPRELPND
)
10227 printf (" DISPRELPND");
10228 val
^= DF_1_DISPRELPND
;
10230 if (val
& DF_1_NODIRECT
)
10232 printf (" NODIRECT");
10233 val
^= DF_1_NODIRECT
;
10235 if (val
& DF_1_IGNMULDEF
)
10237 printf (" IGNMULDEF");
10238 val
^= DF_1_IGNMULDEF
;
10240 if (val
& DF_1_NOKSYMS
)
10242 printf (" NOKSYMS");
10243 val
^= DF_1_NOKSYMS
;
10245 if (val
& DF_1_NOHDR
)
10250 if (val
& DF_1_EDITED
)
10252 printf (" EDITED");
10253 val
^= DF_1_EDITED
;
10255 if (val
& DF_1_NORELOC
)
10257 printf (" NORELOC");
10258 val
^= DF_1_NORELOC
;
10260 if (val
& DF_1_SYMINTPOSE
)
10262 printf (" SYMINTPOSE");
10263 val
^= DF_1_SYMINTPOSE
;
10265 if (val
& DF_1_GLOBAUDIT
)
10267 printf (" GLOBAUDIT");
10268 val
^= DF_1_GLOBAUDIT
;
10270 if (val
& DF_1_SINGLETON
)
10272 printf (" SINGLETON");
10273 val
^= DF_1_SINGLETON
;
10275 if (val
& DF_1_STUB
)
10280 if (val
& DF_1_PIE
)
10285 if (val
& DF_1_KMOD
)
10290 if (val
& DF_1_WEAKFILTER
)
10292 printf (" WEAKFILTER");
10293 val
^= DF_1_WEAKFILTER
;
10295 if (val
& DF_1_NOCOMMON
)
10297 printf (" NOCOMMON");
10298 val
^= DF_1_NOCOMMON
;
10301 printf (" %lx", val
);
10308 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10310 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10330 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10336 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10337 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10343 switch (entry
->d_tag
)
10346 printf (_("Shared library: [%s]"), name
);
10348 if (streq (name
, program_interpreter
))
10349 printf (_(" program interpreter"));
10353 printf (_("Library soname: [%s]"), name
);
10357 printf (_("Library rpath: [%s]"), name
);
10361 printf (_("Library runpath: [%s]"), name
);
10365 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10370 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10383 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10384 /* Fall through. */
10388 case DT_INIT_ARRAYSZ
:
10389 case DT_FINI_ARRAYSZ
:
10390 case DT_GNU_CONFLICTSZ
:
10391 case DT_GNU_LIBLISTSZ
:
10394 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10395 printf (_(" (bytes)\n"));
10400 case DT_VERNEEDNUM
:
10405 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10414 case DT_INIT_ARRAY
:
10415 case DT_FINI_ARRAY
:
10418 if (entry
->d_tag
== DT_USED
10419 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10421 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10425 printf (_("Not needed object: [%s]\n"), name
);
10430 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10436 /* The value of this entry is ignored. */
10441 case DT_GNU_PRELINKED
:
10445 time_t atime
= entry
->d_un
.d_val
;
10447 tmp
= gmtime (&atime
);
10448 /* PR 17533 file: 041-1244816-0.004. */
10450 printf (_("<corrupt time val: %lx"),
10451 (unsigned long) atime
);
10453 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10454 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10455 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10461 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10464 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10470 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10471 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10476 switch (filedata
->file_header
.e_machine
)
10479 dynamic_section_aarch64_val (entry
);
10482 case EM_MIPS_RS3_LE
:
10483 dynamic_section_mips_val (entry
);
10486 dynamic_section_parisc_val (entry
);
10489 dynamic_section_ia64_val (entry
);
10492 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10504 get_ver_flags (unsigned int flags
)
10506 static char buff
[128];
10513 if (flags
& VER_FLG_BASE
)
10514 strcat (buff
, "BASE");
10516 if (flags
& VER_FLG_WEAK
)
10518 if (flags
& VER_FLG_BASE
)
10519 strcat (buff
, " | ");
10521 strcat (buff
, "WEAK");
10524 if (flags
& VER_FLG_INFO
)
10526 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10527 strcat (buff
, " | ");
10529 strcat (buff
, "INFO");
10532 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10534 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10535 strcat (buff
, " | ");
10537 strcat (buff
, _("<unknown>"));
10543 /* Display the contents of the version sections. */
10546 process_version_sections (Filedata
* filedata
)
10548 Elf_Internal_Shdr
* section
;
10550 bfd_boolean found
= FALSE
;
10555 for (i
= 0, section
= filedata
->section_headers
;
10556 i
< filedata
->file_header
.e_shnum
;
10559 switch (section
->sh_type
)
10561 case SHT_GNU_verdef
:
10563 Elf_External_Verdef
* edefs
;
10570 printf (ngettext ("\nVersion definition section '%s' "
10571 "contains %u entry:\n",
10572 "\nVersion definition section '%s' "
10573 "contains %u entries:\n",
10575 printable_section_name (filedata
, section
),
10578 printf (_(" Addr: 0x"));
10579 printf_vma (section
->sh_addr
);
10580 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10581 (unsigned long) section
->sh_offset
, section
->sh_link
,
10582 printable_section_name_from_index (filedata
, section
->sh_link
));
10584 edefs
= (Elf_External_Verdef
*)
10585 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10586 _("version definition section"));
10589 endbuf
= (char *) edefs
+ section
->sh_size
;
10591 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10594 Elf_External_Verdef
* edef
;
10595 Elf_Internal_Verdef ent
;
10596 Elf_External_Verdaux
* eaux
;
10597 Elf_Internal_Verdaux aux
;
10598 unsigned long isum
;
10601 vstart
= ((char *) edefs
) + idx
;
10602 if (vstart
+ sizeof (*edef
) > endbuf
)
10605 edef
= (Elf_External_Verdef
*) vstart
;
10607 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10608 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10609 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10610 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10611 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10612 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10613 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10615 printf (_(" %#06lx: Rev: %d Flags: %s"),
10616 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10618 printf (_(" Index: %d Cnt: %d "),
10619 ent
.vd_ndx
, ent
.vd_cnt
);
10621 /* Check for overflow. */
10622 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10625 vstart
+= ent
.vd_aux
;
10627 if (vstart
+ sizeof (*eaux
) > endbuf
)
10629 eaux
= (Elf_External_Verdaux
*) vstart
;
10631 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10632 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10634 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10635 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10637 printf (_("Name index: %ld\n"), aux
.vda_name
);
10639 isum
= idx
+ ent
.vd_aux
;
10641 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10643 if (aux
.vda_next
< sizeof (*eaux
)
10644 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10646 warn (_("Invalid vda_next field of %lx\n"),
10651 /* Check for overflow. */
10652 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10655 isum
+= aux
.vda_next
;
10656 vstart
+= aux
.vda_next
;
10658 if (vstart
+ sizeof (*eaux
) > endbuf
)
10660 eaux
= (Elf_External_Verdaux
*) vstart
;
10662 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10663 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10665 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10666 printf (_(" %#06lx: Parent %d: %s\n"),
10667 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10669 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10670 isum
, j
, aux
.vda_name
);
10673 if (j
< ent
.vd_cnt
)
10674 printf (_(" Version def aux past end of section\n"));
10677 file: id:000001,src:000172+005151,op:splice,rep:2. */
10678 if (ent
.vd_next
< sizeof (*edef
)
10679 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10681 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10682 cnt
= section
->sh_info
;
10685 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10688 idx
+= ent
.vd_next
;
10691 if (cnt
< section
->sh_info
)
10692 printf (_(" Version definition past end of section\n"));
10698 case SHT_GNU_verneed
:
10700 Elf_External_Verneed
* eneed
;
10707 printf (ngettext ("\nVersion needs section '%s' "
10708 "contains %u entry:\n",
10709 "\nVersion needs section '%s' "
10710 "contains %u entries:\n",
10712 printable_section_name (filedata
, section
), section
->sh_info
);
10714 printf (_(" Addr: 0x"));
10715 printf_vma (section
->sh_addr
);
10716 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10717 (unsigned long) section
->sh_offset
, section
->sh_link
,
10718 printable_section_name_from_index (filedata
, section
->sh_link
));
10720 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10721 section
->sh_offset
, 1,
10723 _("Version Needs section"));
10726 endbuf
= (char *) eneed
+ section
->sh_size
;
10728 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10730 Elf_External_Verneed
* entry
;
10731 Elf_Internal_Verneed ent
;
10732 unsigned long isum
;
10736 vstart
= ((char *) eneed
) + idx
;
10737 if (vstart
+ sizeof (*entry
) > endbuf
)
10740 entry
= (Elf_External_Verneed
*) vstart
;
10742 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10743 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10744 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10745 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10746 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10748 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10750 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10751 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10753 printf (_(" File: %lx"), ent
.vn_file
);
10755 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10757 /* Check for overflow. */
10758 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10760 vstart
+= ent
.vn_aux
;
10762 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10764 Elf_External_Vernaux
* eaux
;
10765 Elf_Internal_Vernaux aux
;
10767 if (vstart
+ sizeof (*eaux
) > endbuf
)
10769 eaux
= (Elf_External_Vernaux
*) vstart
;
10771 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10772 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10773 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10774 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10775 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10777 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10778 printf (_(" %#06lx: Name: %s"),
10779 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10781 printf (_(" %#06lx: Name index: %lx"),
10782 isum
, aux
.vna_name
);
10784 printf (_(" Flags: %s Version: %d\n"),
10785 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10787 if (aux
.vna_next
< sizeof (*eaux
)
10788 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10790 warn (_("Invalid vna_next field of %lx\n"),
10795 /* Check for overflow. */
10796 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10798 isum
+= aux
.vna_next
;
10799 vstart
+= aux
.vna_next
;
10802 if (j
< ent
.vn_cnt
)
10803 warn (_("Missing Version Needs auxillary information\n"));
10805 if (ent
.vn_next
< sizeof (*entry
)
10806 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10808 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10809 cnt
= section
->sh_info
;
10812 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10814 idx
+= ent
.vn_next
;
10817 if (cnt
< section
->sh_info
)
10818 warn (_("Missing Version Needs information\n"));
10824 case SHT_GNU_versym
:
10826 Elf_Internal_Shdr
* link_section
;
10829 unsigned char * edata
;
10830 unsigned short * data
;
10832 Elf_Internal_Sym
* symbols
;
10833 Elf_Internal_Shdr
* string_sec
;
10834 unsigned long num_syms
;
10837 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10840 link_section
= filedata
->section_headers
+ section
->sh_link
;
10841 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10843 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10848 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10849 if (symbols
== NULL
)
10852 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10854 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10855 string_sec
->sh_size
,
10856 _("version string table"));
10863 printf (ngettext ("\nVersion symbols section '%s' "
10864 "contains %lu entry:\n",
10865 "\nVersion symbols section '%s' "
10866 "contains %lu entries:\n",
10868 printable_section_name (filedata
, section
), (unsigned long) total
);
10870 printf (_(" Addr: 0x"));
10871 printf_vma (section
->sh_addr
);
10872 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10873 (unsigned long) section
->sh_offset
, section
->sh_link
,
10874 printable_section_name (filedata
, link_section
));
10876 off
= offset_from_vma (filedata
,
10877 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10878 total
* sizeof (short));
10879 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10881 _("version symbol data"));
10889 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10891 for (cnt
= total
; cnt
--;)
10892 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10897 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10901 char *invalid
= _("*invalid*");
10903 printf (" %03x:", cnt
);
10905 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10906 switch (data
[cnt
+ j
])
10909 fputs (_(" 0 (*local*) "), stdout
);
10913 fputs (_(" 1 (*global*) "), stdout
);
10917 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10918 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10920 /* If this index value is greater than the size of the symbols
10921 array, break to avoid an out-of-bounds read. */
10922 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10924 warn (_("invalid index into symbol array\n"));
10929 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10931 Elf_Internal_Verneed ivn
;
10932 unsigned long offset
;
10934 offset
= offset_from_vma
10935 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10936 sizeof (Elf_External_Verneed
));
10940 Elf_Internal_Vernaux ivna
;
10941 Elf_External_Verneed evn
;
10942 Elf_External_Vernaux evna
;
10943 unsigned long a_off
;
10945 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10946 _("version need")) == NULL
)
10949 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10950 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10952 a_off
= offset
+ ivn
.vn_aux
;
10956 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10957 1, _("version need aux (2)")) == NULL
)
10960 ivna
.vna_other
= 0;
10964 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10965 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10968 a_off
+= ivna
.vna_next
;
10970 while (ivna
.vna_other
!= data
[cnt
+ j
]
10971 && ivna
.vna_next
!= 0);
10973 if (ivna
.vna_other
== data
[cnt
+ j
])
10975 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10977 if (ivna
.vna_name
>= string_sec
->sh_size
)
10980 name
= strtab
+ ivna
.vna_name
;
10984 offset
+= ivn
.vn_next
;
10986 while (ivn
.vn_next
);
10989 if (data
[cnt
+ j
] != 0x8001
10990 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10992 Elf_Internal_Verdef ivd
;
10993 Elf_External_Verdef evd
;
10994 unsigned long offset
;
10996 offset
= offset_from_vma
10997 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11002 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11003 _("version def")) == NULL
)
11006 /* PR 17531: file: 046-1082287-0.004. */
11007 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11012 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11013 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11016 offset
+= ivd
.vd_next
;
11018 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11019 && ivd
.vd_next
!= 0);
11021 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11023 Elf_External_Verdaux evda
;
11024 Elf_Internal_Verdaux ivda
;
11026 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11028 if (get_data (&evda
, filedata
,
11029 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11031 _("version def aux")) == NULL
)
11034 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11036 if (ivda
.vda_name
>= string_sec
->sh_size
)
11038 else if (name
!= NULL
&& name
!= invalid
)
11039 name
= _("*both*");
11041 name
= strtab
+ ivda
.vda_name
;
11045 nn
+= printf ("(%s%-*s",
11047 12 - (int) strlen (name
),
11051 printf ("%*c", 18 - nn
, ' ');
11069 printf (_("\nNo version information found in this file.\n"));
11074 static const char *
11075 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11077 static char buff
[32];
11081 case STB_LOCAL
: return "LOCAL";
11082 case STB_GLOBAL
: return "GLOBAL";
11083 case STB_WEAK
: return "WEAK";
11085 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11086 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11088 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11090 if (binding
== STB_GNU_UNIQUE
11091 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11093 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11096 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11101 static const char *
11102 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11104 static char buff
[32];
11108 case STT_NOTYPE
: return "NOTYPE";
11109 case STT_OBJECT
: return "OBJECT";
11110 case STT_FUNC
: return "FUNC";
11111 case STT_SECTION
: return "SECTION";
11112 case STT_FILE
: return "FILE";
11113 case STT_COMMON
: return "COMMON";
11114 case STT_TLS
: return "TLS";
11115 case STT_RELC
: return "RELC";
11116 case STT_SRELC
: return "SRELC";
11118 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11120 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11121 return "THUMB_FUNC";
11123 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11126 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11127 return "PARISC_MILLI";
11129 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11131 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11133 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11135 if (type
== STT_HP_OPAQUE
)
11136 return "HP_OPAQUE";
11137 if (type
== STT_HP_STUB
)
11141 if (type
== STT_GNU_IFUNC
11142 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11143 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11146 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11149 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11154 static const char *
11155 get_symbol_visibility (unsigned int visibility
)
11157 switch (visibility
)
11159 case STV_DEFAULT
: return "DEFAULT";
11160 case STV_INTERNAL
: return "INTERNAL";
11161 case STV_HIDDEN
: return "HIDDEN";
11162 case STV_PROTECTED
: return "PROTECTED";
11164 error (_("Unrecognized visibility value: %u"), visibility
);
11165 return _("<unknown>");
11169 static const char *
11170 get_alpha_symbol_other (unsigned int other
)
11174 case STO_ALPHA_NOPV
: return "NOPV";
11175 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11177 error (_("Unrecognized alpah specific other value: %u"), other
);
11178 return _("<unknown>");
11182 static const char *
11183 get_solaris_symbol_visibility (unsigned int visibility
)
11185 switch (visibility
)
11187 case 4: return "EXPORTED";
11188 case 5: return "SINGLETON";
11189 case 6: return "ELIMINATE";
11190 default: return get_symbol_visibility (visibility
);
11194 static const char *
11195 get_aarch64_symbol_other (unsigned int other
)
11197 static char buf
[32];
11199 if (other
& STO_AARCH64_VARIANT_PCS
)
11201 other
&= ~STO_AARCH64_VARIANT_PCS
;
11203 return "VARIANT_PCS";
11204 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11210 static const char *
11211 get_mips_symbol_other (unsigned int other
)
11215 case STO_OPTIONAL
: return "OPTIONAL";
11216 case STO_MIPS_PLT
: return "MIPS PLT";
11217 case STO_MIPS_PIC
: return "MIPS PIC";
11218 case STO_MICROMIPS
: return "MICROMIPS";
11219 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11220 case STO_MIPS16
: return "MIPS16";
11221 default: return NULL
;
11225 static const char *
11226 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11228 if (is_ia64_vms (filedata
))
11230 static char res
[32];
11234 /* Function types is for images and .STB files only. */
11235 switch (filedata
->file_header
.e_type
)
11239 switch (VMS_ST_FUNC_TYPE (other
))
11241 case VMS_SFT_CODE_ADDR
:
11242 strcat (res
, " CA");
11244 case VMS_SFT_SYMV_IDX
:
11245 strcat (res
, " VEC");
11248 strcat (res
, " FD");
11250 case VMS_SFT_RESERVE
:
11251 strcat (res
, " RSV");
11254 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11255 VMS_ST_FUNC_TYPE (other
));
11256 strcat (res
, " <unknown>");
11263 switch (VMS_ST_LINKAGE (other
))
11265 case VMS_STL_IGNORE
:
11266 strcat (res
, " IGN");
11268 case VMS_STL_RESERVE
:
11269 strcat (res
, " RSV");
11272 strcat (res
, " STD");
11275 strcat (res
, " LNK");
11278 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11279 VMS_ST_LINKAGE (other
));
11280 strcat (res
, " <unknown>");
11292 static const char *
11293 get_ppc64_symbol_other (unsigned int other
)
11295 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11298 other
>>= STO_PPC64_LOCAL_BIT
;
11301 static char buf
[32];
11303 other
= ppc64_decode_local_entry (other
);
11304 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11310 static const char *
11311 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11313 const char * result
= NULL
;
11314 static char buff
[32];
11319 switch (filedata
->file_header
.e_machine
)
11322 result
= get_alpha_symbol_other (other
);
11325 result
= get_aarch64_symbol_other (other
);
11328 result
= get_mips_symbol_other (other
);
11331 result
= get_ia64_symbol_other (filedata
, other
);
11334 result
= get_ppc64_symbol_other (other
);
11344 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11348 static const char *
11349 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11351 static char buff
[32];
11355 case SHN_UNDEF
: return "UND";
11356 case SHN_ABS
: return "ABS";
11357 case SHN_COMMON
: return "COM";
11359 if (type
== SHN_IA_64_ANSI_COMMON
11360 && filedata
->file_header
.e_machine
== EM_IA_64
11361 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11363 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11364 || filedata
->file_header
.e_machine
== EM_L1OM
11365 || filedata
->file_header
.e_machine
== EM_K1OM
)
11366 && type
== SHN_X86_64_LCOMMON
)
11367 return "LARGE_COM";
11368 else if ((type
== SHN_MIPS_SCOMMON
11369 && filedata
->file_header
.e_machine
== EM_MIPS
)
11370 || (type
== SHN_TIC6X_SCOMMON
11371 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11373 else if (type
== SHN_MIPS_SUNDEFINED
11374 && filedata
->file_header
.e_machine
== EM_MIPS
)
11376 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11377 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11378 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11379 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11380 else if (type
>= SHN_LORESERVE
)
11381 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11382 else if (type
>= filedata
->file_header
.e_shnum
)
11383 sprintf (buff
, _("bad section index[%3d]"), type
);
11385 sprintf (buff
, "%3d", type
);
11393 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11395 unsigned char * e_data
;
11398 /* If the size_t type is smaller than the bfd_size_type, eg because
11399 you are building a 32-bit tool on a 64-bit host, then make sure
11400 that when (number) is cast to (size_t) no information is lost. */
11401 if (sizeof (size_t) < sizeof (bfd_size_type
)
11402 && (bfd_size_type
) ((size_t) number
) != number
)
11404 error (_("Size truncation prevents reading %s elements of size %u\n"),
11405 bfd_vmatoa ("u", number
), ent_size
);
11409 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11410 attempting to allocate memory when the read is bound to fail. */
11411 if (ent_size
* number
> filedata
->file_size
)
11413 error (_("Invalid number of dynamic entries: %s\n"),
11414 bfd_vmatoa ("u", number
));
11418 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11419 if (e_data
== NULL
)
11421 error (_("Out of memory reading %s dynamic entries\n"),
11422 bfd_vmatoa ("u", number
));
11426 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11428 error (_("Unable to read in %s bytes of dynamic data\n"),
11429 bfd_vmatoa ("u", number
* ent_size
));
11434 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11435 if (i_data
== NULL
)
11437 error (_("Out of memory allocating space for %s dynamic entries\n"),
11438 bfd_vmatoa ("u", number
));
11444 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11452 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11454 Elf_Internal_Sym
* psym
;
11457 n
= print_vma (si
, DEC_5
);
11459 fputs (&" "[n
], stdout
);
11460 printf (" %3lu: ", hn
);
11462 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11464 printf (_("<No info available for dynamic symbol number %lu>\n"),
11465 (unsigned long) si
);
11469 psym
= dynamic_symbols
+ si
;
11470 print_vma (psym
->st_value
, LONG_HEX
);
11472 print_vma (psym
->st_size
, DEC_5
);
11474 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11475 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11477 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11478 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11481 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11483 printf (" %-7s", get_symbol_visibility (vis
));
11484 /* Check to see if any other bits in the st_other field are set.
11485 Note - displaying this information disrupts the layout of the
11486 table being generated, but for the moment this case is very
11488 if (psym
->st_other
^ vis
)
11489 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11492 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11493 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11494 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11496 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11500 static const char *
11501 get_symbol_version_string (Filedata
* filedata
,
11502 bfd_boolean is_dynsym
,
11503 const char * strtab
,
11504 unsigned long int strtab_size
,
11506 Elf_Internal_Sym
* psym
,
11507 enum versioned_symbol_info
* sym_info
,
11508 unsigned short * vna_other
)
11510 unsigned char data
[2];
11511 unsigned short vers_data
;
11512 unsigned long offset
;
11513 unsigned short max_vd_ndx
;
11516 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11519 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11520 sizeof data
+ si
* sizeof (vers_data
));
11522 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11523 sizeof (data
), 1, _("version data")) == NULL
)
11526 vers_data
= byte_get (data
, 2);
11528 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11531 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11534 /* Usually we'd only see verdef for defined symbols, and verneed for
11535 undefined symbols. However, symbols defined by the linker in
11536 .dynbss for variables copied from a shared library in order to
11537 avoid text relocations are defined yet have verneed. We could
11538 use a heuristic to detect the special case, for example, check
11539 for verneed first on symbols defined in SHT_NOBITS sections, but
11540 it is simpler and more reliable to just look for both verdef and
11541 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11543 if (psym
->st_shndx
!= SHN_UNDEF
11544 && vers_data
!= 0x8001
11545 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11547 Elf_Internal_Verdef ivd
;
11548 Elf_Internal_Verdaux ivda
;
11549 Elf_External_Verdaux evda
;
11552 off
= offset_from_vma (filedata
,
11553 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11554 sizeof (Elf_External_Verdef
));
11558 Elf_External_Verdef evd
;
11560 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11561 _("version def")) == NULL
)
11570 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11571 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11572 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11573 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11576 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11577 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11579 off
+= ivd
.vd_next
;
11581 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11583 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11585 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11588 off
-= ivd
.vd_next
;
11591 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11592 _("version def aux")) != NULL
)
11594 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11596 if (psym
->st_name
!= ivda
.vda_name
)
11597 return (ivda
.vda_name
< strtab_size
11598 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11603 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11605 Elf_External_Verneed evn
;
11606 Elf_Internal_Verneed ivn
;
11607 Elf_Internal_Vernaux ivna
;
11609 offset
= offset_from_vma (filedata
,
11610 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11614 unsigned long vna_off
;
11616 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11617 _("version need")) == NULL
)
11620 ivna
.vna_other
= 0;
11625 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11626 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11628 vna_off
= offset
+ ivn
.vn_aux
;
11632 Elf_External_Vernaux evna
;
11634 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11635 _("version need aux (3)")) == NULL
)
11638 ivna
.vna_other
= 0;
11643 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11644 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11645 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11648 vna_off
+= ivna
.vna_next
;
11650 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11652 if (ivna
.vna_other
== vers_data
)
11655 offset
+= ivn
.vn_next
;
11657 while (ivn
.vn_next
!= 0);
11659 if (ivna
.vna_other
== vers_data
)
11661 *sym_info
= symbol_undefined
;
11662 *vna_other
= ivna
.vna_other
;
11663 return (ivna
.vna_name
< strtab_size
11664 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11666 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11667 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11668 return _("<corrupt>");
11673 /* Dump the symbol table. */
11675 process_symbol_table (Filedata
* filedata
)
11677 Elf_Internal_Shdr
* section
;
11678 bfd_size_type nbuckets
= 0;
11679 bfd_size_type nchains
= 0;
11680 bfd_vma
* buckets
= NULL
;
11681 bfd_vma
* chains
= NULL
;
11682 bfd_vma ngnubuckets
= 0;
11683 bfd_vma
* gnubuckets
= NULL
;
11684 bfd_vma
* gnuchains
= NULL
;
11685 bfd_vma
* mipsxlat
= NULL
;
11686 bfd_vma gnusymidx
= 0;
11687 bfd_size_type ngnuchains
= 0;
11689 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11692 if (dynamic_info
[DT_HASH
]
11694 || (do_using_dynamic
11696 && dynamic_strings
!= NULL
)))
11698 unsigned char nb
[8];
11699 unsigned char nc
[8];
11700 unsigned int hash_ent_size
= 4;
11702 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11703 || filedata
->file_header
.e_machine
== EM_S390
11704 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11705 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11708 if (fseek (filedata
->handle
,
11709 (archive_file_offset
11710 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11711 sizeof nb
+ sizeof nc
)),
11714 error (_("Unable to seek to start of dynamic information\n"));
11718 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11720 error (_("Failed to read in number of buckets\n"));
11724 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11726 error (_("Failed to read in number of chains\n"));
11730 nbuckets
= byte_get (nb
, hash_ent_size
);
11731 nchains
= byte_get (nc
, hash_ent_size
);
11733 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11734 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11737 if (buckets
== NULL
|| chains
== NULL
)
11739 if (do_using_dynamic
)
11750 if (dynamic_info_DT_GNU_HASH
11752 || (do_using_dynamic
11754 && dynamic_strings
!= NULL
)))
11756 unsigned char nb
[16];
11757 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11758 bfd_vma buckets_vma
;
11760 if (fseek (filedata
->handle
,
11761 (archive_file_offset
11762 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11766 error (_("Unable to seek to start of dynamic information\n"));
11770 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11772 error (_("Failed to read in number of buckets\n"));
11776 ngnubuckets
= byte_get (nb
, 4);
11777 gnusymidx
= byte_get (nb
+ 4, 4);
11778 bitmaskwords
= byte_get (nb
+ 8, 4);
11779 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11781 buckets_vma
+= bitmaskwords
* 4;
11783 buckets_vma
+= bitmaskwords
* 8;
11785 if (fseek (filedata
->handle
,
11786 (archive_file_offset
11787 + offset_from_vma (filedata
, buckets_vma
, 4)),
11790 error (_("Unable to seek to start of dynamic information\n"));
11794 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11796 if (gnubuckets
== NULL
)
11799 for (i
= 0; i
< ngnubuckets
; i
++)
11800 if (gnubuckets
[i
] != 0)
11802 if (gnubuckets
[i
] < gnusymidx
)
11805 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11806 maxchain
= gnubuckets
[i
];
11809 if (maxchain
== 0xffffffff)
11812 maxchain
-= gnusymidx
;
11814 if (fseek (filedata
->handle
,
11815 (archive_file_offset
11816 + offset_from_vma (filedata
, buckets_vma
11817 + 4 * (ngnubuckets
+ maxchain
), 4)),
11820 error (_("Unable to seek to start of dynamic information\n"));
11826 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11828 error (_("Failed to determine last chain length\n"));
11832 if (maxchain
+ 1 == 0)
11837 while ((byte_get (nb
, 4) & 1) == 0);
11839 if (fseek (filedata
->handle
,
11840 (archive_file_offset
11841 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11844 error (_("Unable to seek to start of dynamic information\n"));
11848 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11849 ngnuchains
= maxchain
;
11851 if (gnuchains
== NULL
)
11854 if (dynamic_info_DT_MIPS_XHASH
)
11856 if (fseek (filedata
->handle
,
11857 (archive_file_offset
11858 + offset_from_vma (filedata
, (buckets_vma
11863 error (_("Unable to seek to start of dynamic information\n"));
11867 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11871 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11876 if (gnuchains
== NULL
)
11881 if (do_using_dynamic
)
11886 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11888 && do_using_dynamic
11889 && dynamic_strings
!= NULL
11890 && dynamic_symbols
!= NULL
)
11894 if (dynamic_info
[DT_HASH
])
11899 printf (_("\nSymbol table for image:\n"));
11901 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11903 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11905 visited
= xcmalloc (nchains
, 1);
11906 memset (visited
, 0, nchains
);
11907 for (hn
= 0; hn
< nbuckets
; hn
++)
11909 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11911 print_dynamic_symbol (filedata
, si
, hn
);
11912 if (si
>= nchains
|| visited
[si
])
11914 error (_("histogram chain is corrupt\n"));
11923 if (dynamic_info_DT_GNU_HASH
)
11925 printf (_("\nSymbol table of `%s' for image:\n"),
11926 GNU_HASH_SECTION_NAME
);
11928 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11930 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11932 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11933 if (gnubuckets
[hn
] != 0)
11935 bfd_vma si
= gnubuckets
[hn
];
11936 bfd_vma off
= si
- gnusymidx
;
11940 if (dynamic_info_DT_MIPS_XHASH
)
11941 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11943 print_dynamic_symbol (filedata
, si
, hn
);
11946 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11950 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11951 && filedata
->section_headers
!= NULL
)
11955 for (i
= 0, section
= filedata
->section_headers
;
11956 i
< filedata
->file_header
.e_shnum
;
11960 char * strtab
= NULL
;
11961 unsigned long int strtab_size
= 0;
11962 Elf_Internal_Sym
* symtab
;
11963 Elf_Internal_Sym
* psym
;
11964 unsigned long num_syms
;
11966 if ((section
->sh_type
!= SHT_SYMTAB
11967 && section
->sh_type
!= SHT_DYNSYM
)
11969 && section
->sh_type
== SHT_SYMTAB
))
11972 if (section
->sh_entsize
== 0)
11974 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11975 printable_section_name (filedata
, section
));
11979 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11980 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11981 "\nSymbol table '%s' contains %lu entries:\n",
11983 printable_section_name (filedata
, section
),
11987 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11989 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11991 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11992 if (symtab
== NULL
)
11995 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11997 strtab
= filedata
->string_table
;
11998 strtab_size
= filedata
->string_table_length
;
12000 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12002 Elf_Internal_Shdr
* string_sec
;
12004 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12006 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12007 1, string_sec
->sh_size
,
12008 _("string table"));
12009 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12012 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12014 const char *version_string
;
12015 enum versioned_symbol_info sym_info
;
12016 unsigned short vna_other
;
12018 printf ("%6d: ", si
);
12019 print_vma (psym
->st_value
, LONG_HEX
);
12021 print_vma (psym
->st_size
, DEC_5
);
12022 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12023 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12024 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12025 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12028 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12030 printf (" %-7s", get_symbol_visibility (vis
));
12031 /* Check to see if any other bits in the st_other field are set.
12032 Note - displaying this information disrupts the layout of the
12033 table being generated, but for the moment this case is very rare. */
12034 if (psym
->st_other
^ vis
)
12035 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12037 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12038 print_symbol (25, psym
->st_name
< strtab_size
12039 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12042 = get_symbol_version_string (filedata
,
12043 section
->sh_type
== SHT_DYNSYM
,
12044 strtab
, strtab_size
, si
,
12045 psym
, &sym_info
, &vna_other
);
12046 if (version_string
)
12048 if (sym_info
== symbol_undefined
)
12049 printf ("@%s (%d)", version_string
, vna_other
);
12051 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12057 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12058 && si
>= section
->sh_info
12059 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12060 && filedata
->file_header
.e_machine
!= EM_MIPS
12061 /* Solaris binaries have been found to violate this requirement as
12062 well. Not sure if this is a bug or an ABI requirement. */
12063 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12064 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12065 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12069 if (strtab
!= filedata
->string_table
)
12075 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12077 if (do_histogram
&& buckets
!= NULL
)
12079 unsigned long * lengths
;
12080 unsigned long * counts
;
12083 unsigned long maxlength
= 0;
12084 unsigned long nzero_counts
= 0;
12085 unsigned long nsyms
= 0;
12088 printf (ngettext ("\nHistogram for bucket list length "
12089 "(total of %lu bucket):\n",
12090 "\nHistogram for bucket list length "
12091 "(total of %lu buckets):\n",
12092 (unsigned long) nbuckets
),
12093 (unsigned long) nbuckets
);
12095 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12096 if (lengths
== NULL
)
12098 error (_("Out of memory allocating space for histogram buckets\n"));
12101 visited
= xcmalloc (nchains
, 1);
12102 memset (visited
, 0, nchains
);
12104 printf (_(" Length Number %% of total Coverage\n"));
12105 for (hn
= 0; hn
< nbuckets
; ++hn
)
12107 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12110 if (maxlength
< ++lengths
[hn
])
12112 if (si
>= nchains
|| visited
[si
])
12114 error (_("histogram chain is corrupt\n"));
12122 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12123 if (counts
== NULL
)
12126 error (_("Out of memory allocating space for histogram counts\n"));
12130 for (hn
= 0; hn
< nbuckets
; ++hn
)
12131 ++counts
[lengths
[hn
]];
12136 printf (" 0 %-10lu (%5.1f%%)\n",
12137 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12138 for (i
= 1; i
<= maxlength
; ++i
)
12140 nzero_counts
+= counts
[i
] * i
;
12141 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12142 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12143 (nzero_counts
* 100.0) / nsyms
);
12151 if (buckets
!= NULL
)
12157 if (do_histogram
&& gnubuckets
!= NULL
)
12159 unsigned long * lengths
;
12160 unsigned long * counts
;
12162 unsigned long maxlength
= 0;
12163 unsigned long nzero_counts
= 0;
12164 unsigned long nsyms
= 0;
12166 printf (ngettext ("\nHistogram for `%s' bucket list length "
12167 "(total of %lu bucket):\n",
12168 "\nHistogram for `%s' bucket list length "
12169 "(total of %lu buckets):\n",
12170 (unsigned long) ngnubuckets
),
12171 GNU_HASH_SECTION_NAME
,
12172 (unsigned long) ngnubuckets
);
12174 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12175 if (lengths
== NULL
)
12177 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12181 printf (_(" Length Number %% of total Coverage\n"));
12183 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12184 if (gnubuckets
[hn
] != 0)
12186 bfd_vma off
, length
= 1;
12188 for (off
= gnubuckets
[hn
] - gnusymidx
;
12189 /* PR 17531 file: 010-77222-0.004. */
12190 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12193 lengths
[hn
] = length
;
12194 if (length
> maxlength
)
12195 maxlength
= length
;
12199 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12200 if (counts
== NULL
)
12203 error (_("Out of memory allocating space for gnu histogram counts\n"));
12207 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12208 ++counts
[lengths
[hn
]];
12210 if (ngnubuckets
> 0)
12213 printf (" 0 %-10lu (%5.1f%%)\n",
12214 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12215 for (j
= 1; j
<= maxlength
; ++j
)
12217 nzero_counts
+= counts
[j
] * j
;
12218 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12219 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12220 (nzero_counts
* 100.0) / nsyms
);
12235 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12239 if (dynamic_syminfo
== NULL
12241 /* No syminfo, this is ok. */
12244 /* There better should be a dynamic symbol section. */
12245 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12249 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12250 "contains %d entry:\n",
12251 "\nDynamic info segment at offset 0x%lx "
12252 "contains %d entries:\n",
12253 dynamic_syminfo_nent
),
12254 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12256 printf (_(" Num: Name BoundTo Flags\n"));
12257 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12259 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12261 printf ("%4d: ", i
);
12262 if (i
>= num_dynamic_syms
)
12263 printf (_("<corrupt index>"));
12264 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12265 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12267 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12270 switch (dynamic_syminfo
[i
].si_boundto
)
12272 case SYMINFO_BT_SELF
:
12273 fputs ("SELF ", stdout
);
12275 case SYMINFO_BT_PARENT
:
12276 fputs ("PARENT ", stdout
);
12279 if (dynamic_syminfo
[i
].si_boundto
> 0
12280 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12281 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12283 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12287 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12291 if (flags
& SYMINFO_FLG_DIRECT
)
12292 printf (" DIRECT");
12293 if (flags
& SYMINFO_FLG_PASSTHRU
)
12294 printf (" PASSTHRU");
12295 if (flags
& SYMINFO_FLG_COPY
)
12297 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12298 printf (" LAZYLOAD");
12306 #define IN_RANGE(START,END,ADDR,OFF) \
12307 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12309 /* Check to see if the given reloc needs to be handled in a target specific
12310 manner. If so then process the reloc and return TRUE otherwise return
12313 If called with reloc == NULL, then this is a signal that reloc processing
12314 for the current section has finished, and any saved state should be
12318 target_specific_reloc_handling (Filedata
* filedata
,
12319 Elf_Internal_Rela
* reloc
,
12320 unsigned char * start
,
12321 unsigned char * end
,
12322 Elf_Internal_Sym
* symtab
,
12323 unsigned long num_syms
)
12325 unsigned int reloc_type
= 0;
12326 unsigned long sym_index
= 0;
12330 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12331 sym_index
= get_reloc_symindex (reloc
->r_info
);
12334 switch (filedata
->file_header
.e_machine
)
12337 case EM_MSP430_OLD
:
12339 static Elf_Internal_Sym
* saved_sym
= NULL
;
12347 switch (reloc_type
)
12349 case 10: /* R_MSP430_SYM_DIFF */
12350 if (uses_msp430x_relocs (filedata
))
12352 /* Fall through. */
12353 case 21: /* R_MSP430X_SYM_DIFF */
12355 if (sym_index
>= num_syms
)
12356 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12359 saved_sym
= symtab
+ sym_index
;
12362 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12363 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12364 goto handle_sym_diff
;
12366 case 5: /* R_MSP430_16_BYTE */
12367 case 9: /* R_MSP430_8 */
12368 if (uses_msp430x_relocs (filedata
))
12370 goto handle_sym_diff
;
12372 case 2: /* R_MSP430_ABS16 */
12373 case 15: /* R_MSP430X_ABS16 */
12374 if (! uses_msp430x_relocs (filedata
))
12376 goto handle_sym_diff
;
12379 if (saved_sym
!= NULL
)
12381 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12384 if (sym_index
>= num_syms
)
12385 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12389 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12390 - saved_sym
->st_value
);
12392 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12393 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12396 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12397 (long) reloc
->r_offset
);
12406 if (saved_sym
!= NULL
)
12407 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12414 case EM_CYGNUS_MN10300
:
12416 static Elf_Internal_Sym
* saved_sym
= NULL
;
12424 switch (reloc_type
)
12426 case 34: /* R_MN10300_ALIGN */
12428 case 33: /* R_MN10300_SYM_DIFF */
12429 if (sym_index
>= num_syms
)
12430 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12433 saved_sym
= symtab
+ sym_index
;
12436 case 1: /* R_MN10300_32 */
12437 case 2: /* R_MN10300_16 */
12438 if (saved_sym
!= NULL
)
12440 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12443 if (sym_index
>= num_syms
)
12444 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12448 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12449 - saved_sym
->st_value
);
12451 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12452 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12454 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12455 (long) reloc
->r_offset
);
12463 if (saved_sym
!= NULL
)
12464 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12472 static bfd_vma saved_sym1
= 0;
12473 static bfd_vma saved_sym2
= 0;
12474 static bfd_vma value
;
12478 saved_sym1
= saved_sym2
= 0;
12482 switch (reloc_type
)
12484 case 0x80: /* R_RL78_SYM. */
12485 saved_sym1
= saved_sym2
;
12486 if (sym_index
>= num_syms
)
12487 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12491 saved_sym2
= symtab
[sym_index
].st_value
;
12492 saved_sym2
+= reloc
->r_addend
;
12496 case 0x83: /* R_RL78_OPsub. */
12497 value
= saved_sym1
- saved_sym2
;
12498 saved_sym2
= saved_sym1
= 0;
12502 case 0x41: /* R_RL78_ABS32. */
12503 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12504 byte_put (start
+ reloc
->r_offset
, value
, 4);
12506 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12507 (long) reloc
->r_offset
);
12511 case 0x43: /* R_RL78_ABS16. */
12512 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12513 byte_put (start
+ reloc
->r_offset
, value
, 2);
12515 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12516 (long) reloc
->r_offset
);
12530 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12531 DWARF debug sections. This is a target specific test. Note - we do not
12532 go through the whole including-target-headers-multiple-times route, (as
12533 we have already done with <elf/h8.h>) because this would become very
12534 messy and even then this function would have to contain target specific
12535 information (the names of the relocs instead of their numeric values).
12536 FIXME: This is not the correct way to solve this problem. The proper way
12537 is to have target specific reloc sizing and typing functions created by
12538 the reloc-macros.h header, in the same way that it already creates the
12539 reloc naming functions. */
12542 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12544 /* Please keep this table alpha-sorted for ease of visual lookup. */
12545 switch (filedata
->file_header
.e_machine
)
12549 return reloc_type
== 1; /* R_386_32. */
12551 return reloc_type
== 1; /* R_68K_32. */
12553 return reloc_type
== 1; /* R_860_32. */
12555 return reloc_type
== 2; /* R_960_32. */
12557 return (reloc_type
== 258
12558 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12560 return reloc_type
== 11; /* R_BPF_DATA_32 */
12561 case EM_ADAPTEVA_EPIPHANY
:
12562 return reloc_type
== 3;
12564 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12566 return reloc_type
== 1; /* R_ARC_32. */
12567 case EM_ARC_COMPACT
:
12568 case EM_ARC_COMPACT2
:
12569 return reloc_type
== 4; /* R_ARC_32. */
12571 return reloc_type
== 2; /* R_ARM_ABS32 */
12574 return reloc_type
== 1;
12576 return reloc_type
== 0x12; /* R_byte4_data. */
12578 return reloc_type
== 3; /* R_CRIS_32. */
12580 return reloc_type
== 3; /* R_CR16_NUM32. */
12582 return reloc_type
== 15; /* R_CRX_NUM32. */
12584 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12585 case EM_CYGNUS_FRV
:
12586 return reloc_type
== 1;
12587 case EM_CYGNUS_D10V
:
12589 return reloc_type
== 6; /* R_D10V_32. */
12590 case EM_CYGNUS_D30V
:
12592 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12594 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12595 case EM_CYGNUS_FR30
:
12597 return reloc_type
== 3; /* R_FR30_32. */
12599 return reloc_type
== 1; /* R_FT32_32. */
12603 return reloc_type
== 1; /* R_H8_DIR32. */
12605 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12606 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12607 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12608 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12611 return reloc_type
== 2; /* R_IP2K_32. */
12613 return reloc_type
== 2; /* R_IQ2000_32. */
12614 case EM_LATTICEMICO32
:
12615 return reloc_type
== 3; /* R_LM32_32. */
12618 return reloc_type
== 3; /* R_M32C_32. */
12620 return reloc_type
== 34; /* R_M32R_32_RELA. */
12623 return reloc_type
== 6; /* R_M68HC11_32. */
12625 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12626 reloc_type
== 6; /* R_S12Z_CW32. */
12628 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12629 case EM_CYGNUS_MEP
:
12630 return reloc_type
== 4; /* R_MEP_32. */
12632 return reloc_type
== 2; /* R_METAG_ADDR32. */
12633 case EM_MICROBLAZE
:
12634 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12636 return reloc_type
== 2; /* R_MIPS_32. */
12638 return reloc_type
== 4; /* R_MMIX_32. */
12639 case EM_CYGNUS_MN10200
:
12641 return reloc_type
== 1; /* R_MN10200_32. */
12642 case EM_CYGNUS_MN10300
:
12644 return reloc_type
== 1; /* R_MN10300_32. */
12646 return reloc_type
== 1; /* R_MOXIE_32. */
12647 case EM_MSP430_OLD
:
12649 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12651 return reloc_type
== 2; /* R_MT_32. */
12653 return reloc_type
== 20; /* R_NDS32_RELA. */
12654 case EM_ALTERA_NIOS2
:
12655 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12657 return reloc_type
== 1; /* R_NIOS_32. */
12659 return reloc_type
== 1; /* R_OR1K_32. */
12661 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12662 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12663 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12666 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12668 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12670 return reloc_type
== 1; /* R_PPC_ADDR32. */
12672 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12674 return reloc_type
== 1; /* R_RISCV_32. */
12676 return reloc_type
== 1; /* R_RL78_DIR32. */
12678 return reloc_type
== 1; /* R_RX_DIR32. */
12680 return reloc_type
== 1; /* R_I370_ADDR31. */
12683 return reloc_type
== 4; /* R_S390_32. */
12685 return reloc_type
== 8; /* R_SCORE_ABS32. */
12687 return reloc_type
== 1; /* R_SH_DIR32. */
12688 case EM_SPARC32PLUS
:
12691 return reloc_type
== 3 /* R_SPARC_32. */
12692 || reloc_type
== 23; /* R_SPARC_UA32. */
12694 return reloc_type
== 6; /* R_SPU_ADDR32 */
12696 return reloc_type
== 1; /* R_C6000_ABS32. */
12698 return reloc_type
== 2; /* R_TILEGX_32. */
12700 return reloc_type
== 1; /* R_TILEPRO_32. */
12701 case EM_CYGNUS_V850
:
12703 return reloc_type
== 6; /* R_V850_ABS32. */
12705 return reloc_type
== 0x33; /* R_V810_WORD. */
12707 return reloc_type
== 1; /* R_VAX_32. */
12709 return reloc_type
== 3; /* R_VISIUM_32. */
12710 case EM_WEBASSEMBLY
:
12711 return reloc_type
== 1; /* R_WASM32_32. */
12715 return reloc_type
== 10; /* R_X86_64_32. */
12718 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12720 return reloc_type
== 4; /* R_XGATE_32. */
12722 return reloc_type
== 1; /* R_XSTROMY16_32. */
12723 case EM_XTENSA_OLD
:
12725 return reloc_type
== 1; /* R_XTENSA_32. */
12728 static unsigned int prev_warn
= 0;
12730 /* Avoid repeating the same warning multiple times. */
12731 if (prev_warn
!= filedata
->file_header
.e_machine
)
12732 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12733 filedata
->file_header
.e_machine
);
12734 prev_warn
= filedata
->file_header
.e_machine
;
12740 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12741 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12744 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12746 switch (filedata
->file_header
.e_machine
)
12747 /* Please keep this table alpha-sorted for ease of visual lookup. */
12751 return reloc_type
== 2; /* R_386_PC32. */
12753 return reloc_type
== 4; /* R_68K_PC32. */
12755 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12756 case EM_ADAPTEVA_EPIPHANY
:
12757 return reloc_type
== 6;
12759 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12760 case EM_ARC_COMPACT
:
12761 case EM_ARC_COMPACT2
:
12762 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12764 return reloc_type
== 3; /* R_ARM_REL32 */
12767 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12768 case EM_MICROBLAZE
:
12769 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12771 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12773 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12775 return reloc_type
== 26; /* R_PPC_REL32. */
12777 return reloc_type
== 26; /* R_PPC64_REL32. */
12779 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12782 return reloc_type
== 5; /* R_390_PC32. */
12784 return reloc_type
== 2; /* R_SH_REL32. */
12785 case EM_SPARC32PLUS
:
12788 return reloc_type
== 6; /* R_SPARC_DISP32. */
12790 return reloc_type
== 13; /* R_SPU_REL32. */
12792 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12794 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12796 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12800 return reloc_type
== 2; /* R_X86_64_PC32. */
12802 return reloc_type
== 4; /* R_VAX_PCREL32. */
12803 case EM_XTENSA_OLD
:
12805 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12807 /* Do not abort or issue an error message here. Not all targets use
12808 pc-relative 32-bit relocs in their DWARF debug information and we
12809 have already tested for target coverage in is_32bit_abs_reloc. A
12810 more helpful warning message will be generated by apply_relocations
12811 anyway, so just return. */
12816 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12817 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12820 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12822 switch (filedata
->file_header
.e_machine
)
12825 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12827 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12829 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12830 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12832 return reloc_type
== 80; /* R_PARISC_DIR64. */
12834 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12836 return reloc_type
== 2; /* R_RISCV_64. */
12837 case EM_SPARC32PLUS
:
12840 return reloc_type
== 32 /* R_SPARC_64. */
12841 || reloc_type
== 54; /* R_SPARC_UA64. */
12845 return reloc_type
== 1; /* R_X86_64_64. */
12848 return reloc_type
== 22; /* R_S390_64. */
12850 return reloc_type
== 1; /* R_TILEGX_64. */
12852 return reloc_type
== 18; /* R_MIPS_64. */
12858 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12859 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12862 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12864 switch (filedata
->file_header
.e_machine
)
12867 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12869 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12871 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12872 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12874 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12876 return reloc_type
== 44; /* R_PPC64_REL64. */
12877 case EM_SPARC32PLUS
:
12880 return reloc_type
== 46; /* R_SPARC_DISP64. */
12884 return reloc_type
== 24; /* R_X86_64_PC64. */
12887 return reloc_type
== 23; /* R_S390_PC64. */
12889 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12895 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12896 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12899 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12901 switch (filedata
->file_header
.e_machine
)
12903 case EM_CYGNUS_MN10200
:
12905 return reloc_type
== 4; /* R_MN10200_24. */
12907 return reloc_type
== 5; /* R_FT32_20. */
12913 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12914 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12917 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12919 /* Please keep this table alpha-sorted for ease of visual lookup. */
12920 switch (filedata
->file_header
.e_machine
)
12923 case EM_ARC_COMPACT
:
12924 case EM_ARC_COMPACT2
:
12925 return reloc_type
== 2; /* R_ARC_16. */
12926 case EM_ADAPTEVA_EPIPHANY
:
12927 return reloc_type
== 5;
12930 return reloc_type
== 4; /* R_AVR_16. */
12931 case EM_CYGNUS_D10V
:
12933 return reloc_type
== 3; /* R_D10V_16. */
12935 return reloc_type
== 2; /* R_FT32_16. */
12939 return reloc_type
== R_H8_DIR16
;
12942 return reloc_type
== 1; /* R_IP2K_16. */
12945 return reloc_type
== 1; /* R_M32C_16 */
12946 case EM_CYGNUS_MN10200
:
12948 return reloc_type
== 2; /* R_MN10200_16. */
12949 case EM_CYGNUS_MN10300
:
12951 return reloc_type
== 2; /* R_MN10300_16. */
12953 if (uses_msp430x_relocs (filedata
))
12954 return reloc_type
== 2; /* R_MSP430_ABS16. */
12955 /* Fall through. */
12956 case EM_MSP430_OLD
:
12957 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12959 return reloc_type
== 19; /* R_NDS32_RELA. */
12960 case EM_ALTERA_NIOS2
:
12961 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12963 return reloc_type
== 9; /* R_NIOS_16. */
12965 return reloc_type
== 2; /* R_OR1K_16. */
12967 return reloc_type
== 55; /* R_RISCV_SET16. */
12969 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12971 return reloc_type
== 2; /* R_C6000_ABS16. */
12973 return reloc_type
== 2; /* R_VISIUM_16. */
12976 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12978 return reloc_type
== 3; /* R_XGATE_16. */
12984 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12985 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12988 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12990 switch (filedata
->file_header
.e_machine
)
12993 return reloc_type
== 54; /* R_RISCV_SET8. */
12999 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13000 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13003 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13005 switch (filedata
->file_header
.e_machine
)
13008 return reloc_type
== 53; /* R_RISCV_SET6. */
13014 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13015 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13018 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13020 /* Please keep this table alpha-sorted for ease of visual lookup. */
13021 switch (filedata
->file_header
.e_machine
)
13024 return reloc_type
== 35; /* R_RISCV_ADD32. */
13030 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13031 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13034 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13036 /* Please keep this table alpha-sorted for ease of visual lookup. */
13037 switch (filedata
->file_header
.e_machine
)
13040 return reloc_type
== 39; /* R_RISCV_SUB32. */
13046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13047 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13050 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13052 /* Please keep this table alpha-sorted for ease of visual lookup. */
13053 switch (filedata
->file_header
.e_machine
)
13056 return reloc_type
== 36; /* R_RISCV_ADD64. */
13062 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13063 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13066 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13068 /* Please keep this table alpha-sorted for ease of visual lookup. */
13069 switch (filedata
->file_header
.e_machine
)
13072 return reloc_type
== 40; /* R_RISCV_SUB64. */
13078 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13079 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13082 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13084 /* Please keep this table alpha-sorted for ease of visual lookup. */
13085 switch (filedata
->file_header
.e_machine
)
13088 return reloc_type
== 34; /* R_RISCV_ADD16. */
13094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13095 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13098 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13100 /* Please keep this table alpha-sorted for ease of visual lookup. */
13101 switch (filedata
->file_header
.e_machine
)
13104 return reloc_type
== 38; /* R_RISCV_SUB16. */
13110 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13111 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13114 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13116 /* Please keep this table alpha-sorted for ease of visual lookup. */
13117 switch (filedata
->file_header
.e_machine
)
13120 return reloc_type
== 33; /* R_RISCV_ADD8. */
13126 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13127 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13130 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13132 /* Please keep this table alpha-sorted for ease of visual lookup. */
13133 switch (filedata
->file_header
.e_machine
)
13136 return reloc_type
== 37; /* R_RISCV_SUB8. */
13142 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13143 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13146 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13148 switch (filedata
->file_header
.e_machine
)
13151 return reloc_type
== 52; /* R_RISCV_SUB6. */
13157 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13158 relocation entries (possibly formerly used for SHT_GROUP sections). */
13161 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13163 switch (filedata
->file_header
.e_machine
)
13165 case EM_386
: /* R_386_NONE. */
13166 case EM_68K
: /* R_68K_NONE. */
13167 case EM_ADAPTEVA_EPIPHANY
:
13168 case EM_ALPHA
: /* R_ALPHA_NONE. */
13169 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13170 case EM_ARC
: /* R_ARC_NONE. */
13171 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13172 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13173 case EM_ARM
: /* R_ARM_NONE. */
13174 case EM_C166
: /* R_XC16X_NONE. */
13175 case EM_CRIS
: /* R_CRIS_NONE. */
13176 case EM_FT32
: /* R_FT32_NONE. */
13177 case EM_IA_64
: /* R_IA64_NONE. */
13178 case EM_K1OM
: /* R_X86_64_NONE. */
13179 case EM_L1OM
: /* R_X86_64_NONE. */
13180 case EM_M32R
: /* R_M32R_NONE. */
13181 case EM_MIPS
: /* R_MIPS_NONE. */
13182 case EM_MN10300
: /* R_MN10300_NONE. */
13183 case EM_MOXIE
: /* R_MOXIE_NONE. */
13184 case EM_NIOS32
: /* R_NIOS_NONE. */
13185 case EM_OR1K
: /* R_OR1K_NONE. */
13186 case EM_PARISC
: /* R_PARISC_NONE. */
13187 case EM_PPC64
: /* R_PPC64_NONE. */
13188 case EM_PPC
: /* R_PPC_NONE. */
13189 case EM_RISCV
: /* R_RISCV_NONE. */
13190 case EM_S390
: /* R_390_NONE. */
13192 case EM_SH
: /* R_SH_NONE. */
13193 case EM_SPARC32PLUS
:
13194 case EM_SPARC
: /* R_SPARC_NONE. */
13196 case EM_TILEGX
: /* R_TILEGX_NONE. */
13197 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13198 case EM_TI_C6000
:/* R_C6000_NONE. */
13199 case EM_X86_64
: /* R_X86_64_NONE. */
13201 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13202 return reloc_type
== 0;
13205 return reloc_type
== 0 || reloc_type
== 256;
13208 return (reloc_type
== 0 /* R_AVR_NONE. */
13209 || reloc_type
== 30 /* R_AVR_DIFF8. */
13210 || reloc_type
== 31 /* R_AVR_DIFF16. */
13211 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13213 return reloc_type
== 3; /* R_METAG_NONE. */
13215 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13216 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13217 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13218 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13219 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13221 return (reloc_type
== 0 /* R_PRU_NONE. */
13222 || reloc_type
== 65 /* R_PRU_DIFF8. */
13223 || reloc_type
== 66 /* R_PRU_DIFF16. */
13224 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13225 case EM_XTENSA_OLD
:
13227 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13228 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13229 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13230 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13235 /* Returns TRUE if there is a relocation against
13236 section NAME at OFFSET bytes. */
13239 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13241 Elf_Internal_Rela
* relocs
;
13242 Elf_Internal_Rela
* rp
;
13244 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13247 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13249 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13250 if (rp
->r_offset
== offset
)
13256 /* Apply relocations to a section.
13257 Returns TRUE upon success, FALSE otherwise.
13258 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13259 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13260 will be set to the number of relocs loaded.
13262 Note: So far support has been added only for those relocations
13263 which can be found in debug sections. FIXME: Add support for
13264 more relocations ? */
13267 apply_relocations (Filedata
* filedata
,
13268 const Elf_Internal_Shdr
* section
,
13269 unsigned char * start
,
13270 bfd_size_type size
,
13271 void ** relocs_return
,
13272 unsigned long * num_relocs_return
)
13274 Elf_Internal_Shdr
* relsec
;
13275 unsigned char * end
= start
+ size
;
13277 if (relocs_return
!= NULL
)
13279 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13280 * num_relocs_return
= 0;
13283 if (filedata
->file_header
.e_type
!= ET_REL
)
13284 /* No relocs to apply. */
13287 /* Find the reloc section associated with the section. */
13288 for (relsec
= filedata
->section_headers
;
13289 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13292 bfd_boolean is_rela
;
13293 unsigned long num_relocs
;
13294 Elf_Internal_Rela
* relocs
;
13295 Elf_Internal_Rela
* rp
;
13296 Elf_Internal_Shdr
* symsec
;
13297 Elf_Internal_Sym
* symtab
;
13298 unsigned long num_syms
;
13299 Elf_Internal_Sym
* sym
;
13301 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13302 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13303 || filedata
->section_headers
+ relsec
->sh_info
!= section
13304 || relsec
->sh_size
== 0
13305 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13308 is_rela
= relsec
->sh_type
== SHT_RELA
;
13312 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13313 relsec
->sh_size
, & relocs
, & num_relocs
))
13318 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13319 relsec
->sh_size
, & relocs
, & num_relocs
))
13323 /* SH uses RELA but uses in place value instead of the addend field. */
13324 if (filedata
->file_header
.e_machine
== EM_SH
)
13327 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13328 if (symsec
->sh_type
!= SHT_SYMTAB
13329 && symsec
->sh_type
!= SHT_DYNSYM
)
13331 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13333 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13336 unsigned int reloc_type
;
13337 unsigned int reloc_size
;
13338 bfd_boolean reloc_inplace
= FALSE
;
13339 bfd_boolean reloc_subtract
= FALSE
;
13340 unsigned char * rloc
;
13341 unsigned long sym_index
;
13343 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13345 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13347 else if (is_none_reloc (filedata
, reloc_type
))
13349 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13350 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13352 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13353 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13355 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13357 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13359 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13360 || is_6bit_abs_reloc (filedata
, reloc_type
))
13362 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13364 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13367 reloc_inplace
= TRUE
;
13369 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13371 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13374 reloc_inplace
= TRUE
;
13376 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13378 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13381 reloc_inplace
= TRUE
;
13383 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13385 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13388 reloc_inplace
= TRUE
;
13390 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13394 reloc_inplace
= TRUE
;
13398 static unsigned int prev_reloc
= 0;
13400 if (reloc_type
!= prev_reloc
)
13401 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13402 reloc_type
, printable_section_name (filedata
, section
));
13403 prev_reloc
= reloc_type
;
13407 rloc
= start
+ rp
->r_offset
;
13408 if (rloc
>= end
|| (rloc
+ reloc_size
) > end
|| (rloc
< start
))
13410 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13411 (unsigned long) rp
->r_offset
,
13412 printable_section_name (filedata
, section
));
13416 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13417 if (sym_index
>= num_syms
)
13419 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13420 sym_index
, printable_section_name (filedata
, section
));
13423 sym
= symtab
+ sym_index
;
13425 /* If the reloc has a symbol associated with it,
13426 make sure that it is of an appropriate type.
13428 Relocations against symbols without type can happen.
13429 Gcc -feliminate-dwarf2-dups may generate symbols
13430 without type for debug info.
13432 Icc generates relocations against function symbols
13433 instead of local labels.
13435 Relocations against object symbols can happen, eg when
13436 referencing a global array. For an example of this see
13437 the _clz.o binary in libgcc.a. */
13439 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13440 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13442 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13443 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13444 printable_section_name (filedata
, relsec
),
13445 (long int)(rp
- relocs
));
13451 addend
+= rp
->r_addend
;
13452 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13453 partial_inplace. */
13455 || (filedata
->file_header
.e_machine
== EM_XTENSA
13456 && reloc_type
== 1)
13457 || ((filedata
->file_header
.e_machine
== EM_PJ
13458 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13459 && reloc_type
== 1)
13460 || ((filedata
->file_header
.e_machine
== EM_D30V
13461 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13462 && reloc_type
== 12)
13465 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13466 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13468 addend
+= byte_get (rloc
, reloc_size
);
13471 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13472 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13474 /* On HPPA, all pc-relative relocations are biased by 8. */
13475 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13477 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13480 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13481 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13483 if (reloc_subtract
)
13484 addend
-= sym
->st_value
;
13486 addend
+= sym
->st_value
;
13487 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13488 byte_put (rloc
, addend
, reloc_size
);
13490 else if (reloc_subtract
)
13491 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13493 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13497 /* Let the target specific reloc processing code know that
13498 we have finished with these relocs. */
13499 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13503 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13504 * num_relocs_return
= num_relocs
;
13515 #ifdef SUPPORT_DISASSEMBLY
13517 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13519 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13521 /* FIXME: XXX -- to be done --- XXX */
13527 /* Reads in the contents of SECTION from FILE, returning a pointer
13528 to a malloc'ed buffer or NULL if something went wrong. */
13531 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13533 bfd_size_type num_bytes
= section
->sh_size
;
13535 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13537 printf (_("Section '%s' has no data to dump.\n"),
13538 printable_section_name (filedata
, section
));
13542 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13543 _("section contents"));
13546 /* Uncompresses a section that was compressed using zlib, in place. */
13549 uncompress_section_contents (unsigned char ** buffer
,
13550 dwarf_size_type uncompressed_size
,
13551 dwarf_size_type
* size
)
13553 dwarf_size_type compressed_size
= *size
;
13554 unsigned char * compressed_buffer
= *buffer
;
13555 unsigned char * uncompressed_buffer
;
13559 /* It is possible the section consists of several compressed
13560 buffers concatenated together, so we uncompress in a loop. */
13561 /* PR 18313: The state field in the z_stream structure is supposed
13562 to be invisible to the user (ie us), but some compilers will
13563 still complain about it being used without initialisation. So
13564 we first zero the entire z_stream structure and then set the fields
13566 memset (& strm
, 0, sizeof strm
);
13567 strm
.avail_in
= compressed_size
;
13568 strm
.next_in
= (Bytef
*) compressed_buffer
;
13569 strm
.avail_out
= uncompressed_size
;
13570 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13572 rc
= inflateInit (& strm
);
13573 while (strm
.avail_in
> 0)
13577 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13578 + (uncompressed_size
- strm
.avail_out
));
13579 rc
= inflate (&strm
, Z_FINISH
);
13580 if (rc
!= Z_STREAM_END
)
13582 rc
= inflateReset (& strm
);
13584 rc
= inflateEnd (& strm
);
13586 || strm
.avail_out
!= 0)
13589 *buffer
= uncompressed_buffer
;
13590 *size
= uncompressed_size
;
13594 free (uncompressed_buffer
);
13595 /* Indicate decompression failure. */
13601 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13603 Elf_Internal_Shdr
* relsec
;
13604 bfd_size_type num_bytes
;
13605 unsigned char * data
;
13606 unsigned char * end
;
13607 unsigned char * real_start
;
13608 unsigned char * start
;
13609 bfd_boolean some_strings_shown
;
13611 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13613 /* PR 21820: Do not fail if the section was empty. */
13614 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13616 num_bytes
= section
->sh_size
;
13618 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13620 if (decompress_dumps
)
13622 dwarf_size_type new_size
= num_bytes
;
13623 dwarf_size_type uncompressed_size
= 0;
13625 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13627 Elf_Internal_Chdr chdr
;
13628 unsigned int compression_header_size
13629 = get_compression_header (& chdr
, (unsigned char *) start
,
13632 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13634 warn (_("section '%s' has unsupported compress type: %d\n"),
13635 printable_section_name (filedata
, section
), chdr
.ch_type
);
13638 uncompressed_size
= chdr
.ch_size
;
13639 start
+= compression_header_size
;
13640 new_size
-= compression_header_size
;
13642 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13644 /* Read the zlib header. In this case, it should be "ZLIB"
13645 followed by the uncompressed section size, 8 bytes in
13646 big-endian order. */
13647 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13648 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13649 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13650 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13651 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13652 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13653 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13654 uncompressed_size
+= start
[11];
13659 if (uncompressed_size
)
13661 if (uncompress_section_contents (& start
,
13662 uncompressed_size
, & new_size
))
13663 num_bytes
= new_size
;
13666 error (_("Unable to decompress section %s\n"),
13667 printable_section_name (filedata
, section
));
13672 start
= real_start
;
13675 /* If the section being dumped has relocations against it the user might
13676 be expecting these relocations to have been applied. Check for this
13677 case and issue a warning message in order to avoid confusion.
13678 FIXME: Maybe we ought to have an option that dumps a section with
13679 relocs applied ? */
13680 for (relsec
= filedata
->section_headers
;
13681 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13684 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13685 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13686 || filedata
->section_headers
+ relsec
->sh_info
!= section
13687 || relsec
->sh_size
== 0
13688 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13691 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13696 end
= start
+ num_bytes
;
13697 some_strings_shown
= FALSE
;
13701 while (!ISPRINT (* data
))
13702 if (++ data
>= end
)
13707 size_t maxlen
= end
- data
;
13710 /* PR 11128: Use two separate invocations in order to work
13711 around bugs in the Solaris 8 implementation of printf. */
13712 printf (" [%6tx] ", data
- start
);
13714 printf (" [%6Ix] ", (size_t) (data
- start
));
13718 print_symbol ((int) maxlen
, (const char *) data
);
13720 data
+= strnlen ((const char *) data
, maxlen
);
13724 printf (_("<corrupt>\n"));
13727 some_strings_shown
= TRUE
;
13731 if (! some_strings_shown
)
13732 printf (_(" No strings found in this section."));
13741 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13742 Filedata
* filedata
,
13743 bfd_boolean relocate
)
13745 Elf_Internal_Shdr
* relsec
;
13746 bfd_size_type bytes
;
13747 bfd_size_type section_size
;
13749 unsigned char * data
;
13750 unsigned char * real_start
;
13751 unsigned char * start
;
13753 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13755 /* PR 21820: Do not fail if the section was empty. */
13756 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13758 section_size
= section
->sh_size
;
13760 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13762 if (decompress_dumps
)
13764 dwarf_size_type new_size
= section_size
;
13765 dwarf_size_type uncompressed_size
= 0;
13767 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13769 Elf_Internal_Chdr chdr
;
13770 unsigned int compression_header_size
13771 = get_compression_header (& chdr
, start
, section_size
);
13773 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13775 warn (_("section '%s' has unsupported compress type: %d\n"),
13776 printable_section_name (filedata
, section
), chdr
.ch_type
);
13779 uncompressed_size
= chdr
.ch_size
;
13780 start
+= compression_header_size
;
13781 new_size
-= compression_header_size
;
13783 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13785 /* Read the zlib header. In this case, it should be "ZLIB"
13786 followed by the uncompressed section size, 8 bytes in
13787 big-endian order. */
13788 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13789 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13790 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13791 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13792 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13793 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13794 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13795 uncompressed_size
+= start
[11];
13800 if (uncompressed_size
)
13802 if (uncompress_section_contents (& start
, uncompressed_size
,
13805 section_size
= new_size
;
13809 error (_("Unable to decompress section %s\n"),
13810 printable_section_name (filedata
, section
));
13811 /* FIXME: Print the section anyway ? */
13816 start
= real_start
;
13821 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13826 /* If the section being dumped has relocations against it the user might
13827 be expecting these relocations to have been applied. Check for this
13828 case and issue a warning message in order to avoid confusion.
13829 FIXME: Maybe we ought to have an option that dumps a section with
13830 relocs applied ? */
13831 for (relsec
= filedata
->section_headers
;
13832 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13835 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13836 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13837 || filedata
->section_headers
+ relsec
->sh_info
!= section
13838 || relsec
->sh_size
== 0
13839 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13842 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13847 addr
= section
->sh_addr
;
13848 bytes
= section_size
;
13857 lbytes
= (bytes
> 16 ? 16 : bytes
);
13859 printf (" 0x%8.8lx ", (unsigned long) addr
);
13861 for (j
= 0; j
< 16; j
++)
13864 printf ("%2.2x", data
[j
]);
13872 for (j
= 0; j
< lbytes
; j
++)
13875 if (k
>= ' ' && k
< 0x7f)
13894 static ctf_sect_t
*
13895 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13897 buf
->cts_name
= SECTION_NAME (shdr
);
13898 buf
->cts_size
= shdr
->sh_size
;
13899 buf
->cts_entsize
= shdr
->sh_entsize
;
13904 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13905 it is passed, or a pointer to newly-allocated storage, in which case
13906 dump_ctf() will free it when it no longer needs it. */
13908 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13909 char *s
, void *arg
)
13911 const char *blanks
= arg
;
13914 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13920 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13922 Elf_Internal_Shdr
* parent_sec
= NULL
;
13923 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13924 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13925 void * data
= NULL
;
13926 void * symdata
= NULL
;
13927 void * strdata
= NULL
;
13928 void * parentdata
= NULL
;
13929 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13930 ctf_sect_t
* symsectp
= NULL
;
13931 ctf_sect_t
* strsectp
= NULL
;
13932 ctf_file_t
* ctf
= NULL
;
13933 ctf_file_t
* parent
= NULL
;
13935 const char *things
[] = {"Header", "Labels", "Data objects",
13936 "Function objects", "Variables", "Types", "Strings",
13938 const char **thing
;
13940 bfd_boolean ret
= FALSE
;
13943 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13944 data
= get_section_contents (section
, filedata
);
13945 ctfsect
.cts_data
= data
;
13947 if (!dump_ctf_symtab_name
)
13948 dump_ctf_symtab_name
= strdup (".symtab");
13950 if (!dump_ctf_strtab_name
)
13951 dump_ctf_strtab_name
= strdup (".strtab");
13953 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
13955 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13957 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13960 if ((symdata
= (void *) get_data (NULL
, filedata
,
13961 symtab_sec
->sh_offset
, 1,
13962 symtab_sec
->sh_size
,
13963 _("symbols"))) == NULL
)
13965 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13966 symsect
.cts_data
= symdata
;
13968 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
13970 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
13972 error (_("No string table section named %s\n"),
13973 dump_ctf_strtab_name
);
13976 if ((strdata
= (void *) get_data (NULL
, filedata
,
13977 strtab_sec
->sh_offset
, 1,
13978 strtab_sec
->sh_size
,
13979 _("strings"))) == NULL
)
13981 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
13982 strsect
.cts_data
= strdata
;
13984 if (dump_ctf_parent_name
)
13986 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
13988 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
13991 if ((parentdata
= (void *) get_data (NULL
, filedata
,
13992 parent_sec
->sh_offset
, 1,
13993 parent_sec
->sh_size
,
13994 _("CTF parent"))) == NULL
)
13996 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
13997 parentsect
.cts_data
= parentdata
;
14000 /* Load the CTF file and dump it. */
14002 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14004 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14010 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14012 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14016 ctf_import (ctf
, parent
);
14021 printf (_("\nDump of CTF section '%s':\n"),
14022 printable_section_name (filedata
, section
));
14024 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14026 ctf_dump_state_t
*s
= NULL
;
14029 printf ("\n %s:\n", *thing
);
14030 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14031 (void *) " ")) != NULL
)
14033 printf ("%s\n", item
);
14037 if (ctf_errno (ctf
))
14039 error (_("Iteration failed: %s, %s\n"), *thing
,
14040 ctf_errmsg (ctf_errno (ctf
)));
14046 ctf_file_close (ctf
);
14047 ctf_file_close (parent
);
14056 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14057 const Elf_Internal_Shdr
* sec
,
14060 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14062 Filedata
* filedata
= (Filedata
*) data
;
14064 if (section
->start
!= NULL
)
14066 /* If it is already loaded, do nothing. */
14067 if (streq (section
->filename
, filedata
->file_name
))
14069 free (section
->start
);
14072 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14073 section
->address
= sec
->sh_addr
;
14074 section
->user_data
= NULL
;
14075 section
->filename
= filedata
->file_name
;
14076 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14078 sec
->sh_size
, buf
);
14079 if (section
->start
== NULL
)
14083 unsigned char *start
= section
->start
;
14084 dwarf_size_type size
= sec
->sh_size
;
14085 dwarf_size_type uncompressed_size
= 0;
14087 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14089 Elf_Internal_Chdr chdr
;
14090 unsigned int compression_header_size
;
14092 if (size
< (is_32bit_elf
14093 ? sizeof (Elf32_External_Chdr
)
14094 : sizeof (Elf64_External_Chdr
)))
14096 warn (_("compressed section %s is too small to contain a compression header"),
14101 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14103 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14105 warn (_("section '%s' has unsupported compress type: %d\n"),
14106 section
->name
, chdr
.ch_type
);
14109 uncompressed_size
= chdr
.ch_size
;
14110 start
+= compression_header_size
;
14111 size
-= compression_header_size
;
14113 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14115 /* Read the zlib header. In this case, it should be "ZLIB"
14116 followed by the uncompressed section size, 8 bytes in
14117 big-endian order. */
14118 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14119 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14120 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14121 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14122 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14123 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14124 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14125 uncompressed_size
+= start
[11];
14130 if (uncompressed_size
)
14132 if (uncompress_section_contents (&start
, uncompressed_size
,
14135 /* Free the compressed buffer, update the section buffer
14136 and the section size if uncompress is successful. */
14137 free (section
->start
);
14138 section
->start
= start
;
14142 error (_("Unable to decompress section %s\n"),
14143 printable_section_name (filedata
, sec
));
14148 section
->size
= size
;
14151 if (section
->start
== NULL
)
14154 if (debug_displays
[debug
].relocate
)
14156 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14157 & section
->reloc_info
, & section
->num_relocs
))
14162 section
->reloc_info
= NULL
;
14163 section
->num_relocs
= 0;
14169 /* If this is not NULL, load_debug_section will only look for sections
14170 within the list of sections given here. */
14171 static unsigned int * section_subset
= NULL
;
14174 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14176 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14177 Elf_Internal_Shdr
* sec
;
14178 Filedata
* filedata
= (Filedata
*) data
;
14180 /* Without section headers we cannot find any sections. */
14181 if (filedata
->section_headers
== NULL
)
14184 if (filedata
->string_table
== NULL
14185 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14186 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14188 Elf_Internal_Shdr
* strs
;
14190 /* Read in the string table, so that we have section names to scan. */
14191 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14193 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14195 filedata
->string_table
14196 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14197 1, strs
->sh_size
, _("string table"));
14199 filedata
->string_table_length
14200 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14204 /* Locate the debug section. */
14205 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14207 section
->name
= section
->uncompressed_name
;
14210 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14212 section
->name
= section
->compressed_name
;
14217 /* If we're loading from a subset of sections, and we've loaded
14218 a section matching this name before, it's likely that it's a
14220 if (section_subset
!= NULL
)
14221 free_debug_section (debug
);
14223 return load_specific_debug_section (debug
, sec
, data
);
14227 free_debug_section (enum dwarf_section_display_enum debug
)
14229 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14231 if (section
->start
== NULL
)
14234 free ((char *) section
->start
);
14235 section
->start
= NULL
;
14236 section
->address
= 0;
14241 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14243 char * name
= SECTION_NAME (section
);
14244 const char * print_name
= printable_section_name (filedata
, section
);
14245 bfd_size_type length
;
14246 bfd_boolean result
= TRUE
;
14249 length
= section
->sh_size
;
14252 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14255 if (section
->sh_type
== SHT_NOBITS
)
14257 /* There is no point in dumping the contents of a debugging section
14258 which has the NOBITS type - the bits in the file will be random.
14259 This can happen when a file containing a .eh_frame section is
14260 stripped with the --only-keep-debug command line option. */
14261 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14266 if (const_strneq (name
, ".gnu.linkonce.wi."))
14267 name
= ".debug_info";
14269 /* See if we know how to display the contents of this section. */
14270 for (i
= 0; i
< max
; i
++)
14272 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14273 struct dwarf_section_display
* display
= debug_displays
+ i
;
14274 struct dwarf_section
* sec
= & display
->section
;
14276 if (streq (sec
->uncompressed_name
, name
)
14277 || (id
== line
&& const_strneq (name
, ".debug_line."))
14278 || streq (sec
->compressed_name
, name
))
14280 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14283 free_debug_section (id
);
14285 if (i
== line
&& const_strneq (name
, ".debug_line."))
14287 else if (streq (sec
->uncompressed_name
, name
))
14288 sec
->name
= sec
->uncompressed_name
;
14290 sec
->name
= sec
->compressed_name
;
14292 if (load_specific_debug_section (id
, section
, filedata
))
14294 /* If this debug section is part of a CU/TU set in a .dwp file,
14295 restrict load_debug_section to the sections in that set. */
14296 section_subset
= find_cu_tu_set (filedata
, shndx
);
14298 result
&= display
->display (sec
, filedata
);
14300 section_subset
= NULL
;
14302 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14303 free_debug_section (id
);
14311 printf (_("Unrecognized debug section: %s\n"), print_name
);
14318 /* Set DUMP_SECTS for all sections where dumps were requested
14319 based on section name. */
14322 initialise_dumps_byname (Filedata
* filedata
)
14324 struct dump_list_entry
* cur
;
14326 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14329 bfd_boolean any
= FALSE
;
14331 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14332 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14334 request_dump_bynumber (filedata
, i
, cur
->type
);
14339 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14345 process_section_contents (Filedata
* filedata
)
14347 Elf_Internal_Shdr
* section
;
14349 bfd_boolean res
= TRUE
;
14354 initialise_dumps_byname (filedata
);
14356 for (i
= 0, section
= filedata
->section_headers
;
14357 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14360 dump_type dump
= filedata
->dump_sects
[i
];
14362 #ifdef SUPPORT_DISASSEMBLY
14363 if (dump
& DISASS_DUMP
)
14365 if (! disassemble_section (section
, filedata
))
14369 if (dump
& HEX_DUMP
)
14371 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14375 if (dump
& RELOC_DUMP
)
14377 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14381 if (dump
& STRING_DUMP
)
14383 if (! dump_section_as_strings (section
, filedata
))
14387 if (dump
& DEBUG_DUMP
)
14389 if (! display_debug_section (i
, section
, filedata
))
14393 if (dump
& CTF_DUMP
)
14395 if (! dump_section_as_ctf (section
, filedata
))
14400 /* Check to see if the user requested a
14401 dump of a section that does not exist. */
14402 while (i
< filedata
->num_dump_sects
)
14404 if (filedata
->dump_sects
[i
])
14406 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14416 process_mips_fpe_exception (int mask
)
14420 bfd_boolean first
= TRUE
;
14422 if (mask
& OEX_FPU_INEX
)
14423 fputs ("INEX", stdout
), first
= FALSE
;
14424 if (mask
& OEX_FPU_UFLO
)
14425 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14426 if (mask
& OEX_FPU_OFLO
)
14427 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14428 if (mask
& OEX_FPU_DIV0
)
14429 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14430 if (mask
& OEX_FPU_INVAL
)
14431 printf ("%sINVAL", first
? "" : "|");
14434 fputs ("0", stdout
);
14437 /* Display's the value of TAG at location P. If TAG is
14438 greater than 0 it is assumed to be an unknown tag, and
14439 a message is printed to this effect. Otherwise it is
14440 assumed that a message has already been printed.
14442 If the bottom bit of TAG is set it assumed to have a
14443 string value, otherwise it is assumed to have an integer
14446 Returns an updated P pointing to the first unread byte
14447 beyond the end of TAG's value.
14449 Reads at or beyond END will not be made. */
14451 static unsigned char *
14452 display_tag_value (signed int tag
,
14454 const unsigned char * const end
)
14459 printf (" Tag_unknown_%d: ", tag
);
14463 warn (_("<corrupt tag>\n"));
14467 /* PR 17531 file: 027-19978-0.004. */
14468 size_t maxlen
= (end
- p
) - 1;
14473 print_symbol ((int) maxlen
, (const char *) p
);
14474 p
+= strnlen ((char *) p
, maxlen
) + 1;
14478 printf (_("<corrupt string tag>"));
14479 p
= (unsigned char *) end
;
14487 val
= read_uleb128 (p
, &len
, end
);
14489 printf ("%ld (0x%lx)\n", val
, val
);
14496 /* ARC ABI attributes section. */
14498 static unsigned char *
14499 display_arc_attribute (unsigned char * p
,
14500 const unsigned char * const end
)
14506 tag
= read_uleb128 (p
, &len
, end
);
14511 case Tag_ARC_PCS_config
:
14512 val
= read_uleb128 (p
, &len
, end
);
14514 printf (" Tag_ARC_PCS_config: ");
14518 printf (_("Absent/Non standard\n"));
14521 printf (_("Bare metal/mwdt\n"));
14524 printf (_("Bare metal/newlib\n"));
14527 printf (_("Linux/uclibc\n"));
14530 printf (_("Linux/glibc\n"));
14533 printf (_("Unknown\n"));
14538 case Tag_ARC_CPU_base
:
14539 val
= read_uleb128 (p
, &len
, end
);
14541 printf (" Tag_ARC_CPU_base: ");
14546 printf (_("Absent\n"));
14548 case TAG_CPU_ARC6xx
:
14549 printf ("ARC6xx\n");
14551 case TAG_CPU_ARC7xx
:
14552 printf ("ARC7xx\n");
14554 case TAG_CPU_ARCEM
:
14555 printf ("ARCEM\n");
14557 case TAG_CPU_ARCHS
:
14558 printf ("ARCHS\n");
14563 case Tag_ARC_CPU_variation
:
14564 val
= read_uleb128 (p
, &len
, end
);
14566 printf (" Tag_ARC_CPU_variation: ");
14570 if (val
> 0 && val
< 16)
14571 printf ("Core%d\n", val
);
14573 printf ("Unknown\n");
14577 printf (_("Absent\n"));
14582 case Tag_ARC_CPU_name
:
14583 printf (" Tag_ARC_CPU_name: ");
14584 p
= display_tag_value (-1, p
, end
);
14587 case Tag_ARC_ABI_rf16
:
14588 val
= read_uleb128 (p
, &len
, end
);
14590 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14593 case Tag_ARC_ABI_osver
:
14594 val
= read_uleb128 (p
, &len
, end
);
14596 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14599 case Tag_ARC_ABI_pic
:
14600 case Tag_ARC_ABI_sda
:
14601 val
= read_uleb128 (p
, &len
, end
);
14603 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14604 : " Tag_ARC_ABI_pic: ");
14608 printf (_("Absent\n"));
14617 printf (_("Unknown\n"));
14622 case Tag_ARC_ABI_tls
:
14623 val
= read_uleb128 (p
, &len
, end
);
14625 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14628 case Tag_ARC_ABI_enumsize
:
14629 val
= read_uleb128 (p
, &len
, end
);
14631 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14635 case Tag_ARC_ABI_exceptions
:
14636 val
= read_uleb128 (p
, &len
, end
);
14638 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14642 case Tag_ARC_ABI_double_size
:
14643 val
= read_uleb128 (p
, &len
, end
);
14645 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14648 case Tag_ARC_ISA_config
:
14649 printf (" Tag_ARC_ISA_config: ");
14650 p
= display_tag_value (-1, p
, end
);
14653 case Tag_ARC_ISA_apex
:
14654 printf (" Tag_ARC_ISA_apex: ");
14655 p
= display_tag_value (-1, p
, end
);
14658 case Tag_ARC_ISA_mpy_option
:
14659 val
= read_uleb128 (p
, &len
, end
);
14661 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14664 case Tag_ARC_ATR_version
:
14665 val
= read_uleb128 (p
, &len
, end
);
14667 printf (" Tag_ARC_ATR_version: %d\n", val
);
14671 return display_tag_value (tag
& 1, p
, end
);
14677 /* ARM EABI attributes section. */
14682 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14684 const char ** table
;
14685 } arm_attr_public_tag
;
14687 static const char * arm_attr_tag_CPU_arch
[] =
14688 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14689 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14690 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14691 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14692 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14693 {"No", "Thumb-1", "Thumb-2", "Yes"};
14694 static const char * arm_attr_tag_FP_arch
[] =
14695 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14696 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14697 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14698 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14699 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14700 "NEON for ARMv8.1"};
14701 static const char * arm_attr_tag_PCS_config
[] =
14702 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14703 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14704 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14705 {"V6", "SB", "TLS", "Unused"};
14706 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14707 {"Absolute", "PC-relative", "SB-relative", "None"};
14708 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14709 {"Absolute", "PC-relative", "None"};
14710 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14711 {"None", "direct", "GOT-indirect"};
14712 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14713 {"None", "??? 1", "2", "??? 3", "4"};
14714 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14715 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14716 {"Unused", "Needed", "Sign only"};
14717 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14718 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14719 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14720 {"Unused", "Finite", "RTABI", "IEEE 754"};
14721 static const char * arm_attr_tag_ABI_enum_size
[] =
14722 {"Unused", "small", "int", "forced to int"};
14723 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14724 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14725 static const char * arm_attr_tag_ABI_VFP_args
[] =
14726 {"AAPCS", "VFP registers", "custom", "compatible"};
14727 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14728 {"AAPCS", "WMMX registers", "custom"};
14729 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14730 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14731 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14732 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14733 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14734 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14735 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14736 static const char * arm_attr_tag_FP_HP_extension
[] =
14737 {"Not Allowed", "Allowed"};
14738 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14739 {"None", "IEEE 754", "Alternative Format"};
14740 static const char * arm_attr_tag_DSP_extension
[] =
14741 {"Follow architecture", "Allowed"};
14742 static const char * arm_attr_tag_MPextension_use
[] =
14743 {"Not Allowed", "Allowed"};
14744 static const char * arm_attr_tag_DIV_use
[] =
14745 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14746 "Allowed in v7-A with integer division extension"};
14747 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14748 static const char * arm_attr_tag_Virtualization_use
[] =
14749 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14750 "TrustZone and Virtualization Extensions"};
14751 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14752 {"Not Allowed", "Allowed"};
14754 static const char * arm_attr_tag_MVE_arch
[] =
14755 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14757 #define LOOKUP(id, name) \
14758 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14759 static arm_attr_public_tag arm_attr_public_tags
[] =
14761 {4, "CPU_raw_name", 1, NULL
},
14762 {5, "CPU_name", 1, NULL
},
14763 LOOKUP(6, CPU_arch
),
14764 {7, "CPU_arch_profile", 0, NULL
},
14765 LOOKUP(8, ARM_ISA_use
),
14766 LOOKUP(9, THUMB_ISA_use
),
14767 LOOKUP(10, FP_arch
),
14768 LOOKUP(11, WMMX_arch
),
14769 LOOKUP(12, Advanced_SIMD_arch
),
14770 LOOKUP(13, PCS_config
),
14771 LOOKUP(14, ABI_PCS_R9_use
),
14772 LOOKUP(15, ABI_PCS_RW_data
),
14773 LOOKUP(16, ABI_PCS_RO_data
),
14774 LOOKUP(17, ABI_PCS_GOT_use
),
14775 LOOKUP(18, ABI_PCS_wchar_t
),
14776 LOOKUP(19, ABI_FP_rounding
),
14777 LOOKUP(20, ABI_FP_denormal
),
14778 LOOKUP(21, ABI_FP_exceptions
),
14779 LOOKUP(22, ABI_FP_user_exceptions
),
14780 LOOKUP(23, ABI_FP_number_model
),
14781 {24, "ABI_align_needed", 0, NULL
},
14782 {25, "ABI_align_preserved", 0, NULL
},
14783 LOOKUP(26, ABI_enum_size
),
14784 LOOKUP(27, ABI_HardFP_use
),
14785 LOOKUP(28, ABI_VFP_args
),
14786 LOOKUP(29, ABI_WMMX_args
),
14787 LOOKUP(30, ABI_optimization_goals
),
14788 LOOKUP(31, ABI_FP_optimization_goals
),
14789 {32, "compatibility", 0, NULL
},
14790 LOOKUP(34, CPU_unaligned_access
),
14791 LOOKUP(36, FP_HP_extension
),
14792 LOOKUP(38, ABI_FP_16bit_format
),
14793 LOOKUP(42, MPextension_use
),
14794 LOOKUP(44, DIV_use
),
14795 LOOKUP(46, DSP_extension
),
14796 LOOKUP(48, MVE_arch
),
14797 {64, "nodefaults", 0, NULL
},
14798 {65, "also_compatible_with", 0, NULL
},
14799 LOOKUP(66, T2EE_use
),
14800 {67, "conformance", 1, NULL
},
14801 LOOKUP(68, Virtualization_use
),
14802 LOOKUP(70, MPextension_use_legacy
)
14806 static unsigned char *
14807 display_arm_attribute (unsigned char * p
,
14808 const unsigned char * const end
)
14813 arm_attr_public_tag
* attr
;
14817 tag
= read_uleb128 (p
, &len
, end
);
14820 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14822 if (arm_attr_public_tags
[i
].tag
== tag
)
14824 attr
= &arm_attr_public_tags
[i
];
14831 printf (" Tag_%s: ", attr
->name
);
14832 switch (attr
->type
)
14837 case 7: /* Tag_CPU_arch_profile. */
14838 val
= read_uleb128 (p
, &len
, end
);
14842 case 0: printf (_("None\n")); break;
14843 case 'A': printf (_("Application\n")); break;
14844 case 'R': printf (_("Realtime\n")); break;
14845 case 'M': printf (_("Microcontroller\n")); break;
14846 case 'S': printf (_("Application or Realtime\n")); break;
14847 default: printf ("??? (%d)\n", val
); break;
14851 case 24: /* Tag_align_needed. */
14852 val
= read_uleb128 (p
, &len
, end
);
14856 case 0: printf (_("None\n")); break;
14857 case 1: printf (_("8-byte\n")); break;
14858 case 2: printf (_("4-byte\n")); break;
14859 case 3: printf ("??? 3\n"); break;
14862 printf (_("8-byte and up to %d-byte extended\n"),
14865 printf ("??? (%d)\n", val
);
14870 case 25: /* Tag_align_preserved. */
14871 val
= read_uleb128 (p
, &len
, end
);
14875 case 0: printf (_("None\n")); break;
14876 case 1: printf (_("8-byte, except leaf SP\n")); break;
14877 case 2: printf (_("8-byte\n")); break;
14878 case 3: printf ("??? 3\n"); break;
14881 printf (_("8-byte and up to %d-byte extended\n"),
14884 printf ("??? (%d)\n", val
);
14889 case 32: /* Tag_compatibility. */
14891 val
= read_uleb128 (p
, &len
, end
);
14893 printf (_("flag = %d, vendor = "), val
);
14896 size_t maxlen
= (end
- p
) - 1;
14898 print_symbol ((int) maxlen
, (const char *) p
);
14899 p
+= strnlen ((char *) p
, maxlen
) + 1;
14903 printf (_("<corrupt>"));
14904 p
= (unsigned char *) end
;
14910 case 64: /* Tag_nodefaults. */
14911 /* PR 17531: file: 001-505008-0.01. */
14914 printf (_("True\n"));
14917 case 65: /* Tag_also_compatible_with. */
14918 val
= read_uleb128 (p
, &len
, end
);
14920 if (val
== 6 /* Tag_CPU_arch. */)
14922 val
= read_uleb128 (p
, &len
, end
);
14924 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14925 printf ("??? (%d)\n", val
);
14927 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14931 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14936 printf (_("<unknown: %d>\n"), tag
);
14942 return display_tag_value (-1, p
, end
);
14944 return display_tag_value (0, p
, end
);
14947 assert (attr
->type
& 0x80);
14948 val
= read_uleb128 (p
, &len
, end
);
14950 type
= attr
->type
& 0x7f;
14952 printf ("??? (%d)\n", val
);
14954 printf ("%s\n", attr
->table
[val
]);
14959 return display_tag_value (tag
, p
, end
);
14962 static unsigned char *
14963 display_gnu_attribute (unsigned char * p
,
14964 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14965 const unsigned char * const end
)
14971 tag
= read_uleb128 (p
, &len
, end
);
14974 /* Tag_compatibility is the only generic GNU attribute defined at
14978 val
= read_uleb128 (p
, &len
, end
);
14981 printf (_("flag = %d, vendor = "), val
);
14984 printf (_("<corrupt>\n"));
14985 warn (_("corrupt vendor attribute\n"));
14991 size_t maxlen
= (end
- p
) - 1;
14993 print_symbol ((int) maxlen
, (const char *) p
);
14994 p
+= strnlen ((char *) p
, maxlen
) + 1;
14998 printf (_("<corrupt>"));
14999 p
= (unsigned char *) end
;
15006 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15007 return display_proc_gnu_attribute (p
, tag
, end
);
15009 return display_tag_value (tag
, p
, end
);
15012 static unsigned char *
15013 display_power_gnu_attribute (unsigned char * p
,
15015 const unsigned char * const end
)
15020 if (tag
== Tag_GNU_Power_ABI_FP
)
15022 val
= read_uleb128 (p
, &len
, end
);
15024 printf (" Tag_GNU_Power_ABI_FP: ");
15027 printf (_("<corrupt>\n"));
15032 printf ("(%#x), ", val
);
15037 printf (_("unspecified hard/soft float, "));
15040 printf (_("hard float, "));
15043 printf (_("soft float, "));
15046 printf (_("single-precision hard float, "));
15053 printf (_("unspecified long double\n"));
15056 printf (_("128-bit IBM long double\n"));
15059 printf (_("64-bit long double\n"));
15062 printf (_("128-bit IEEE long double\n"));
15068 if (tag
== Tag_GNU_Power_ABI_Vector
)
15070 val
= read_uleb128 (p
, &len
, end
);
15072 printf (" Tag_GNU_Power_ABI_Vector: ");
15075 printf (_("<corrupt>\n"));
15080 printf ("(%#x), ", val
);
15085 printf (_("unspecified\n"));
15088 printf (_("generic\n"));
15091 printf ("AltiVec\n");
15100 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15102 val
= read_uleb128 (p
, &len
, end
);
15104 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15107 printf (_("<corrupt>\n"));
15112 printf ("(%#x), ", val
);
15117 printf (_("unspecified\n"));
15120 printf ("r3/r4\n");
15123 printf (_("memory\n"));
15132 return display_tag_value (tag
& 1, p
, end
);
15135 static unsigned char *
15136 display_s390_gnu_attribute (unsigned char * p
,
15138 const unsigned char * const end
)
15143 if (tag
== Tag_GNU_S390_ABI_Vector
)
15145 val
= read_uleb128 (p
, &len
, end
);
15147 printf (" Tag_GNU_S390_ABI_Vector: ");
15152 printf (_("any\n"));
15155 printf (_("software\n"));
15158 printf (_("hardware\n"));
15161 printf ("??? (%d)\n", val
);
15167 return display_tag_value (tag
& 1, p
, end
);
15171 display_sparc_hwcaps (unsigned int mask
)
15175 bfd_boolean first
= TRUE
;
15177 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15178 fputs ("mul32", stdout
), first
= FALSE
;
15179 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15180 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15181 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15182 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15183 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15184 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15185 if (mask
& ELF_SPARC_HWCAP_POPC
)
15186 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15187 if (mask
& ELF_SPARC_HWCAP_VIS
)
15188 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15189 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15190 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15191 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15192 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15193 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15194 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15195 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15196 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15197 if (mask
& ELF_SPARC_HWCAP_HPC
)
15198 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15199 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15200 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15201 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15202 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15203 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15204 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15205 if (mask
& ELF_SPARC_HWCAP_IMA
)
15206 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15207 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15208 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15211 fputc ('0', stdout
);
15212 fputc ('\n', stdout
);
15216 display_sparc_hwcaps2 (unsigned int mask
)
15220 bfd_boolean first
= TRUE
;
15222 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15223 fputs ("fjathplus", stdout
), first
= FALSE
;
15224 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15225 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15226 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15227 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15228 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15229 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15230 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15231 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15232 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15233 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15234 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15235 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15236 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15237 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15238 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15239 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15240 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15241 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15242 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15243 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15246 fputc ('0', stdout
);
15247 fputc ('\n', stdout
);
15250 static unsigned char *
15251 display_sparc_gnu_attribute (unsigned char * p
,
15253 const unsigned char * const end
)
15258 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15260 val
= read_uleb128 (p
, &len
, end
);
15262 printf (" Tag_GNU_Sparc_HWCAPS: ");
15263 display_sparc_hwcaps (val
);
15266 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15268 val
= read_uleb128 (p
, &len
, end
);
15270 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15271 display_sparc_hwcaps2 (val
);
15275 return display_tag_value (tag
, p
, end
);
15279 print_mips_fp_abi_value (unsigned int val
)
15283 case Val_GNU_MIPS_ABI_FP_ANY
:
15284 printf (_("Hard or soft float\n"));
15286 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15287 printf (_("Hard float (double precision)\n"));
15289 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15290 printf (_("Hard float (single precision)\n"));
15292 case Val_GNU_MIPS_ABI_FP_SOFT
:
15293 printf (_("Soft float\n"));
15295 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15296 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15298 case Val_GNU_MIPS_ABI_FP_XX
:
15299 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15301 case Val_GNU_MIPS_ABI_FP_64
:
15302 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15304 case Val_GNU_MIPS_ABI_FP_64A
:
15305 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15307 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15308 printf (_("NaN 2008 compatibility\n"));
15311 printf ("??? (%d)\n", val
);
15316 static unsigned char *
15317 display_mips_gnu_attribute (unsigned char * p
,
15319 const unsigned char * const end
)
15321 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15326 val
= read_uleb128 (p
, &len
, end
);
15328 printf (" Tag_GNU_MIPS_ABI_FP: ");
15330 print_mips_fp_abi_value (val
);
15335 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15340 val
= read_uleb128 (p
, &len
, end
);
15342 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15346 case Val_GNU_MIPS_ABI_MSA_ANY
:
15347 printf (_("Any MSA or not\n"));
15349 case Val_GNU_MIPS_ABI_MSA_128
:
15350 printf (_("128-bit MSA\n"));
15353 printf ("??? (%d)\n", val
);
15359 return display_tag_value (tag
& 1, p
, end
);
15362 static unsigned char *
15363 display_tic6x_attribute (unsigned char * p
,
15364 const unsigned char * const end
)
15370 tag
= read_uleb128 (p
, &len
, end
);
15376 val
= read_uleb128 (p
, &len
, end
);
15378 printf (" Tag_ISA: ");
15382 case C6XABI_Tag_ISA_none
:
15383 printf (_("None\n"));
15385 case C6XABI_Tag_ISA_C62X
:
15388 case C6XABI_Tag_ISA_C67X
:
15391 case C6XABI_Tag_ISA_C67XP
:
15392 printf ("C67x+\n");
15394 case C6XABI_Tag_ISA_C64X
:
15397 case C6XABI_Tag_ISA_C64XP
:
15398 printf ("C64x+\n");
15400 case C6XABI_Tag_ISA_C674X
:
15401 printf ("C674x\n");
15404 printf ("??? (%d)\n", val
);
15409 case Tag_ABI_wchar_t
:
15410 val
= read_uleb128 (p
, &len
, end
);
15412 printf (" Tag_ABI_wchar_t: ");
15416 printf (_("Not used\n"));
15419 printf (_("2 bytes\n"));
15422 printf (_("4 bytes\n"));
15425 printf ("??? (%d)\n", val
);
15430 case Tag_ABI_stack_align_needed
:
15431 val
= read_uleb128 (p
, &len
, end
);
15433 printf (" Tag_ABI_stack_align_needed: ");
15437 printf (_("8-byte\n"));
15440 printf (_("16-byte\n"));
15443 printf ("??? (%d)\n", val
);
15448 case Tag_ABI_stack_align_preserved
:
15449 val
= read_uleb128 (p
, &len
, end
);
15451 printf (" Tag_ABI_stack_align_preserved: ");
15455 printf (_("8-byte\n"));
15458 printf (_("16-byte\n"));
15461 printf ("??? (%d)\n", val
);
15467 val
= read_uleb128 (p
, &len
, end
);
15469 printf (" Tag_ABI_DSBT: ");
15473 printf (_("DSBT addressing not used\n"));
15476 printf (_("DSBT addressing used\n"));
15479 printf ("??? (%d)\n", val
);
15485 val
= read_uleb128 (p
, &len
, end
);
15487 printf (" Tag_ABI_PID: ");
15491 printf (_("Data addressing position-dependent\n"));
15494 printf (_("Data addressing position-independent, GOT near DP\n"));
15497 printf (_("Data addressing position-independent, GOT far from DP\n"));
15500 printf ("??? (%d)\n", val
);
15506 val
= read_uleb128 (p
, &len
, end
);
15508 printf (" Tag_ABI_PIC: ");
15512 printf (_("Code addressing position-dependent\n"));
15515 printf (_("Code addressing position-independent\n"));
15518 printf ("??? (%d)\n", val
);
15523 case Tag_ABI_array_object_alignment
:
15524 val
= read_uleb128 (p
, &len
, end
);
15526 printf (" Tag_ABI_array_object_alignment: ");
15530 printf (_("8-byte\n"));
15533 printf (_("4-byte\n"));
15536 printf (_("16-byte\n"));
15539 printf ("??? (%d)\n", val
);
15544 case Tag_ABI_array_object_align_expected
:
15545 val
= read_uleb128 (p
, &len
, end
);
15547 printf (" Tag_ABI_array_object_align_expected: ");
15551 printf (_("8-byte\n"));
15554 printf (_("4-byte\n"));
15557 printf (_("16-byte\n"));
15560 printf ("??? (%d)\n", val
);
15565 case Tag_ABI_compatibility
:
15567 val
= read_uleb128 (p
, &len
, end
);
15569 printf (" Tag_ABI_compatibility: ");
15570 printf (_("flag = %d, vendor = "), val
);
15573 size_t maxlen
= (end
- p
) - 1;
15575 print_symbol ((int) maxlen
, (const char *) p
);
15576 p
+= strnlen ((char *) p
, maxlen
) + 1;
15580 printf (_("<corrupt>"));
15581 p
= (unsigned char *) end
;
15587 case Tag_ABI_conformance
:
15589 printf (" Tag_ABI_conformance: \"");
15592 size_t maxlen
= (end
- p
) - 1;
15594 print_symbol ((int) maxlen
, (const char *) p
);
15595 p
+= strnlen ((char *) p
, maxlen
) + 1;
15599 printf (_("<corrupt>"));
15600 p
= (unsigned char *) end
;
15607 return display_tag_value (tag
, p
, end
);
15611 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15613 unsigned long addr
= 0;
15614 size_t bytes
= end
- p
;
15621 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15623 printf (" 0x%8.8lx ", addr
);
15625 for (j
= 0; j
< 16; j
++)
15628 printf ("%2.2x", p
[j
]);
15636 for (j
= 0; j
< lbytes
; j
++)
15639 if (k
>= ' ' && k
< 0x7f)
15655 static unsigned char *
15656 display_msp430x_attribute (unsigned char * p
,
15657 const unsigned char * const end
)
15663 tag
= read_uleb128 (p
, & len
, end
);
15668 case OFBA_MSPABI_Tag_ISA
:
15669 val
= read_uleb128 (p
, &len
, end
);
15671 printf (" Tag_ISA: ");
15674 case 0: printf (_("None\n")); break;
15675 case 1: printf (_("MSP430\n")); break;
15676 case 2: printf (_("MSP430X\n")); break;
15677 default: printf ("??? (%d)\n", val
); break;
15681 case OFBA_MSPABI_Tag_Code_Model
:
15682 val
= read_uleb128 (p
, &len
, end
);
15684 printf (" Tag_Code_Model: ");
15687 case 0: printf (_("None\n")); break;
15688 case 1: printf (_("Small\n")); break;
15689 case 2: printf (_("Large\n")); break;
15690 default: printf ("??? (%d)\n", val
); break;
15694 case OFBA_MSPABI_Tag_Data_Model
:
15695 val
= read_uleb128 (p
, &len
, end
);
15697 printf (" Tag_Data_Model: ");
15700 case 0: printf (_("None\n")); break;
15701 case 1: printf (_("Small\n")); break;
15702 case 2: printf (_("Large\n")); break;
15703 case 3: printf (_("Restricted Large\n")); break;
15704 default: printf ("??? (%d)\n", val
); break;
15709 printf (_(" <unknown tag %d>: "), tag
);
15716 size_t maxlen
= (end
- p
) - 1;
15718 print_symbol ((int) maxlen
, (const char *) p
);
15719 p
+= strnlen ((char *) p
, maxlen
) + 1;
15723 printf (_("<corrupt>"));
15724 p
= (unsigned char *) end
;
15730 val
= read_uleb128 (p
, &len
, end
);
15732 printf ("%d (0x%x)\n", val
, val
);
15741 static unsigned char *
15742 display_msp430_gnu_attribute (unsigned char * p
,
15744 const unsigned char * const end
)
15746 if (tag
== Tag_GNU_MSP430_Data_Region
)
15751 val
= read_uleb128 (p
, &len
, end
);
15753 printf (" Tag_GNU_MSP430_Data_Region: ");
15757 case Val_GNU_MSP430_Data_Region_Any
:
15758 printf (_("Any Region\n"));
15760 case Val_GNU_MSP430_Data_Region_Lower
:
15761 printf (_("Lower Region Only\n"));
15764 printf ("??? (%d)\n", val
);
15768 return display_tag_value (tag
& 1, p
, end
);
15771 struct riscv_attr_tag_t
{
15776 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15778 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15781 T(priv_spec_minor
),
15782 T(priv_spec_revision
),
15783 T(unaligned_access
),
15788 static unsigned char *
15789 display_riscv_attribute (unsigned char *p
,
15790 const unsigned char * const end
)
15795 struct riscv_attr_tag_t
*attr
= NULL
;
15798 tag
= read_uleb128 (p
, &len
, end
);
15801 /* Find the name of attribute. */
15802 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15804 if (riscv_attr_tag
[i
].tag
== tag
)
15806 attr
= &riscv_attr_tag
[i
];
15812 printf (" %s: ", attr
->name
);
15814 return display_tag_value (tag
, p
, end
);
15818 case Tag_RISCV_priv_spec
:
15819 case Tag_RISCV_priv_spec_minor
:
15820 case Tag_RISCV_priv_spec_revision
:
15821 val
= read_uleb128 (p
, &len
, end
);
15823 printf (_("%d\n"), val
);
15825 case Tag_RISCV_unaligned_access
:
15826 val
= read_uleb128 (p
, &len
, end
);
15831 printf (_("No unaligned access\n"));
15834 printf (_("Unaligned access\n"));
15838 case Tag_RISCV_stack_align
:
15839 val
= read_uleb128 (p
, &len
, end
);
15841 printf (_("%d-bytes\n"), val
);
15843 case Tag_RISCV_arch
:
15844 p
= display_tag_value (-1, p
, end
);
15847 return display_tag_value (tag
, p
, end
);
15854 process_attributes (Filedata
* filedata
,
15855 const char * public_name
,
15856 unsigned int proc_type
,
15857 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15858 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15860 Elf_Internal_Shdr
* sect
;
15862 bfd_boolean res
= TRUE
;
15864 /* Find the section header so that we get the size. */
15865 for (i
= 0, sect
= filedata
->section_headers
;
15866 i
< filedata
->file_header
.e_shnum
;
15869 unsigned char * contents
;
15872 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15875 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15876 sect
->sh_size
, _("attributes"));
15877 if (contents
== NULL
)
15884 /* The first character is the version of the attributes.
15885 Currently only version 1, (aka 'A') is recognised here. */
15888 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15893 bfd_vma section_len
;
15895 section_len
= sect
->sh_size
- 1;
15898 while (section_len
> 0)
15901 unsigned int namelen
;
15902 bfd_boolean public_section
;
15903 bfd_boolean gnu_section
;
15905 if (section_len
<= 4)
15907 error (_("Tag section ends prematurely\n"));
15911 attr_len
= byte_get (p
, 4);
15914 if (attr_len
> section_len
)
15916 error (_("Bad attribute length (%u > %u)\n"),
15917 (unsigned) attr_len
, (unsigned) section_len
);
15918 attr_len
= section_len
;
15921 /* PR 17531: file: 001-101425-0.004 */
15922 else if (attr_len
< 5)
15924 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15929 section_len
-= attr_len
;
15932 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15933 if (namelen
== 0 || namelen
>= attr_len
)
15935 error (_("Corrupt attribute section name\n"));
15940 printf (_("Attribute Section: "));
15941 print_symbol (INT_MAX
, (const char *) p
);
15944 if (public_name
&& streq ((char *) p
, public_name
))
15945 public_section
= TRUE
;
15947 public_section
= FALSE
;
15949 if (streq ((char *) p
, "gnu"))
15950 gnu_section
= TRUE
;
15952 gnu_section
= FALSE
;
15955 attr_len
-= namelen
;
15957 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15962 unsigned char * end
;
15964 /* PR binutils/17531: Safe handling of corrupt files. */
15967 error (_("Unused bytes at end of section\n"));
15974 size
= byte_get (p
, 4);
15975 if (size
> attr_len
)
15977 error (_("Bad subsection length (%u > %u)\n"),
15978 (unsigned) size
, (unsigned) attr_len
);
15982 /* PR binutils/17531: Safe handling of corrupt files. */
15985 error (_("Bad subsection length (%u < 6)\n"),
15993 end
= p
+ size
- 1;
15994 assert (end
<= contents
+ sect
->sh_size
);
16000 printf (_("File Attributes\n"));
16003 printf (_("Section Attributes:"));
16006 printf (_("Symbol Attributes:"));
16007 /* Fall through. */
16013 val
= read_uleb128 (p
, &j
, end
);
16017 printf (" %d", val
);
16022 printf (_("Unknown tag: %d\n"), tag
);
16023 public_section
= FALSE
;
16027 if (public_section
&& display_pub_attribute
!= NULL
)
16030 p
= display_pub_attribute (p
, end
);
16033 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16036 p
= display_gnu_attribute (p
,
16037 display_proc_gnu_attribute
,
16043 printf (_(" Unknown attribute:\n"));
16044 display_raw_attribute (p
, end
);
16059 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16060 Print the Address, Access and Initial fields of an entry at VMA ADDR
16061 and return the VMA of the next entry, or -1 if there was a problem.
16062 Does not read from DATA_END or beyond. */
16065 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16066 unsigned char * data_end
)
16069 print_vma (addr
, LONG_HEX
);
16071 if (addr
< pltgot
+ 0xfff0)
16072 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16074 printf ("%10s", "");
16077 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16081 unsigned char * from
= data
+ addr
- pltgot
;
16083 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16085 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16086 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16087 return (bfd_vma
) -1;
16091 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16092 print_vma (entry
, LONG_HEX
);
16095 return addr
+ (is_32bit_elf
? 4 : 8);
16098 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16099 PLTGOT. Print the Address and Initial fields of an entry at VMA
16100 ADDR and return the VMA of the next entry. */
16103 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16106 print_vma (addr
, LONG_HEX
);
16109 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16114 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16115 print_vma (entry
, LONG_HEX
);
16117 return addr
+ (is_32bit_elf
? 4 : 8);
16121 print_mips_ases (unsigned int mask
)
16123 if (mask
& AFL_ASE_DSP
)
16124 fputs ("\n\tDSP ASE", stdout
);
16125 if (mask
& AFL_ASE_DSPR2
)
16126 fputs ("\n\tDSP R2 ASE", stdout
);
16127 if (mask
& AFL_ASE_DSPR3
)
16128 fputs ("\n\tDSP R3 ASE", stdout
);
16129 if (mask
& AFL_ASE_EVA
)
16130 fputs ("\n\tEnhanced VA Scheme", stdout
);
16131 if (mask
& AFL_ASE_MCU
)
16132 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16133 if (mask
& AFL_ASE_MDMX
)
16134 fputs ("\n\tMDMX ASE", stdout
);
16135 if (mask
& AFL_ASE_MIPS3D
)
16136 fputs ("\n\tMIPS-3D ASE", stdout
);
16137 if (mask
& AFL_ASE_MT
)
16138 fputs ("\n\tMT ASE", stdout
);
16139 if (mask
& AFL_ASE_SMARTMIPS
)
16140 fputs ("\n\tSmartMIPS ASE", stdout
);
16141 if (mask
& AFL_ASE_VIRT
)
16142 fputs ("\n\tVZ ASE", stdout
);
16143 if (mask
& AFL_ASE_MSA
)
16144 fputs ("\n\tMSA ASE", stdout
);
16145 if (mask
& AFL_ASE_MIPS16
)
16146 fputs ("\n\tMIPS16 ASE", stdout
);
16147 if (mask
& AFL_ASE_MICROMIPS
)
16148 fputs ("\n\tMICROMIPS ASE", stdout
);
16149 if (mask
& AFL_ASE_XPA
)
16150 fputs ("\n\tXPA ASE", stdout
);
16151 if (mask
& AFL_ASE_MIPS16E2
)
16152 fputs ("\n\tMIPS16e2 ASE", stdout
);
16153 if (mask
& AFL_ASE_CRC
)
16154 fputs ("\n\tCRC ASE", stdout
);
16155 if (mask
& AFL_ASE_GINV
)
16156 fputs ("\n\tGINV ASE", stdout
);
16157 if (mask
& AFL_ASE_LOONGSON_MMI
)
16158 fputs ("\n\tLoongson MMI ASE", stdout
);
16159 if (mask
& AFL_ASE_LOONGSON_CAM
)
16160 fputs ("\n\tLoongson CAM ASE", stdout
);
16161 if (mask
& AFL_ASE_LOONGSON_EXT
)
16162 fputs ("\n\tLoongson EXT ASE", stdout
);
16163 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16164 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16166 fprintf (stdout
, "\n\t%s", _("None"));
16167 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16168 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16172 print_mips_isa_ext (unsigned int isa_ext
)
16177 fputs (_("None"), stdout
);
16180 fputs ("RMI XLR", stdout
);
16182 case AFL_EXT_OCTEON3
:
16183 fputs ("Cavium Networks Octeon3", stdout
);
16185 case AFL_EXT_OCTEON2
:
16186 fputs ("Cavium Networks Octeon2", stdout
);
16188 case AFL_EXT_OCTEONP
:
16189 fputs ("Cavium Networks OcteonP", stdout
);
16191 case AFL_EXT_OCTEON
:
16192 fputs ("Cavium Networks Octeon", stdout
);
16195 fputs ("Toshiba R5900", stdout
);
16198 fputs ("MIPS R4650", stdout
);
16201 fputs ("LSI R4010", stdout
);
16204 fputs ("NEC VR4100", stdout
);
16207 fputs ("Toshiba R3900", stdout
);
16209 case AFL_EXT_10000
:
16210 fputs ("MIPS R10000", stdout
);
16213 fputs ("Broadcom SB-1", stdout
);
16216 fputs ("NEC VR4111/VR4181", stdout
);
16219 fputs ("NEC VR4120", stdout
);
16222 fputs ("NEC VR5400", stdout
);
16225 fputs ("NEC VR5500", stdout
);
16227 case AFL_EXT_LOONGSON_2E
:
16228 fputs ("ST Microelectronics Loongson 2E", stdout
);
16230 case AFL_EXT_LOONGSON_2F
:
16231 fputs ("ST Microelectronics Loongson 2F", stdout
);
16233 case AFL_EXT_INTERAPTIV_MR2
:
16234 fputs ("Imagination interAptiv MR2", stdout
);
16237 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16242 get_mips_reg_size (int reg_size
)
16244 return (reg_size
== AFL_REG_NONE
) ? 0
16245 : (reg_size
== AFL_REG_32
) ? 32
16246 : (reg_size
== AFL_REG_64
) ? 64
16247 : (reg_size
== AFL_REG_128
) ? 128
16252 process_mips_specific (Filedata
* filedata
)
16254 Elf_Internal_Dyn
* entry
;
16255 Elf_Internal_Shdr
*sect
= NULL
;
16256 size_t liblist_offset
= 0;
16257 size_t liblistno
= 0;
16258 size_t conflictsno
= 0;
16259 size_t options_offset
= 0;
16260 size_t conflicts_offset
= 0;
16261 size_t pltrelsz
= 0;
16263 bfd_vma pltgot
= 0;
16264 bfd_vma mips_pltgot
= 0;
16265 bfd_vma jmprel
= 0;
16266 bfd_vma local_gotno
= 0;
16267 bfd_vma gotsym
= 0;
16268 bfd_vma symtabno
= 0;
16269 bfd_boolean res
= TRUE
;
16271 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16272 display_mips_gnu_attribute
))
16275 sect
= find_section (filedata
, ".MIPS.abiflags");
16279 Elf_External_ABIFlags_v0
*abiflags_ext
;
16280 Elf_Internal_ABIFlags_v0 abiflags_in
;
16282 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16284 error (_("Corrupt MIPS ABI Flags section.\n"));
16289 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16290 sect
->sh_size
, _("MIPS ABI Flags section"));
16293 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16294 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16295 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16296 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16297 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16298 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16299 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16300 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16301 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16302 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16303 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16305 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16306 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16307 if (abiflags_in
.isa_rev
> 1)
16308 printf ("r%d", abiflags_in
.isa_rev
);
16309 printf ("\nGPR size: %d",
16310 get_mips_reg_size (abiflags_in
.gpr_size
));
16311 printf ("\nCPR1 size: %d",
16312 get_mips_reg_size (abiflags_in
.cpr1_size
));
16313 printf ("\nCPR2 size: %d",
16314 get_mips_reg_size (abiflags_in
.cpr2_size
));
16315 fputs ("\nFP ABI: ", stdout
);
16316 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16317 fputs ("ISA Extension: ", stdout
);
16318 print_mips_isa_ext (abiflags_in
.isa_ext
);
16319 fputs ("\nASEs:", stdout
);
16320 print_mips_ases (abiflags_in
.ases
);
16321 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16322 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16323 fputc ('\n', stdout
);
16324 free (abiflags_ext
);
16329 /* We have a lot of special sections. Thanks SGI! */
16330 if (dynamic_section
== NULL
)
16332 /* No dynamic information available. See if there is static GOT. */
16333 sect
= find_section (filedata
, ".got");
16336 unsigned char *data_end
;
16337 unsigned char *data
;
16341 pltgot
= sect
->sh_addr
;
16344 addr_size
= (is_32bit_elf
? 4 : 8);
16345 end
= pltgot
+ sect
->sh_size
;
16347 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16349 _("Global Offset Table data"));
16350 /* PR 12855: Null data is handled gracefully throughout. */
16351 data_end
= data
+ (end
- pltgot
);
16353 printf (_("\nStatic GOT:\n"));
16354 printf (_(" Canonical gp value: "));
16355 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16358 /* In a dynamic binary GOT[0] is reserved for the dynamic
16359 loader to store the lazy resolver pointer, however in
16360 a static binary it may well have been omitted and GOT
16361 reduced to a table of addresses.
16362 PR 21344: Check for the entry being fully available
16363 before fetching it. */
16365 && data
+ ent
- pltgot
+ addr_size
<= data_end
16366 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16368 printf (_(" Reserved entries:\n"));
16369 printf (_(" %*s %10s %*s\n"),
16370 addr_size
* 2, _("Address"), _("Access"),
16371 addr_size
* 2, _("Value"));
16372 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16374 if (ent
== (bfd_vma
) -1)
16375 goto sgot_print_fail
;
16377 /* Check for the MSB of GOT[1] being set, identifying a
16378 GNU object. This entry will be used by some runtime
16379 loaders, to store the module pointer. Otherwise this
16380 is an ordinary local entry.
16381 PR 21344: Check for the entry being fully available
16382 before fetching it. */
16384 && data
+ ent
- pltgot
+ addr_size
<= data_end
16385 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16386 >> (addr_size
* 8 - 1)) != 0)
16388 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16390 if (ent
== (bfd_vma
) -1)
16391 goto sgot_print_fail
;
16396 if (data
!= NULL
&& ent
< end
)
16398 printf (_(" Local entries:\n"));
16399 printf (" %*s %10s %*s\n",
16400 addr_size
* 2, _("Address"), _("Access"),
16401 addr_size
* 2, _("Value"));
16404 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16406 if (ent
== (bfd_vma
) -1)
16407 goto sgot_print_fail
;
16419 for (entry
= dynamic_section
;
16420 /* PR 17531 file: 012-50589-0.004. */
16421 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16423 switch (entry
->d_tag
)
16425 case DT_MIPS_LIBLIST
:
16427 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16428 liblistno
* sizeof (Elf32_External_Lib
));
16430 case DT_MIPS_LIBLISTNO
:
16431 liblistno
= entry
->d_un
.d_val
;
16433 case DT_MIPS_OPTIONS
:
16434 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16436 case DT_MIPS_CONFLICT
:
16438 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16439 conflictsno
* sizeof (Elf32_External_Conflict
));
16441 case DT_MIPS_CONFLICTNO
:
16442 conflictsno
= entry
->d_un
.d_val
;
16445 pltgot
= entry
->d_un
.d_ptr
;
16447 case DT_MIPS_LOCAL_GOTNO
:
16448 local_gotno
= entry
->d_un
.d_val
;
16450 case DT_MIPS_GOTSYM
:
16451 gotsym
= entry
->d_un
.d_val
;
16453 case DT_MIPS_SYMTABNO
:
16454 symtabno
= entry
->d_un
.d_val
;
16456 case DT_MIPS_PLTGOT
:
16457 mips_pltgot
= entry
->d_un
.d_ptr
;
16460 pltrel
= entry
->d_un
.d_val
;
16463 pltrelsz
= entry
->d_un
.d_val
;
16466 jmprel
= entry
->d_un
.d_ptr
;
16472 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16474 Elf32_External_Lib
* elib
;
16477 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16479 sizeof (Elf32_External_Lib
),
16480 _("liblist section data"));
16483 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16484 "\nSection '.liblist' contains %lu entries:\n",
16485 (unsigned long) liblistno
),
16486 (unsigned long) liblistno
);
16487 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16490 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16497 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16498 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16499 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16500 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16501 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16503 tmp
= gmtime (&atime
);
16504 snprintf (timebuf
, sizeof (timebuf
),
16505 "%04u-%02u-%02uT%02u:%02u:%02u",
16506 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16507 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16509 printf ("%3lu: ", (unsigned long) cnt
);
16510 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16511 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16513 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16514 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16515 liblist
.l_version
);
16517 if (liblist
.l_flags
== 0)
16521 static const struct
16528 { " EXACT_MATCH", LL_EXACT_MATCH
},
16529 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16530 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16531 { " EXPORTS", LL_EXPORTS
},
16532 { " DELAY_LOAD", LL_DELAY_LOAD
},
16533 { " DELTA", LL_DELTA
}
16535 int flags
= liblist
.l_flags
;
16538 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16539 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16541 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16542 flags
^= l_flags_vals
[fcnt
].bit
;
16545 printf (" %#x", (unsigned int) flags
);
16557 if (options_offset
!= 0)
16559 Elf_External_Options
* eopt
;
16562 sect
= filedata
->section_headers
;
16564 /* Find the section header so that we get the size. */
16565 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16566 /* PR 17533 file: 012-277276-0.004. */
16569 error (_("No MIPS_OPTIONS header found\n"));
16573 if (sect
->sh_size
< sizeof (* eopt
))
16575 error (_("The MIPS options section is too small.\n"));
16579 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16580 sect
->sh_size
, _("options"));
16583 Elf_Internal_Options
* iopt
;
16584 Elf_Internal_Options
* option
;
16585 Elf_Internal_Options
* iopt_end
;
16587 iopt
= (Elf_Internal_Options
*)
16588 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16591 error (_("Out of memory allocating space for MIPS options\n"));
16597 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16599 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16601 Elf_External_Options
* eoption
;
16603 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16605 option
->kind
= BYTE_GET (eoption
->kind
);
16606 option
->size
= BYTE_GET (eoption
->size
);
16607 option
->section
= BYTE_GET (eoption
->section
);
16608 option
->info
= BYTE_GET (eoption
->info
);
16610 /* PR 17531: file: ffa0fa3b. */
16611 if (option
->size
< sizeof (* eopt
)
16612 || offset
+ option
->size
> sect
->sh_size
)
16614 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16617 offset
+= option
->size
;
16623 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16624 "\nSection '%s' contains %d entries:\n",
16626 printable_section_name (filedata
, sect
), cnt
);
16635 switch (option
->kind
)
16638 /* This shouldn't happen. */
16639 printf (" NULL %d %lx", option
->section
, option
->info
);
16643 printf (" REGINFO ");
16644 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16646 Elf32_External_RegInfo
* ereg
;
16647 Elf32_RegInfo reginfo
;
16650 if (option
+ 2 > iopt_end
)
16652 printf (_("<corrupt>\n"));
16653 error (_("Truncated MIPS REGINFO option\n"));
16658 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16660 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16661 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16662 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16663 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16664 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16665 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16667 printf ("GPR %08lx GP 0x%lx\n",
16668 reginfo
.ri_gprmask
,
16669 (unsigned long) reginfo
.ri_gp_value
);
16670 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16671 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16672 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16677 Elf64_External_RegInfo
* ereg
;
16678 Elf64_Internal_RegInfo reginfo
;
16680 if (option
+ 2 > iopt_end
)
16682 printf (_("<corrupt>\n"));
16683 error (_("Truncated MIPS REGINFO option\n"));
16688 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16689 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16690 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16691 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16692 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16693 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16694 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16696 printf ("GPR %08lx GP 0x",
16697 reginfo
.ri_gprmask
);
16698 printf_vma (reginfo
.ri_gp_value
);
16701 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16702 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16703 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16708 case ODK_EXCEPTIONS
:
16709 fputs (" EXCEPTIONS fpe_min(", stdout
);
16710 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16711 fputs (") fpe_max(", stdout
);
16712 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16713 fputs (")", stdout
);
16715 if (option
->info
& OEX_PAGE0
)
16716 fputs (" PAGE0", stdout
);
16717 if (option
->info
& OEX_SMM
)
16718 fputs (" SMM", stdout
);
16719 if (option
->info
& OEX_FPDBUG
)
16720 fputs (" FPDBUG", stdout
);
16721 if (option
->info
& OEX_DISMISS
)
16722 fputs (" DISMISS", stdout
);
16726 fputs (" PAD ", stdout
);
16727 if (option
->info
& OPAD_PREFIX
)
16728 fputs (" PREFIX", stdout
);
16729 if (option
->info
& OPAD_POSTFIX
)
16730 fputs (" POSTFIX", stdout
);
16731 if (option
->info
& OPAD_SYMBOL
)
16732 fputs (" SYMBOL", stdout
);
16736 fputs (" HWPATCH ", stdout
);
16737 if (option
->info
& OHW_R4KEOP
)
16738 fputs (" R4KEOP", stdout
);
16739 if (option
->info
& OHW_R8KPFETCH
)
16740 fputs (" R8KPFETCH", stdout
);
16741 if (option
->info
& OHW_R5KEOP
)
16742 fputs (" R5KEOP", stdout
);
16743 if (option
->info
& OHW_R5KCVTL
)
16744 fputs (" R5KCVTL", stdout
);
16748 fputs (" FILL ", stdout
);
16749 /* XXX Print content of info word? */
16753 fputs (" TAGS ", stdout
);
16754 /* XXX Print content of info word? */
16758 fputs (" HWAND ", stdout
);
16759 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16760 fputs (" R4KEOP_CHECKED", stdout
);
16761 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16762 fputs (" R4KEOP_CLEAN", stdout
);
16766 fputs (" HWOR ", stdout
);
16767 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16768 fputs (" R4KEOP_CHECKED", stdout
);
16769 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16770 fputs (" R4KEOP_CLEAN", stdout
);
16774 printf (" GP_GROUP %#06lx self-contained %#06lx",
16775 option
->info
& OGP_GROUP
,
16776 (option
->info
& OGP_SELF
) >> 16);
16780 printf (" IDENT %#06lx self-contained %#06lx",
16781 option
->info
& OGP_GROUP
,
16782 (option
->info
& OGP_SELF
) >> 16);
16786 /* This shouldn't happen. */
16787 printf (" %3d ??? %d %lx",
16788 option
->kind
, option
->section
, option
->info
);
16792 len
= sizeof (* eopt
);
16793 while (len
< option
->size
)
16795 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16797 if (ISPRINT (datum
))
16798 printf ("%c", datum
);
16800 printf ("\\%03o", datum
);
16803 fputs ("\n", stdout
);
16805 offset
+= option
->size
;
16815 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16817 Elf32_Conflict
* iconf
;
16820 if (dynamic_symbols
== NULL
)
16822 error (_("conflict list found without a dynamic symbol table\n"));
16826 /* PR 21345 - print a slightly more helpful error message
16827 if we are sure that the cmalloc will fail. */
16828 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16830 error (_("Overlarge number of conflicts detected: %lx\n"),
16831 (long) conflictsno
);
16835 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16838 error (_("Out of memory allocating space for dynamic conflicts\n"));
16844 Elf32_External_Conflict
* econf32
;
16846 econf32
= (Elf32_External_Conflict
*)
16847 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16848 sizeof (* econf32
), _("conflict"));
16852 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16853 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16859 Elf64_External_Conflict
* econf64
;
16861 econf64
= (Elf64_External_Conflict
*)
16862 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16863 sizeof (* econf64
), _("conflict"));
16867 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16868 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16873 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16874 "\nSection '.conflict' contains %lu entries:\n",
16875 (unsigned long) conflictsno
),
16876 (unsigned long) conflictsno
);
16877 puts (_(" Num: Index Value Name"));
16879 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16881 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16883 if (iconf
[cnt
] >= num_dynamic_syms
)
16884 printf (_("<corrupt symbol index>"));
16887 Elf_Internal_Sym
* psym
;
16889 psym
= & dynamic_symbols
[iconf
[cnt
]];
16890 print_vma (psym
->st_value
, FULL_HEX
);
16892 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16893 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16895 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16903 if (pltgot
!= 0 && local_gotno
!= 0)
16905 bfd_vma ent
, local_end
, global_end
;
16907 unsigned char * data
;
16908 unsigned char * data_end
;
16912 addr_size
= (is_32bit_elf
? 4 : 8);
16913 local_end
= pltgot
+ local_gotno
* addr_size
;
16915 /* PR binutils/17533 file: 012-111227-0.004 */
16916 if (symtabno
< gotsym
)
16918 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16919 (unsigned long) gotsym
, (unsigned long) symtabno
);
16923 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16924 /* PR 17531: file: 54c91a34. */
16925 if (global_end
< local_end
)
16927 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16931 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16932 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16933 global_end
- pltgot
, 1,
16934 _("Global Offset Table data"));
16935 /* PR 12855: Null data is handled gracefully throughout. */
16936 data_end
= data
+ (global_end
- pltgot
);
16938 printf (_("\nPrimary GOT:\n"));
16939 printf (_(" Canonical gp value: "));
16940 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16943 printf (_(" Reserved entries:\n"));
16944 printf (_(" %*s %10s %*s Purpose\n"),
16945 addr_size
* 2, _("Address"), _("Access"),
16946 addr_size
* 2, _("Initial"));
16947 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16948 printf (_(" Lazy resolver\n"));
16949 if (ent
== (bfd_vma
) -1)
16950 goto got_print_fail
;
16952 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16953 This entry will be used by some runtime loaders, to store the
16954 module pointer. Otherwise this is an ordinary local entry.
16955 PR 21344: Check for the entry being fully available before
16958 && data
+ ent
- pltgot
+ addr_size
<= data_end
16959 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16960 >> (addr_size
* 8 - 1)) != 0)
16962 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16963 printf (_(" Module pointer (GNU extension)\n"));
16964 if (ent
== (bfd_vma
) -1)
16965 goto got_print_fail
;
16969 if (data
!= NULL
&& ent
< local_end
)
16971 printf (_(" Local entries:\n"));
16972 printf (" %*s %10s %*s\n",
16973 addr_size
* 2, _("Address"), _("Access"),
16974 addr_size
* 2, _("Initial"));
16975 while (ent
< local_end
)
16977 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16979 if (ent
== (bfd_vma
) -1)
16980 goto got_print_fail
;
16985 if (data
!= NULL
&& gotsym
< symtabno
)
16989 printf (_(" Global entries:\n"));
16990 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16991 addr_size
* 2, _("Address"),
16993 addr_size
* 2, _("Initial"),
16994 addr_size
* 2, _("Sym.Val."),
16996 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16997 _("Ndx"), _("Name"));
16999 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17001 for (i
= gotsym
; i
< symtabno
; i
++)
17003 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17006 if (dynamic_symbols
== NULL
)
17007 printf (_("<no dynamic symbols>"));
17008 else if (i
< num_dynamic_syms
)
17010 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17012 print_vma (psym
->st_value
, LONG_HEX
);
17013 printf (" %-7s %3s ",
17014 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17015 get_symbol_index_type (filedata
, psym
->st_shndx
));
17017 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17018 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17020 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17023 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17024 (unsigned long) i
);
17027 if (ent
== (bfd_vma
) -1)
17038 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17041 size_t offset
, rel_offset
;
17042 unsigned long count
, i
;
17043 unsigned char * data
;
17044 int addr_size
, sym_width
;
17045 Elf_Internal_Rela
* rels
;
17047 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17048 if (pltrel
== DT_RELA
)
17050 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17055 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17060 addr_size
= (is_32bit_elf
? 4 : 8);
17061 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17063 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17064 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17065 1, _("Procedure Linkage Table data"));
17069 printf ("\nPLT GOT:\n\n");
17070 printf (_(" Reserved entries:\n"));
17071 printf (_(" %*s %*s Purpose\n"),
17072 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17073 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17074 printf (_(" PLT lazy resolver\n"));
17075 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17076 printf (_(" Module pointer\n"));
17079 printf (_(" Entries:\n"));
17080 printf (" %*s %*s %*s %-7s %3s %s\n",
17081 addr_size
* 2, _("Address"),
17082 addr_size
* 2, _("Initial"),
17083 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17084 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17085 for (i
= 0; i
< count
; i
++)
17087 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17089 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17092 if (idx
>= num_dynamic_syms
)
17093 printf (_("<corrupt symbol index: %lu>"), idx
);
17096 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17098 print_vma (psym
->st_value
, LONG_HEX
);
17099 printf (" %-7s %3s ",
17100 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17101 get_symbol_index_type (filedata
, psym
->st_shndx
));
17102 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17103 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17105 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17120 process_nds32_specific (Filedata
* filedata
)
17122 Elf_Internal_Shdr
*sect
= NULL
;
17124 sect
= find_section (filedata
, ".nds32_e_flags");
17127 unsigned int *flag
;
17129 printf ("\nNDS32 elf flags section:\n");
17130 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17131 sect
->sh_size
, _("NDS32 elf flags section"));
17136 switch ((*flag
) & 0x3)
17139 printf ("(VEC_SIZE):\tNo entry.\n");
17142 printf ("(VEC_SIZE):\t4 bytes\n");
17145 printf ("(VEC_SIZE):\t16 bytes\n");
17148 printf ("(VEC_SIZE):\treserved\n");
17157 process_gnu_liblist (Filedata
* filedata
)
17159 Elf_Internal_Shdr
* section
;
17160 Elf_Internal_Shdr
* string_sec
;
17161 Elf32_External_Lib
* elib
;
17163 size_t strtab_size
;
17165 unsigned long num_liblist
;
17167 bfd_boolean res
= TRUE
;
17172 for (i
= 0, section
= filedata
->section_headers
;
17173 i
< filedata
->file_header
.e_shnum
;
17176 switch (section
->sh_type
)
17178 case SHT_GNU_LIBLIST
:
17179 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17182 elib
= (Elf32_External_Lib
*)
17183 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17184 _("liblist section data"));
17192 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17193 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17194 string_sec
->sh_size
,
17195 _("liblist string table"));
17197 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17204 strtab_size
= string_sec
->sh_size
;
17206 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17207 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17208 "\nLibrary list section '%s' contains %lu entries:\n",
17210 printable_section_name (filedata
, section
),
17213 puts (_(" Library Time Stamp Checksum Version Flags"));
17215 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17223 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17224 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17225 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17226 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17227 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17229 tmp
= gmtime (&atime
);
17230 snprintf (timebuf
, sizeof (timebuf
),
17231 "%04u-%02u-%02uT%02u:%02u:%02u",
17232 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17233 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17235 printf ("%3lu: ", (unsigned long) cnt
);
17237 printf ("%-20s", liblist
.l_name
< strtab_size
17238 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17240 printf ("%-20.20s", liblist
.l_name
< strtab_size
17241 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17242 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17243 liblist
.l_version
, liblist
.l_flags
);
17254 static const char *
17255 get_note_type (Filedata
* filedata
, unsigned e_type
)
17257 static char buff
[64];
17259 if (filedata
->file_header
.e_type
== ET_CORE
)
17263 return _("NT_AUXV (auxiliary vector)");
17265 return _("NT_PRSTATUS (prstatus structure)");
17267 return _("NT_FPREGSET (floating point registers)");
17269 return _("NT_PRPSINFO (prpsinfo structure)");
17270 case NT_TASKSTRUCT
:
17271 return _("NT_TASKSTRUCT (task structure)");
17273 return _("NT_PRXFPREG (user_xfpregs structure)");
17275 return _("NT_PPC_VMX (ppc Altivec registers)");
17277 return _("NT_PPC_VSX (ppc VSX registers)");
17279 return _("NT_PPC_TAR (ppc TAR register)");
17281 return _("NT_PPC_PPR (ppc PPR register)");
17283 return _("NT_PPC_DSCR (ppc DSCR register)");
17285 return _("NT_PPC_EBB (ppc EBB registers)");
17287 return _("NT_PPC_PMU (ppc PMU registers)");
17288 case NT_PPC_TM_CGPR
:
17289 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17290 case NT_PPC_TM_CFPR
:
17291 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17292 case NT_PPC_TM_CVMX
:
17293 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17294 case NT_PPC_TM_CVSX
:
17295 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17296 case NT_PPC_TM_SPR
:
17297 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17298 case NT_PPC_TM_CTAR
:
17299 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17300 case NT_PPC_TM_CPPR
:
17301 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17302 case NT_PPC_TM_CDSCR
:
17303 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17305 return _("NT_386_TLS (x86 TLS information)");
17306 case NT_386_IOPERM
:
17307 return _("NT_386_IOPERM (x86 I/O permissions)");
17308 case NT_X86_XSTATE
:
17309 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17310 case NT_S390_HIGH_GPRS
:
17311 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17312 case NT_S390_TIMER
:
17313 return _("NT_S390_TIMER (s390 timer register)");
17314 case NT_S390_TODCMP
:
17315 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17316 case NT_S390_TODPREG
:
17317 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17319 return _("NT_S390_CTRS (s390 control registers)");
17320 case NT_S390_PREFIX
:
17321 return _("NT_S390_PREFIX (s390 prefix register)");
17322 case NT_S390_LAST_BREAK
:
17323 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17324 case NT_S390_SYSTEM_CALL
:
17325 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17327 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17328 case NT_S390_VXRS_LOW
:
17329 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17330 case NT_S390_VXRS_HIGH
:
17331 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17332 case NT_S390_GS_CB
:
17333 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17334 case NT_S390_GS_BC
:
17335 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17337 return _("NT_ARM_VFP (arm VFP registers)");
17339 return _("NT_ARM_TLS (AArch TLS registers)");
17340 case NT_ARM_HW_BREAK
:
17341 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17342 case NT_ARM_HW_WATCH
:
17343 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17345 return _("NT_PSTATUS (pstatus structure)");
17347 return _("NT_FPREGS (floating point registers)");
17349 return _("NT_PSINFO (psinfo structure)");
17351 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17353 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17354 case NT_WIN32PSTATUS
:
17355 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17357 return _("NT_SIGINFO (siginfo_t data)");
17359 return _("NT_FILE (mapped files)");
17367 return _("NT_VERSION (version)");
17369 return _("NT_ARCH (architecture)");
17370 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17372 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17378 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17383 print_core_note (Elf_Internal_Note
*pnote
)
17385 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17386 bfd_vma count
, page_size
;
17387 unsigned char *descdata
, *filenames
, *descend
;
17389 if (pnote
->type
!= NT_FILE
)
17399 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17400 /* Still "successful". */
17405 if (pnote
->descsz
< 2 * addr_size
)
17407 error (_(" Malformed note - too short for header\n"));
17411 descdata
= (unsigned char *) pnote
->descdata
;
17412 descend
= descdata
+ pnote
->descsz
;
17414 if (descdata
[pnote
->descsz
- 1] != '\0')
17416 error (_(" Malformed note - does not end with \\0\n"));
17420 count
= byte_get (descdata
, addr_size
);
17421 descdata
+= addr_size
;
17423 page_size
= byte_get (descdata
, addr_size
);
17424 descdata
+= addr_size
;
17426 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17427 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17429 error (_(" Malformed note - too short for supplied file count\n"));
17433 printf (_(" Page size: "));
17434 print_vma (page_size
, DEC
);
17437 printf (_(" %*s%*s%*s\n"),
17438 (int) (2 + 2 * addr_size
), _("Start"),
17439 (int) (4 + 2 * addr_size
), _("End"),
17440 (int) (4 + 2 * addr_size
), _("Page Offset"));
17441 filenames
= descdata
+ count
* 3 * addr_size
;
17442 while (count
-- > 0)
17444 bfd_vma start
, end
, file_ofs
;
17446 if (filenames
== descend
)
17448 error (_(" Malformed note - filenames end too early\n"));
17452 start
= byte_get (descdata
, addr_size
);
17453 descdata
+= addr_size
;
17454 end
= byte_get (descdata
, addr_size
);
17455 descdata
+= addr_size
;
17456 file_ofs
= byte_get (descdata
, addr_size
);
17457 descdata
+= addr_size
;
17460 print_vma (start
, FULL_HEX
);
17462 print_vma (end
, FULL_HEX
);
17464 print_vma (file_ofs
, FULL_HEX
);
17465 printf ("\n %s\n", filenames
);
17467 filenames
+= 1 + strlen ((char *) filenames
);
17473 static const char *
17474 get_gnu_elf_note_type (unsigned e_type
)
17476 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17479 case NT_GNU_ABI_TAG
:
17480 return _("NT_GNU_ABI_TAG (ABI version tag)");
17482 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17483 case NT_GNU_BUILD_ID
:
17484 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17485 case NT_GNU_GOLD_VERSION
:
17486 return _("NT_GNU_GOLD_VERSION (gold version)");
17487 case NT_GNU_PROPERTY_TYPE_0
:
17488 return _("NT_GNU_PROPERTY_TYPE_0");
17489 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17490 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17491 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17492 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17495 static char buff
[64];
17497 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17504 decode_x86_compat_isa (unsigned int bitmask
)
17508 unsigned int bit
= bitmask
& (- bitmask
);
17513 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17516 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17519 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17522 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17525 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17528 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17531 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17534 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17537 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17540 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17543 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17546 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17547 printf ("AVX512F");
17549 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17550 printf ("AVX512CD");
17552 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17553 printf ("AVX512ER");
17555 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17556 printf ("AVX512PF");
17558 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17559 printf ("AVX512VL");
17561 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17562 printf ("AVX512DQ");
17564 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17565 printf ("AVX512BW");
17568 printf (_("<unknown: %x>"), bit
);
17577 decode_x86_isa (unsigned int bitmask
)
17581 printf (_("<None>"));
17587 unsigned int bit
= bitmask
& (- bitmask
);
17592 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17595 case GNU_PROPERTY_X86_ISA_1_SSE
:
17598 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17601 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17604 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17607 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17610 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17613 case GNU_PROPERTY_X86_ISA_1_AVX
:
17616 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17619 case GNU_PROPERTY_X86_ISA_1_FMA
:
17622 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17623 printf ("AVX512F");
17625 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17626 printf ("AVX512CD");
17628 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17629 printf ("AVX512ER");
17631 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17632 printf ("AVX512PF");
17634 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17635 printf ("AVX512VL");
17637 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17638 printf ("AVX512DQ");
17640 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17641 printf ("AVX512BW");
17643 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17644 printf ("AVX512_4FMAPS");
17646 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17647 printf ("AVX512_4VNNIW");
17649 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17650 printf ("AVX512_BITALG");
17652 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17653 printf ("AVX512_IFMA");
17655 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17656 printf ("AVX512_VBMI");
17658 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17659 printf ("AVX512_VBMI2");
17661 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17662 printf ("AVX512_VNNI");
17664 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17665 printf ("AVX512_BF16");
17668 printf (_("<unknown: %x>"), bit
);
17677 decode_x86_feature_1 (unsigned int bitmask
)
17681 printf (_("<None>"));
17687 unsigned int bit
= bitmask
& (- bitmask
);
17692 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17695 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17699 printf (_("<unknown: %x>"), bit
);
17708 decode_x86_feature_2 (unsigned int bitmask
)
17712 printf (_("<None>"));
17718 unsigned int bit
= bitmask
& (- bitmask
);
17723 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17726 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17729 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17732 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17735 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17738 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17741 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17744 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17747 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17748 printf ("XSAVEOPT");
17750 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17754 printf (_("<unknown: %x>"), bit
);
17763 decode_aarch64_feature_1_and (unsigned int bitmask
)
17767 unsigned int bit
= bitmask
& (- bitmask
);
17772 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17776 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17781 printf (_("<unknown: %x>"), bit
);
17790 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17792 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17793 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17794 unsigned int size
= is_32bit_elf
? 4 : 8;
17796 printf (_(" Properties: "));
17798 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17800 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17804 while (ptr
< ptr_end
)
17808 unsigned int datasz
;
17810 if ((size_t) (ptr_end
- ptr
) < 8)
17812 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17816 type
= byte_get (ptr
, 4);
17817 datasz
= byte_get (ptr
+ 4, 4);
17821 if (datasz
> (size_t) (ptr_end
- ptr
))
17823 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17828 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17830 if (filedata
->file_header
.e_machine
== EM_X86_64
17831 || filedata
->file_header
.e_machine
== EM_IAMCU
17832 || filedata
->file_header
.e_machine
== EM_386
)
17834 unsigned int bitmask
;
17837 bitmask
= byte_get (ptr
, 4);
17843 case GNU_PROPERTY_X86_ISA_1_USED
:
17845 printf (_("x86 ISA used: <corrupt length: %#x> "),
17849 printf ("x86 ISA used: ");
17850 decode_x86_isa (bitmask
);
17854 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17856 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17860 printf ("x86 ISA needed: ");
17861 decode_x86_isa (bitmask
);
17865 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17867 printf (_("x86 feature: <corrupt length: %#x> "),
17871 printf ("x86 feature: ");
17872 decode_x86_feature_1 (bitmask
);
17876 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17878 printf (_("x86 feature used: <corrupt length: %#x> "),
17882 printf ("x86 feature used: ");
17883 decode_x86_feature_2 (bitmask
);
17887 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17889 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17892 printf ("x86 feature needed: ");
17893 decode_x86_feature_2 (bitmask
);
17897 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17899 printf (_("x86 ISA used: <corrupt length: %#x> "),
17903 printf ("x86 ISA used: ");
17904 decode_x86_compat_isa (bitmask
);
17908 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17910 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17914 printf ("x86 ISA needed: ");
17915 decode_x86_compat_isa (bitmask
);
17923 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
17925 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
17927 printf ("AArch64 feature: ");
17929 printf (_("<corrupt length: %#x> "), datasz
);
17931 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
17940 case GNU_PROPERTY_STACK_SIZE
:
17941 printf (_("stack size: "));
17942 if (datasz
!= size
)
17943 printf (_("<corrupt length: %#x> "), datasz
);
17945 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17948 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17949 printf ("no copy on protected ");
17951 printf (_("<corrupt length: %#x> "), datasz
);
17959 if (type
< GNU_PROPERTY_LOPROC
)
17960 printf (_("<unknown type %#x data: "), type
);
17961 else if (type
< GNU_PROPERTY_LOUSER
)
17962 printf (_("<procesor-specific type %#x data: "), type
);
17964 printf (_("<application-specific type %#x data: "), type
);
17965 for (j
= 0; j
< datasz
; ++j
)
17966 printf ("%02x ", ptr
[j
] & 0xff);
17970 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17971 if (ptr
== ptr_end
)
17984 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17986 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17987 switch (pnote
->type
)
17989 case NT_GNU_BUILD_ID
:
17993 printf (_(" Build ID: "));
17994 for (i
= 0; i
< pnote
->descsz
; ++i
)
17995 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18000 case NT_GNU_ABI_TAG
:
18002 unsigned long os
, major
, minor
, subminor
;
18003 const char *osname
;
18005 /* PR 17531: file: 030-599401-0.004. */
18006 if (pnote
->descsz
< 16)
18008 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18012 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18013 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18014 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18015 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18019 case GNU_ABI_TAG_LINUX
:
18022 case GNU_ABI_TAG_HURD
:
18025 case GNU_ABI_TAG_SOLARIS
:
18026 osname
= "Solaris";
18028 case GNU_ABI_TAG_FREEBSD
:
18029 osname
= "FreeBSD";
18031 case GNU_ABI_TAG_NETBSD
:
18034 case GNU_ABI_TAG_SYLLABLE
:
18035 osname
= "Syllable";
18037 case GNU_ABI_TAG_NACL
:
18041 osname
= "Unknown";
18045 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18046 major
, minor
, subminor
);
18050 case NT_GNU_GOLD_VERSION
:
18054 printf (_(" Version: "));
18055 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18056 printf ("%c", pnote
->descdata
[i
]);
18063 unsigned long num_entries
, mask
;
18065 /* Hardware capabilities information. Word 0 is the number of entries.
18066 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18067 is a series of entries, where each entry is a single byte followed
18068 by a nul terminated string. The byte gives the bit number to test
18069 if enabled in the bitmask. */
18070 printf (_(" Hardware Capabilities: "));
18071 if (pnote
->descsz
< 8)
18073 error (_("<corrupt GNU_HWCAP>\n"));
18076 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18077 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18078 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18079 /* FIXME: Add code to display the entries... */
18083 case NT_GNU_PROPERTY_TYPE_0
:
18084 print_gnu_property_note (filedata
, pnote
);
18088 /* Handle unrecognised types. An error message should have already been
18089 created by get_gnu_elf_note_type(), so all that we need to do is to
18090 display the data. */
18094 printf (_(" Description data: "));
18095 for (i
= 0; i
< pnote
->descsz
; ++i
)
18096 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18105 static const char *
18106 get_v850_elf_note_type (enum v850_notes n_type
)
18108 static char buff
[64];
18112 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18113 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18114 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18115 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18116 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18117 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18119 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18125 print_v850_note (Elf_Internal_Note
* pnote
)
18129 if (pnote
->descsz
!= 4)
18132 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18136 printf (_("not set\n"));
18140 switch (pnote
->type
)
18142 case V850_NOTE_ALIGNMENT
:
18145 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18146 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18150 case V850_NOTE_DATA_SIZE
:
18153 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18154 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18158 case V850_NOTE_FPU_INFO
:
18161 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18162 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18166 case V850_NOTE_MMU_INFO
:
18167 case V850_NOTE_CACHE_INFO
:
18168 case V850_NOTE_SIMD_INFO
:
18169 if (val
== EF_RH850_SIMD
)
18171 printf (_("yes\n"));
18177 /* An 'unknown note type' message will already have been displayed. */
18181 printf (_("unknown value: %x\n"), val
);
18186 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18188 unsigned int version
;
18190 switch (pnote
->type
)
18192 case NT_NETBSD_IDENT
:
18193 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18194 if ((version
/ 10000) % 100)
18195 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18196 version
, version
/ 100000000, (version
/ 1000000) % 100,
18197 (version
/ 10000) % 100 > 26 ? "Z" : "",
18198 'A' + (version
/ 10000) % 26);
18200 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18201 version
, version
/ 100000000, (version
/ 1000000) % 100,
18202 (version
/ 100) % 100);
18205 case NT_NETBSD_MARCH
:
18206 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18210 #ifdef NT_NETBSD_PAX
18211 case NT_NETBSD_PAX
:
18212 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18213 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18214 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18215 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18216 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18217 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18218 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18219 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18224 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18230 static const char *
18231 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18235 case NT_FREEBSD_THRMISC
:
18236 return _("NT_THRMISC (thrmisc structure)");
18237 case NT_FREEBSD_PROCSTAT_PROC
:
18238 return _("NT_PROCSTAT_PROC (proc data)");
18239 case NT_FREEBSD_PROCSTAT_FILES
:
18240 return _("NT_PROCSTAT_FILES (files data)");
18241 case NT_FREEBSD_PROCSTAT_VMMAP
:
18242 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18243 case NT_FREEBSD_PROCSTAT_GROUPS
:
18244 return _("NT_PROCSTAT_GROUPS (groups data)");
18245 case NT_FREEBSD_PROCSTAT_UMASK
:
18246 return _("NT_PROCSTAT_UMASK (umask data)");
18247 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18248 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18249 case NT_FREEBSD_PROCSTAT_OSREL
:
18250 return _("NT_PROCSTAT_OSREL (osreldate data)");
18251 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18252 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18253 case NT_FREEBSD_PROCSTAT_AUXV
:
18254 return _("NT_PROCSTAT_AUXV (auxv data)");
18255 case NT_FREEBSD_PTLWPINFO
:
18256 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18258 return get_note_type (filedata
, e_type
);
18261 static const char *
18262 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18264 static char buff
[64];
18268 case NT_NETBSDCORE_PROCINFO
:
18269 /* NetBSD core "procinfo" structure. */
18270 return _("NetBSD procinfo structure");
18272 #ifdef NT_NETBSDCORE_AUXV
18273 case NT_NETBSDCORE_AUXV
:
18274 return _("NetBSD ELF auxiliary vector data");
18278 /* As of Jan 2002 there are no other machine-independent notes
18279 defined for NetBSD core files. If the note type is less
18280 than the start of the machine-dependent note types, we don't
18283 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18285 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18291 switch (filedata
->file_header
.e_machine
)
18293 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18294 and PT_GETFPREGS == mach+2. */
18299 case EM_SPARC32PLUS
:
18303 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18304 return _("PT_GETREGS (reg structure)");
18305 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18306 return _("PT_GETFPREGS (fpreg structure)");
18312 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18313 There's also old PT___GETREGS40 == mach + 1 for old reg
18314 structure which lacks GBR. */
18318 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18319 return _("PT___GETREGS40 (old reg structure)");
18320 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18321 return _("PT_GETREGS (reg structure)");
18322 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18323 return _("PT_GETFPREGS (fpreg structure)");
18329 /* On all other arch's, PT_GETREGS == mach+1 and
18330 PT_GETFPREGS == mach+3. */
18334 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18335 return _("PT_GETREGS (reg structure)");
18336 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18337 return _("PT_GETFPREGS (fpreg structure)");
18343 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18344 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18348 static const char *
18349 get_stapsdt_note_type (unsigned e_type
)
18351 static char buff
[64];
18356 return _("NT_STAPSDT (SystemTap probe descriptors)");
18362 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18367 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18369 size_t len
, maxlen
;
18370 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18371 char *data
= pnote
->descdata
;
18372 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18373 bfd_vma pc
, base_addr
, semaphore
;
18374 char *provider
, *probe
, *arg_fmt
;
18376 if (pnote
->descsz
< (addr_size
* 3))
18377 goto stapdt_note_too_small
;
18379 pc
= byte_get ((unsigned char *) data
, addr_size
);
18382 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18385 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18388 if (data
>= data_end
)
18389 goto stapdt_note_too_small
;
18390 maxlen
= data_end
- data
;
18391 len
= strnlen (data
, maxlen
);
18398 goto stapdt_note_too_small
;
18400 if (data
>= data_end
)
18401 goto stapdt_note_too_small
;
18402 maxlen
= data_end
- data
;
18403 len
= strnlen (data
, maxlen
);
18410 goto stapdt_note_too_small
;
18412 if (data
>= data_end
)
18413 goto stapdt_note_too_small
;
18414 maxlen
= data_end
- data
;
18415 len
= strnlen (data
, maxlen
);
18422 goto stapdt_note_too_small
;
18424 printf (_(" Provider: %s\n"), provider
);
18425 printf (_(" Name: %s\n"), probe
);
18426 printf (_(" Location: "));
18427 print_vma (pc
, FULL_HEX
);
18428 printf (_(", Base: "));
18429 print_vma (base_addr
, FULL_HEX
);
18430 printf (_(", Semaphore: "));
18431 print_vma (semaphore
, FULL_HEX
);
18433 printf (_(" Arguments: %s\n"), arg_fmt
);
18435 return data
== data_end
;
18437 stapdt_note_too_small
:
18438 printf (_(" <corrupt - note is too small>\n"));
18439 error (_("corrupt stapdt note - the data size is too small\n"));
18443 static const char *
18444 get_ia64_vms_note_type (unsigned e_type
)
18446 static char buff
[64];
18451 return _("NT_VMS_MHD (module header)");
18453 return _("NT_VMS_LNM (language name)");
18455 return _("NT_VMS_SRC (source files)");
18457 return "NT_VMS_TITLE";
18459 return _("NT_VMS_EIDC (consistency check)");
18460 case NT_VMS_FPMODE
:
18461 return _("NT_VMS_FPMODE (FP mode)");
18462 case NT_VMS_LINKTIME
:
18463 return "NT_VMS_LINKTIME";
18464 case NT_VMS_IMGNAM
:
18465 return _("NT_VMS_IMGNAM (image name)");
18467 return _("NT_VMS_IMGID (image id)");
18468 case NT_VMS_LINKID
:
18469 return _("NT_VMS_LINKID (link id)");
18470 case NT_VMS_IMGBID
:
18471 return _("NT_VMS_IMGBID (build id)");
18472 case NT_VMS_GSTNAM
:
18473 return _("NT_VMS_GSTNAM (sym table name)");
18474 case NT_VMS_ORIG_DYN
:
18475 return "NT_VMS_ORIG_DYN";
18476 case NT_VMS_PATCHTIME
:
18477 return "NT_VMS_PATCHTIME";
18479 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18485 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18487 int maxlen
= pnote
->descsz
;
18489 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18490 goto desc_size_fail
;
18492 switch (pnote
->type
)
18496 goto desc_size_fail
;
18498 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18500 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18501 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18502 if (l
+ 34 < maxlen
)
18504 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18505 if (l
+ 35 < maxlen
)
18506 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18508 printf (_(" Module version : <missing>\n"));
18512 printf (_(" Module name : <missing>\n"));
18513 printf (_(" Module version : <missing>\n"));
18518 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18522 case NT_VMS_FPMODE
:
18523 printf (_(" Floating Point mode: "));
18525 goto desc_size_fail
;
18526 /* FIXME: Generate an error if descsz > 8 ? */
18528 printf ("0x%016" BFD_VMA_FMT
"x\n",
18529 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18532 case NT_VMS_LINKTIME
:
18533 printf (_(" Link time: "));
18535 goto desc_size_fail
;
18536 /* FIXME: Generate an error if descsz > 8 ? */
18539 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18543 case NT_VMS_PATCHTIME
:
18544 printf (_(" Patch time: "));
18546 goto desc_size_fail
;
18547 /* FIXME: Generate an error if descsz > 8 ? */
18550 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18554 case NT_VMS_ORIG_DYN
:
18556 goto desc_size_fail
;
18558 printf (_(" Major id: %u, minor id: %u\n"),
18559 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18560 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18561 printf (_(" Last modified : "));
18563 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18564 printf (_("\n Link flags : "));
18565 printf ("0x%016" BFD_VMA_FMT
"x\n",
18566 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18567 printf (_(" Header flags: 0x%08x\n"),
18568 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18569 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18573 case NT_VMS_IMGNAM
:
18574 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18577 case NT_VMS_GSTNAM
:
18578 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18582 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18585 case NT_VMS_LINKID
:
18586 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18596 printf (_(" <corrupt - data size is too small>\n"));
18597 error (_("corrupt IA64 note: data size is too small\n"));
18601 /* Find the symbol associated with a build attribute that is attached
18602 to address OFFSET. If PNAME is non-NULL then store the name of
18603 the symbol (if found) in the provided pointer, Returns NULL if a
18604 symbol could not be found. */
18606 static Elf_Internal_Sym
*
18607 get_symbol_for_build_attribute (Filedata
* filedata
,
18608 unsigned long offset
,
18609 bfd_boolean is_open_attr
,
18610 const char ** pname
)
18612 static Filedata
* saved_filedata
= NULL
;
18613 static char * strtab
;
18614 static unsigned long strtablen
;
18615 static Elf_Internal_Sym
* symtab
;
18616 static unsigned long nsyms
;
18617 Elf_Internal_Sym
* saved_sym
= NULL
;
18618 Elf_Internal_Sym
* sym
;
18620 if (filedata
->section_headers
!= NULL
18621 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18623 Elf_Internal_Shdr
* symsec
;
18625 /* Load the symbol and string sections. */
18626 for (symsec
= filedata
->section_headers
;
18627 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18630 if (symsec
->sh_type
== SHT_SYMTAB
)
18632 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18634 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18636 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18638 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18639 1, strtab_sec
->sh_size
,
18640 _("string table"));
18641 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18645 saved_filedata
= filedata
;
18648 if (symtab
== NULL
|| strtab
== NULL
)
18651 /* Find a symbol whose value matches offset. */
18652 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18653 if (sym
->st_value
== offset
)
18655 if (sym
->st_name
>= strtablen
)
18656 /* Huh ? This should not happen. */
18659 if (strtab
[sym
->st_name
] == 0)
18662 /* The AArch64 and ARM architectures define mapping symbols
18663 (eg $d, $x, $t) which we want to ignore. */
18664 if (strtab
[sym
->st_name
] == '$'
18665 && strtab
[sym
->st_name
+ 1] != 0
18666 && strtab
[sym
->st_name
+ 2] == 0)
18671 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18672 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18673 FUNC symbols entirely. */
18674 switch (ELF_ST_TYPE (sym
->st_info
))
18681 /* If the symbol has a size associated
18682 with it then we can stop searching. */
18683 sym
= symtab
+ nsyms
;
18688 /* Ignore function symbols. */
18695 switch (ELF_ST_BIND (sym
->st_info
))
18698 if (saved_sym
== NULL
18699 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18704 if (saved_sym
== NULL
)
18714 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18722 if (saved_sym
&& pname
)
18723 * pname
= strtab
+ saved_sym
->st_name
;
18728 /* Returns true iff addr1 and addr2 are in the same section. */
18731 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18733 Elf_Internal_Shdr
* a1
;
18734 Elf_Internal_Shdr
* a2
;
18736 a1
= find_section_by_address (filedata
, addr1
);
18737 a2
= find_section_by_address (filedata
, addr2
);
18739 return a1
== a2
&& a1
!= NULL
;
18743 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18744 Filedata
* filedata
)
18746 static unsigned long global_offset
= 0;
18747 static unsigned long global_end
= 0;
18748 static unsigned long func_offset
= 0;
18749 static unsigned long func_end
= 0;
18751 Elf_Internal_Sym
* sym
;
18753 unsigned long start
;
18755 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18757 switch (pnote
->descsz
)
18760 /* A zero-length description means that the range of
18761 the previous note of the same type should be used. */
18764 if (global_end
> global_offset
)
18765 printf (_(" Applies to region from %#lx to %#lx\n"),
18766 global_offset
, global_end
);
18768 printf (_(" Applies to region from %#lx\n"), global_offset
);
18772 if (func_end
> func_offset
)
18773 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18775 printf (_(" Applies to region from %#lx\n"), func_offset
);
18780 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18787 /* FIXME: We should check that version 3+ notes are being used here... */
18788 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18789 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18793 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18799 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18800 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18804 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18805 printf (_(" <invalid descsz>"));
18810 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18811 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18812 in order to avoid them being confused with the start address of the
18813 first function in the file... */
18814 if (sym
== NULL
&& is_open_attr
)
18815 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18818 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18819 end
= start
+ sym
->st_size
;
18823 /* FIXME: Need to properly allow for section alignment.
18824 16 is just the alignment used on x86_64. */
18826 && start
> BFD_ALIGN (global_end
, 16)
18827 /* Build notes are not guaranteed to be organised in order of
18828 increasing address, but we should find the all of the notes
18829 for one section in the same place. */
18830 && same_section (filedata
, start
, global_end
))
18831 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18832 global_end
+ 1, start
- 1);
18834 printf (_(" Applies to region from %#lx"), start
);
18835 global_offset
= start
;
18839 printf (_(" to %#lx"), end
);
18845 printf (_(" Applies to region from %#lx"), start
);
18846 func_offset
= start
;
18850 printf (_(" to %#lx"), end
);
18856 printf (_(" (%s)"), name
);
18863 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18865 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18866 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18867 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18869 char name_attribute
;
18870 const char * expected_types
;
18871 const char * name
= pnote
->namedata
;
18875 if (name
== NULL
|| pnote
->namesz
< 2)
18877 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18878 print_symbol (-20, _(" <corrupt name>"));
18887 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18888 if (name
[0] == 'G' && name
[1] == 'A')
18890 if (pnote
->namesz
< 4)
18892 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18893 print_symbol (-20, _(" <corrupt name>"));
18902 switch ((name_type
= * name
))
18904 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18905 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18906 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18907 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18908 printf ("%c", * name
);
18912 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18913 print_symbol (-20, _("<unknown name type>"));
18920 switch ((name_attribute
= * name
))
18922 case GNU_BUILD_ATTRIBUTE_VERSION
:
18923 text
= _("<version>");
18924 expected_types
= string_expected
;
18927 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18928 text
= _("<stack prot>");
18929 expected_types
= "!+*";
18932 case GNU_BUILD_ATTRIBUTE_RELRO
:
18933 text
= _("<relro>");
18934 expected_types
= bool_expected
;
18937 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18938 text
= _("<stack size>");
18939 expected_types
= number_expected
;
18942 case GNU_BUILD_ATTRIBUTE_TOOL
:
18943 text
= _("<tool>");
18944 expected_types
= string_expected
;
18947 case GNU_BUILD_ATTRIBUTE_ABI
:
18949 expected_types
= "$*";
18952 case GNU_BUILD_ATTRIBUTE_PIC
:
18954 expected_types
= number_expected
;
18957 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18958 text
= _("<short enum>");
18959 expected_types
= bool_expected
;
18963 if (ISPRINT (* name
))
18965 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18967 if (len
> left
&& ! do_wide
)
18969 printf ("%.*s:", len
, name
);
18975 static char tmpbuf
[128];
18977 error (_("unrecognised byte in name field: %d\n"), * name
);
18978 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18982 expected_types
= "*$!+";
18987 left
-= printf ("%s", text
);
18989 if (strchr (expected_types
, name_type
) == NULL
)
18990 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18992 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18994 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18995 (unsigned long) pnote
->namesz
,
18996 (long) (name
- pnote
->namedata
));
19000 if (left
< 1 && ! do_wide
)
19005 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19007 unsigned int bytes
;
19008 unsigned long long val
= 0;
19009 unsigned int shift
= 0;
19010 char * decoded
= NULL
;
19012 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19014 /* The -1 is because the name field is always 0 terminated, and we
19015 want to be able to ensure that the shift in the while loop below
19016 will not overflow. */
19019 if (bytes
> sizeof (val
))
19021 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19023 bytes
= sizeof (val
);
19025 /* We do not bother to warn if bytes == 0 as this can
19026 happen with some early versions of the gcc plugin. */
19030 unsigned long byte
= (* name
++) & 0xff;
19032 val
|= byte
<< shift
;
19036 switch (name_attribute
)
19038 case GNU_BUILD_ATTRIBUTE_PIC
:
19041 case 0: decoded
= "static"; break;
19042 case 1: decoded
= "pic"; break;
19043 case 2: decoded
= "PIC"; break;
19044 case 3: decoded
= "pie"; break;
19045 case 4: decoded
= "PIE"; break;
19049 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19052 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19053 case 0: decoded
= "off"; break;
19054 case 1: decoded
= "on"; break;
19055 case 2: decoded
= "all"; break;
19056 case 3: decoded
= "strong"; break;
19057 case 4: decoded
= "explicit"; break;
19065 if (decoded
!= NULL
)
19067 print_symbol (-left
, decoded
);
19078 left
-= printf ("0x%llx", val
);
19080 left
-= printf ("0x%-.*llx", left
, val
);
19084 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19085 left
-= print_symbol (- left
, name
);
19087 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19088 left
-= print_symbol (- left
, "true");
19090 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19091 left
-= print_symbol (- left
, "false");
19095 if (do_wide
&& left
> 0)
19096 printf ("%-*s", left
, " ");
19101 /* Note that by the ELF standard, the name field is already null byte
19102 terminated, and namesz includes the terminating null byte.
19103 I.E. the value of namesz for the name "FSF" is 4.
19105 If the value of namesz is zero, there is no name present. */
19108 process_note (Elf_Internal_Note
* pnote
,
19109 Filedata
* filedata
)
19111 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19114 if (pnote
->namesz
== 0)
19115 /* If there is no note name, then use the default set of
19116 note type strings. */
19117 nt
= get_note_type (filedata
, pnote
->type
);
19119 else if (const_strneq (pnote
->namedata
, "GNU"))
19120 /* GNU-specific object file notes. */
19121 nt
= get_gnu_elf_note_type (pnote
->type
);
19123 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19124 /* FreeBSD-specific core file notes. */
19125 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19127 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19128 /* NetBSD-specific core file notes. */
19129 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19131 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19132 /* NetBSD-specific core file notes. */
19133 return process_netbsd_elf_note (pnote
);
19135 else if (const_strneq (pnote
->namedata
, "PaX"))
19136 /* NetBSD-specific core file notes. */
19137 return process_netbsd_elf_note (pnote
);
19139 else if (strneq (pnote
->namedata
, "SPU/", 4))
19141 /* SPU-specific core file notes. */
19142 nt
= pnote
->namedata
+ 4;
19146 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19147 /* VMS/ia64-specific file notes. */
19148 nt
= get_ia64_vms_note_type (pnote
->type
);
19150 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19151 nt
= get_stapsdt_note_type (pnote
->type
);
19154 /* Don't recognize this note name; just use the default set of
19155 note type strings. */
19156 nt
= get_note_type (filedata
, pnote
->type
);
19160 if (((const_strneq (pnote
->namedata
, "GA")
19161 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19162 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19163 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19164 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19165 print_gnu_build_attribute_name (pnote
);
19167 print_symbol (-20, name
);
19170 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19172 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19174 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19175 return print_ia64_vms_note (pnote
);
19176 else if (const_strneq (pnote
->namedata
, "GNU"))
19177 return print_gnu_note (filedata
, pnote
);
19178 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19179 return print_stapsdt_note (pnote
);
19180 else if (const_strneq (pnote
->namedata
, "CORE"))
19181 return print_core_note (pnote
);
19182 else if (((const_strneq (pnote
->namedata
, "GA")
19183 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19184 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19185 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19186 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19187 return print_gnu_build_attribute_description (pnote
, filedata
);
19193 printf (_(" description data: "));
19194 for (i
= 0; i
< pnote
->descsz
; i
++)
19195 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19207 process_notes_at (Filedata
* filedata
,
19208 Elf_Internal_Shdr
* section
,
19213 Elf_External_Note
* pnotes
;
19214 Elf_External_Note
* external
;
19216 bfd_boolean res
= TRUE
;
19223 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19226 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19231 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19234 if (pnotes
== NULL
)
19240 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19242 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19243 (unsigned long) offset
, (unsigned long) length
);
19245 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19246 specifies that notes should be aligned to 4 bytes in 32-bit
19247 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19248 we also support 4 byte alignment in 64-bit objects. If section
19249 alignment is less than 4, we treate alignment as 4 bytes. */
19252 else if (align
!= 4 && align
!= 8)
19254 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19259 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19261 end
= (char *) pnotes
+ length
;
19262 while ((char *) external
< end
)
19264 Elf_Internal_Note inote
;
19267 char * temp
= NULL
;
19268 size_t data_remaining
= end
- (char *) external
;
19270 if (!is_ia64_vms (filedata
))
19272 /* PR binutils/15191
19273 Make sure that there is enough data to read. */
19274 min_notesz
= offsetof (Elf_External_Note
, name
);
19275 if (data_remaining
< min_notesz
)
19277 warn (ngettext ("Corrupt note: only %ld byte remains, "
19278 "not enough for a full note\n",
19279 "Corrupt note: only %ld bytes remain, "
19280 "not enough for a full note\n",
19282 (long) data_remaining
);
19285 data_remaining
-= min_notesz
;
19287 inote
.type
= BYTE_GET (external
->type
);
19288 inote
.namesz
= BYTE_GET (external
->namesz
);
19289 inote
.namedata
= external
->name
;
19290 inote
.descsz
= BYTE_GET (external
->descsz
);
19291 inote
.descdata
= ((char *) external
19292 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19293 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19294 next
= ((char *) external
19295 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19299 Elf64_External_VMS_Note
*vms_external
;
19301 /* PR binutils/15191
19302 Make sure that there is enough data to read. */
19303 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19304 if (data_remaining
< min_notesz
)
19306 warn (ngettext ("Corrupt note: only %ld byte remains, "
19307 "not enough for a full note\n",
19308 "Corrupt note: only %ld bytes remain, "
19309 "not enough for a full note\n",
19311 (long) data_remaining
);
19314 data_remaining
-= min_notesz
;
19316 vms_external
= (Elf64_External_VMS_Note
*) external
;
19317 inote
.type
= BYTE_GET (vms_external
->type
);
19318 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19319 inote
.namedata
= vms_external
->name
;
19320 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19321 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19322 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19323 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19326 /* PR 17531: file: 3443835e. */
19327 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19328 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19329 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19330 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19331 || ((size_t) (next
- inote
.descdata
)
19332 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19334 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19335 (unsigned long) ((char *) external
- (char *) pnotes
));
19336 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19337 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19341 external
= (Elf_External_Note
*) next
;
19343 /* Verify that name is null terminated. It appears that at least
19344 one version of Linux (RedHat 6.0) generates corefiles that don't
19345 comply with the ELF spec by failing to include the null byte in
19347 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19349 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19351 temp
= (char *) malloc (inote
.namesz
+ 1);
19354 error (_("Out of memory allocating space for inote name\n"));
19359 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19360 inote
.namedata
= temp
;
19362 inote
.namedata
[inote
.namesz
] = 0;
19365 if (! process_note (& inote
, filedata
))
19381 process_corefile_note_segments (Filedata
* filedata
)
19383 Elf_Internal_Phdr
* segment
;
19385 bfd_boolean res
= TRUE
;
19387 if (! get_program_headers (filedata
))
19390 for (i
= 0, segment
= filedata
->program_headers
;
19391 i
< filedata
->file_header
.e_phnum
;
19394 if (segment
->p_type
== PT_NOTE
)
19395 if (! process_notes_at (filedata
, NULL
,
19396 (bfd_vma
) segment
->p_offset
,
19397 (bfd_vma
) segment
->p_filesz
,
19398 (bfd_vma
) segment
->p_align
))
19406 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19408 Elf_External_Note
* pnotes
;
19409 Elf_External_Note
* external
;
19411 bfd_boolean res
= TRUE
;
19416 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19418 if (pnotes
== NULL
)
19422 end
= (char*) pnotes
+ length
;
19424 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19425 (unsigned long) offset
, (unsigned long) length
);
19427 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19429 Elf_External_Note
* next
;
19430 Elf_Internal_Note inote
;
19432 inote
.type
= BYTE_GET (external
->type
);
19433 inote
.namesz
= BYTE_GET (external
->namesz
);
19434 inote
.namedata
= external
->name
;
19435 inote
.descsz
= BYTE_GET (external
->descsz
);
19436 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19437 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19439 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19441 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19442 inote
.descdata
= inote
.namedata
;
19446 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19448 if ( ((char *) next
> end
)
19449 || ((char *) next
< (char *) pnotes
))
19451 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19452 (unsigned long) ((char *) external
- (char *) pnotes
));
19453 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19454 inote
.type
, inote
.namesz
, inote
.descsz
);
19460 /* Prevent out-of-bounds indexing. */
19461 if ( inote
.namedata
+ inote
.namesz
> end
19462 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19464 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19465 (unsigned long) ((char *) external
- (char *) pnotes
));
19466 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19467 inote
.type
, inote
.namesz
, inote
.descsz
);
19471 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19473 if (! print_v850_note (& inote
))
19476 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19477 inote
.namesz
, inote
.descsz
);
19487 process_note_sections (Filedata
* filedata
)
19489 Elf_Internal_Shdr
* section
;
19491 unsigned int n
= 0;
19492 bfd_boolean res
= TRUE
;
19494 for (i
= 0, section
= filedata
->section_headers
;
19495 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19498 if (section
->sh_type
== SHT_NOTE
)
19500 if (! process_notes_at (filedata
, section
,
19501 (bfd_vma
) section
->sh_offset
,
19502 (bfd_vma
) section
->sh_size
,
19503 (bfd_vma
) section
->sh_addralign
))
19508 if (( filedata
->file_header
.e_machine
== EM_V800
19509 || filedata
->file_header
.e_machine
== EM_V850
19510 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19511 && section
->sh_type
== SHT_RENESAS_INFO
)
19513 if (! process_v850_notes (filedata
,
19514 (bfd_vma
) section
->sh_offset
,
19515 (bfd_vma
) section
->sh_size
))
19522 /* Try processing NOTE segments instead. */
19523 return process_corefile_note_segments (filedata
);
19529 process_notes (Filedata
* filedata
)
19531 /* If we have not been asked to display the notes then do nothing. */
19535 if (filedata
->file_header
.e_type
!= ET_CORE
)
19536 return process_note_sections (filedata
);
19538 /* No program headers means no NOTE segment. */
19539 if (filedata
->file_header
.e_phnum
> 0)
19540 return process_corefile_note_segments (filedata
);
19542 printf (_("No note segments present in the core file.\n"));
19546 static unsigned char *
19547 display_public_gnu_attributes (unsigned char * start
,
19548 const unsigned char * const end
)
19550 printf (_(" Unknown GNU attribute: %s\n"), start
);
19552 start
+= strnlen ((char *) start
, end
- start
);
19553 display_raw_attribute (start
, end
);
19555 return (unsigned char *) end
;
19558 static unsigned char *
19559 display_generic_attribute (unsigned char * start
,
19561 const unsigned char * const end
)
19564 return (unsigned char *) end
;
19566 return display_tag_value (tag
, start
, end
);
19570 process_arch_specific (Filedata
* filedata
)
19575 switch (filedata
->file_header
.e_machine
)
19578 case EM_ARC_COMPACT
:
19579 case EM_ARC_COMPACT2
:
19580 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19581 display_arc_attribute
,
19582 display_generic_attribute
);
19584 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19585 display_arm_attribute
,
19586 display_generic_attribute
);
19589 case EM_MIPS_RS3_LE
:
19590 return process_mips_specific (filedata
);
19593 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19594 display_msp430x_attribute
,
19595 display_msp430_gnu_attribute
);
19598 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19599 display_riscv_attribute
,
19600 display_generic_attribute
);
19603 return process_nds32_specific (filedata
);
19607 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19608 display_power_gnu_attribute
);
19612 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19613 display_s390_gnu_attribute
);
19616 case EM_SPARC32PLUS
:
19618 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19619 display_sparc_gnu_attribute
);
19622 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19623 display_tic6x_attribute
,
19624 display_generic_attribute
);
19627 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19628 display_public_gnu_attributes
,
19629 display_generic_attribute
);
19634 get_file_header (Filedata
* filedata
)
19636 /* Read in the identity array. */
19637 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19640 /* Determine how to read the rest of the header. */
19641 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19646 byte_get
= byte_get_little_endian
;
19647 byte_put
= byte_put_little_endian
;
19650 byte_get
= byte_get_big_endian
;
19651 byte_put
= byte_put_big_endian
;
19655 /* For now we only support 32 bit and 64 bit ELF files. */
19656 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19658 /* Read in the rest of the header. */
19661 Elf32_External_Ehdr ehdr32
;
19663 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19666 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19667 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19668 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19669 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19670 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19671 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19672 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19673 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19674 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19675 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19676 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19677 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19678 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19682 Elf64_External_Ehdr ehdr64
;
19684 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19685 we will not be able to cope with the 64bit data found in
19686 64 ELF files. Detect this now and abort before we start
19687 overwriting things. */
19688 if (sizeof (bfd_vma
) < 8)
19690 error (_("This instance of readelf has been built without support for a\n\
19691 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19695 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19698 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19699 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19700 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19701 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19702 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19703 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19704 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19705 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19706 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19707 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19708 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19709 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19710 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19713 if (filedata
->file_header
.e_shoff
)
19715 /* There may be some extensions in the first section header. Don't
19716 bomb if we can't read it. */
19718 get_32bit_section_headers (filedata
, TRUE
);
19720 get_64bit_section_headers (filedata
, TRUE
);
19727 close_file (Filedata
* filedata
)
19731 if (filedata
->handle
)
19732 fclose (filedata
->handle
);
19738 close_debug_file (void * data
)
19740 close_file ((Filedata
*) data
);
19744 open_file (const char * pathname
)
19746 struct stat statbuf
;
19747 Filedata
* filedata
= NULL
;
19749 if (stat (pathname
, & statbuf
) < 0
19750 || ! S_ISREG (statbuf
.st_mode
))
19753 filedata
= calloc (1, sizeof * filedata
);
19754 if (filedata
== NULL
)
19757 filedata
->handle
= fopen (pathname
, "rb");
19758 if (filedata
->handle
== NULL
)
19761 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19762 filedata
->file_name
= pathname
;
19764 if (! get_file_header (filedata
))
19767 if (filedata
->file_header
.e_shoff
)
19771 /* Read the section headers again, this time for real. */
19773 res
= get_32bit_section_headers (filedata
, FALSE
);
19775 res
= get_64bit_section_headers (filedata
, FALSE
);
19786 if (filedata
->handle
)
19787 fclose (filedata
->handle
);
19794 open_debug_file (const char * pathname
)
19796 return open_file (pathname
);
19799 /* Process one ELF object file according to the command line options.
19800 This file may actually be stored in an archive. The file is
19801 positioned at the start of the ELF object. Returns TRUE if no
19802 problems were encountered, FALSE otherwise. */
19805 process_object (Filedata
* filedata
)
19807 bfd_boolean have_separate_files
;
19809 bfd_boolean res
= TRUE
;
19811 if (! get_file_header (filedata
))
19813 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19817 /* Initialise per file variables. */
19818 for (i
= ARRAY_SIZE (version_info
); i
--;)
19819 version_info
[i
] = 0;
19821 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19822 dynamic_info
[i
] = 0;
19823 dynamic_info_DT_GNU_HASH
= 0;
19824 dynamic_info_DT_MIPS_XHASH
= 0;
19826 /* Process the file. */
19828 printf (_("\nFile: %s\n"), filedata
->file_name
);
19830 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19831 Note we do this even if cmdline_dump_sects is empty because we
19832 must make sure that the dump_sets array is zeroed out before each
19833 object file is processed. */
19834 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19835 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19837 if (cmdline
.num_dump_sects
> 0)
19839 if (filedata
->num_dump_sects
== 0)
19840 /* A sneaky way of allocating the dump_sects array. */
19841 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19843 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19844 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19845 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19848 if (! process_file_header (filedata
))
19851 if (! process_section_headers (filedata
))
19853 /* Without loaded section headers we cannot process lots of things. */
19854 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19856 if (! do_using_dynamic
)
19857 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19860 if (! process_section_groups (filedata
))
19861 /* Without loaded section groups we cannot process unwind. */
19864 if (process_program_headers (filedata
))
19865 process_dynamic_section (filedata
);
19869 if (! process_relocs (filedata
))
19872 if (! process_unwind (filedata
))
19875 if (! process_symbol_table (filedata
))
19878 if (! process_syminfo (filedata
))
19881 if (! process_version_sections (filedata
))
19884 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19885 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19887 have_separate_files
= FALSE
;
19889 if (! process_section_contents (filedata
))
19892 if (have_separate_files
)
19896 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19898 if (! process_section_headers (d
->handle
))
19900 else if (! process_section_contents (d
->handle
))
19904 /* The file handles are closed by the call to free_debug_memory() below. */
19907 if (! process_notes (filedata
))
19910 if (! process_gnu_liblist (filedata
))
19913 if (! process_arch_specific (filedata
))
19916 free (filedata
->program_headers
);
19917 filedata
->program_headers
= NULL
;
19919 free (filedata
->section_headers
);
19920 filedata
->section_headers
= NULL
;
19922 free (filedata
->string_table
);
19923 filedata
->string_table
= NULL
;
19924 filedata
->string_table_length
= 0;
19926 if (dynamic_strings
)
19928 free (dynamic_strings
);
19929 dynamic_strings
= NULL
;
19930 dynamic_strings_length
= 0;
19933 if (dynamic_symbols
)
19935 free (dynamic_symbols
);
19936 dynamic_symbols
= NULL
;
19937 num_dynamic_syms
= 0;
19940 if (dynamic_syminfo
)
19942 free (dynamic_syminfo
);
19943 dynamic_syminfo
= NULL
;
19946 if (dynamic_section
)
19948 free (dynamic_section
);
19949 dynamic_section
= NULL
;
19952 if (section_headers_groups
)
19954 free (section_headers_groups
);
19955 section_headers_groups
= NULL
;
19958 if (section_groups
)
19960 struct group_list
* g
;
19961 struct group_list
* next
;
19963 for (i
= 0; i
< group_count
; i
++)
19965 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19972 free (section_groups
);
19973 section_groups
= NULL
;
19976 free_debug_memory ();
19981 /* Process an ELF archive.
19982 On entry the file is positioned just after the ARMAG string.
19983 Returns TRUE upon success, FALSE otherwise. */
19986 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19988 struct archive_info arch
;
19989 struct archive_info nested_arch
;
19991 bfd_boolean ret
= TRUE
;
19995 /* The ARCH structure is used to hold information about this archive. */
19996 arch
.file_name
= NULL
;
19998 arch
.index_array
= NULL
;
19999 arch
.sym_table
= NULL
;
20000 arch
.longnames
= NULL
;
20002 /* The NESTED_ARCH structure is used as a single-item cache of information
20003 about a nested archive (when members of a thin archive reside within
20004 another regular archive file). */
20005 nested_arch
.file_name
= NULL
;
20006 nested_arch
.file
= NULL
;
20007 nested_arch
.index_array
= NULL
;
20008 nested_arch
.sym_table
= NULL
;
20009 nested_arch
.longnames
= NULL
;
20011 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20012 is_thin_archive
, do_archive_index
) != 0)
20018 if (do_archive_index
)
20020 if (arch
.sym_table
== NULL
)
20021 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20024 unsigned long i
, l
;
20025 unsigned long current_pos
;
20027 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20028 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20030 current_pos
= ftell (filedata
->handle
);
20032 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20034 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20036 char * member_name
;
20038 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20040 if (member_name
!= NULL
)
20042 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20044 if (qualified_name
!= NULL
)
20046 printf (_("Contents of binary %s at offset "), qualified_name
);
20047 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20049 free (qualified_name
);
20054 if (l
>= arch
.sym_size
)
20056 error (_("%s: end of the symbol table reached before the end of the index\n"),
20057 filedata
->file_name
);
20061 /* PR 17531: file: 0b6630b2. */
20062 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20063 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20066 if (arch
.uses_64bit_indices
)
20071 if (l
< arch
.sym_size
)
20073 error (ngettext ("%s: %ld byte remains in the symbol table, "
20074 "but without corresponding entries in "
20075 "the index table\n",
20076 "%s: %ld bytes remain in the symbol table, "
20077 "but without corresponding entries in "
20078 "the index table\n",
20079 arch
.sym_size
- l
),
20080 filedata
->file_name
, arch
.sym_size
- l
);
20084 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20086 error (_("%s: failed to seek back to start of object files in the archive\n"),
20087 filedata
->file_name
);
20093 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20094 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20095 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20096 && !do_section_groups
&& !do_dyn_syms
)
20098 ret
= TRUE
; /* Archive index only. */
20107 char * qualified_name
;
20109 /* Read the next archive header. */
20110 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20112 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20115 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20116 if (got
!= sizeof arch
.arhdr
)
20120 /* PR 24049 - we cannot use filedata->file_name as this will
20121 have already been freed. */
20122 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20127 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20129 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20134 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20136 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20137 if (archive_file_size
& 01)
20138 ++archive_file_size
;
20140 name
= get_archive_member_name (&arch
, &nested_arch
);
20143 error (_("%s: bad archive file name\n"), arch
.file_name
);
20147 namelen
= strlen (name
);
20149 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20150 if (qualified_name
== NULL
)
20152 error (_("%s: bad archive file name\n"), arch
.file_name
);
20157 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20159 /* This is a proxy for an external member of a thin archive. */
20160 Filedata
* member_filedata
;
20161 char * member_file_name
= adjust_relative_path
20162 (filedata
->file_name
, name
, namelen
);
20164 if (member_file_name
== NULL
)
20170 member_filedata
= open_file (member_file_name
);
20171 if (member_filedata
== NULL
)
20173 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20174 free (member_file_name
);
20179 archive_file_offset
= arch
.nested_member_origin
;
20180 member_filedata
->file_name
= qualified_name
;
20182 if (! process_object (member_filedata
))
20185 close_file (member_filedata
);
20186 free (member_file_name
);
20188 else if (is_thin_archive
)
20190 Filedata thin_filedata
;
20192 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20194 /* PR 15140: Allow for corrupt thin archives. */
20195 if (nested_arch
.file
== NULL
)
20197 error (_("%s: contains corrupt thin archive: %s\n"),
20198 qualified_name
, name
);
20203 /* This is a proxy for a member of a nested archive. */
20204 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20206 /* The nested archive file will have been opened and setup by
20207 get_archive_member_name. */
20208 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20210 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20215 thin_filedata
.handle
= nested_arch
.file
;
20216 thin_filedata
.file_name
= qualified_name
;
20218 if (! process_object (& thin_filedata
))
20223 archive_file_offset
= arch
.next_arhdr_offset
;
20224 arch
.next_arhdr_offset
+= archive_file_size
;
20226 filedata
->file_name
= qualified_name
;
20227 if (! process_object (filedata
))
20231 if (filedata
->dump_sects
!= NULL
)
20233 free (filedata
->dump_sects
);
20234 filedata
->dump_sects
= NULL
;
20235 filedata
->num_dump_sects
= 0;
20238 free (qualified_name
);
20242 if (nested_arch
.file
!= NULL
)
20243 fclose (nested_arch
.file
);
20244 release_archive (&nested_arch
);
20245 release_archive (&arch
);
20251 process_file (char * file_name
)
20253 Filedata
* filedata
= NULL
;
20254 struct stat statbuf
;
20255 char armag
[SARMAG
];
20256 bfd_boolean ret
= TRUE
;
20258 if (stat (file_name
, &statbuf
) < 0)
20260 if (errno
== ENOENT
)
20261 error (_("'%s': No such file\n"), file_name
);
20263 error (_("Could not locate '%s'. System error message: %s\n"),
20264 file_name
, strerror (errno
));
20268 if (! S_ISREG (statbuf
.st_mode
))
20270 error (_("'%s' is not an ordinary file\n"), file_name
);
20274 filedata
= calloc (1, sizeof * filedata
);
20275 if (filedata
== NULL
)
20277 error (_("Out of memory allocating file data structure\n"));
20281 filedata
->file_name
= file_name
;
20282 filedata
->handle
= fopen (file_name
, "rb");
20283 if (filedata
->handle
== NULL
)
20285 error (_("Input file '%s' is not readable.\n"), file_name
);
20290 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20292 error (_("%s: Failed to read file's magic number\n"), file_name
);
20293 fclose (filedata
->handle
);
20298 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20300 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20302 if (! process_archive (filedata
, FALSE
))
20305 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20307 if ( ! process_archive (filedata
, TRUE
))
20312 if (do_archive_index
)
20313 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20316 rewind (filedata
->handle
);
20317 archive_file_size
= archive_file_offset
= 0;
20319 if (! process_object (filedata
))
20323 fclose (filedata
->handle
);
20329 #ifdef SUPPORT_DISASSEMBLY
20330 /* Needed by the i386 disassembler. For extra credit, someone could
20331 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20335 print_address (unsigned int addr
, FILE * outfile
)
20337 fprintf (outfile
,"0x%8.8x", addr
);
20340 /* Needed by the i386 disassembler. */
20343 db_task_printsym (unsigned int addr
)
20345 print_address (addr
, stderr
);
20350 main (int argc
, char ** argv
)
20354 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20355 setlocale (LC_MESSAGES
, "");
20357 #if defined (HAVE_SETLOCALE)
20358 setlocale (LC_CTYPE
, "");
20360 bindtextdomain (PACKAGE
, LOCALEDIR
);
20361 textdomain (PACKAGE
);
20363 expandargv (&argc
, &argv
);
20365 cmdline
.file_name
= "<cmdline>";
20366 parse_args (& cmdline
, argc
, argv
);
20368 if (optind
< (argc
- 1))
20370 else if (optind
>= argc
)
20372 warn (_("Nothing to do.\n"));
20377 while (optind
< argc
)
20378 if (! process_file (argv
[optind
++]))
20381 if (cmdline
.dump_sects
!= NULL
)
20382 free (cmdline
.dump_sects
);
20384 free (dump_ctf_symtab_name
);
20385 free (dump_ctf_strtab_name
);
20386 free (dump_ctf_parent_name
);
20388 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;