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
++)
5266 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5267 if (load
->p_type
== PT_LOAD
5268 && load
->p_offset
<= segment
->p_offset
5269 && (load
->p_offset
+ load
->p_filesz
5270 >= segment
->p_offset
+ segment
->p_filesz
)
5271 && load
->p_vaddr
<= segment
->p_vaddr
5272 && (load
->p_vaddr
+ load
->p_filesz
5273 >= segment
->p_vaddr
+ segment
->p_filesz
))
5276 if (j
== filedata
->file_header
.e_phnum
)
5277 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5283 error (_("more than one dynamic segment\n"));
5285 /* By default, assume that the .dynamic section is the first
5286 section in the DYNAMIC segment. */
5287 dynamic_addr
= segment
->p_offset
;
5288 dynamic_size
= segment
->p_filesz
;
5290 /* Try to locate the .dynamic section. If there is
5291 a section header table, we can easily locate it. */
5292 if (filedata
->section_headers
!= NULL
)
5294 Elf_Internal_Shdr
* sec
;
5296 sec
= find_section (filedata
, ".dynamic");
5297 if (sec
== NULL
|| sec
->sh_size
== 0)
5299 /* A corresponding .dynamic section is expected, but on
5300 IA-64/OpenVMS it is OK for it to be missing. */
5301 if (!is_ia64_vms (filedata
))
5302 error (_("no .dynamic section in the dynamic segment\n"));
5306 if (sec
->sh_type
== SHT_NOBITS
)
5312 dynamic_addr
= sec
->sh_offset
;
5313 dynamic_size
= sec
->sh_size
;
5315 if (dynamic_addr
< segment
->p_offset
5316 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5317 warn (_("the .dynamic section is not contained"
5318 " within the dynamic segment\n"));
5319 else if (dynamic_addr
> segment
->p_offset
)
5320 warn (_("the .dynamic section is not the first section"
5321 " in the dynamic segment.\n"));
5324 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5325 segment. Check this after matching against the section headers
5326 so we don't warn on debuginfo file (which have NOBITS .dynamic
5328 if (dynamic_addr
> filedata
->file_size
5329 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5331 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5332 dynamic_addr
= dynamic_size
= 0;
5337 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5339 error (_("Unable to find program interpreter name\n"));
5343 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5345 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5346 error (_("Internal error: failed to create format string to display program interpreter\n"));
5348 program_interpreter
[0] = 0;
5349 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5350 error (_("Unable to read program interpreter name\n"));
5353 printf (_(" [Requesting program interpreter: %s]\n"),
5354 program_interpreter
);
5361 && filedata
->section_headers
!= NULL
5362 && filedata
->string_table
!= NULL
)
5364 printf (_("\n Section to Segment mapping:\n"));
5365 printf (_(" Segment Sections...\n"));
5367 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5370 Elf_Internal_Shdr
* section
;
5372 segment
= filedata
->program_headers
+ i
;
5373 section
= filedata
->section_headers
+ 1;
5375 printf (" %2.2d ", i
);
5377 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5379 if (!ELF_TBSS_SPECIAL (section
, segment
)
5380 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5381 printf ("%s ", printable_section_name (filedata
, section
));
5392 /* Find the file offset corresponding to VMA by using the program headers. */
5395 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5397 Elf_Internal_Phdr
* seg
;
5399 if (! get_program_headers (filedata
))
5401 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5405 for (seg
= filedata
->program_headers
;
5406 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5409 if (seg
->p_type
!= PT_LOAD
)
5412 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5413 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5414 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5417 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5418 (unsigned long) vma
);
5423 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5424 If PROBE is true, this is just a probe and we do not generate any error
5425 messages if the load fails. */
5428 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5430 Elf32_External_Shdr
* shdrs
;
5431 Elf_Internal_Shdr
* internal
;
5433 unsigned int size
= filedata
->file_header
.e_shentsize
;
5434 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5436 /* PR binutils/17531: Cope with unexpected section header sizes. */
5437 if (size
== 0 || num
== 0)
5439 if (size
< sizeof * shdrs
)
5442 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5445 if (!probe
&& size
> sizeof * shdrs
)
5446 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5448 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5450 probe
? NULL
: _("section headers"));
5454 free (filedata
->section_headers
);
5455 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5456 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5457 if (filedata
->section_headers
== NULL
)
5460 error (_("Out of memory reading %u section headers\n"), num
);
5465 for (i
= 0, internal
= filedata
->section_headers
;
5469 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5470 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5471 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5472 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5473 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5474 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5475 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5476 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5477 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5478 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5479 if (!probe
&& internal
->sh_link
> num
)
5480 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5481 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5482 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5489 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5492 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5494 Elf64_External_Shdr
* shdrs
;
5495 Elf_Internal_Shdr
* internal
;
5497 unsigned int size
= filedata
->file_header
.e_shentsize
;
5498 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5500 /* PR binutils/17531: Cope with unexpected section header sizes. */
5501 if (size
== 0 || num
== 0)
5504 if (size
< sizeof * shdrs
)
5507 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5511 if (! probe
&& size
> sizeof * shdrs
)
5512 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5514 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5515 filedata
->file_header
.e_shoff
,
5517 probe
? NULL
: _("section headers"));
5521 free (filedata
->section_headers
);
5522 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5523 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5524 if (filedata
->section_headers
== NULL
)
5527 error (_("Out of memory reading %u section headers\n"), num
);
5532 for (i
= 0, internal
= filedata
->section_headers
;
5536 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5537 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5538 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5539 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5540 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5541 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5542 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5543 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5544 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5545 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5546 if (!probe
&& internal
->sh_link
> num
)
5547 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5548 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5549 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5556 static Elf_Internal_Sym
*
5557 get_32bit_elf_symbols (Filedata
* filedata
,
5558 Elf_Internal_Shdr
* section
,
5559 unsigned long * num_syms_return
)
5561 unsigned long number
= 0;
5562 Elf32_External_Sym
* esyms
= NULL
;
5563 Elf_External_Sym_Shndx
* shndx
= NULL
;
5564 Elf_Internal_Sym
* isyms
= NULL
;
5565 Elf_Internal_Sym
* psym
;
5567 elf_section_list
* entry
;
5569 if (section
->sh_size
== 0)
5571 if (num_syms_return
!= NULL
)
5572 * num_syms_return
= 0;
5576 /* Run some sanity checks first. */
5577 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5579 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5580 printable_section_name (filedata
, section
),
5581 (unsigned long) section
->sh_entsize
);
5585 if (section
->sh_size
> filedata
->file_size
)
5587 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5588 printable_section_name (filedata
, section
),
5589 (unsigned long) section
->sh_size
);
5593 number
= section
->sh_size
/ section
->sh_entsize
;
5595 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5597 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5598 (unsigned long) section
->sh_size
,
5599 printable_section_name (filedata
, section
),
5600 (unsigned long) section
->sh_entsize
);
5604 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5605 section
->sh_size
, _("symbols"));
5610 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5612 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5617 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5621 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5622 entry
->hdr
->sh_offset
,
5623 1, entry
->hdr
->sh_size
,
5624 _("symbol table section indices"));
5628 /* PR17531: file: heap-buffer-overflow */
5629 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5631 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5632 printable_section_name (filedata
, entry
->hdr
),
5633 (unsigned long) entry
->hdr
->sh_size
,
5634 (unsigned long) section
->sh_size
);
5639 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5643 error (_("Out of memory reading %lu symbols\n"),
5644 (unsigned long) number
);
5648 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5650 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5651 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5652 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5653 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5654 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5656 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5657 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5658 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5659 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5660 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5667 if (num_syms_return
!= NULL
)
5668 * num_syms_return
= isyms
== NULL
? 0 : number
;
5673 static Elf_Internal_Sym
*
5674 get_64bit_elf_symbols (Filedata
* filedata
,
5675 Elf_Internal_Shdr
* section
,
5676 unsigned long * num_syms_return
)
5678 unsigned long number
= 0;
5679 Elf64_External_Sym
* esyms
= NULL
;
5680 Elf_External_Sym_Shndx
* shndx
= NULL
;
5681 Elf_Internal_Sym
* isyms
= NULL
;
5682 Elf_Internal_Sym
* psym
;
5684 elf_section_list
* entry
;
5686 if (section
->sh_size
== 0)
5688 if (num_syms_return
!= NULL
)
5689 * num_syms_return
= 0;
5693 /* Run some sanity checks first. */
5694 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5696 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5697 printable_section_name (filedata
, section
),
5698 (unsigned long) section
->sh_entsize
);
5702 if (section
->sh_size
> filedata
->file_size
)
5704 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5705 printable_section_name (filedata
, section
),
5706 (unsigned long) section
->sh_size
);
5710 number
= section
->sh_size
/ section
->sh_entsize
;
5712 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5714 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5715 (unsigned long) section
->sh_size
,
5716 printable_section_name (filedata
, section
),
5717 (unsigned long) section
->sh_entsize
);
5721 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5722 section
->sh_size
, _("symbols"));
5727 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5729 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5734 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5738 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5739 entry
->hdr
->sh_offset
,
5740 1, entry
->hdr
->sh_size
,
5741 _("symbol table section indices"));
5745 /* PR17531: file: heap-buffer-overflow */
5746 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5748 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5749 printable_section_name (filedata
, entry
->hdr
),
5750 (unsigned long) entry
->hdr
->sh_size
,
5751 (unsigned long) section
->sh_size
);
5756 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5760 error (_("Out of memory reading %lu symbols\n"),
5761 (unsigned long) number
);
5765 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5767 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5768 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5769 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5770 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5772 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5774 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5775 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5776 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5778 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5779 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5786 if (num_syms_return
!= NULL
)
5787 * num_syms_return
= isyms
== NULL
? 0 : number
;
5793 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5795 static char buff
[1024];
5797 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5799 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5800 bfd_vma os_flags
= 0;
5801 bfd_vma proc_flags
= 0;
5802 bfd_vma unknown_flags
= 0;
5810 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5811 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5812 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5813 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5814 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5815 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5816 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5817 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5818 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5819 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5820 /* IA-64 specific. */
5821 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5822 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5823 /* IA-64 OpenVMS specific. */
5824 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5825 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5826 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5827 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5828 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5829 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5831 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5832 /* SPARC specific. */
5833 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5834 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5836 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5837 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5838 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5840 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5842 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5845 if (do_section_details
)
5847 sprintf (buff
, "[%*.*lx]: ",
5848 field_size
, field_size
, (unsigned long) sh_flags
);
5849 p
+= field_size
+ 4;
5856 flag
= sh_flags
& - sh_flags
;
5859 if (do_section_details
)
5863 case SHF_WRITE
: sindex
= 0; break;
5864 case SHF_ALLOC
: sindex
= 1; break;
5865 case SHF_EXECINSTR
: sindex
= 2; break;
5866 case SHF_MERGE
: sindex
= 3; break;
5867 case SHF_STRINGS
: sindex
= 4; break;
5868 case SHF_INFO_LINK
: sindex
= 5; break;
5869 case SHF_LINK_ORDER
: sindex
= 6; break;
5870 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5871 case SHF_GROUP
: sindex
= 8; break;
5872 case SHF_TLS
: sindex
= 9; break;
5873 case SHF_EXCLUDE
: sindex
= 18; break;
5874 case SHF_COMPRESSED
: sindex
= 20; break;
5875 case SHF_GNU_MBIND
: sindex
= 24; break;
5879 switch (filedata
->file_header
.e_machine
)
5882 if (flag
== SHF_IA_64_SHORT
)
5884 else if (flag
== SHF_IA_64_NORECOV
)
5887 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5890 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5891 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5892 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5893 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5894 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5895 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5906 case EM_OLD_SPARCV9
:
5907 case EM_SPARC32PLUS
:
5910 if (flag
== SHF_ORDERED
)
5917 case SHF_ENTRYSECT
: sindex
= 21; break;
5918 case SHF_ARM_PURECODE
: sindex
= 22; break;
5919 case SHF_COMDEF
: sindex
= 23; break;
5924 if (flag
== SHF_PPC_VLE
)
5935 if (p
!= buff
+ field_size
+ 4)
5937 if (size
< (10 + 2))
5939 warn (_("Internal error: not enough buffer room for section flag info"));
5940 return _("<unknown>");
5947 size
-= flags
[sindex
].len
;
5948 p
= stpcpy (p
, flags
[sindex
].str
);
5950 else if (flag
& SHF_MASKOS
)
5952 else if (flag
& SHF_MASKPROC
)
5955 unknown_flags
|= flag
;
5961 case SHF_WRITE
: *p
= 'W'; break;
5962 case SHF_ALLOC
: *p
= 'A'; break;
5963 case SHF_EXECINSTR
: *p
= 'X'; break;
5964 case SHF_MERGE
: *p
= 'M'; break;
5965 case SHF_STRINGS
: *p
= 'S'; break;
5966 case SHF_INFO_LINK
: *p
= 'I'; break;
5967 case SHF_LINK_ORDER
: *p
= 'L'; break;
5968 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5969 case SHF_GROUP
: *p
= 'G'; break;
5970 case SHF_TLS
: *p
= 'T'; break;
5971 case SHF_EXCLUDE
: *p
= 'E'; break;
5972 case SHF_COMPRESSED
: *p
= 'C'; break;
5973 case SHF_GNU_MBIND
: *p
= 'D'; break;
5976 if ((filedata
->file_header
.e_machine
== EM_X86_64
5977 || filedata
->file_header
.e_machine
== EM_L1OM
5978 || filedata
->file_header
.e_machine
== EM_K1OM
)
5979 && flag
== SHF_X86_64_LARGE
)
5981 else if (filedata
->file_header
.e_machine
== EM_ARM
5982 && flag
== SHF_ARM_PURECODE
)
5984 else if (filedata
->file_header
.e_machine
== EM_PPC
5985 && flag
== SHF_PPC_VLE
)
5987 else if (flag
& SHF_MASKOS
)
5990 sh_flags
&= ~ SHF_MASKOS
;
5992 else if (flag
& SHF_MASKPROC
)
5995 sh_flags
&= ~ SHF_MASKPROC
;
6005 if (do_section_details
)
6009 size
-= 5 + field_size
;
6010 if (p
!= buff
+ field_size
+ 4)
6014 warn (_("Internal error: not enough buffer room for section flag info"));
6015 return _("<unknown>");
6021 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6022 (unsigned long) os_flags
);
6023 p
+= 5 + field_size
;
6027 size
-= 7 + field_size
;
6028 if (p
!= buff
+ field_size
+ 4)
6032 warn (_("Internal error: not enough buffer room for section flag info"));
6033 return _("<unknown>");
6039 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6040 (unsigned long) proc_flags
);
6041 p
+= 7 + field_size
;
6045 size
-= 10 + field_size
;
6046 if (p
!= buff
+ field_size
+ 4)
6050 warn (_("Internal error: not enough buffer room for section flag info"));
6051 return _("<unknown>");
6057 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6058 (unsigned long) unknown_flags
);
6059 p
+= 10 + field_size
;
6068 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6072 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6074 if (size
< sizeof (* echdr
))
6076 error (_("Compressed section is too small even for a compression header\n"));
6080 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6081 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6082 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6083 return sizeof (*echdr
);
6087 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6089 if (size
< sizeof (* echdr
))
6091 error (_("Compressed section is too small even for a compression header\n"));
6095 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6096 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6097 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6098 return sizeof (*echdr
);
6103 process_section_headers (Filedata
* filedata
)
6105 Elf_Internal_Shdr
* section
;
6108 filedata
->section_headers
= NULL
;
6110 if (filedata
->file_header
.e_shnum
== 0)
6112 /* PR binutils/12467. */
6113 if (filedata
->file_header
.e_shoff
!= 0)
6115 warn (_("possibly corrupt ELF file header - it has a non-zero"
6116 " section header offset, but no section headers\n"));
6119 else if (do_sections
)
6120 printf (_("\nThere are no sections in this file.\n"));
6125 if (do_sections
&& !do_header
)
6126 printf (ngettext ("There is %d section header, "
6127 "starting at offset 0x%lx:\n",
6128 "There are %d section headers, "
6129 "starting at offset 0x%lx:\n",
6130 filedata
->file_header
.e_shnum
),
6131 filedata
->file_header
.e_shnum
,
6132 (unsigned long) filedata
->file_header
.e_shoff
);
6136 if (! get_32bit_section_headers (filedata
, FALSE
))
6141 if (! get_64bit_section_headers (filedata
, FALSE
))
6145 /* Read in the string table, so that we have names to display. */
6146 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6147 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6149 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6151 if (section
->sh_size
!= 0)
6153 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6154 1, section
->sh_size
,
6157 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6161 /* Scan the sections for the dynamic symbol table
6162 and dynamic string table and debug sections. */
6163 dynamic_symbols
= NULL
;
6164 dynamic_strings
= NULL
;
6165 dynamic_syminfo
= NULL
;
6166 symtab_shndx_list
= NULL
;
6168 eh_addr_size
= is_32bit_elf
? 4 : 8;
6169 switch (filedata
->file_header
.e_machine
)
6172 case EM_MIPS_RS3_LE
:
6173 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6174 FDE addresses. However, the ABI also has a semi-official ILP32
6175 variant for which the normal FDE address size rules apply.
6177 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6178 section, where XX is the size of longs in bits. Unfortunately,
6179 earlier compilers provided no way of distinguishing ILP32 objects
6180 from LP64 objects, so if there's any doubt, we should assume that
6181 the official LP64 form is being used. */
6182 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6183 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6189 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6191 case E_H8_MACH_H8300
:
6192 case E_H8_MACH_H8300HN
:
6193 case E_H8_MACH_H8300SN
:
6194 case E_H8_MACH_H8300SXN
:
6197 case E_H8_MACH_H8300H
:
6198 case E_H8_MACH_H8300S
:
6199 case E_H8_MACH_H8300SX
:
6207 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6209 case EF_M32C_CPU_M16C
:
6216 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6219 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6220 if (section->sh_entsize != expected_entsize) \
6223 sprintf_vma (buf, section->sh_entsize); \
6224 /* Note: coded this way so that there is a single string for \
6226 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6227 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6228 (unsigned) expected_entsize); \
6229 section->sh_entsize = expected_entsize; \
6234 #define CHECK_ENTSIZE(section, i, type) \
6235 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6236 sizeof (Elf64_External_##type))
6238 for (i
= 0, section
= filedata
->section_headers
;
6239 i
< filedata
->file_header
.e_shnum
;
6242 char * name
= SECTION_NAME (section
);
6244 if (section
->sh_type
== SHT_DYNSYM
)
6246 if (dynamic_symbols
!= NULL
)
6248 error (_("File contains multiple dynamic symbol tables\n"));
6252 CHECK_ENTSIZE (section
, i
, Sym
);
6253 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6255 else if (section
->sh_type
== SHT_STRTAB
6256 && streq (name
, ".dynstr"))
6258 if (dynamic_strings
!= NULL
)
6260 error (_("File contains multiple dynamic string tables\n"));
6264 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6265 1, section
->sh_size
,
6266 _("dynamic strings"));
6267 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6269 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6271 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6273 entry
->hdr
= section
;
6274 entry
->next
= symtab_shndx_list
;
6275 symtab_shndx_list
= entry
;
6277 else if (section
->sh_type
== SHT_SYMTAB
)
6278 CHECK_ENTSIZE (section
, i
, Sym
);
6279 else if (section
->sh_type
== SHT_GROUP
)
6280 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6281 else if (section
->sh_type
== SHT_REL
)
6282 CHECK_ENTSIZE (section
, i
, Rel
);
6283 else if (section
->sh_type
== SHT_RELA
)
6284 CHECK_ENTSIZE (section
, i
, Rela
);
6285 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6286 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6287 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6288 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6289 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6290 && (const_strneq (name
, ".debug_")
6291 || const_strneq (name
, ".zdebug_")))
6294 name
+= sizeof (".zdebug_") - 1;
6296 name
+= sizeof (".debug_") - 1;
6299 || (do_debug_info
&& const_strneq (name
, "info"))
6300 || (do_debug_info
&& const_strneq (name
, "types"))
6301 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6302 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6303 || (do_debug_lines
&& const_strneq (name
, "line."))
6304 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6305 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6306 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6307 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6308 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6309 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6310 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6311 || (do_debug_frames
&& const_strneq (name
, "frame"))
6312 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6313 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6314 || (do_debug_str
&& const_strneq (name
, "str"))
6315 || (do_debug_loc
&& const_strneq (name
, "loc"))
6316 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6317 || (do_debug_addr
&& const_strneq (name
, "addr"))
6318 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6319 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6321 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6323 /* Linkonce section to be combined with .debug_info at link time. */
6324 else if ((do_debugging
|| do_debug_info
)
6325 && const_strneq (name
, ".gnu.linkonce.wi."))
6326 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6327 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6328 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6329 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6330 || streq (name
, ".debug_names")))
6331 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6332 /* Trace sections for Itanium VMS. */
6333 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6334 || do_trace_aranges
)
6335 && const_strneq (name
, ".trace_"))
6337 name
+= sizeof (".trace_") - 1;
6340 || (do_trace_info
&& streq (name
, "info"))
6341 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6342 || (do_trace_aranges
&& streq (name
, "aranges"))
6344 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6346 else if ((do_debugging
|| do_debug_links
)
6347 && (const_strneq (name
, ".gnu_debuglink")
6348 || const_strneq (name
, ".gnu_debugaltlink")))
6349 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6355 if (filedata
->file_header
.e_shnum
> 1)
6356 printf (_("\nSection Headers:\n"));
6358 printf (_("\nSection Header:\n"));
6362 if (do_section_details
)
6364 printf (_(" [Nr] Name\n"));
6365 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6369 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6373 if (do_section_details
)
6375 printf (_(" [Nr] Name\n"));
6376 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6380 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6384 if (do_section_details
)
6386 printf (_(" [Nr] Name\n"));
6387 printf (_(" Type Address Offset Link\n"));
6388 printf (_(" Size EntSize Info Align\n"));
6392 printf (_(" [Nr] Name Type Address Offset\n"));
6393 printf (_(" Size EntSize Flags Link Info Align\n"));
6397 if (do_section_details
)
6398 printf (_(" Flags\n"));
6400 for (i
= 0, section
= filedata
->section_headers
;
6401 i
< filedata
->file_header
.e_shnum
;
6404 /* Run some sanity checks on the section header. */
6406 /* Check the sh_link field. */
6407 switch (section
->sh_type
)
6411 if (section
->sh_link
== 0
6412 && (filedata
->file_header
.e_type
== ET_EXEC
6413 || filedata
->file_header
.e_type
== ET_DYN
))
6414 /* A dynamic relocation section where all entries use a
6415 zero symbol index need not specify a symtab section. */
6418 case SHT_SYMTAB_SHNDX
:
6422 case SHT_GNU_versym
:
6423 if (section
->sh_link
== 0
6424 || section
->sh_link
>= filedata
->file_header
.e_shnum
6425 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6426 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6427 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6428 i
, section
->sh_link
);
6434 case SHT_GNU_verneed
:
6435 case SHT_GNU_verdef
:
6436 case SHT_GNU_LIBLIST
:
6437 if (section
->sh_link
== 0
6438 || section
->sh_link
>= filedata
->file_header
.e_shnum
6439 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6440 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6441 i
, section
->sh_link
);
6444 case SHT_INIT_ARRAY
:
6445 case SHT_FINI_ARRAY
:
6446 case SHT_PREINIT_ARRAY
:
6447 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6448 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6449 i
, section
->sh_link
);
6453 /* FIXME: Add support for target specific section types. */
6454 #if 0 /* Currently we do not check other section types as there are too
6455 many special cases. Stab sections for example have a type
6456 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6458 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6459 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6460 i
, section
->sh_link
);
6465 /* Check the sh_info field. */
6466 switch (section
->sh_type
)
6470 if (section
->sh_info
== 0
6471 && (filedata
->file_header
.e_type
== ET_EXEC
6472 || filedata
->file_header
.e_type
== ET_DYN
))
6473 /* Dynamic relocations apply to segments, so they do not
6474 need to specify the section they relocate. */
6476 if (section
->sh_info
== 0
6477 || section
->sh_info
>= filedata
->file_header
.e_shnum
6478 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6479 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6480 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6481 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6482 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6483 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6484 /* FIXME: Are other section types valid ? */
6485 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6486 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6487 i
, section
->sh_info
);
6492 case SHT_SYMTAB_SHNDX
:
6493 case SHT_INIT_ARRAY
:
6494 case SHT_FINI_ARRAY
:
6495 case SHT_PREINIT_ARRAY
:
6496 if (section
->sh_info
!= 0)
6497 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6498 i
, section
->sh_info
);
6504 /* A symbol index - we assume that it is valid. */
6508 /* FIXME: Add support for target specific section types. */
6509 if (section
->sh_type
== SHT_NOBITS
)
6510 /* NOBITS section headers with non-zero sh_info fields can be
6511 created when a binary is stripped of everything but its debug
6512 information. The stripped sections have their headers
6513 preserved but their types set to SHT_NOBITS. So do not check
6514 this type of section. */
6516 else if (section
->sh_flags
& SHF_INFO_LINK
)
6518 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6519 warn (_("[%2u]: Expected link to another section in info field"), i
);
6521 else if (section
->sh_type
< SHT_LOOS
6522 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6523 && section
->sh_info
!= 0)
6524 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6525 i
, section
->sh_info
);
6529 /* Check the sh_size field. */
6530 if (section
->sh_size
> filedata
->file_size
6531 && section
->sh_type
!= SHT_NOBITS
6532 && section
->sh_type
!= SHT_NULL
6533 && section
->sh_type
< SHT_LOOS
)
6534 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6536 printf (" [%2u] ", i
);
6537 if (do_section_details
)
6538 printf ("%s\n ", printable_section_name (filedata
, section
));
6540 print_symbol (-17, SECTION_NAME (section
));
6542 printf (do_wide
? " %-15s " : " %-15.15s ",
6543 get_section_type_name (filedata
, section
->sh_type
));
6547 const char * link_too_big
= NULL
;
6549 print_vma (section
->sh_addr
, LONG_HEX
);
6551 printf ( " %6.6lx %6.6lx %2.2lx",
6552 (unsigned long) section
->sh_offset
,
6553 (unsigned long) section
->sh_size
,
6554 (unsigned long) section
->sh_entsize
);
6556 if (do_section_details
)
6557 fputs (" ", stdout
);
6559 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6561 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6564 /* The sh_link value is out of range. Normally this indicates
6565 an error but it can have special values in Solaris binaries. */
6566 switch (filedata
->file_header
.e_machine
)
6573 case EM_OLD_SPARCV9
:
6574 case EM_SPARC32PLUS
:
6577 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6578 link_too_big
= "BEFORE";
6579 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6580 link_too_big
= "AFTER";
6587 if (do_section_details
)
6589 if (link_too_big
!= NULL
&& * link_too_big
)
6590 printf ("<%s> ", link_too_big
);
6592 printf ("%2u ", section
->sh_link
);
6593 printf ("%3u %2lu\n", section
->sh_info
,
6594 (unsigned long) section
->sh_addralign
);
6597 printf ("%2u %3u %2lu\n",
6600 (unsigned long) section
->sh_addralign
);
6602 if (link_too_big
&& ! * link_too_big
)
6603 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6604 i
, section
->sh_link
);
6608 print_vma (section
->sh_addr
, LONG_HEX
);
6610 if ((long) section
->sh_offset
== section
->sh_offset
)
6611 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6615 print_vma (section
->sh_offset
, LONG_HEX
);
6618 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6619 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6623 print_vma (section
->sh_size
, LONG_HEX
);
6626 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6627 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6631 print_vma (section
->sh_entsize
, LONG_HEX
);
6634 if (do_section_details
)
6635 fputs (" ", stdout
);
6637 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6639 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6641 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6642 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6645 print_vma (section
->sh_addralign
, DEC
);
6649 else if (do_section_details
)
6652 print_vma (section
->sh_addr
, LONG_HEX
);
6653 if ((long) section
->sh_offset
== section
->sh_offset
)
6654 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6658 print_vma (section
->sh_offset
, LONG_HEX
);
6660 printf (" %u\n ", section
->sh_link
);
6661 print_vma (section
->sh_size
, LONG_HEX
);
6663 print_vma (section
->sh_entsize
, LONG_HEX
);
6665 printf (" %-16u %lu\n",
6667 (unsigned long) section
->sh_addralign
);
6672 print_vma (section
->sh_addr
, LONG_HEX
);
6673 if ((long) section
->sh_offset
== section
->sh_offset
)
6674 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6678 print_vma (section
->sh_offset
, LONG_HEX
);
6681 print_vma (section
->sh_size
, LONG_HEX
);
6683 print_vma (section
->sh_entsize
, LONG_HEX
);
6685 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6687 printf (" %2u %3u %lu\n",
6690 (unsigned long) section
->sh_addralign
);
6693 if (do_section_details
)
6695 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6696 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6698 /* Minimum section size is 12 bytes for 32-bit compression
6699 header + 12 bytes for compressed data header. */
6700 unsigned char buf
[24];
6702 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6703 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6704 sizeof (buf
), _("compression header")))
6706 Elf_Internal_Chdr chdr
;
6708 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6710 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6713 printf (_(" [<unknown>: 0x%x], "),
6715 print_vma (chdr
.ch_size
, LONG_HEX
);
6716 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6722 if (!do_section_details
)
6724 /* The ordering of the letters shown here matches the ordering of the
6725 corresponding SHF_xxx values, and hence the order in which these
6726 letters will be displayed to the user. */
6727 printf (_("Key to Flags:\n\
6728 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6729 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6730 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6731 if (filedata
->file_header
.e_machine
== EM_X86_64
6732 || filedata
->file_header
.e_machine
== EM_L1OM
6733 || filedata
->file_header
.e_machine
== EM_K1OM
)
6734 printf (_("l (large), "));
6735 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6736 printf (_("y (purecode), "));
6737 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6738 printf (_("v (VLE), "));
6739 printf ("p (processor specific)\n");
6746 get_group_flags (unsigned int flags
)
6748 static char buff
[128];
6752 else if (flags
== GRP_COMDAT
)
6755 snprintf (buff
, 14, _("[0x%x: "), flags
);
6757 flags
&= ~ GRP_COMDAT
;
6758 if (flags
& GRP_MASKOS
)
6760 strcat (buff
, "<OS specific>");
6761 flags
&= ~ GRP_MASKOS
;
6764 if (flags
& GRP_MASKPROC
)
6766 strcat (buff
, "<PROC specific>");
6767 flags
&= ~ GRP_MASKPROC
;
6771 strcat (buff
, "<unknown>");
6778 process_section_groups (Filedata
* filedata
)
6780 Elf_Internal_Shdr
* section
;
6782 struct group
* group
;
6783 Elf_Internal_Shdr
* symtab_sec
;
6784 Elf_Internal_Shdr
* strtab_sec
;
6785 Elf_Internal_Sym
* symtab
;
6786 unsigned long num_syms
;
6790 /* Don't process section groups unless needed. */
6791 if (!do_unwind
&& !do_section_groups
)
6794 if (filedata
->file_header
.e_shnum
== 0)
6796 if (do_section_groups
)
6797 printf (_("\nThere are no sections to group in this file.\n"));
6802 if (filedata
->section_headers
== NULL
)
6804 error (_("Section headers are not available!\n"));
6805 /* PR 13622: This can happen with a corrupt ELF header. */
6809 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6810 sizeof (struct group
*));
6812 if (section_headers_groups
== NULL
)
6814 error (_("Out of memory reading %u section group headers\n"),
6815 filedata
->file_header
.e_shnum
);
6819 /* Scan the sections for the group section. */
6821 for (i
= 0, section
= filedata
->section_headers
;
6822 i
< filedata
->file_header
.e_shnum
;
6824 if (section
->sh_type
== SHT_GROUP
)
6827 if (group_count
== 0)
6829 if (do_section_groups
)
6830 printf (_("\nThere are no section groups in this file.\n"));
6835 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6837 if (section_groups
== NULL
)
6839 error (_("Out of memory reading %lu groups\n"),
6840 (unsigned long) group_count
);
6850 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6851 i
< filedata
->file_header
.e_shnum
;
6854 if (section
->sh_type
== SHT_GROUP
)
6856 const char * name
= printable_section_name (filedata
, section
);
6857 const char * group_name
;
6858 unsigned char * start
;
6859 unsigned char * indices
;
6860 unsigned int entry
, j
, size
;
6861 Elf_Internal_Shdr
* sec
;
6862 Elf_Internal_Sym
* sym
;
6864 /* Get the symbol table. */
6865 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6866 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6869 error (_("Bad sh_link in group section `%s'\n"), name
);
6873 if (symtab_sec
!= sec
)
6878 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6883 error (_("Corrupt header in group section `%s'\n"), name
);
6887 if (section
->sh_info
>= num_syms
)
6889 error (_("Bad sh_info in group section `%s'\n"), name
);
6893 sym
= symtab
+ section
->sh_info
;
6895 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6897 if (sym
->st_shndx
== 0
6898 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6900 error (_("Bad sh_info in group section `%s'\n"), name
);
6904 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6913 /* Get the string table. */
6914 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6923 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6929 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6930 1, strtab_sec
->sh_size
,
6932 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6934 group_name
= sym
->st_name
< strtab_size
6935 ? strtab
+ sym
->st_name
: _("<corrupt>");
6938 /* PR 17531: file: loop. */
6939 if (section
->sh_entsize
> section
->sh_size
)
6941 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6942 printable_section_name (filedata
, section
),
6943 (unsigned long) section
->sh_entsize
,
6944 (unsigned long) section
->sh_size
);
6948 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6949 1, section
->sh_size
,
6955 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6956 entry
= byte_get (indices
, 4);
6959 if (do_section_groups
)
6961 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6962 get_group_flags (entry
), i
, name
, group_name
, size
);
6964 printf (_(" [Index] Name\n"));
6967 group
->group_index
= i
;
6969 for (j
= 0; j
< size
; j
++)
6971 struct group_list
* g
;
6973 entry
= byte_get (indices
, 4);
6976 if (entry
>= filedata
->file_header
.e_shnum
)
6978 static unsigned num_group_errors
= 0;
6980 if (num_group_errors
++ < 10)
6982 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6983 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6984 if (num_group_errors
== 10)
6985 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6990 if (section_headers_groups
[entry
] != NULL
)
6994 static unsigned num_errs
= 0;
6996 if (num_errs
++ < 10)
6998 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7000 section_headers_groups
[entry
]->group_index
);
7002 warn (_("Further error messages about already contained group sections suppressed\n"));
7008 /* Intel C/C++ compiler may put section 0 in a
7009 section group. We just warn it the first time
7010 and ignore it afterwards. */
7011 static bfd_boolean warned
= FALSE
;
7014 error (_("section 0 in group section [%5u]\n"),
7015 section_headers_groups
[entry
]->group_index
);
7021 section_headers_groups
[entry
] = group
;
7023 if (do_section_groups
)
7025 sec
= filedata
->section_headers
+ entry
;
7026 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7029 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7030 g
->section_index
= entry
;
7031 g
->next
= group
->root
;
7049 /* Data used to display dynamic fixups. */
7051 struct ia64_vms_dynfixup
7053 bfd_vma needed_ident
; /* Library ident number. */
7054 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7055 bfd_vma fixup_needed
; /* Index of the library. */
7056 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7057 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7060 /* Data used to display dynamic relocations. */
7062 struct ia64_vms_dynimgrela
7064 bfd_vma img_rela_cnt
; /* Number of relocations. */
7065 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7068 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7072 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7073 struct ia64_vms_dynfixup
* fixup
,
7074 const char * strtab
,
7075 unsigned int strtab_sz
)
7077 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7079 const char * lib_name
;
7081 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7082 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7083 _("dynamic section image fixups"));
7087 if (fixup
->needed
< strtab_sz
)
7088 lib_name
= strtab
+ fixup
->needed
;
7091 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7092 (unsigned long) fixup
->needed
);
7095 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7096 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7098 (_("Seg Offset Type SymVec DataType\n"));
7100 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7105 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7106 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7107 type
= BYTE_GET (imfs
[i
].type
);
7108 rtype
= elf_ia64_reloc_type (type
);
7110 printf (" 0x%08x ", type
);
7112 printf (" %-32s ", rtype
);
7113 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7114 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7121 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7124 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7126 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7129 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7130 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7131 _("dynamic section image relocations"));
7135 printf (_("\nImage relocs\n"));
7137 (_("Seg Offset Type Addend Seg Sym Off\n"));
7139 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7144 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7145 printf ("%08" BFD_VMA_FMT
"x ",
7146 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7147 type
= BYTE_GET (imrs
[i
].type
);
7148 rtype
= elf_ia64_reloc_type (type
);
7150 printf ("0x%08x ", type
);
7152 printf ("%-31s ", rtype
);
7153 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7154 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7155 printf ("%08" BFD_VMA_FMT
"x\n",
7156 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7163 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7166 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7168 struct ia64_vms_dynfixup fixup
;
7169 struct ia64_vms_dynimgrela imgrela
;
7170 Elf_Internal_Dyn
*entry
;
7171 bfd_vma strtab_off
= 0;
7172 bfd_vma strtab_sz
= 0;
7173 char *strtab
= NULL
;
7174 bfd_boolean res
= TRUE
;
7176 memset (&fixup
, 0, sizeof (fixup
));
7177 memset (&imgrela
, 0, sizeof (imgrela
));
7179 /* Note: the order of the entries is specified by the OpenVMS specs. */
7180 for (entry
= dynamic_section
;
7181 entry
< dynamic_section
+ dynamic_nent
;
7184 switch (entry
->d_tag
)
7186 case DT_IA_64_VMS_STRTAB_OFFSET
:
7187 strtab_off
= entry
->d_un
.d_val
;
7190 strtab_sz
= entry
->d_un
.d_val
;
7192 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7193 1, strtab_sz
, _("dynamic string section"));
7196 case DT_IA_64_VMS_NEEDED_IDENT
:
7197 fixup
.needed_ident
= entry
->d_un
.d_val
;
7200 fixup
.needed
= entry
->d_un
.d_val
;
7202 case DT_IA_64_VMS_FIXUP_NEEDED
:
7203 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7205 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7206 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7208 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7209 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7210 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7213 case DT_IA_64_VMS_IMG_RELA_CNT
:
7214 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7216 case DT_IA_64_VMS_IMG_RELA_OFF
:
7217 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7218 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7240 dynamic_relocations
[] =
7242 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7243 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7244 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7247 /* Process the reloc section. */
7250 process_relocs (Filedata
* filedata
)
7252 unsigned long rel_size
;
7253 unsigned long rel_offset
;
7258 if (do_using_dynamic
)
7262 bfd_boolean has_dynamic_reloc
;
7265 has_dynamic_reloc
= FALSE
;
7267 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7269 is_rela
= dynamic_relocations
[i
].rela
;
7270 name
= dynamic_relocations
[i
].name
;
7271 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7272 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7275 has_dynamic_reloc
= TRUE
;
7277 if (is_rela
== UNKNOWN
)
7279 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7280 switch (dynamic_info
[DT_PLTREL
])
7294 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7295 name
, rel_offset
, rel_size
);
7297 dump_relocations (filedata
,
7298 offset_from_vma (filedata
, rel_offset
, rel_size
),
7300 dynamic_symbols
, num_dynamic_syms
,
7301 dynamic_strings
, dynamic_strings_length
,
7302 is_rela
, TRUE
/* is_dynamic */);
7306 if (is_ia64_vms (filedata
))
7307 if (process_ia64_vms_dynamic_relocs (filedata
))
7308 has_dynamic_reloc
= TRUE
;
7310 if (! has_dynamic_reloc
)
7311 printf (_("\nThere are no dynamic relocations in this file.\n"));
7315 Elf_Internal_Shdr
* section
;
7317 bfd_boolean found
= FALSE
;
7319 for (i
= 0, section
= filedata
->section_headers
;
7320 i
< filedata
->file_header
.e_shnum
;
7323 if ( section
->sh_type
!= SHT_RELA
7324 && section
->sh_type
!= SHT_REL
)
7327 rel_offset
= section
->sh_offset
;
7328 rel_size
= section
->sh_size
;
7332 Elf_Internal_Shdr
* strsec
;
7334 unsigned long num_rela
;
7336 printf (_("\nRelocation section "));
7338 if (filedata
->string_table
== NULL
)
7339 printf ("%d", section
->sh_name
);
7341 printf ("'%s'", printable_section_name (filedata
, section
));
7343 num_rela
= rel_size
/ section
->sh_entsize
;
7344 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7345 " at offset 0x%lx contains %lu entries:\n",
7347 rel_offset
, num_rela
);
7349 is_rela
= section
->sh_type
== SHT_RELA
;
7351 if (section
->sh_link
!= 0
7352 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7354 Elf_Internal_Shdr
* symsec
;
7355 Elf_Internal_Sym
* symtab
;
7356 unsigned long nsyms
;
7357 unsigned long strtablen
= 0;
7358 char * strtab
= NULL
;
7360 symsec
= filedata
->section_headers
+ section
->sh_link
;
7361 if (symsec
->sh_type
!= SHT_SYMTAB
7362 && symsec
->sh_type
!= SHT_DYNSYM
)
7365 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7370 if (symsec
->sh_link
!= 0
7371 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7373 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7375 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7378 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7381 dump_relocations (filedata
, rel_offset
, rel_size
,
7382 symtab
, nsyms
, strtab
, strtablen
,
7384 symsec
->sh_type
== SHT_DYNSYM
);
7390 dump_relocations (filedata
, rel_offset
, rel_size
,
7391 NULL
, 0, NULL
, 0, is_rela
,
7392 FALSE
/* is_dynamic */);
7400 /* Users sometimes forget the -D option, so try to be helpful. */
7401 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7403 if (dynamic_info
[dynamic_relocations
[i
].size
])
7405 printf (_("\nThere are no static relocations in this file."));
7406 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7411 if (i
== ARRAY_SIZE (dynamic_relocations
))
7412 printf (_("\nThere are no relocations in this file.\n"));
7419 /* An absolute address consists of a section and an offset. If the
7420 section is NULL, the offset itself is the address, otherwise, the
7421 address equals to LOAD_ADDRESS(section) + offset. */
7425 unsigned short section
;
7429 /* Find the nearest symbol at or below ADDR. Returns the symbol
7430 name, if found, and the offset from the symbol to ADDR. */
7433 find_symbol_for_address (Filedata
* filedata
,
7434 Elf_Internal_Sym
* symtab
,
7435 unsigned long nsyms
,
7436 const char * strtab
,
7437 unsigned long strtab_size
,
7438 struct absaddr addr
,
7439 const char ** symname
,
7442 bfd_vma dist
= 0x100000;
7443 Elf_Internal_Sym
* sym
;
7444 Elf_Internal_Sym
* beg
;
7445 Elf_Internal_Sym
* end
;
7446 Elf_Internal_Sym
* best
= NULL
;
7448 REMOVE_ARCH_BITS (addr
.offset
);
7450 end
= symtab
+ nsyms
;
7456 sym
= beg
+ (end
- beg
) / 2;
7458 value
= sym
->st_value
;
7459 REMOVE_ARCH_BITS (value
);
7461 if (sym
->st_name
!= 0
7462 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7463 && addr
.offset
>= value
7464 && addr
.offset
- value
< dist
)
7467 dist
= addr
.offset
- value
;
7472 if (addr
.offset
< value
)
7480 *symname
= (best
->st_name
>= strtab_size
7481 ? _("<corrupt>") : strtab
+ best
->st_name
);
7487 *offset
= addr
.offset
;
7490 static /* signed */ int
7491 symcmp (const void *p
, const void *q
)
7493 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7494 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7496 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7499 /* Process the unwind section. */
7501 #include "unwind-ia64.h"
7503 struct ia64_unw_table_entry
7505 struct absaddr start
;
7507 struct absaddr info
;
7510 struct ia64_unw_aux_info
7512 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7513 unsigned long table_len
; /* Length of unwind table. */
7514 unsigned char * info
; /* Unwind info. */
7515 unsigned long info_size
; /* Size of unwind info. */
7516 bfd_vma info_addr
; /* Starting address of unwind info. */
7517 bfd_vma seg_base
; /* Starting address of segment. */
7518 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7519 unsigned long nsyms
; /* Number of symbols. */
7520 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7521 unsigned long nfuns
; /* Number of entries in funtab. */
7522 char * strtab
; /* The string table. */
7523 unsigned long strtab_size
; /* Size of string table. */
7527 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7529 struct ia64_unw_table_entry
* tp
;
7530 unsigned long j
, nfuns
;
7532 bfd_boolean res
= TRUE
;
7534 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7535 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7536 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7537 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7539 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7541 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7545 const unsigned char * dp
;
7546 const unsigned char * head
;
7547 const unsigned char * end
;
7548 const char * procname
;
7550 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7551 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7553 fputs ("\n<", stdout
);
7557 fputs (procname
, stdout
);
7560 printf ("+%lx", (unsigned long) offset
);
7563 fputs (">: [", stdout
);
7564 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7565 fputc ('-', stdout
);
7566 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7567 printf ("], info at +0x%lx\n",
7568 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7570 /* PR 17531: file: 86232b32. */
7571 if (aux
->info
== NULL
)
7574 offset
= tp
->info
.offset
;
7575 if (tp
->info
.section
)
7577 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7579 warn (_("Invalid section %u in table entry %ld\n"),
7580 tp
->info
.section
, (long) (tp
- aux
->table
));
7584 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7586 offset
-= aux
->info_addr
;
7587 /* PR 17531: file: 0997b4d1. */
7588 if (offset
>= aux
->info_size
7589 || aux
->info_size
- offset
< 8)
7591 warn (_("Invalid offset %lx in table entry %ld\n"),
7592 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7597 head
= aux
->info
+ offset
;
7598 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7600 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7601 (unsigned) UNW_VER (stamp
),
7602 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7603 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7604 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7605 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7607 if (UNW_VER (stamp
) != 1)
7609 printf (_("\tUnknown version.\n"));
7614 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7615 /* PR 17531: file: 16ceda89. */
7616 if (end
> aux
->info
+ aux
->info_size
)
7617 end
= aux
->info
+ aux
->info_size
;
7618 for (dp
= head
+ 8; dp
< end
;)
7619 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7628 slurp_ia64_unwind_table (Filedata
* filedata
,
7629 struct ia64_unw_aux_info
* aux
,
7630 Elf_Internal_Shdr
* sec
)
7632 unsigned long size
, nrelas
, i
;
7633 Elf_Internal_Phdr
* seg
;
7634 struct ia64_unw_table_entry
* tep
;
7635 Elf_Internal_Shdr
* relsec
;
7636 Elf_Internal_Rela
* rela
;
7637 Elf_Internal_Rela
* rp
;
7638 unsigned char * table
;
7640 Elf_Internal_Sym
* sym
;
7641 const char * relname
;
7645 /* First, find the starting address of the segment that includes
7648 if (filedata
->file_header
.e_phnum
)
7650 if (! get_program_headers (filedata
))
7653 for (seg
= filedata
->program_headers
;
7654 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7657 if (seg
->p_type
!= PT_LOAD
)
7660 if (sec
->sh_addr
>= seg
->p_vaddr
7661 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7663 aux
->seg_base
= seg
->p_vaddr
;
7669 /* Second, build the unwind table from the contents of the unwind section: */
7670 size
= sec
->sh_size
;
7671 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7676 aux
->table_len
= size
/ (3 * eh_addr_size
);
7677 aux
->table
= (struct ia64_unw_table_entry
*)
7678 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7681 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7683 tep
->start
.section
= SHN_UNDEF
;
7684 tep
->end
.section
= SHN_UNDEF
;
7685 tep
->info
.section
= SHN_UNDEF
;
7686 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7687 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7688 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7689 tep
->start
.offset
+= aux
->seg_base
;
7690 tep
->end
.offset
+= aux
->seg_base
;
7691 tep
->info
.offset
+= aux
->seg_base
;
7695 /* Third, apply any relocations to the unwind table: */
7696 for (relsec
= filedata
->section_headers
;
7697 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7700 if (relsec
->sh_type
!= SHT_RELA
7701 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7702 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7705 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7714 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7716 unsigned int sym_ndx
;
7717 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7718 relname
= elf_ia64_reloc_type (r_type
);
7720 /* PR 17531: file: 9fa67536. */
7721 if (relname
== NULL
)
7723 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7727 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7729 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7733 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7735 /* PR 17531: file: 5bc8d9bf. */
7736 if (i
>= aux
->table_len
)
7738 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7742 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7743 if (sym_ndx
>= aux
->nsyms
)
7745 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7749 sym
= aux
->symtab
+ sym_ndx
;
7751 switch (rp
->r_offset
/ eh_addr_size
% 3)
7754 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7755 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7758 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7759 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7762 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7763 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7777 ia64_process_unwind (Filedata
* filedata
)
7779 Elf_Internal_Shdr
* sec
;
7780 Elf_Internal_Shdr
* unwsec
= NULL
;
7781 Elf_Internal_Shdr
* strsec
;
7782 unsigned long i
, unwcount
= 0, unwstart
= 0;
7783 struct ia64_unw_aux_info aux
;
7784 bfd_boolean res
= TRUE
;
7786 memset (& aux
, 0, sizeof (aux
));
7788 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7790 if (sec
->sh_type
== SHT_SYMTAB
7791 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7793 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7795 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7796 if (aux
.strtab
!= NULL
)
7798 error (_("Multiple auxillary string tables encountered\n"));
7802 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7805 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7807 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7812 printf (_("\nThere are no unwind sections in this file.\n"));
7814 while (unwcount
-- > 0)
7819 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7820 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7821 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7826 /* We have already counted the number of SHT_IA64_UNWIND
7827 sections so the loop above should never fail. */
7828 assert (unwsec
!= NULL
);
7831 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7833 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7835 /* We need to find which section group it is in. */
7836 struct group_list
* g
;
7838 if (section_headers_groups
== NULL
7839 || section_headers_groups
[i
] == NULL
)
7840 i
= filedata
->file_header
.e_shnum
;
7843 g
= section_headers_groups
[i
]->root
;
7845 for (; g
!= NULL
; g
= g
->next
)
7847 sec
= filedata
->section_headers
+ g
->section_index
;
7849 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7854 i
= filedata
->file_header
.e_shnum
;
7857 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7859 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7860 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7861 suffix
= SECTION_NAME (unwsec
) + len
;
7862 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7864 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7865 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7870 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7871 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7872 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7873 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7875 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7876 suffix
= SECTION_NAME (unwsec
) + len
;
7877 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7879 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7880 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7884 if (i
== filedata
->file_header
.e_shnum
)
7886 printf (_("\nCould not find unwind info section for "));
7888 if (filedata
->string_table
== NULL
)
7889 printf ("%d", unwsec
->sh_name
);
7891 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7895 aux
.info_addr
= sec
->sh_addr
;
7896 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7899 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7901 printf (_("\nUnwind section "));
7903 if (filedata
->string_table
== NULL
)
7904 printf ("%d", unwsec
->sh_name
);
7906 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7908 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7909 (unsigned long) unwsec
->sh_offset
,
7910 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7912 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7913 && aux
.table_len
> 0)
7914 dump_ia64_unwind (filedata
, & aux
);
7917 free ((char *) aux
.table
);
7919 free ((char *) aux
.info
);
7928 free ((char *) aux
.strtab
);
7933 struct hppa_unw_table_entry
7935 struct absaddr start
;
7937 unsigned int Cannot_unwind
:1; /* 0 */
7938 unsigned int Millicode
:1; /* 1 */
7939 unsigned int Millicode_save_sr0
:1; /* 2 */
7940 unsigned int Region_description
:2; /* 3..4 */
7941 unsigned int reserved1
:1; /* 5 */
7942 unsigned int Entry_SR
:1; /* 6 */
7943 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7944 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7945 unsigned int Args_stored
:1; /* 16 */
7946 unsigned int Variable_Frame
:1; /* 17 */
7947 unsigned int Separate_Package_Body
:1; /* 18 */
7948 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7949 unsigned int Stack_Overflow_Check
:1; /* 20 */
7950 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7951 unsigned int Ada_Region
:1; /* 22 */
7952 unsigned int cxx_info
:1; /* 23 */
7953 unsigned int cxx_try_catch
:1; /* 24 */
7954 unsigned int sched_entry_seq
:1; /* 25 */
7955 unsigned int reserved2
:1; /* 26 */
7956 unsigned int Save_SP
:1; /* 27 */
7957 unsigned int Save_RP
:1; /* 28 */
7958 unsigned int Save_MRP_in_frame
:1; /* 29 */
7959 unsigned int extn_ptr_defined
:1; /* 30 */
7960 unsigned int Cleanup_defined
:1; /* 31 */
7962 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7963 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7964 unsigned int Large_frame
:1; /* 2 */
7965 unsigned int Pseudo_SP_Set
:1; /* 3 */
7966 unsigned int reserved4
:1; /* 4 */
7967 unsigned int Total_frame_size
:27; /* 5..31 */
7970 struct hppa_unw_aux_info
7972 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7973 unsigned long table_len
; /* Length of unwind table. */
7974 bfd_vma seg_base
; /* Starting address of segment. */
7975 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7976 unsigned long nsyms
; /* Number of symbols. */
7977 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7978 unsigned long nfuns
; /* Number of entries in funtab. */
7979 char * strtab
; /* The string table. */
7980 unsigned long strtab_size
; /* Size of string table. */
7984 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7986 struct hppa_unw_table_entry
* tp
;
7987 unsigned long j
, nfuns
;
7988 bfd_boolean res
= TRUE
;
7990 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7991 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7992 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7993 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7995 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7997 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8000 const char * procname
;
8002 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8003 aux
->strtab_size
, tp
->start
, &procname
,
8006 fputs ("\n<", stdout
);
8010 fputs (procname
, stdout
);
8013 printf ("+%lx", (unsigned long) offset
);
8016 fputs (">: [", stdout
);
8017 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8018 fputc ('-', stdout
);
8019 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8022 #define PF(_m) if (tp->_m) printf (#_m " ");
8023 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8026 PF(Millicode_save_sr0
);
8027 /* PV(Region_description); */
8033 PF(Separate_Package_Body
);
8034 PF(Frame_Extension_Millicode
);
8035 PF(Stack_Overflow_Check
);
8036 PF(Two_Instruction_SP_Increment
);
8040 PF(sched_entry_seq
);
8043 PF(Save_MRP_in_frame
);
8044 PF(extn_ptr_defined
);
8045 PF(Cleanup_defined
);
8046 PF(MPE_XL_interrupt_marker
);
8047 PF(HP_UX_interrupt_marker
);
8050 PV(Total_frame_size
);
8063 slurp_hppa_unwind_table (Filedata
* filedata
,
8064 struct hppa_unw_aux_info
* aux
,
8065 Elf_Internal_Shdr
* sec
)
8067 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8068 Elf_Internal_Phdr
* seg
;
8069 struct hppa_unw_table_entry
* tep
;
8070 Elf_Internal_Shdr
* relsec
;
8071 Elf_Internal_Rela
* rela
;
8072 Elf_Internal_Rela
* rp
;
8073 unsigned char * table
;
8075 Elf_Internal_Sym
* sym
;
8076 const char * relname
;
8078 /* First, find the starting address of the segment that includes
8080 if (filedata
->file_header
.e_phnum
)
8082 if (! get_program_headers (filedata
))
8085 for (seg
= filedata
->program_headers
;
8086 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8089 if (seg
->p_type
!= PT_LOAD
)
8092 if (sec
->sh_addr
>= seg
->p_vaddr
8093 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8095 aux
->seg_base
= seg
->p_vaddr
;
8101 /* Second, build the unwind table from the contents of the unwind
8103 size
= sec
->sh_size
;
8104 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8110 nentries
= size
/ unw_ent_size
;
8111 size
= unw_ent_size
* nentries
;
8113 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8114 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8116 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8118 unsigned int tmp1
, tmp2
;
8120 tep
->start
.section
= SHN_UNDEF
;
8121 tep
->end
.section
= SHN_UNDEF
;
8123 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8124 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8125 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8126 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8128 tep
->start
.offset
+= aux
->seg_base
;
8129 tep
->end
.offset
+= aux
->seg_base
;
8131 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8132 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8133 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8134 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8135 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8136 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8137 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8138 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8139 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8140 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8141 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8142 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8143 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8144 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8145 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8146 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8147 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8148 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8149 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8150 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8151 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8152 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8153 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8154 tep
->Cleanup_defined
= tmp1
& 0x1;
8156 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8157 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8158 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8159 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8160 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8161 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8165 /* Third, apply any relocations to the unwind table. */
8166 for (relsec
= filedata
->section_headers
;
8167 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8170 if (relsec
->sh_type
!= SHT_RELA
8171 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8172 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8175 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8179 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8181 unsigned int sym_ndx
;
8182 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8183 relname
= elf_hppa_reloc_type (r_type
);
8185 if (relname
== NULL
)
8187 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8191 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8192 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8194 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8198 i
= rp
->r_offset
/ unw_ent_size
;
8199 if (i
>= aux
->table_len
)
8201 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8205 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8206 if (sym_ndx
>= aux
->nsyms
)
8208 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8212 sym
= aux
->symtab
+ sym_ndx
;
8214 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8217 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8218 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8221 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8222 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8232 aux
->table_len
= nentries
;
8238 hppa_process_unwind (Filedata
* filedata
)
8240 struct hppa_unw_aux_info aux
;
8241 Elf_Internal_Shdr
* unwsec
= NULL
;
8242 Elf_Internal_Shdr
* strsec
;
8243 Elf_Internal_Shdr
* sec
;
8245 bfd_boolean res
= TRUE
;
8247 if (filedata
->string_table
== NULL
)
8250 memset (& aux
, 0, sizeof (aux
));
8252 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8254 if (sec
->sh_type
== SHT_SYMTAB
8255 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8257 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8259 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8260 if (aux
.strtab
!= NULL
)
8262 error (_("Multiple auxillary string tables encountered\n"));
8266 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8269 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8271 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8276 printf (_("\nThere are no unwind sections in this file.\n"));
8278 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8280 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8282 unsigned long num_unwind
= sec
->sh_size
/ 16;
8284 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8285 "contains %lu entry:\n",
8286 "\nUnwind section '%s' at offset 0x%lx "
8287 "contains %lu entries:\n",
8289 printable_section_name (filedata
, sec
),
8290 (unsigned long) sec
->sh_offset
,
8293 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8296 if (res
&& aux
.table_len
> 0)
8298 if (! dump_hppa_unwind (filedata
, &aux
))
8303 free ((char *) aux
.table
);
8311 free ((char *) aux
.strtab
);
8318 unsigned char * data
; /* The unwind data. */
8319 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8320 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8321 unsigned long nrelas
; /* The number of relocations. */
8322 unsigned int rel_type
; /* REL or RELA ? */
8323 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8326 struct arm_unw_aux_info
8328 Filedata
* filedata
; /* The file containing the unwind sections. */
8329 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8330 unsigned long nsyms
; /* Number of symbols. */
8331 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8332 unsigned long nfuns
; /* Number of these symbols. */
8333 char * strtab
; /* The file's string table. */
8334 unsigned long strtab_size
; /* Size of string table. */
8338 arm_print_vma_and_name (Filedata
* filedata
,
8339 struct arm_unw_aux_info
* aux
,
8341 struct absaddr addr
)
8343 const char *procname
;
8346 if (addr
.section
== SHN_UNDEF
)
8349 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8350 aux
->strtab_size
, addr
, &procname
,
8353 print_vma (fn
, PREFIX_HEX
);
8357 fputs (" <", stdout
);
8358 fputs (procname
, stdout
);
8361 printf ("+0x%lx", (unsigned long) sym_offset
);
8362 fputc ('>', stdout
);
8369 arm_free_section (struct arm_section
*arm_sec
)
8371 if (arm_sec
->data
!= NULL
)
8372 free (arm_sec
->data
);
8374 if (arm_sec
->rela
!= NULL
)
8375 free (arm_sec
->rela
);
8378 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8379 cached section and install SEC instead.
8380 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8381 and return its valued in * WORDP, relocating if necessary.
8382 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8383 relocation's offset in ADDR.
8384 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8385 into the string table of the symbol associated with the reloc. If no
8386 reloc was applied store -1 there.
8387 5) Return TRUE upon success, FALSE otherwise. */
8390 get_unwind_section_word (Filedata
* filedata
,
8391 struct arm_unw_aux_info
* aux
,
8392 struct arm_section
* arm_sec
,
8393 Elf_Internal_Shdr
* sec
,
8394 bfd_vma word_offset
,
8395 unsigned int * wordp
,
8396 struct absaddr
* addr
,
8399 Elf_Internal_Rela
*rp
;
8400 Elf_Internal_Sym
*sym
;
8401 const char * relname
;
8403 bfd_boolean wrapped
;
8405 if (sec
== NULL
|| arm_sec
== NULL
)
8408 addr
->section
= SHN_UNDEF
;
8411 if (sym_name
!= NULL
)
8412 *sym_name
= (bfd_vma
) -1;
8414 /* If necessary, update the section cache. */
8415 if (sec
!= arm_sec
->sec
)
8417 Elf_Internal_Shdr
*relsec
;
8419 arm_free_section (arm_sec
);
8422 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8423 sec
->sh_size
, _("unwind data"));
8424 arm_sec
->rela
= NULL
;
8425 arm_sec
->nrelas
= 0;
8427 for (relsec
= filedata
->section_headers
;
8428 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8431 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8432 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8433 /* PR 15745: Check the section type as well. */
8434 || (relsec
->sh_type
!= SHT_REL
8435 && relsec
->sh_type
!= SHT_RELA
))
8438 arm_sec
->rel_type
= relsec
->sh_type
;
8439 if (relsec
->sh_type
== SHT_REL
)
8441 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8443 & arm_sec
->rela
, & arm_sec
->nrelas
))
8446 else /* relsec->sh_type == SHT_RELA */
8448 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8450 & arm_sec
->rela
, & arm_sec
->nrelas
))
8456 arm_sec
->next_rela
= arm_sec
->rela
;
8459 /* If there is no unwind data we can do nothing. */
8460 if (arm_sec
->data
== NULL
)
8463 /* If the offset is invalid then fail. */
8464 if (/* PR 21343 *//* PR 18879 */
8466 || word_offset
> (sec
->sh_size
- 4)
8467 || ((bfd_signed_vma
) word_offset
) < 0)
8470 /* Get the word at the required offset. */
8471 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8473 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8474 if (arm_sec
->rela
== NULL
)
8480 /* Look through the relocs to find the one that applies to the provided offset. */
8482 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8484 bfd_vma prelval
, offset
;
8486 if (rp
->r_offset
> word_offset
&& !wrapped
)
8491 if (rp
->r_offset
> word_offset
)
8494 if (rp
->r_offset
& 3)
8496 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8497 (unsigned long) rp
->r_offset
);
8501 if (rp
->r_offset
< word_offset
)
8504 /* PR 17531: file: 027-161405-0.004 */
8505 if (aux
->symtab
== NULL
)
8508 if (arm_sec
->rel_type
== SHT_REL
)
8510 offset
= word
& 0x7fffffff;
8511 if (offset
& 0x40000000)
8512 offset
|= ~ (bfd_vma
) 0x7fffffff;
8514 else if (arm_sec
->rel_type
== SHT_RELA
)
8515 offset
= rp
->r_addend
;
8518 error (_("Unknown section relocation type %d encountered\n"),
8523 /* PR 17531 file: 027-1241568-0.004. */
8524 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8526 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8527 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8531 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8532 offset
+= sym
->st_value
;
8533 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8535 /* Check that we are processing the expected reloc type. */
8536 if (filedata
->file_header
.e_machine
== EM_ARM
)
8538 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8539 if (relname
== NULL
)
8541 warn (_("Skipping unknown ARM relocation type: %d\n"),
8542 (int) ELF32_R_TYPE (rp
->r_info
));
8546 if (streq (relname
, "R_ARM_NONE"))
8549 if (! streq (relname
, "R_ARM_PREL31"))
8551 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8555 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8557 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8558 if (relname
== NULL
)
8560 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8561 (int) ELF32_R_TYPE (rp
->r_info
));
8565 if (streq (relname
, "R_C6000_NONE"))
8568 if (! streq (relname
, "R_C6000_PREL31"))
8570 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8578 /* This function currently only supports ARM and TI unwinders. */
8579 warn (_("Only TI and ARM unwinders are currently supported\n"));
8583 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8584 addr
->section
= sym
->st_shndx
;
8585 addr
->offset
= offset
;
8588 * sym_name
= sym
->st_name
;
8593 arm_sec
->next_rela
= rp
;
8598 static const char *tic6x_unwind_regnames
[16] =
8600 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8601 "A14", "A13", "A12", "A11", "A10",
8602 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8606 decode_tic6x_unwind_regmask (unsigned int mask
)
8610 for (i
= 12; mask
; mask
>>= 1, i
--)
8614 fputs (tic6x_unwind_regnames
[i
], stdout
);
8616 fputs (", ", stdout
);
8622 if (remaining == 0 && more_words) \
8625 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8626 data_offset, & word, & addr, NULL)) \
8632 #define GET_OP(OP) \
8637 (OP) = word >> 24; \
8642 printf (_("[Truncated opcode]\n")); \
8645 printf ("0x%02x ", OP)
8648 decode_arm_unwind_bytecode (Filedata
* filedata
,
8649 struct arm_unw_aux_info
* aux
,
8651 unsigned int remaining
,
8652 unsigned int more_words
,
8653 bfd_vma data_offset
,
8654 Elf_Internal_Shdr
* data_sec
,
8655 struct arm_section
* data_arm_sec
)
8657 struct absaddr addr
;
8658 bfd_boolean res
= TRUE
;
8660 /* Decode the unwinding instructions. */
8663 unsigned int op
, op2
;
8672 printf (" 0x%02x ", op
);
8674 if ((op
& 0xc0) == 0x00)
8676 int offset
= ((op
& 0x3f) << 2) + 4;
8678 printf (" vsp = vsp + %d", offset
);
8680 else if ((op
& 0xc0) == 0x40)
8682 int offset
= ((op
& 0x3f) << 2) + 4;
8684 printf (" vsp = vsp - %d", offset
);
8686 else if ((op
& 0xf0) == 0x80)
8689 if (op
== 0x80 && op2
== 0)
8690 printf (_("Refuse to unwind"));
8693 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8694 bfd_boolean first
= TRUE
;
8698 for (i
= 0; i
< 12; i
++)
8699 if (mask
& (1 << i
))
8705 printf ("r%d", 4 + i
);
8710 else if ((op
& 0xf0) == 0x90)
8712 if (op
== 0x9d || op
== 0x9f)
8713 printf (_(" [Reserved]"));
8715 printf (" vsp = r%d", op
& 0x0f);
8717 else if ((op
& 0xf0) == 0xa0)
8719 int end
= 4 + (op
& 0x07);
8720 bfd_boolean first
= TRUE
;
8724 for (i
= 4; i
<= end
; i
++)
8740 else if (op
== 0xb0)
8741 printf (_(" finish"));
8742 else if (op
== 0xb1)
8745 if (op2
== 0 || (op2
& 0xf0) != 0)
8746 printf (_("[Spare]"));
8749 unsigned int mask
= op2
& 0x0f;
8750 bfd_boolean first
= TRUE
;
8754 for (i
= 0; i
< 12; i
++)
8755 if (mask
& (1 << i
))
8766 else if (op
== 0xb2)
8768 unsigned char buf
[9];
8769 unsigned int i
, len
;
8770 unsigned long offset
;
8772 for (i
= 0; i
< sizeof (buf
); i
++)
8775 if ((buf
[i
] & 0x80) == 0)
8778 if (i
== sizeof (buf
))
8780 error (_("corrupt change to vsp"));
8785 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8786 assert (len
== i
+ 1);
8787 offset
= offset
* 4 + 0x204;
8788 printf ("vsp = vsp + %ld", offset
);
8791 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8793 unsigned int first
, last
;
8800 printf ("pop {D%d", first
);
8802 printf ("-D%d", first
+ last
);
8805 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8807 unsigned int count
= op
& 0x07;
8811 printf ("-D%d", 8 + count
);
8814 else if (op
>= 0xc0 && op
<= 0xc5)
8816 unsigned int count
= op
& 0x07;
8818 printf (" pop {wR10");
8820 printf ("-wR%d", 10 + count
);
8823 else if (op
== 0xc6)
8825 unsigned int first
, last
;
8830 printf ("pop {wR%d", first
);
8832 printf ("-wR%d", first
+ last
);
8835 else if (op
== 0xc7)
8838 if (op2
== 0 || (op2
& 0xf0) != 0)
8839 printf (_("[Spare]"));
8842 unsigned int mask
= op2
& 0x0f;
8843 bfd_boolean first
= TRUE
;
8847 for (i
= 0; i
< 4; i
++)
8848 if (mask
& (1 << i
))
8854 printf ("wCGR%d", i
);
8861 printf (_(" [unsupported opcode]"));
8872 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8873 struct arm_unw_aux_info
* aux
,
8875 unsigned int remaining
,
8876 unsigned int more_words
,
8877 bfd_vma data_offset
,
8878 Elf_Internal_Shdr
* data_sec
,
8879 struct arm_section
* data_arm_sec
)
8881 struct absaddr addr
;
8883 /* Decode the unwinding instructions. */
8886 unsigned int op
, op2
;
8895 printf (" 0x%02x ", op
);
8897 if ((op
& 0xc0) == 0x00)
8899 int offset
= ((op
& 0x3f) << 3) + 8;
8900 printf (" sp = sp + %d", offset
);
8902 else if ((op
& 0xc0) == 0x80)
8905 if (op
== 0x80 && op2
== 0)
8906 printf (_("Refuse to unwind"));
8909 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8911 printf ("pop compact {");
8915 decode_tic6x_unwind_regmask (mask
);
8919 else if ((op
& 0xf0) == 0xc0)
8927 unsigned int offset
;
8931 /* Scan entire instruction first so that GET_OP output is not
8932 interleaved with disassembly. */
8934 for (i
= 0; nregs
< (op
& 0xf); i
++)
8940 regpos
[nregs
].offset
= i
* 2;
8941 regpos
[nregs
].reg
= reg
;
8948 regpos
[nregs
].offset
= i
* 2 + 1;
8949 regpos
[nregs
].reg
= reg
;
8954 printf (_("pop frame {"));
8957 printf (_("*corrupt* - no registers specified"));
8962 for (i
= i
* 2; i
> 0; i
--)
8964 if (regpos
[reg
].offset
== i
- 1)
8966 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8973 fputs (name
, stdout
);
8981 else if (op
== 0xd0)
8982 printf (" MOV FP, SP");
8983 else if (op
== 0xd1)
8984 printf (" __c6xabi_pop_rts");
8985 else if (op
== 0xd2)
8987 unsigned char buf
[9];
8988 unsigned int i
, len
;
8989 unsigned long offset
;
8991 for (i
= 0; i
< sizeof (buf
); i
++)
8994 if ((buf
[i
] & 0x80) == 0)
8997 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8998 if (i
== sizeof (buf
))
9000 warn (_("Corrupt stack pointer adjustment detected\n"));
9004 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
9005 assert (len
== i
+ 1);
9006 offset
= offset
* 8 + 0x408;
9007 printf (_("sp = sp + %ld"), offset
);
9009 else if ((op
& 0xf0) == 0xe0)
9011 if ((op
& 0x0f) == 7)
9014 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9018 printf (_(" [unsupported opcode]"));
9027 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9031 offset
= word
& 0x7fffffff;
9032 if (offset
& 0x40000000)
9033 offset
|= ~ (bfd_vma
) 0x7fffffff;
9035 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9038 return offset
+ where
;
9042 decode_arm_unwind (Filedata
* filedata
,
9043 struct arm_unw_aux_info
* aux
,
9045 unsigned int remaining
,
9046 bfd_vma data_offset
,
9047 Elf_Internal_Shdr
* data_sec
,
9048 struct arm_section
* data_arm_sec
)
9051 unsigned int more_words
= 0;
9052 struct absaddr addr
;
9053 bfd_vma sym_name
= (bfd_vma
) -1;
9054 bfd_boolean res
= TRUE
;
9058 /* Fetch the first word.
9059 Note - when decoding an object file the address extracted
9060 here will always be 0. So we also pass in the sym_name
9061 parameter so that we can find the symbol associated with
9062 the personality routine. */
9063 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9064 & word
, & addr
, & sym_name
))
9071 addr
.section
= SHN_UNDEF
;
9075 if ((word
& 0x80000000) == 0)
9077 /* Expand prel31 for personality routine. */
9079 const char *procname
;
9081 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9082 printf (_(" Personality routine: "));
9084 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9085 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9087 procname
= aux
->strtab
+ sym_name
;
9088 print_vma (fn
, PREFIX_HEX
);
9091 fputs (" <", stdout
);
9092 fputs (procname
, stdout
);
9093 fputc ('>', stdout
);
9097 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9098 fputc ('\n', stdout
);
9100 /* The GCC personality routines use the standard compact
9101 encoding, starting with one byte giving the number of
9103 if (procname
!= NULL
9104 && (const_strneq (procname
, "__gcc_personality_v0")
9105 || const_strneq (procname
, "__gxx_personality_v0")
9106 || const_strneq (procname
, "__gcj_personality_v0")
9107 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9114 printf (_(" [Truncated data]\n"));
9117 more_words
= word
>> 24;
9127 /* ARM EHABI Section 6.3:
9129 An exception-handling table entry for the compact model looks like:
9133 1 0 index Data for personalityRoutine[index] */
9135 if (filedata
->file_header
.e_machine
== EM_ARM
9136 && (word
& 0x70000000))
9138 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9142 per_index
= (word
>> 24) & 0x7f;
9143 printf (_(" Compact model index: %d\n"), per_index
);
9150 else if (per_index
< 3)
9152 more_words
= (word
>> 16) & 0xff;
9158 switch (filedata
->file_header
.e_machine
)
9163 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9164 data_offset
, data_sec
, data_arm_sec
))
9169 warn (_("Unknown ARM compact model index encountered\n"));
9170 printf (_(" [reserved]\n"));
9178 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9179 data_offset
, data_sec
, data_arm_sec
))
9182 else if (per_index
< 5)
9184 if (((word
>> 17) & 0x7f) == 0x7f)
9185 printf (_(" Restore stack from frame pointer\n"));
9187 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9188 printf (_(" Registers restored: "));
9190 printf (" (compact) ");
9191 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9193 printf (_(" Return register: %s\n"),
9194 tic6x_unwind_regnames
[word
& 0xf]);
9197 printf (_(" [reserved (%d)]\n"), per_index
);
9201 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9202 filedata
->file_header
.e_machine
);
9206 /* Decode the descriptors. Not implemented. */
9212 dump_arm_unwind (Filedata
* filedata
,
9213 struct arm_unw_aux_info
* aux
,
9214 Elf_Internal_Shdr
* exidx_sec
)
9216 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9217 unsigned int i
, exidx_len
;
9218 unsigned long j
, nfuns
;
9219 bfd_boolean res
= TRUE
;
9221 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9222 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9223 exidx_len
= exidx_sec
->sh_size
/ 8;
9225 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9226 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9227 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9228 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9230 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9232 for (i
= 0; i
< exidx_len
; i
++)
9234 unsigned int exidx_fn
, exidx_entry
;
9235 struct absaddr fn_addr
, entry_addr
;
9238 fputc ('\n', stdout
);
9240 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9241 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9242 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9243 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9246 arm_free_section (& exidx_arm_sec
);
9247 arm_free_section (& extab_arm_sec
);
9251 /* ARM EHABI, Section 5:
9252 An index table entry consists of 2 words.
9253 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9254 if (exidx_fn
& 0x80000000)
9256 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9260 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9262 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9263 fputs (": ", stdout
);
9265 if (exidx_entry
== 1)
9267 print_vma (exidx_entry
, PREFIX_HEX
);
9268 fputs (" [cantunwind]\n", stdout
);
9270 else if (exidx_entry
& 0x80000000)
9272 print_vma (exidx_entry
, PREFIX_HEX
);
9273 fputc ('\n', stdout
);
9274 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9278 bfd_vma table
, table_offset
= 0;
9279 Elf_Internal_Shdr
*table_sec
;
9281 fputs ("@", stdout
);
9282 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9283 print_vma (table
, PREFIX_HEX
);
9286 /* Locate the matching .ARM.extab. */
9287 if (entry_addr
.section
!= SHN_UNDEF
9288 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9290 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9291 table_offset
= entry_addr
.offset
;
9293 if (table_offset
> table_sec
->sh_size
9294 || ((bfd_signed_vma
) table_offset
) < 0)
9296 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9297 (unsigned long) table_offset
,
9298 printable_section_name (filedata
, table_sec
));
9305 table_sec
= find_section_by_address (filedata
, table
);
9306 if (table_sec
!= NULL
)
9307 table_offset
= table
- table_sec
->sh_addr
;
9310 if (table_sec
== NULL
)
9312 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9313 (unsigned long) table
);
9318 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9327 arm_free_section (&exidx_arm_sec
);
9328 arm_free_section (&extab_arm_sec
);
9333 /* Used for both ARM and C6X unwinding tables. */
9336 arm_process_unwind (Filedata
* filedata
)
9338 struct arm_unw_aux_info aux
;
9339 Elf_Internal_Shdr
*unwsec
= NULL
;
9340 Elf_Internal_Shdr
*strsec
;
9341 Elf_Internal_Shdr
*sec
;
9343 unsigned int sec_type
;
9344 bfd_boolean res
= TRUE
;
9346 switch (filedata
->file_header
.e_machine
)
9349 sec_type
= SHT_ARM_EXIDX
;
9353 sec_type
= SHT_C6000_UNWIND
;
9357 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9358 filedata
->file_header
.e_machine
);
9362 if (filedata
->string_table
== NULL
)
9365 memset (& aux
, 0, sizeof (aux
));
9366 aux
.filedata
= filedata
;
9368 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9370 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9372 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9374 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9376 /* PR binutils/17531 file: 011-12666-0.004. */
9377 if (aux
.strtab
!= NULL
)
9379 error (_("Multiple string tables found in file.\n"));
9383 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9384 1, strsec
->sh_size
, _("string table"));
9385 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9387 else if (sec
->sh_type
== sec_type
)
9392 printf (_("\nThere are no unwind sections in this file.\n"));
9394 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9396 if (sec
->sh_type
== sec_type
)
9398 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9399 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9400 "contains %lu entry:\n",
9401 "\nUnwind section '%s' at offset 0x%lx "
9402 "contains %lu entries:\n",
9404 printable_section_name (filedata
, sec
),
9405 (unsigned long) sec
->sh_offset
,
9408 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9416 free ((char *) aux
.strtab
);
9422 process_unwind (Filedata
* filedata
)
9424 struct unwind_handler
9426 unsigned int machtype
;
9427 bfd_boolean (* handler
)(Filedata
*);
9430 { EM_ARM
, arm_process_unwind
},
9431 { EM_IA_64
, ia64_process_unwind
},
9432 { EM_PARISC
, hppa_process_unwind
},
9433 { EM_TI_C6000
, arm_process_unwind
},
9441 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9442 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9443 return handlers
[i
].handler (filedata
);
9445 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9446 get_machine_name (filedata
->file_header
.e_machine
));
9451 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9453 switch (entry
->d_tag
)
9455 case DT_AARCH64_BTI_PLT
:
9456 case DT_AARCH64_PAC_PLT
:
9459 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9466 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9468 switch (entry
->d_tag
)
9471 if (entry
->d_un
.d_val
== 0)
9475 static const char * opts
[] =
9477 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9478 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9479 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9480 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9484 bfd_boolean first
= TRUE
;
9486 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9487 if (entry
->d_un
.d_val
& (1 << cnt
))
9489 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9495 case DT_MIPS_IVERSION
:
9496 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9497 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9501 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9502 /* Note: coded this way so that there is a single string for translation. */
9503 printf (_("<corrupt: %s>"), buf
);
9507 case DT_MIPS_TIME_STAMP
:
9511 time_t atime
= entry
->d_un
.d_val
;
9513 tmp
= gmtime (&atime
);
9514 /* PR 17531: file: 6accc532. */
9516 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9518 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9519 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9520 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9521 printf (_("Time Stamp: %s"), timebuf
);
9525 case DT_MIPS_RLD_VERSION
:
9526 case DT_MIPS_LOCAL_GOTNO
:
9527 case DT_MIPS_CONFLICTNO
:
9528 case DT_MIPS_LIBLISTNO
:
9529 case DT_MIPS_SYMTABNO
:
9530 case DT_MIPS_UNREFEXTNO
:
9531 case DT_MIPS_HIPAGENO
:
9532 case DT_MIPS_DELTA_CLASS_NO
:
9533 case DT_MIPS_DELTA_INSTANCE_NO
:
9534 case DT_MIPS_DELTA_RELOC_NO
:
9535 case DT_MIPS_DELTA_SYM_NO
:
9536 case DT_MIPS_DELTA_CLASSSYM_NO
:
9537 case DT_MIPS_COMPACT_SIZE
:
9538 print_vma (entry
->d_un
.d_val
, DEC
);
9542 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9543 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9544 /* Falls through. */
9547 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9553 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9555 switch (entry
->d_tag
)
9557 case DT_HP_DLD_FLAGS
:
9566 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9567 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9568 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9569 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9570 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9571 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9572 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9573 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9574 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9575 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9576 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9577 { DT_HP_GST
, "HP_GST" },
9578 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9579 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9580 { DT_HP_NODELETE
, "HP_NODELETE" },
9581 { DT_HP_GROUP
, "HP_GROUP" },
9582 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9584 bfd_boolean first
= TRUE
;
9586 bfd_vma val
= entry
->d_un
.d_val
;
9588 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9589 if (val
& flags
[cnt
].bit
)
9593 fputs (flags
[cnt
].str
, stdout
);
9595 val
^= flags
[cnt
].bit
;
9598 if (val
!= 0 || first
)
9602 print_vma (val
, HEX
);
9608 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9616 /* VMS vs Unix time offset and factor. */
9618 #define VMS_EPOCH_OFFSET 35067168000000000LL
9619 #define VMS_GRANULARITY_FACTOR 10000000
9621 /* Display a VMS time in a human readable format. */
9624 print_vms_time (bfd_int64_t vmstime
)
9629 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9630 tm
= gmtime (&unxtime
);
9631 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9632 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9633 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9638 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9640 switch (entry
->d_tag
)
9642 case DT_IA_64_PLT_RESERVE
:
9643 /* First 3 slots reserved. */
9644 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9646 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9649 case DT_IA_64_VMS_LINKTIME
:
9651 print_vms_time (entry
->d_un
.d_val
);
9655 case DT_IA_64_VMS_LNKFLAGS
:
9656 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9657 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9658 printf (" CALL_DEBUG");
9659 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9660 printf (" NOP0BUFS");
9661 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9662 printf (" P0IMAGE");
9663 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9664 printf (" MKTHREADS");
9665 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9666 printf (" UPCALLS");
9667 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9669 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9670 printf (" INITIALIZE");
9671 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9673 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9674 printf (" EXE_INIT");
9675 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9676 printf (" TBK_IN_IMG");
9677 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9678 printf (" DBG_IN_IMG");
9679 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9680 printf (" TBK_IN_DSF");
9681 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9682 printf (" DBG_IN_DSF");
9683 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9684 printf (" SIGNATURES");
9685 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9686 printf (" REL_SEG_OFF");
9690 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9697 get_32bit_dynamic_section (Filedata
* filedata
)
9699 Elf32_External_Dyn
* edyn
;
9700 Elf32_External_Dyn
* ext
;
9701 Elf_Internal_Dyn
* entry
;
9703 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9704 dynamic_size
, _("dynamic section"));
9708 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9709 might not have the luxury of section headers. Look for the DT_NULL
9710 terminator to determine the number of entries. */
9711 for (ext
= edyn
, dynamic_nent
= 0;
9712 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9716 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9720 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9722 if (dynamic_section
== NULL
)
9724 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9725 (unsigned long) dynamic_nent
);
9730 for (ext
= edyn
, entry
= dynamic_section
;
9731 entry
< dynamic_section
+ dynamic_nent
;
9734 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9735 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9744 get_64bit_dynamic_section (Filedata
* filedata
)
9746 Elf64_External_Dyn
* edyn
;
9747 Elf64_External_Dyn
* ext
;
9748 Elf_Internal_Dyn
* entry
;
9750 /* Read in the data. */
9751 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9752 dynamic_size
, _("dynamic section"));
9756 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9757 might not have the luxury of section headers. Look for the DT_NULL
9758 terminator to determine the number of entries. */
9759 for (ext
= edyn
, dynamic_nent
= 0;
9760 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9761 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9765 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9769 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9771 if (dynamic_section
== NULL
)
9773 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9774 (unsigned long) dynamic_nent
);
9779 /* Convert from external to internal formats. */
9780 for (ext
= edyn
, entry
= dynamic_section
;
9781 entry
< dynamic_section
+ dynamic_nent
;
9784 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9785 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9794 print_dynamic_flags (bfd_vma flags
)
9796 bfd_boolean first
= TRUE
;
9802 flag
= flags
& - flags
;
9812 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9813 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9814 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9815 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9816 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9817 default: fputs (_("unknown"), stdout
); break;
9823 /* Parse and display the contents of the dynamic section. */
9826 process_dynamic_section (Filedata
* filedata
)
9828 Elf_Internal_Dyn
* entry
;
9830 if (dynamic_size
== 0)
9833 printf (_("\nThere is no dynamic section in this file.\n"));
9840 if (! get_32bit_dynamic_section (filedata
))
9845 if (! get_64bit_dynamic_section (filedata
))
9849 /* Find the appropriate symbol table. */
9850 if (dynamic_symbols
== NULL
)
9852 for (entry
= dynamic_section
;
9853 entry
< dynamic_section
+ dynamic_nent
;
9856 Elf_Internal_Shdr section
;
9858 if (entry
->d_tag
!= DT_SYMTAB
)
9861 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9863 /* Since we do not know how big the symbol table is,
9864 we default to reading in the entire file (!) and
9865 processing that. This is overkill, I know, but it
9867 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9868 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9870 /* See PR 21379 for a reproducer. */
9871 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9875 if (archive_file_offset
!= 0)
9876 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9878 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9881 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9883 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9884 section
.sh_name
= filedata
->string_table_length
;
9886 if (dynamic_symbols
!= NULL
)
9888 error (_("Multiple dynamic symbol table sections found\n"));
9889 free (dynamic_symbols
);
9891 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9892 if (num_dynamic_syms
< 1)
9894 error (_("Unable to determine the number of symbols to load\n"));
9900 /* Similarly find a string table. */
9901 if (dynamic_strings
== NULL
)
9903 for (entry
= dynamic_section
;
9904 entry
< dynamic_section
+ dynamic_nent
;
9907 unsigned long offset
;
9910 if (entry
->d_tag
!= DT_STRTAB
)
9913 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9915 /* Since we do not know how big the string table is,
9916 we default to reading in the entire file (!) and
9917 processing that. This is overkill, I know, but it
9920 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9922 if (archive_file_offset
!= 0)
9923 str_tab_len
= archive_file_size
- offset
;
9925 str_tab_len
= filedata
->file_size
- offset
;
9927 if (str_tab_len
< 1)
9930 (_("Unable to determine the length of the dynamic string table\n"));
9934 if (dynamic_strings
!= NULL
)
9936 error (_("Multiple dynamic string tables found\n"));
9937 free (dynamic_strings
);
9940 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9942 _("dynamic string table"));
9943 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9947 /* And find the syminfo section if available. */
9948 if (dynamic_syminfo
== NULL
)
9950 unsigned long syminsz
= 0;
9952 for (entry
= dynamic_section
;
9953 entry
< dynamic_section
+ dynamic_nent
;
9956 if (entry
->d_tag
== DT_SYMINENT
)
9958 /* Note: these braces are necessary to avoid a syntax
9959 error from the SunOS4 C compiler. */
9960 /* PR binutils/17531: A corrupt file can trigger this test.
9961 So do not use an assert, instead generate an error message. */
9962 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9963 error (_("Bad value (%d) for SYMINENT entry\n"),
9964 (int) entry
->d_un
.d_val
);
9966 else if (entry
->d_tag
== DT_SYMINSZ
)
9967 syminsz
= entry
->d_un
.d_val
;
9968 else if (entry
->d_tag
== DT_SYMINFO
)
9969 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9973 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9975 Elf_External_Syminfo
* extsyminfo
;
9976 Elf_External_Syminfo
* extsym
;
9977 Elf_Internal_Syminfo
* syminfo
;
9979 /* There is a syminfo section. Read the data. */
9980 extsyminfo
= (Elf_External_Syminfo
*)
9981 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9982 _("symbol information"));
9986 if (dynamic_syminfo
!= NULL
)
9988 error (_("Multiple dynamic symbol information sections found\n"));
9989 free (dynamic_syminfo
);
9991 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9992 if (dynamic_syminfo
== NULL
)
9994 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9995 (unsigned long) syminsz
);
9999 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10000 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10001 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10002 ++syminfo
, ++extsym
)
10004 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10005 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10012 if (do_dynamic
&& dynamic_addr
)
10013 printf (ngettext ("\nDynamic section at offset 0x%lx "
10014 "contains %lu entry:\n",
10015 "\nDynamic section at offset 0x%lx "
10016 "contains %lu entries:\n",
10018 dynamic_addr
, (unsigned long) dynamic_nent
);
10020 printf (_(" Tag Type Name/Value\n"));
10022 for (entry
= dynamic_section
;
10023 entry
< dynamic_section
+ dynamic_nent
;
10028 const char * dtype
;
10031 print_vma (entry
->d_tag
, FULL_HEX
);
10032 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10033 printf (" (%s)%*s", dtype
,
10034 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10037 switch (entry
->d_tag
)
10041 print_dynamic_flags (entry
->d_un
.d_val
);
10051 switch (entry
->d_tag
)
10054 printf (_("Auxiliary library"));
10058 printf (_("Filter library"));
10062 printf (_("Configuration file"));
10066 printf (_("Dependency audit library"));
10070 printf (_("Audit library"));
10074 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10075 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10079 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10088 printf (_("Flags:"));
10090 if (entry
->d_un
.d_val
== 0)
10091 printf (_(" None\n"));
10094 unsigned long int val
= entry
->d_un
.d_val
;
10096 if (val
& DTF_1_PARINIT
)
10098 printf (" PARINIT");
10099 val
^= DTF_1_PARINIT
;
10101 if (val
& DTF_1_CONFEXP
)
10103 printf (" CONFEXP");
10104 val
^= DTF_1_CONFEXP
;
10107 printf (" %lx", val
);
10116 printf (_("Flags:"));
10118 if (entry
->d_un
.d_val
== 0)
10119 printf (_(" None\n"));
10122 unsigned long int val
= entry
->d_un
.d_val
;
10124 if (val
& DF_P1_LAZYLOAD
)
10126 printf (" LAZYLOAD");
10127 val
^= DF_P1_LAZYLOAD
;
10129 if (val
& DF_P1_GROUPPERM
)
10131 printf (" GROUPPERM");
10132 val
^= DF_P1_GROUPPERM
;
10135 printf (" %lx", val
);
10144 printf (_("Flags:"));
10145 if (entry
->d_un
.d_val
== 0)
10146 printf (_(" None\n"));
10149 unsigned long int val
= entry
->d_un
.d_val
;
10151 if (val
& DF_1_NOW
)
10156 if (val
& DF_1_GLOBAL
)
10158 printf (" GLOBAL");
10159 val
^= DF_1_GLOBAL
;
10161 if (val
& DF_1_GROUP
)
10166 if (val
& DF_1_NODELETE
)
10168 printf (" NODELETE");
10169 val
^= DF_1_NODELETE
;
10171 if (val
& DF_1_LOADFLTR
)
10173 printf (" LOADFLTR");
10174 val
^= DF_1_LOADFLTR
;
10176 if (val
& DF_1_INITFIRST
)
10178 printf (" INITFIRST");
10179 val
^= DF_1_INITFIRST
;
10181 if (val
& DF_1_NOOPEN
)
10183 printf (" NOOPEN");
10184 val
^= DF_1_NOOPEN
;
10186 if (val
& DF_1_ORIGIN
)
10188 printf (" ORIGIN");
10189 val
^= DF_1_ORIGIN
;
10191 if (val
& DF_1_DIRECT
)
10193 printf (" DIRECT");
10194 val
^= DF_1_DIRECT
;
10196 if (val
& DF_1_TRANS
)
10201 if (val
& DF_1_INTERPOSE
)
10203 printf (" INTERPOSE");
10204 val
^= DF_1_INTERPOSE
;
10206 if (val
& DF_1_NODEFLIB
)
10208 printf (" NODEFLIB");
10209 val
^= DF_1_NODEFLIB
;
10211 if (val
& DF_1_NODUMP
)
10213 printf (" NODUMP");
10214 val
^= DF_1_NODUMP
;
10216 if (val
& DF_1_CONFALT
)
10218 printf (" CONFALT");
10219 val
^= DF_1_CONFALT
;
10221 if (val
& DF_1_ENDFILTEE
)
10223 printf (" ENDFILTEE");
10224 val
^= DF_1_ENDFILTEE
;
10226 if (val
& DF_1_DISPRELDNE
)
10228 printf (" DISPRELDNE");
10229 val
^= DF_1_DISPRELDNE
;
10231 if (val
& DF_1_DISPRELPND
)
10233 printf (" DISPRELPND");
10234 val
^= DF_1_DISPRELPND
;
10236 if (val
& DF_1_NODIRECT
)
10238 printf (" NODIRECT");
10239 val
^= DF_1_NODIRECT
;
10241 if (val
& DF_1_IGNMULDEF
)
10243 printf (" IGNMULDEF");
10244 val
^= DF_1_IGNMULDEF
;
10246 if (val
& DF_1_NOKSYMS
)
10248 printf (" NOKSYMS");
10249 val
^= DF_1_NOKSYMS
;
10251 if (val
& DF_1_NOHDR
)
10256 if (val
& DF_1_EDITED
)
10258 printf (" EDITED");
10259 val
^= DF_1_EDITED
;
10261 if (val
& DF_1_NORELOC
)
10263 printf (" NORELOC");
10264 val
^= DF_1_NORELOC
;
10266 if (val
& DF_1_SYMINTPOSE
)
10268 printf (" SYMINTPOSE");
10269 val
^= DF_1_SYMINTPOSE
;
10271 if (val
& DF_1_GLOBAUDIT
)
10273 printf (" GLOBAUDIT");
10274 val
^= DF_1_GLOBAUDIT
;
10276 if (val
& DF_1_SINGLETON
)
10278 printf (" SINGLETON");
10279 val
^= DF_1_SINGLETON
;
10281 if (val
& DF_1_STUB
)
10286 if (val
& DF_1_PIE
)
10291 if (val
& DF_1_KMOD
)
10296 if (val
& DF_1_WEAKFILTER
)
10298 printf (" WEAKFILTER");
10299 val
^= DF_1_WEAKFILTER
;
10301 if (val
& DF_1_NOCOMMON
)
10303 printf (" NOCOMMON");
10304 val
^= DF_1_NOCOMMON
;
10307 printf (" %lx", val
);
10314 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10316 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10336 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10342 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10343 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10349 switch (entry
->d_tag
)
10352 printf (_("Shared library: [%s]"), name
);
10354 if (streq (name
, program_interpreter
))
10355 printf (_(" program interpreter"));
10359 printf (_("Library soname: [%s]"), name
);
10363 printf (_("Library rpath: [%s]"), name
);
10367 printf (_("Library runpath: [%s]"), name
);
10371 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10376 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10389 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10390 /* Fall through. */
10394 case DT_INIT_ARRAYSZ
:
10395 case DT_FINI_ARRAYSZ
:
10396 case DT_GNU_CONFLICTSZ
:
10397 case DT_GNU_LIBLISTSZ
:
10400 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10401 printf (_(" (bytes)\n"));
10406 case DT_VERNEEDNUM
:
10411 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10420 case DT_INIT_ARRAY
:
10421 case DT_FINI_ARRAY
:
10424 if (entry
->d_tag
== DT_USED
10425 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10427 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10431 printf (_("Not needed object: [%s]\n"), name
);
10436 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10442 /* The value of this entry is ignored. */
10447 case DT_GNU_PRELINKED
:
10451 time_t atime
= entry
->d_un
.d_val
;
10453 tmp
= gmtime (&atime
);
10454 /* PR 17533 file: 041-1244816-0.004. */
10456 printf (_("<corrupt time val: %lx"),
10457 (unsigned long) atime
);
10459 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10460 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10461 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10467 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10470 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10476 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10477 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10482 switch (filedata
->file_header
.e_machine
)
10485 dynamic_section_aarch64_val (entry
);
10488 case EM_MIPS_RS3_LE
:
10489 dynamic_section_mips_val (entry
);
10492 dynamic_section_parisc_val (entry
);
10495 dynamic_section_ia64_val (entry
);
10498 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10510 get_ver_flags (unsigned int flags
)
10512 static char buff
[128];
10519 if (flags
& VER_FLG_BASE
)
10520 strcat (buff
, "BASE");
10522 if (flags
& VER_FLG_WEAK
)
10524 if (flags
& VER_FLG_BASE
)
10525 strcat (buff
, " | ");
10527 strcat (buff
, "WEAK");
10530 if (flags
& VER_FLG_INFO
)
10532 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10533 strcat (buff
, " | ");
10535 strcat (buff
, "INFO");
10538 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10540 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10541 strcat (buff
, " | ");
10543 strcat (buff
, _("<unknown>"));
10549 /* Display the contents of the version sections. */
10552 process_version_sections (Filedata
* filedata
)
10554 Elf_Internal_Shdr
* section
;
10556 bfd_boolean found
= FALSE
;
10561 for (i
= 0, section
= filedata
->section_headers
;
10562 i
< filedata
->file_header
.e_shnum
;
10565 switch (section
->sh_type
)
10567 case SHT_GNU_verdef
:
10569 Elf_External_Verdef
* edefs
;
10576 printf (ngettext ("\nVersion definition section '%s' "
10577 "contains %u entry:\n",
10578 "\nVersion definition section '%s' "
10579 "contains %u entries:\n",
10581 printable_section_name (filedata
, section
),
10584 printf (_(" Addr: 0x"));
10585 printf_vma (section
->sh_addr
);
10586 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10587 (unsigned long) section
->sh_offset
, section
->sh_link
,
10588 printable_section_name_from_index (filedata
, section
->sh_link
));
10590 edefs
= (Elf_External_Verdef
*)
10591 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10592 _("version definition section"));
10595 endbuf
= (char *) edefs
+ section
->sh_size
;
10597 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10600 Elf_External_Verdef
* edef
;
10601 Elf_Internal_Verdef ent
;
10602 Elf_External_Verdaux
* eaux
;
10603 Elf_Internal_Verdaux aux
;
10604 unsigned long isum
;
10607 vstart
= ((char *) edefs
) + idx
;
10608 if (vstart
+ sizeof (*edef
) > endbuf
)
10611 edef
= (Elf_External_Verdef
*) vstart
;
10613 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10614 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10615 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10616 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10617 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10618 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10619 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10621 printf (_(" %#06lx: Rev: %d Flags: %s"),
10622 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10624 printf (_(" Index: %d Cnt: %d "),
10625 ent
.vd_ndx
, ent
.vd_cnt
);
10627 /* Check for overflow. */
10628 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10631 vstart
+= ent
.vd_aux
;
10633 if (vstart
+ sizeof (*eaux
) > endbuf
)
10635 eaux
= (Elf_External_Verdaux
*) vstart
;
10637 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10638 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10640 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10641 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10643 printf (_("Name index: %ld\n"), aux
.vda_name
);
10645 isum
= idx
+ ent
.vd_aux
;
10647 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10649 if (aux
.vda_next
< sizeof (*eaux
)
10650 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10652 warn (_("Invalid vda_next field of %lx\n"),
10657 /* Check for overflow. */
10658 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10661 isum
+= aux
.vda_next
;
10662 vstart
+= aux
.vda_next
;
10664 if (vstart
+ sizeof (*eaux
) > endbuf
)
10666 eaux
= (Elf_External_Verdaux
*) vstart
;
10668 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10669 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10671 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10672 printf (_(" %#06lx: Parent %d: %s\n"),
10673 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10675 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10676 isum
, j
, aux
.vda_name
);
10679 if (j
< ent
.vd_cnt
)
10680 printf (_(" Version def aux past end of section\n"));
10683 file: id:000001,src:000172+005151,op:splice,rep:2. */
10684 if (ent
.vd_next
< sizeof (*edef
)
10685 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10687 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10688 cnt
= section
->sh_info
;
10691 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10694 idx
+= ent
.vd_next
;
10697 if (cnt
< section
->sh_info
)
10698 printf (_(" Version definition past end of section\n"));
10704 case SHT_GNU_verneed
:
10706 Elf_External_Verneed
* eneed
;
10713 printf (ngettext ("\nVersion needs section '%s' "
10714 "contains %u entry:\n",
10715 "\nVersion needs section '%s' "
10716 "contains %u entries:\n",
10718 printable_section_name (filedata
, section
), section
->sh_info
);
10720 printf (_(" Addr: 0x"));
10721 printf_vma (section
->sh_addr
);
10722 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10723 (unsigned long) section
->sh_offset
, section
->sh_link
,
10724 printable_section_name_from_index (filedata
, section
->sh_link
));
10726 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10727 section
->sh_offset
, 1,
10729 _("Version Needs section"));
10732 endbuf
= (char *) eneed
+ section
->sh_size
;
10734 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10736 Elf_External_Verneed
* entry
;
10737 Elf_Internal_Verneed ent
;
10738 unsigned long isum
;
10742 vstart
= ((char *) eneed
) + idx
;
10743 if (vstart
+ sizeof (*entry
) > endbuf
)
10746 entry
= (Elf_External_Verneed
*) vstart
;
10748 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10749 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10750 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10751 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10752 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10754 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10756 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10757 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10759 printf (_(" File: %lx"), ent
.vn_file
);
10761 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10763 /* Check for overflow. */
10764 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10766 vstart
+= ent
.vn_aux
;
10768 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10770 Elf_External_Vernaux
* eaux
;
10771 Elf_Internal_Vernaux aux
;
10773 if (vstart
+ sizeof (*eaux
) > endbuf
)
10775 eaux
= (Elf_External_Vernaux
*) vstart
;
10777 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10778 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10779 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10780 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10781 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10783 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10784 printf (_(" %#06lx: Name: %s"),
10785 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10787 printf (_(" %#06lx: Name index: %lx"),
10788 isum
, aux
.vna_name
);
10790 printf (_(" Flags: %s Version: %d\n"),
10791 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10793 if (aux
.vna_next
< sizeof (*eaux
)
10794 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10796 warn (_("Invalid vna_next field of %lx\n"),
10801 /* Check for overflow. */
10802 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10804 isum
+= aux
.vna_next
;
10805 vstart
+= aux
.vna_next
;
10808 if (j
< ent
.vn_cnt
)
10809 warn (_("Missing Version Needs auxillary information\n"));
10811 if (ent
.vn_next
< sizeof (*entry
)
10812 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10814 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10815 cnt
= section
->sh_info
;
10818 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10820 idx
+= ent
.vn_next
;
10823 if (cnt
< section
->sh_info
)
10824 warn (_("Missing Version Needs information\n"));
10830 case SHT_GNU_versym
:
10832 Elf_Internal_Shdr
* link_section
;
10835 unsigned char * edata
;
10836 unsigned short * data
;
10838 Elf_Internal_Sym
* symbols
;
10839 Elf_Internal_Shdr
* string_sec
;
10840 unsigned long num_syms
;
10843 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10846 link_section
= filedata
->section_headers
+ section
->sh_link
;
10847 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10849 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10854 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10855 if (symbols
== NULL
)
10858 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10860 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10861 string_sec
->sh_size
,
10862 _("version string table"));
10869 printf (ngettext ("\nVersion symbols section '%s' "
10870 "contains %lu entry:\n",
10871 "\nVersion symbols section '%s' "
10872 "contains %lu entries:\n",
10874 printable_section_name (filedata
, section
), (unsigned long) total
);
10876 printf (_(" Addr: 0x"));
10877 printf_vma (section
->sh_addr
);
10878 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10879 (unsigned long) section
->sh_offset
, section
->sh_link
,
10880 printable_section_name (filedata
, link_section
));
10882 off
= offset_from_vma (filedata
,
10883 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10884 total
* sizeof (short));
10885 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10887 _("version symbol data"));
10895 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10897 for (cnt
= total
; cnt
--;)
10898 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10903 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10907 char *invalid
= _("*invalid*");
10909 printf (" %03x:", cnt
);
10911 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10912 switch (data
[cnt
+ j
])
10915 fputs (_(" 0 (*local*) "), stdout
);
10919 fputs (_(" 1 (*global*) "), stdout
);
10923 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10924 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10926 /* If this index value is greater than the size of the symbols
10927 array, break to avoid an out-of-bounds read. */
10928 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10930 warn (_("invalid index into symbol array\n"));
10935 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10937 Elf_Internal_Verneed ivn
;
10938 unsigned long offset
;
10940 offset
= offset_from_vma
10941 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10942 sizeof (Elf_External_Verneed
));
10946 Elf_Internal_Vernaux ivna
;
10947 Elf_External_Verneed evn
;
10948 Elf_External_Vernaux evna
;
10949 unsigned long a_off
;
10951 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10952 _("version need")) == NULL
)
10955 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10956 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10958 a_off
= offset
+ ivn
.vn_aux
;
10962 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10963 1, _("version need aux (2)")) == NULL
)
10966 ivna
.vna_other
= 0;
10970 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10971 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10974 a_off
+= ivna
.vna_next
;
10976 while (ivna
.vna_other
!= data
[cnt
+ j
]
10977 && ivna
.vna_next
!= 0);
10979 if (ivna
.vna_other
== data
[cnt
+ j
])
10981 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10983 if (ivna
.vna_name
>= string_sec
->sh_size
)
10986 name
= strtab
+ ivna
.vna_name
;
10990 offset
+= ivn
.vn_next
;
10992 while (ivn
.vn_next
);
10995 if (data
[cnt
+ j
] != 0x8001
10996 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10998 Elf_Internal_Verdef ivd
;
10999 Elf_External_Verdef evd
;
11000 unsigned long offset
;
11002 offset
= offset_from_vma
11003 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11008 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11009 _("version def")) == NULL
)
11012 /* PR 17531: file: 046-1082287-0.004. */
11013 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11018 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11019 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11022 offset
+= ivd
.vd_next
;
11024 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11025 && ivd
.vd_next
!= 0);
11027 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11029 Elf_External_Verdaux evda
;
11030 Elf_Internal_Verdaux ivda
;
11032 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11034 if (get_data (&evda
, filedata
,
11035 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11037 _("version def aux")) == NULL
)
11040 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11042 if (ivda
.vda_name
>= string_sec
->sh_size
)
11044 else if (name
!= NULL
&& name
!= invalid
)
11045 name
= _("*both*");
11047 name
= strtab
+ ivda
.vda_name
;
11051 nn
+= printf ("(%s%-*s",
11053 12 - (int) strlen (name
),
11057 printf ("%*c", 18 - nn
, ' ');
11075 printf (_("\nNo version information found in this file.\n"));
11080 static const char *
11081 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11083 static char buff
[32];
11087 case STB_LOCAL
: return "LOCAL";
11088 case STB_GLOBAL
: return "GLOBAL";
11089 case STB_WEAK
: return "WEAK";
11091 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11092 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11094 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11096 if (binding
== STB_GNU_UNIQUE
11097 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11099 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11102 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11107 static const char *
11108 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11110 static char buff
[32];
11114 case STT_NOTYPE
: return "NOTYPE";
11115 case STT_OBJECT
: return "OBJECT";
11116 case STT_FUNC
: return "FUNC";
11117 case STT_SECTION
: return "SECTION";
11118 case STT_FILE
: return "FILE";
11119 case STT_COMMON
: return "COMMON";
11120 case STT_TLS
: return "TLS";
11121 case STT_RELC
: return "RELC";
11122 case STT_SRELC
: return "SRELC";
11124 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11126 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11127 return "THUMB_FUNC";
11129 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11132 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11133 return "PARISC_MILLI";
11135 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11137 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11139 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11141 if (type
== STT_HP_OPAQUE
)
11142 return "HP_OPAQUE";
11143 if (type
== STT_HP_STUB
)
11147 if (type
== STT_GNU_IFUNC
11148 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11149 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11152 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11155 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11160 static const char *
11161 get_symbol_visibility (unsigned int visibility
)
11163 switch (visibility
)
11165 case STV_DEFAULT
: return "DEFAULT";
11166 case STV_INTERNAL
: return "INTERNAL";
11167 case STV_HIDDEN
: return "HIDDEN";
11168 case STV_PROTECTED
: return "PROTECTED";
11170 error (_("Unrecognized visibility value: %u"), visibility
);
11171 return _("<unknown>");
11175 static const char *
11176 get_alpha_symbol_other (unsigned int other
)
11180 case STO_ALPHA_NOPV
: return "NOPV";
11181 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11183 error (_("Unrecognized alpah specific other value: %u"), other
);
11184 return _("<unknown>");
11188 static const char *
11189 get_solaris_symbol_visibility (unsigned int visibility
)
11191 switch (visibility
)
11193 case 4: return "EXPORTED";
11194 case 5: return "SINGLETON";
11195 case 6: return "ELIMINATE";
11196 default: return get_symbol_visibility (visibility
);
11200 static const char *
11201 get_aarch64_symbol_other (unsigned int other
)
11203 static char buf
[32];
11205 if (other
& STO_AARCH64_VARIANT_PCS
)
11207 other
&= ~STO_AARCH64_VARIANT_PCS
;
11209 return "VARIANT_PCS";
11210 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11216 static const char *
11217 get_mips_symbol_other (unsigned int other
)
11221 case STO_OPTIONAL
: return "OPTIONAL";
11222 case STO_MIPS_PLT
: return "MIPS PLT";
11223 case STO_MIPS_PIC
: return "MIPS PIC";
11224 case STO_MICROMIPS
: return "MICROMIPS";
11225 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11226 case STO_MIPS16
: return "MIPS16";
11227 default: return NULL
;
11231 static const char *
11232 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11234 if (is_ia64_vms (filedata
))
11236 static char res
[32];
11240 /* Function types is for images and .STB files only. */
11241 switch (filedata
->file_header
.e_type
)
11245 switch (VMS_ST_FUNC_TYPE (other
))
11247 case VMS_SFT_CODE_ADDR
:
11248 strcat (res
, " CA");
11250 case VMS_SFT_SYMV_IDX
:
11251 strcat (res
, " VEC");
11254 strcat (res
, " FD");
11256 case VMS_SFT_RESERVE
:
11257 strcat (res
, " RSV");
11260 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11261 VMS_ST_FUNC_TYPE (other
));
11262 strcat (res
, " <unknown>");
11269 switch (VMS_ST_LINKAGE (other
))
11271 case VMS_STL_IGNORE
:
11272 strcat (res
, " IGN");
11274 case VMS_STL_RESERVE
:
11275 strcat (res
, " RSV");
11278 strcat (res
, " STD");
11281 strcat (res
, " LNK");
11284 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11285 VMS_ST_LINKAGE (other
));
11286 strcat (res
, " <unknown>");
11298 static const char *
11299 get_ppc64_symbol_other (unsigned int other
)
11301 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11304 other
>>= STO_PPC64_LOCAL_BIT
;
11307 static char buf
[32];
11309 other
= ppc64_decode_local_entry (other
);
11310 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11316 static const char *
11317 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11319 const char * result
= NULL
;
11320 static char buff
[32];
11325 switch (filedata
->file_header
.e_machine
)
11328 result
= get_alpha_symbol_other (other
);
11331 result
= get_aarch64_symbol_other (other
);
11334 result
= get_mips_symbol_other (other
);
11337 result
= get_ia64_symbol_other (filedata
, other
);
11340 result
= get_ppc64_symbol_other (other
);
11350 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11354 static const char *
11355 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11357 static char buff
[32];
11361 case SHN_UNDEF
: return "UND";
11362 case SHN_ABS
: return "ABS";
11363 case SHN_COMMON
: return "COM";
11365 if (type
== SHN_IA_64_ANSI_COMMON
11366 && filedata
->file_header
.e_machine
== EM_IA_64
11367 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11369 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11370 || filedata
->file_header
.e_machine
== EM_L1OM
11371 || filedata
->file_header
.e_machine
== EM_K1OM
)
11372 && type
== SHN_X86_64_LCOMMON
)
11373 return "LARGE_COM";
11374 else if ((type
== SHN_MIPS_SCOMMON
11375 && filedata
->file_header
.e_machine
== EM_MIPS
)
11376 || (type
== SHN_TIC6X_SCOMMON
11377 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11379 else if (type
== SHN_MIPS_SUNDEFINED
11380 && filedata
->file_header
.e_machine
== EM_MIPS
)
11382 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11383 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11384 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11385 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11386 else if (type
>= SHN_LORESERVE
)
11387 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11388 else if (type
>= filedata
->file_header
.e_shnum
)
11389 sprintf (buff
, _("bad section index[%3d]"), type
);
11391 sprintf (buff
, "%3d", type
);
11399 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11401 unsigned char * e_data
;
11404 /* If the size_t type is smaller than the bfd_size_type, eg because
11405 you are building a 32-bit tool on a 64-bit host, then make sure
11406 that when (number) is cast to (size_t) no information is lost. */
11407 if (sizeof (size_t) < sizeof (bfd_size_type
)
11408 && (bfd_size_type
) ((size_t) number
) != number
)
11410 error (_("Size truncation prevents reading %s elements of size %u\n"),
11411 bfd_vmatoa ("u", number
), ent_size
);
11415 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11416 attempting to allocate memory when the read is bound to fail. */
11417 if (ent_size
* number
> filedata
->file_size
)
11419 error (_("Invalid number of dynamic entries: %s\n"),
11420 bfd_vmatoa ("u", number
));
11424 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11425 if (e_data
== NULL
)
11427 error (_("Out of memory reading %s dynamic entries\n"),
11428 bfd_vmatoa ("u", number
));
11432 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11434 error (_("Unable to read in %s bytes of dynamic data\n"),
11435 bfd_vmatoa ("u", number
* ent_size
));
11440 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11441 if (i_data
== NULL
)
11443 error (_("Out of memory allocating space for %s dynamic entries\n"),
11444 bfd_vmatoa ("u", number
));
11450 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11458 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11460 Elf_Internal_Sym
* psym
;
11463 n
= print_vma (si
, DEC_5
);
11465 fputs (&" "[n
], stdout
);
11466 printf (" %3lu: ", hn
);
11468 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11470 printf (_("<No info available for dynamic symbol number %lu>\n"),
11471 (unsigned long) si
);
11475 psym
= dynamic_symbols
+ si
;
11476 print_vma (psym
->st_value
, LONG_HEX
);
11478 print_vma (psym
->st_size
, DEC_5
);
11480 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11481 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11483 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11484 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11487 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11489 printf (" %-7s", get_symbol_visibility (vis
));
11490 /* Check to see if any other bits in the st_other field are set.
11491 Note - displaying this information disrupts the layout of the
11492 table being generated, but for the moment this case is very
11494 if (psym
->st_other
^ vis
)
11495 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11498 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11499 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11500 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11502 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11506 static const char *
11507 get_symbol_version_string (Filedata
* filedata
,
11508 bfd_boolean is_dynsym
,
11509 const char * strtab
,
11510 unsigned long int strtab_size
,
11512 Elf_Internal_Sym
* psym
,
11513 enum versioned_symbol_info
* sym_info
,
11514 unsigned short * vna_other
)
11516 unsigned char data
[2];
11517 unsigned short vers_data
;
11518 unsigned long offset
;
11519 unsigned short max_vd_ndx
;
11522 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11525 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11526 sizeof data
+ si
* sizeof (vers_data
));
11528 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11529 sizeof (data
), 1, _("version data")) == NULL
)
11532 vers_data
= byte_get (data
, 2);
11534 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11537 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11540 /* Usually we'd only see verdef for defined symbols, and verneed for
11541 undefined symbols. However, symbols defined by the linker in
11542 .dynbss for variables copied from a shared library in order to
11543 avoid text relocations are defined yet have verneed. We could
11544 use a heuristic to detect the special case, for example, check
11545 for verneed first on symbols defined in SHT_NOBITS sections, but
11546 it is simpler and more reliable to just look for both verdef and
11547 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11549 if (psym
->st_shndx
!= SHN_UNDEF
11550 && vers_data
!= 0x8001
11551 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11553 Elf_Internal_Verdef ivd
;
11554 Elf_Internal_Verdaux ivda
;
11555 Elf_External_Verdaux evda
;
11558 off
= offset_from_vma (filedata
,
11559 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11560 sizeof (Elf_External_Verdef
));
11564 Elf_External_Verdef evd
;
11566 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11567 _("version def")) == NULL
)
11576 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11577 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11578 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11579 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11582 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11583 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11585 off
+= ivd
.vd_next
;
11587 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11589 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11591 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11594 off
-= ivd
.vd_next
;
11597 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11598 _("version def aux")) != NULL
)
11600 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11602 if (psym
->st_name
!= ivda
.vda_name
)
11603 return (ivda
.vda_name
< strtab_size
11604 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11609 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11611 Elf_External_Verneed evn
;
11612 Elf_Internal_Verneed ivn
;
11613 Elf_Internal_Vernaux ivna
;
11615 offset
= offset_from_vma (filedata
,
11616 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11620 unsigned long vna_off
;
11622 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11623 _("version need")) == NULL
)
11626 ivna
.vna_other
= 0;
11631 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11632 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11634 vna_off
= offset
+ ivn
.vn_aux
;
11638 Elf_External_Vernaux evna
;
11640 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11641 _("version need aux (3)")) == NULL
)
11644 ivna
.vna_other
= 0;
11649 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11650 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11651 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11654 vna_off
+= ivna
.vna_next
;
11656 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11658 if (ivna
.vna_other
== vers_data
)
11661 offset
+= ivn
.vn_next
;
11663 while (ivn
.vn_next
!= 0);
11665 if (ivna
.vna_other
== vers_data
)
11667 *sym_info
= symbol_undefined
;
11668 *vna_other
= ivna
.vna_other
;
11669 return (ivna
.vna_name
< strtab_size
11670 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11672 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11673 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11674 return _("<corrupt>");
11679 /* Dump the symbol table. */
11681 process_symbol_table (Filedata
* filedata
)
11683 Elf_Internal_Shdr
* section
;
11684 bfd_size_type nbuckets
= 0;
11685 bfd_size_type nchains
= 0;
11686 bfd_vma
* buckets
= NULL
;
11687 bfd_vma
* chains
= NULL
;
11688 bfd_vma ngnubuckets
= 0;
11689 bfd_vma
* gnubuckets
= NULL
;
11690 bfd_vma
* gnuchains
= NULL
;
11691 bfd_vma
* mipsxlat
= NULL
;
11692 bfd_vma gnusymidx
= 0;
11693 bfd_size_type ngnuchains
= 0;
11695 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11698 if (dynamic_info
[DT_HASH
]
11700 || (do_using_dynamic
11702 && dynamic_strings
!= NULL
)))
11704 unsigned char nb
[8];
11705 unsigned char nc
[8];
11706 unsigned int hash_ent_size
= 4;
11708 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11709 || filedata
->file_header
.e_machine
== EM_S390
11710 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11711 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11714 if (fseek (filedata
->handle
,
11715 (archive_file_offset
11716 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11717 sizeof nb
+ sizeof nc
)),
11720 error (_("Unable to seek to start of dynamic information\n"));
11724 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11726 error (_("Failed to read in number of buckets\n"));
11730 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11732 error (_("Failed to read in number of chains\n"));
11736 nbuckets
= byte_get (nb
, hash_ent_size
);
11737 nchains
= byte_get (nc
, hash_ent_size
);
11739 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11740 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11743 if (buckets
== NULL
|| chains
== NULL
)
11745 if (do_using_dynamic
)
11756 if (dynamic_info_DT_GNU_HASH
11758 || (do_using_dynamic
11760 && dynamic_strings
!= NULL
)))
11762 unsigned char nb
[16];
11763 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11764 bfd_vma buckets_vma
;
11766 if (fseek (filedata
->handle
,
11767 (archive_file_offset
11768 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11772 error (_("Unable to seek to start of dynamic information\n"));
11776 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11778 error (_("Failed to read in number of buckets\n"));
11782 ngnubuckets
= byte_get (nb
, 4);
11783 gnusymidx
= byte_get (nb
+ 4, 4);
11784 bitmaskwords
= byte_get (nb
+ 8, 4);
11785 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11787 buckets_vma
+= bitmaskwords
* 4;
11789 buckets_vma
+= bitmaskwords
* 8;
11791 if (fseek (filedata
->handle
,
11792 (archive_file_offset
11793 + offset_from_vma (filedata
, buckets_vma
, 4)),
11796 error (_("Unable to seek to start of dynamic information\n"));
11800 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11802 if (gnubuckets
== NULL
)
11805 for (i
= 0; i
< ngnubuckets
; i
++)
11806 if (gnubuckets
[i
] != 0)
11808 if (gnubuckets
[i
] < gnusymidx
)
11811 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11812 maxchain
= gnubuckets
[i
];
11815 if (maxchain
== 0xffffffff)
11818 maxchain
-= gnusymidx
;
11820 if (fseek (filedata
->handle
,
11821 (archive_file_offset
11822 + offset_from_vma (filedata
, buckets_vma
11823 + 4 * (ngnubuckets
+ maxchain
), 4)),
11826 error (_("Unable to seek to start of dynamic information\n"));
11832 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11834 error (_("Failed to determine last chain length\n"));
11838 if (maxchain
+ 1 == 0)
11843 while ((byte_get (nb
, 4) & 1) == 0);
11845 if (fseek (filedata
->handle
,
11846 (archive_file_offset
11847 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11850 error (_("Unable to seek to start of dynamic information\n"));
11854 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11855 ngnuchains
= maxchain
;
11857 if (gnuchains
== NULL
)
11860 if (dynamic_info_DT_MIPS_XHASH
)
11862 if (fseek (filedata
->handle
,
11863 (archive_file_offset
11864 + offset_from_vma (filedata
, (buckets_vma
11869 error (_("Unable to seek to start of dynamic information\n"));
11873 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11877 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11882 if (gnuchains
== NULL
)
11887 if (do_using_dynamic
)
11892 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11894 && do_using_dynamic
11895 && dynamic_strings
!= NULL
11896 && dynamic_symbols
!= NULL
)
11900 if (dynamic_info
[DT_HASH
])
11905 printf (_("\nSymbol table for image:\n"));
11907 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11909 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11911 visited
= xcmalloc (nchains
, 1);
11912 memset (visited
, 0, nchains
);
11913 for (hn
= 0; hn
< nbuckets
; hn
++)
11915 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11917 print_dynamic_symbol (filedata
, si
, hn
);
11918 if (si
>= nchains
|| visited
[si
])
11920 error (_("histogram chain is corrupt\n"));
11929 if (dynamic_info_DT_GNU_HASH
)
11931 printf (_("\nSymbol table of `%s' for image:\n"),
11932 GNU_HASH_SECTION_NAME
);
11934 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11936 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11938 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11939 if (gnubuckets
[hn
] != 0)
11941 bfd_vma si
= gnubuckets
[hn
];
11942 bfd_vma off
= si
- gnusymidx
;
11946 if (dynamic_info_DT_MIPS_XHASH
)
11947 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11949 print_dynamic_symbol (filedata
, si
, hn
);
11952 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11956 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11957 && filedata
->section_headers
!= NULL
)
11961 for (i
= 0, section
= filedata
->section_headers
;
11962 i
< filedata
->file_header
.e_shnum
;
11966 char * strtab
= NULL
;
11967 unsigned long int strtab_size
= 0;
11968 Elf_Internal_Sym
* symtab
;
11969 Elf_Internal_Sym
* psym
;
11970 unsigned long num_syms
;
11972 if ((section
->sh_type
!= SHT_SYMTAB
11973 && section
->sh_type
!= SHT_DYNSYM
)
11975 && section
->sh_type
== SHT_SYMTAB
))
11978 if (section
->sh_entsize
== 0)
11980 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11981 printable_section_name (filedata
, section
));
11985 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11986 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11987 "\nSymbol table '%s' contains %lu entries:\n",
11989 printable_section_name (filedata
, section
),
11993 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11995 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11997 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11998 if (symtab
== NULL
)
12001 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12003 strtab
= filedata
->string_table
;
12004 strtab_size
= filedata
->string_table_length
;
12006 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12008 Elf_Internal_Shdr
* string_sec
;
12010 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12012 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12013 1, string_sec
->sh_size
,
12014 _("string table"));
12015 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12018 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12020 const char *version_string
;
12021 enum versioned_symbol_info sym_info
;
12022 unsigned short vna_other
;
12024 printf ("%6d: ", si
);
12025 print_vma (psym
->st_value
, LONG_HEX
);
12027 print_vma (psym
->st_size
, DEC_5
);
12028 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12029 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12030 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12031 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12034 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12036 printf (" %-7s", get_symbol_visibility (vis
));
12037 /* Check to see if any other bits in the st_other field are set.
12038 Note - displaying this information disrupts the layout of the
12039 table being generated, but for the moment this case is very rare. */
12040 if (psym
->st_other
^ vis
)
12041 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12043 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12044 print_symbol (25, psym
->st_name
< strtab_size
12045 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12048 = get_symbol_version_string (filedata
,
12049 section
->sh_type
== SHT_DYNSYM
,
12050 strtab
, strtab_size
, si
,
12051 psym
, &sym_info
, &vna_other
);
12052 if (version_string
)
12054 if (sym_info
== symbol_undefined
)
12055 printf ("@%s (%d)", version_string
, vna_other
);
12057 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12063 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12064 && si
>= section
->sh_info
12065 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12066 && filedata
->file_header
.e_machine
!= EM_MIPS
12067 /* Solaris binaries have been found to violate this requirement as
12068 well. Not sure if this is a bug or an ABI requirement. */
12069 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12070 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12071 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12075 if (strtab
!= filedata
->string_table
)
12081 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12083 if (do_histogram
&& buckets
!= NULL
)
12085 unsigned long * lengths
;
12086 unsigned long * counts
;
12089 unsigned long maxlength
= 0;
12090 unsigned long nzero_counts
= 0;
12091 unsigned long nsyms
= 0;
12094 printf (ngettext ("\nHistogram for bucket list length "
12095 "(total of %lu bucket):\n",
12096 "\nHistogram for bucket list length "
12097 "(total of %lu buckets):\n",
12098 (unsigned long) nbuckets
),
12099 (unsigned long) nbuckets
);
12101 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12102 if (lengths
== NULL
)
12104 error (_("Out of memory allocating space for histogram buckets\n"));
12107 visited
= xcmalloc (nchains
, 1);
12108 memset (visited
, 0, nchains
);
12110 printf (_(" Length Number %% of total Coverage\n"));
12111 for (hn
= 0; hn
< nbuckets
; ++hn
)
12113 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12116 if (maxlength
< ++lengths
[hn
])
12118 if (si
>= nchains
|| visited
[si
])
12120 error (_("histogram chain is corrupt\n"));
12128 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12129 if (counts
== NULL
)
12132 error (_("Out of memory allocating space for histogram counts\n"));
12136 for (hn
= 0; hn
< nbuckets
; ++hn
)
12137 ++counts
[lengths
[hn
]];
12142 printf (" 0 %-10lu (%5.1f%%)\n",
12143 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12144 for (i
= 1; i
<= maxlength
; ++i
)
12146 nzero_counts
+= counts
[i
] * i
;
12147 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12148 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12149 (nzero_counts
* 100.0) / nsyms
);
12157 if (buckets
!= NULL
)
12163 if (do_histogram
&& gnubuckets
!= NULL
)
12165 unsigned long * lengths
;
12166 unsigned long * counts
;
12168 unsigned long maxlength
= 0;
12169 unsigned long nzero_counts
= 0;
12170 unsigned long nsyms
= 0;
12172 printf (ngettext ("\nHistogram for `%s' bucket list length "
12173 "(total of %lu bucket):\n",
12174 "\nHistogram for `%s' bucket list length "
12175 "(total of %lu buckets):\n",
12176 (unsigned long) ngnubuckets
),
12177 GNU_HASH_SECTION_NAME
,
12178 (unsigned long) ngnubuckets
);
12180 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12181 if (lengths
== NULL
)
12183 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12187 printf (_(" Length Number %% of total Coverage\n"));
12189 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12190 if (gnubuckets
[hn
] != 0)
12192 bfd_vma off
, length
= 1;
12194 for (off
= gnubuckets
[hn
] - gnusymidx
;
12195 /* PR 17531 file: 010-77222-0.004. */
12196 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12199 lengths
[hn
] = length
;
12200 if (length
> maxlength
)
12201 maxlength
= length
;
12205 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12206 if (counts
== NULL
)
12209 error (_("Out of memory allocating space for gnu histogram counts\n"));
12213 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12214 ++counts
[lengths
[hn
]];
12216 if (ngnubuckets
> 0)
12219 printf (" 0 %-10lu (%5.1f%%)\n",
12220 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12221 for (j
= 1; j
<= maxlength
; ++j
)
12223 nzero_counts
+= counts
[j
] * j
;
12224 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12225 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12226 (nzero_counts
* 100.0) / nsyms
);
12241 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12245 if (dynamic_syminfo
== NULL
12247 /* No syminfo, this is ok. */
12250 /* There better should be a dynamic symbol section. */
12251 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12255 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12256 "contains %d entry:\n",
12257 "\nDynamic info segment at offset 0x%lx "
12258 "contains %d entries:\n",
12259 dynamic_syminfo_nent
),
12260 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12262 printf (_(" Num: Name BoundTo Flags\n"));
12263 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12265 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12267 printf ("%4d: ", i
);
12268 if (i
>= num_dynamic_syms
)
12269 printf (_("<corrupt index>"));
12270 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12271 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12273 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12276 switch (dynamic_syminfo
[i
].si_boundto
)
12278 case SYMINFO_BT_SELF
:
12279 fputs ("SELF ", stdout
);
12281 case SYMINFO_BT_PARENT
:
12282 fputs ("PARENT ", stdout
);
12285 if (dynamic_syminfo
[i
].si_boundto
> 0
12286 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12287 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12289 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12293 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12297 if (flags
& SYMINFO_FLG_DIRECT
)
12298 printf (" DIRECT");
12299 if (flags
& SYMINFO_FLG_PASSTHRU
)
12300 printf (" PASSTHRU");
12301 if (flags
& SYMINFO_FLG_COPY
)
12303 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12304 printf (" LAZYLOAD");
12312 #define IN_RANGE(START,END,ADDR,OFF) \
12313 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12315 /* Check to see if the given reloc needs to be handled in a target specific
12316 manner. If so then process the reloc and return TRUE otherwise return
12319 If called with reloc == NULL, then this is a signal that reloc processing
12320 for the current section has finished, and any saved state should be
12324 target_specific_reloc_handling (Filedata
* filedata
,
12325 Elf_Internal_Rela
* reloc
,
12326 unsigned char * start
,
12327 unsigned char * end
,
12328 Elf_Internal_Sym
* symtab
,
12329 unsigned long num_syms
)
12331 unsigned int reloc_type
= 0;
12332 unsigned long sym_index
= 0;
12336 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12337 sym_index
= get_reloc_symindex (reloc
->r_info
);
12340 switch (filedata
->file_header
.e_machine
)
12343 case EM_MSP430_OLD
:
12345 static Elf_Internal_Sym
* saved_sym
= NULL
;
12353 switch (reloc_type
)
12355 case 10: /* R_MSP430_SYM_DIFF */
12356 if (uses_msp430x_relocs (filedata
))
12358 /* Fall through. */
12359 case 21: /* R_MSP430X_SYM_DIFF */
12361 if (sym_index
>= num_syms
)
12362 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12365 saved_sym
= symtab
+ sym_index
;
12368 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12369 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12370 goto handle_sym_diff
;
12372 case 5: /* R_MSP430_16_BYTE */
12373 case 9: /* R_MSP430_8 */
12374 if (uses_msp430x_relocs (filedata
))
12376 goto handle_sym_diff
;
12378 case 2: /* R_MSP430_ABS16 */
12379 case 15: /* R_MSP430X_ABS16 */
12380 if (! uses_msp430x_relocs (filedata
))
12382 goto handle_sym_diff
;
12385 if (saved_sym
!= NULL
)
12387 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12390 if (sym_index
>= num_syms
)
12391 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12395 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12396 - saved_sym
->st_value
);
12398 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12399 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12402 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12403 (long) reloc
->r_offset
);
12412 if (saved_sym
!= NULL
)
12413 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12420 case EM_CYGNUS_MN10300
:
12422 static Elf_Internal_Sym
* saved_sym
= NULL
;
12430 switch (reloc_type
)
12432 case 34: /* R_MN10300_ALIGN */
12434 case 33: /* R_MN10300_SYM_DIFF */
12435 if (sym_index
>= num_syms
)
12436 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12439 saved_sym
= symtab
+ sym_index
;
12442 case 1: /* R_MN10300_32 */
12443 case 2: /* R_MN10300_16 */
12444 if (saved_sym
!= NULL
)
12446 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12449 if (sym_index
>= num_syms
)
12450 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12454 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12455 - saved_sym
->st_value
);
12457 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12458 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12460 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12461 (long) reloc
->r_offset
);
12469 if (saved_sym
!= NULL
)
12470 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12478 static bfd_vma saved_sym1
= 0;
12479 static bfd_vma saved_sym2
= 0;
12480 static bfd_vma value
;
12484 saved_sym1
= saved_sym2
= 0;
12488 switch (reloc_type
)
12490 case 0x80: /* R_RL78_SYM. */
12491 saved_sym1
= saved_sym2
;
12492 if (sym_index
>= num_syms
)
12493 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12497 saved_sym2
= symtab
[sym_index
].st_value
;
12498 saved_sym2
+= reloc
->r_addend
;
12502 case 0x83: /* R_RL78_OPsub. */
12503 value
= saved_sym1
- saved_sym2
;
12504 saved_sym2
= saved_sym1
= 0;
12508 case 0x41: /* R_RL78_ABS32. */
12509 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12510 byte_put (start
+ reloc
->r_offset
, value
, 4);
12512 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12513 (long) reloc
->r_offset
);
12517 case 0x43: /* R_RL78_ABS16. */
12518 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12519 byte_put (start
+ reloc
->r_offset
, value
, 2);
12521 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12522 (long) reloc
->r_offset
);
12536 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12537 DWARF debug sections. This is a target specific test. Note - we do not
12538 go through the whole including-target-headers-multiple-times route, (as
12539 we have already done with <elf/h8.h>) because this would become very
12540 messy and even then this function would have to contain target specific
12541 information (the names of the relocs instead of their numeric values).
12542 FIXME: This is not the correct way to solve this problem. The proper way
12543 is to have target specific reloc sizing and typing functions created by
12544 the reloc-macros.h header, in the same way that it already creates the
12545 reloc naming functions. */
12548 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12550 /* Please keep this table alpha-sorted for ease of visual lookup. */
12551 switch (filedata
->file_header
.e_machine
)
12555 return reloc_type
== 1; /* R_386_32. */
12557 return reloc_type
== 1; /* R_68K_32. */
12559 return reloc_type
== 1; /* R_860_32. */
12561 return reloc_type
== 2; /* R_960_32. */
12563 return (reloc_type
== 258
12564 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12566 return reloc_type
== 11; /* R_BPF_DATA_32 */
12567 case EM_ADAPTEVA_EPIPHANY
:
12568 return reloc_type
== 3;
12570 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12572 return reloc_type
== 1; /* R_ARC_32. */
12573 case EM_ARC_COMPACT
:
12574 case EM_ARC_COMPACT2
:
12575 return reloc_type
== 4; /* R_ARC_32. */
12577 return reloc_type
== 2; /* R_ARM_ABS32 */
12580 return reloc_type
== 1;
12582 return reloc_type
== 0x12; /* R_byte4_data. */
12584 return reloc_type
== 3; /* R_CRIS_32. */
12586 return reloc_type
== 3; /* R_CR16_NUM32. */
12588 return reloc_type
== 15; /* R_CRX_NUM32. */
12590 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12591 case EM_CYGNUS_FRV
:
12592 return reloc_type
== 1;
12593 case EM_CYGNUS_D10V
:
12595 return reloc_type
== 6; /* R_D10V_32. */
12596 case EM_CYGNUS_D30V
:
12598 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12600 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12601 case EM_CYGNUS_FR30
:
12603 return reloc_type
== 3; /* R_FR30_32. */
12605 return reloc_type
== 1; /* R_FT32_32. */
12609 return reloc_type
== 1; /* R_H8_DIR32. */
12611 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12612 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12613 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12614 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12617 return reloc_type
== 2; /* R_IP2K_32. */
12619 return reloc_type
== 2; /* R_IQ2000_32. */
12620 case EM_LATTICEMICO32
:
12621 return reloc_type
== 3; /* R_LM32_32. */
12624 return reloc_type
== 3; /* R_M32C_32. */
12626 return reloc_type
== 34; /* R_M32R_32_RELA. */
12629 return reloc_type
== 6; /* R_M68HC11_32. */
12631 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12632 reloc_type
== 6; /* R_S12Z_CW32. */
12634 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12635 case EM_CYGNUS_MEP
:
12636 return reloc_type
== 4; /* R_MEP_32. */
12638 return reloc_type
== 2; /* R_METAG_ADDR32. */
12639 case EM_MICROBLAZE
:
12640 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12642 return reloc_type
== 2; /* R_MIPS_32. */
12644 return reloc_type
== 4; /* R_MMIX_32. */
12645 case EM_CYGNUS_MN10200
:
12647 return reloc_type
== 1; /* R_MN10200_32. */
12648 case EM_CYGNUS_MN10300
:
12650 return reloc_type
== 1; /* R_MN10300_32. */
12652 return reloc_type
== 1; /* R_MOXIE_32. */
12653 case EM_MSP430_OLD
:
12655 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12657 return reloc_type
== 2; /* R_MT_32. */
12659 return reloc_type
== 20; /* R_NDS32_RELA. */
12660 case EM_ALTERA_NIOS2
:
12661 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12663 return reloc_type
== 1; /* R_NIOS_32. */
12665 return reloc_type
== 1; /* R_OR1K_32. */
12667 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12668 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12669 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12672 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12674 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12676 return reloc_type
== 1; /* R_PPC_ADDR32. */
12678 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12680 return reloc_type
== 1; /* R_RISCV_32. */
12682 return reloc_type
== 1; /* R_RL78_DIR32. */
12684 return reloc_type
== 1; /* R_RX_DIR32. */
12686 return reloc_type
== 1; /* R_I370_ADDR31. */
12689 return reloc_type
== 4; /* R_S390_32. */
12691 return reloc_type
== 8; /* R_SCORE_ABS32. */
12693 return reloc_type
== 1; /* R_SH_DIR32. */
12694 case EM_SPARC32PLUS
:
12697 return reloc_type
== 3 /* R_SPARC_32. */
12698 || reloc_type
== 23; /* R_SPARC_UA32. */
12700 return reloc_type
== 6; /* R_SPU_ADDR32 */
12702 return reloc_type
== 1; /* R_C6000_ABS32. */
12704 return reloc_type
== 2; /* R_TILEGX_32. */
12706 return reloc_type
== 1; /* R_TILEPRO_32. */
12707 case EM_CYGNUS_V850
:
12709 return reloc_type
== 6; /* R_V850_ABS32. */
12711 return reloc_type
== 0x33; /* R_V810_WORD. */
12713 return reloc_type
== 1; /* R_VAX_32. */
12715 return reloc_type
== 3; /* R_VISIUM_32. */
12716 case EM_WEBASSEMBLY
:
12717 return reloc_type
== 1; /* R_WASM32_32. */
12721 return reloc_type
== 10; /* R_X86_64_32. */
12724 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12726 return reloc_type
== 4; /* R_XGATE_32. */
12728 return reloc_type
== 1; /* R_XSTROMY16_32. */
12729 case EM_XTENSA_OLD
:
12731 return reloc_type
== 1; /* R_XTENSA_32. */
12734 static unsigned int prev_warn
= 0;
12736 /* Avoid repeating the same warning multiple times. */
12737 if (prev_warn
!= filedata
->file_header
.e_machine
)
12738 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12739 filedata
->file_header
.e_machine
);
12740 prev_warn
= filedata
->file_header
.e_machine
;
12746 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12747 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12750 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12752 switch (filedata
->file_header
.e_machine
)
12753 /* Please keep this table alpha-sorted for ease of visual lookup. */
12757 return reloc_type
== 2; /* R_386_PC32. */
12759 return reloc_type
== 4; /* R_68K_PC32. */
12761 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12762 case EM_ADAPTEVA_EPIPHANY
:
12763 return reloc_type
== 6;
12765 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12766 case EM_ARC_COMPACT
:
12767 case EM_ARC_COMPACT2
:
12768 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12770 return reloc_type
== 3; /* R_ARM_REL32 */
12773 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12774 case EM_MICROBLAZE
:
12775 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12777 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12779 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12781 return reloc_type
== 26; /* R_PPC_REL32. */
12783 return reloc_type
== 26; /* R_PPC64_REL32. */
12785 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12788 return reloc_type
== 5; /* R_390_PC32. */
12790 return reloc_type
== 2; /* R_SH_REL32. */
12791 case EM_SPARC32PLUS
:
12794 return reloc_type
== 6; /* R_SPARC_DISP32. */
12796 return reloc_type
== 13; /* R_SPU_REL32. */
12798 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12800 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12802 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12806 return reloc_type
== 2; /* R_X86_64_PC32. */
12808 return reloc_type
== 4; /* R_VAX_PCREL32. */
12809 case EM_XTENSA_OLD
:
12811 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12813 /* Do not abort or issue an error message here. Not all targets use
12814 pc-relative 32-bit relocs in their DWARF debug information and we
12815 have already tested for target coverage in is_32bit_abs_reloc. A
12816 more helpful warning message will be generated by apply_relocations
12817 anyway, so just return. */
12822 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12823 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12826 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12828 switch (filedata
->file_header
.e_machine
)
12831 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12833 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12835 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12836 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12838 return reloc_type
== 80; /* R_PARISC_DIR64. */
12840 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12842 return reloc_type
== 2; /* R_RISCV_64. */
12843 case EM_SPARC32PLUS
:
12846 return reloc_type
== 32 /* R_SPARC_64. */
12847 || reloc_type
== 54; /* R_SPARC_UA64. */
12851 return reloc_type
== 1; /* R_X86_64_64. */
12854 return reloc_type
== 22; /* R_S390_64. */
12856 return reloc_type
== 1; /* R_TILEGX_64. */
12858 return reloc_type
== 18; /* R_MIPS_64. */
12864 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12865 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12868 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12870 switch (filedata
->file_header
.e_machine
)
12873 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12875 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12877 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12878 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12880 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12882 return reloc_type
== 44; /* R_PPC64_REL64. */
12883 case EM_SPARC32PLUS
:
12886 return reloc_type
== 46; /* R_SPARC_DISP64. */
12890 return reloc_type
== 24; /* R_X86_64_PC64. */
12893 return reloc_type
== 23; /* R_S390_PC64. */
12895 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12901 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12902 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12905 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12907 switch (filedata
->file_header
.e_machine
)
12909 case EM_CYGNUS_MN10200
:
12911 return reloc_type
== 4; /* R_MN10200_24. */
12913 return reloc_type
== 5; /* R_FT32_20. */
12919 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12920 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12923 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12925 /* Please keep this table alpha-sorted for ease of visual lookup. */
12926 switch (filedata
->file_header
.e_machine
)
12929 case EM_ARC_COMPACT
:
12930 case EM_ARC_COMPACT2
:
12931 return reloc_type
== 2; /* R_ARC_16. */
12932 case EM_ADAPTEVA_EPIPHANY
:
12933 return reloc_type
== 5;
12936 return reloc_type
== 4; /* R_AVR_16. */
12937 case EM_CYGNUS_D10V
:
12939 return reloc_type
== 3; /* R_D10V_16. */
12941 return reloc_type
== 2; /* R_FT32_16. */
12945 return reloc_type
== R_H8_DIR16
;
12948 return reloc_type
== 1; /* R_IP2K_16. */
12951 return reloc_type
== 1; /* R_M32C_16 */
12952 case EM_CYGNUS_MN10200
:
12954 return reloc_type
== 2; /* R_MN10200_16. */
12955 case EM_CYGNUS_MN10300
:
12957 return reloc_type
== 2; /* R_MN10300_16. */
12959 if (uses_msp430x_relocs (filedata
))
12960 return reloc_type
== 2; /* R_MSP430_ABS16. */
12961 /* Fall through. */
12962 case EM_MSP430_OLD
:
12963 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12965 return reloc_type
== 19; /* R_NDS32_RELA. */
12966 case EM_ALTERA_NIOS2
:
12967 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12969 return reloc_type
== 9; /* R_NIOS_16. */
12971 return reloc_type
== 2; /* R_OR1K_16. */
12973 return reloc_type
== 55; /* R_RISCV_SET16. */
12975 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12977 return reloc_type
== 2; /* R_C6000_ABS16. */
12979 return reloc_type
== 2; /* R_VISIUM_16. */
12982 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12984 return reloc_type
== 3; /* R_XGATE_16. */
12990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12991 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12994 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12996 switch (filedata
->file_header
.e_machine
)
12999 return reloc_type
== 54; /* R_RISCV_SET8. */
13005 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13006 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13009 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13011 switch (filedata
->file_header
.e_machine
)
13014 return reloc_type
== 53; /* R_RISCV_SET6. */
13020 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13021 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13024 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13026 /* Please keep this table alpha-sorted for ease of visual lookup. */
13027 switch (filedata
->file_header
.e_machine
)
13030 return reloc_type
== 35; /* R_RISCV_ADD32. */
13036 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13037 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13040 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13042 /* Please keep this table alpha-sorted for ease of visual lookup. */
13043 switch (filedata
->file_header
.e_machine
)
13046 return reloc_type
== 39; /* R_RISCV_SUB32. */
13052 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13053 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13056 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13058 /* Please keep this table alpha-sorted for ease of visual lookup. */
13059 switch (filedata
->file_header
.e_machine
)
13062 return reloc_type
== 36; /* R_RISCV_ADD64. */
13068 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13069 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13072 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13074 /* Please keep this table alpha-sorted for ease of visual lookup. */
13075 switch (filedata
->file_header
.e_machine
)
13078 return reloc_type
== 40; /* R_RISCV_SUB64. */
13084 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13085 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13088 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13090 /* Please keep this table alpha-sorted for ease of visual lookup. */
13091 switch (filedata
->file_header
.e_machine
)
13094 return reloc_type
== 34; /* R_RISCV_ADD16. */
13100 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13101 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13104 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13106 /* Please keep this table alpha-sorted for ease of visual lookup. */
13107 switch (filedata
->file_header
.e_machine
)
13110 return reloc_type
== 38; /* R_RISCV_SUB16. */
13116 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13117 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13120 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13122 /* Please keep this table alpha-sorted for ease of visual lookup. */
13123 switch (filedata
->file_header
.e_machine
)
13126 return reloc_type
== 33; /* R_RISCV_ADD8. */
13132 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13133 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13136 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13138 /* Please keep this table alpha-sorted for ease of visual lookup. */
13139 switch (filedata
->file_header
.e_machine
)
13142 return reloc_type
== 37; /* R_RISCV_SUB8. */
13148 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13149 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13152 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13154 switch (filedata
->file_header
.e_machine
)
13157 return reloc_type
== 52; /* R_RISCV_SUB6. */
13163 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13164 relocation entries (possibly formerly used for SHT_GROUP sections). */
13167 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13169 switch (filedata
->file_header
.e_machine
)
13171 case EM_386
: /* R_386_NONE. */
13172 case EM_68K
: /* R_68K_NONE. */
13173 case EM_ADAPTEVA_EPIPHANY
:
13174 case EM_ALPHA
: /* R_ALPHA_NONE. */
13175 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13176 case EM_ARC
: /* R_ARC_NONE. */
13177 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13178 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13179 case EM_ARM
: /* R_ARM_NONE. */
13180 case EM_C166
: /* R_XC16X_NONE. */
13181 case EM_CRIS
: /* R_CRIS_NONE. */
13182 case EM_FT32
: /* R_FT32_NONE. */
13183 case EM_IA_64
: /* R_IA64_NONE. */
13184 case EM_K1OM
: /* R_X86_64_NONE. */
13185 case EM_L1OM
: /* R_X86_64_NONE. */
13186 case EM_M32R
: /* R_M32R_NONE. */
13187 case EM_MIPS
: /* R_MIPS_NONE. */
13188 case EM_MN10300
: /* R_MN10300_NONE. */
13189 case EM_MOXIE
: /* R_MOXIE_NONE. */
13190 case EM_NIOS32
: /* R_NIOS_NONE. */
13191 case EM_OR1K
: /* R_OR1K_NONE. */
13192 case EM_PARISC
: /* R_PARISC_NONE. */
13193 case EM_PPC64
: /* R_PPC64_NONE. */
13194 case EM_PPC
: /* R_PPC_NONE. */
13195 case EM_RISCV
: /* R_RISCV_NONE. */
13196 case EM_S390
: /* R_390_NONE. */
13198 case EM_SH
: /* R_SH_NONE. */
13199 case EM_SPARC32PLUS
:
13200 case EM_SPARC
: /* R_SPARC_NONE. */
13202 case EM_TILEGX
: /* R_TILEGX_NONE. */
13203 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13204 case EM_TI_C6000
:/* R_C6000_NONE. */
13205 case EM_X86_64
: /* R_X86_64_NONE. */
13207 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13208 return reloc_type
== 0;
13211 return reloc_type
== 0 || reloc_type
== 256;
13214 return (reloc_type
== 0 /* R_AVR_NONE. */
13215 || reloc_type
== 30 /* R_AVR_DIFF8. */
13216 || reloc_type
== 31 /* R_AVR_DIFF16. */
13217 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13219 return reloc_type
== 3; /* R_METAG_NONE. */
13221 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13222 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13223 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13224 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13225 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13227 return (reloc_type
== 0 /* R_PRU_NONE. */
13228 || reloc_type
== 65 /* R_PRU_DIFF8. */
13229 || reloc_type
== 66 /* R_PRU_DIFF16. */
13230 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13231 case EM_XTENSA_OLD
:
13233 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13234 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13235 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13236 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13241 /* Returns TRUE if there is a relocation against
13242 section NAME at OFFSET bytes. */
13245 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13247 Elf_Internal_Rela
* relocs
;
13248 Elf_Internal_Rela
* rp
;
13250 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13253 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13255 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13256 if (rp
->r_offset
== offset
)
13262 /* Apply relocations to a section.
13263 Returns TRUE upon success, FALSE otherwise.
13264 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13265 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13266 will be set to the number of relocs loaded.
13268 Note: So far support has been added only for those relocations
13269 which can be found in debug sections. FIXME: Add support for
13270 more relocations ? */
13273 apply_relocations (Filedata
* filedata
,
13274 const Elf_Internal_Shdr
* section
,
13275 unsigned char * start
,
13276 bfd_size_type size
,
13277 void ** relocs_return
,
13278 unsigned long * num_relocs_return
)
13280 Elf_Internal_Shdr
* relsec
;
13281 unsigned char * end
= start
+ size
;
13283 if (relocs_return
!= NULL
)
13285 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13286 * num_relocs_return
= 0;
13289 if (filedata
->file_header
.e_type
!= ET_REL
)
13290 /* No relocs to apply. */
13293 /* Find the reloc section associated with the section. */
13294 for (relsec
= filedata
->section_headers
;
13295 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13298 bfd_boolean is_rela
;
13299 unsigned long num_relocs
;
13300 Elf_Internal_Rela
* relocs
;
13301 Elf_Internal_Rela
* rp
;
13302 Elf_Internal_Shdr
* symsec
;
13303 Elf_Internal_Sym
* symtab
;
13304 unsigned long num_syms
;
13305 Elf_Internal_Sym
* sym
;
13307 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13308 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13309 || filedata
->section_headers
+ relsec
->sh_info
!= section
13310 || relsec
->sh_size
== 0
13311 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13314 is_rela
= relsec
->sh_type
== SHT_RELA
;
13318 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13319 relsec
->sh_size
, & relocs
, & num_relocs
))
13324 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13325 relsec
->sh_size
, & relocs
, & num_relocs
))
13329 /* SH uses RELA but uses in place value instead of the addend field. */
13330 if (filedata
->file_header
.e_machine
== EM_SH
)
13333 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13334 if (symsec
->sh_type
!= SHT_SYMTAB
13335 && symsec
->sh_type
!= SHT_DYNSYM
)
13337 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13339 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13342 unsigned int reloc_type
;
13343 unsigned int reloc_size
;
13344 bfd_boolean reloc_inplace
= FALSE
;
13345 bfd_boolean reloc_subtract
= FALSE
;
13346 unsigned char * rloc
;
13347 unsigned long sym_index
;
13349 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13351 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13353 else if (is_none_reloc (filedata
, reloc_type
))
13355 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13356 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13358 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13359 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13361 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13363 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13365 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13366 || is_6bit_abs_reloc (filedata
, reloc_type
))
13368 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13370 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13373 reloc_inplace
= TRUE
;
13375 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13377 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13380 reloc_inplace
= TRUE
;
13382 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13384 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13387 reloc_inplace
= TRUE
;
13389 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13391 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13394 reloc_inplace
= TRUE
;
13396 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13400 reloc_inplace
= TRUE
;
13404 static unsigned int prev_reloc
= 0;
13406 if (reloc_type
!= prev_reloc
)
13407 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13408 reloc_type
, printable_section_name (filedata
, section
));
13409 prev_reloc
= reloc_type
;
13413 rloc
= start
+ rp
->r_offset
;
13414 if (rloc
>= end
|| (rloc
+ reloc_size
) > end
|| (rloc
< start
))
13416 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13417 (unsigned long) rp
->r_offset
,
13418 printable_section_name (filedata
, section
));
13422 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13423 if (sym_index
>= num_syms
)
13425 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13426 sym_index
, printable_section_name (filedata
, section
));
13429 sym
= symtab
+ sym_index
;
13431 /* If the reloc has a symbol associated with it,
13432 make sure that it is of an appropriate type.
13434 Relocations against symbols without type can happen.
13435 Gcc -feliminate-dwarf2-dups may generate symbols
13436 without type for debug info.
13438 Icc generates relocations against function symbols
13439 instead of local labels.
13441 Relocations against object symbols can happen, eg when
13442 referencing a global array. For an example of this see
13443 the _clz.o binary in libgcc.a. */
13445 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13446 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13448 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13449 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13450 printable_section_name (filedata
, relsec
),
13451 (long int)(rp
- relocs
));
13457 addend
+= rp
->r_addend
;
13458 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13459 partial_inplace. */
13461 || (filedata
->file_header
.e_machine
== EM_XTENSA
13462 && reloc_type
== 1)
13463 || ((filedata
->file_header
.e_machine
== EM_PJ
13464 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13465 && reloc_type
== 1)
13466 || ((filedata
->file_header
.e_machine
== EM_D30V
13467 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13468 && reloc_type
== 12)
13471 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13472 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13474 addend
+= byte_get (rloc
, reloc_size
);
13477 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13478 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13480 /* On HPPA, all pc-relative relocations are biased by 8. */
13481 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13483 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13486 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13487 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13489 if (reloc_subtract
)
13490 addend
-= sym
->st_value
;
13492 addend
+= sym
->st_value
;
13493 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13494 byte_put (rloc
, addend
, reloc_size
);
13496 else if (reloc_subtract
)
13497 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13499 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13503 /* Let the target specific reloc processing code know that
13504 we have finished with these relocs. */
13505 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13509 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13510 * num_relocs_return
= num_relocs
;
13521 #ifdef SUPPORT_DISASSEMBLY
13523 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13525 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13527 /* FIXME: XXX -- to be done --- XXX */
13533 /* Reads in the contents of SECTION from FILE, returning a pointer
13534 to a malloc'ed buffer or NULL if something went wrong. */
13537 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13539 bfd_size_type num_bytes
= section
->sh_size
;
13541 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13543 printf (_("Section '%s' has no data to dump.\n"),
13544 printable_section_name (filedata
, section
));
13548 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13549 _("section contents"));
13552 /* Uncompresses a section that was compressed using zlib, in place. */
13555 uncompress_section_contents (unsigned char ** buffer
,
13556 dwarf_size_type uncompressed_size
,
13557 dwarf_size_type
* size
)
13559 dwarf_size_type compressed_size
= *size
;
13560 unsigned char * compressed_buffer
= *buffer
;
13561 unsigned char * uncompressed_buffer
;
13565 /* It is possible the section consists of several compressed
13566 buffers concatenated together, so we uncompress in a loop. */
13567 /* PR 18313: The state field in the z_stream structure is supposed
13568 to be invisible to the user (ie us), but some compilers will
13569 still complain about it being used without initialisation. So
13570 we first zero the entire z_stream structure and then set the fields
13572 memset (& strm
, 0, sizeof strm
);
13573 strm
.avail_in
= compressed_size
;
13574 strm
.next_in
= (Bytef
*) compressed_buffer
;
13575 strm
.avail_out
= uncompressed_size
;
13576 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13578 rc
= inflateInit (& strm
);
13579 while (strm
.avail_in
> 0)
13583 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13584 + (uncompressed_size
- strm
.avail_out
));
13585 rc
= inflate (&strm
, Z_FINISH
);
13586 if (rc
!= Z_STREAM_END
)
13588 rc
= inflateReset (& strm
);
13590 rc
= inflateEnd (& strm
);
13592 || strm
.avail_out
!= 0)
13595 *buffer
= uncompressed_buffer
;
13596 *size
= uncompressed_size
;
13600 free (uncompressed_buffer
);
13601 /* Indicate decompression failure. */
13607 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13609 Elf_Internal_Shdr
* relsec
;
13610 bfd_size_type num_bytes
;
13611 unsigned char * data
;
13612 unsigned char * end
;
13613 unsigned char * real_start
;
13614 unsigned char * start
;
13615 bfd_boolean some_strings_shown
;
13617 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13619 /* PR 21820: Do not fail if the section was empty. */
13620 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13622 num_bytes
= section
->sh_size
;
13624 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13626 if (decompress_dumps
)
13628 dwarf_size_type new_size
= num_bytes
;
13629 dwarf_size_type uncompressed_size
= 0;
13631 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13633 Elf_Internal_Chdr chdr
;
13634 unsigned int compression_header_size
13635 = get_compression_header (& chdr
, (unsigned char *) start
,
13638 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13640 warn (_("section '%s' has unsupported compress type: %d\n"),
13641 printable_section_name (filedata
, section
), chdr
.ch_type
);
13644 uncompressed_size
= chdr
.ch_size
;
13645 start
+= compression_header_size
;
13646 new_size
-= compression_header_size
;
13648 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13650 /* Read the zlib header. In this case, it should be "ZLIB"
13651 followed by the uncompressed section size, 8 bytes in
13652 big-endian order. */
13653 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13654 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13655 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13656 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13657 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13658 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13659 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13660 uncompressed_size
+= start
[11];
13665 if (uncompressed_size
)
13667 if (uncompress_section_contents (& start
,
13668 uncompressed_size
, & new_size
))
13669 num_bytes
= new_size
;
13672 error (_("Unable to decompress section %s\n"),
13673 printable_section_name (filedata
, section
));
13678 start
= real_start
;
13681 /* If the section being dumped has relocations against it the user might
13682 be expecting these relocations to have been applied. Check for this
13683 case and issue a warning message in order to avoid confusion.
13684 FIXME: Maybe we ought to have an option that dumps a section with
13685 relocs applied ? */
13686 for (relsec
= filedata
->section_headers
;
13687 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13690 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13691 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13692 || filedata
->section_headers
+ relsec
->sh_info
!= section
13693 || relsec
->sh_size
== 0
13694 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13697 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13702 end
= start
+ num_bytes
;
13703 some_strings_shown
= FALSE
;
13707 while (!ISPRINT (* data
))
13708 if (++ data
>= end
)
13713 size_t maxlen
= end
- data
;
13716 /* PR 11128: Use two separate invocations in order to work
13717 around bugs in the Solaris 8 implementation of printf. */
13718 printf (" [%6tx] ", data
- start
);
13720 printf (" [%6Ix] ", (size_t) (data
- start
));
13724 print_symbol ((int) maxlen
, (const char *) data
);
13726 data
+= strnlen ((const char *) data
, maxlen
);
13730 printf (_("<corrupt>\n"));
13733 some_strings_shown
= TRUE
;
13737 if (! some_strings_shown
)
13738 printf (_(" No strings found in this section."));
13747 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13748 Filedata
* filedata
,
13749 bfd_boolean relocate
)
13751 Elf_Internal_Shdr
* relsec
;
13752 bfd_size_type bytes
;
13753 bfd_size_type section_size
;
13755 unsigned char * data
;
13756 unsigned char * real_start
;
13757 unsigned char * start
;
13759 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13761 /* PR 21820: Do not fail if the section was empty. */
13762 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13764 section_size
= section
->sh_size
;
13766 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13768 if (decompress_dumps
)
13770 dwarf_size_type new_size
= section_size
;
13771 dwarf_size_type uncompressed_size
= 0;
13773 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13775 Elf_Internal_Chdr chdr
;
13776 unsigned int compression_header_size
13777 = get_compression_header (& chdr
, start
, section_size
);
13779 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13781 warn (_("section '%s' has unsupported compress type: %d\n"),
13782 printable_section_name (filedata
, section
), chdr
.ch_type
);
13785 uncompressed_size
= chdr
.ch_size
;
13786 start
+= compression_header_size
;
13787 new_size
-= compression_header_size
;
13789 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13791 /* Read the zlib header. In this case, it should be "ZLIB"
13792 followed by the uncompressed section size, 8 bytes in
13793 big-endian order. */
13794 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13795 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13796 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13797 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13798 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13799 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13800 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13801 uncompressed_size
+= start
[11];
13806 if (uncompressed_size
)
13808 if (uncompress_section_contents (& start
, uncompressed_size
,
13811 section_size
= new_size
;
13815 error (_("Unable to decompress section %s\n"),
13816 printable_section_name (filedata
, section
));
13817 /* FIXME: Print the section anyway ? */
13822 start
= real_start
;
13827 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13832 /* If the section being dumped has relocations against it the user might
13833 be expecting these relocations to have been applied. Check for this
13834 case and issue a warning message in order to avoid confusion.
13835 FIXME: Maybe we ought to have an option that dumps a section with
13836 relocs applied ? */
13837 for (relsec
= filedata
->section_headers
;
13838 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13841 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13842 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13843 || filedata
->section_headers
+ relsec
->sh_info
!= section
13844 || relsec
->sh_size
== 0
13845 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13848 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13853 addr
= section
->sh_addr
;
13854 bytes
= section_size
;
13863 lbytes
= (bytes
> 16 ? 16 : bytes
);
13865 printf (" 0x%8.8lx ", (unsigned long) addr
);
13867 for (j
= 0; j
< 16; j
++)
13870 printf ("%2.2x", data
[j
]);
13878 for (j
= 0; j
< lbytes
; j
++)
13881 if (k
>= ' ' && k
< 0x7f)
13900 static ctf_sect_t
*
13901 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13903 buf
->cts_name
= SECTION_NAME (shdr
);
13904 buf
->cts_size
= shdr
->sh_size
;
13905 buf
->cts_entsize
= shdr
->sh_entsize
;
13910 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13911 it is passed, or a pointer to newly-allocated storage, in which case
13912 dump_ctf() will free it when it no longer needs it. */
13914 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13915 char *s
, void *arg
)
13917 const char *blanks
= arg
;
13920 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13926 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13928 Elf_Internal_Shdr
* parent_sec
= NULL
;
13929 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13930 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13931 void * data
= NULL
;
13932 void * symdata
= NULL
;
13933 void * strdata
= NULL
;
13934 void * parentdata
= NULL
;
13935 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13936 ctf_sect_t
* symsectp
= NULL
;
13937 ctf_sect_t
* strsectp
= NULL
;
13938 ctf_file_t
* ctf
= NULL
;
13939 ctf_file_t
* parent
= NULL
;
13941 const char *things
[] = {"Header", "Labels", "Data objects",
13942 "Function objects", "Variables", "Types", "Strings",
13944 const char **thing
;
13946 bfd_boolean ret
= FALSE
;
13949 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13950 data
= get_section_contents (section
, filedata
);
13951 ctfsect
.cts_data
= data
;
13953 if (!dump_ctf_symtab_name
)
13954 dump_ctf_symtab_name
= strdup (".symtab");
13956 if (!dump_ctf_strtab_name
)
13957 dump_ctf_strtab_name
= strdup (".strtab");
13959 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
13961 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13963 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13966 if ((symdata
= (void *) get_data (NULL
, filedata
,
13967 symtab_sec
->sh_offset
, 1,
13968 symtab_sec
->sh_size
,
13969 _("symbols"))) == NULL
)
13971 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13972 symsect
.cts_data
= symdata
;
13974 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
13976 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
13978 error (_("No string table section named %s\n"),
13979 dump_ctf_strtab_name
);
13982 if ((strdata
= (void *) get_data (NULL
, filedata
,
13983 strtab_sec
->sh_offset
, 1,
13984 strtab_sec
->sh_size
,
13985 _("strings"))) == NULL
)
13987 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
13988 strsect
.cts_data
= strdata
;
13990 if (dump_ctf_parent_name
)
13992 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
13994 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
13997 if ((parentdata
= (void *) get_data (NULL
, filedata
,
13998 parent_sec
->sh_offset
, 1,
13999 parent_sec
->sh_size
,
14000 _("CTF parent"))) == NULL
)
14002 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14003 parentsect
.cts_data
= parentdata
;
14006 /* Load the CTF file and dump it. */
14008 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14010 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14016 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14018 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14022 ctf_import (ctf
, parent
);
14027 printf (_("\nDump of CTF section '%s':\n"),
14028 printable_section_name (filedata
, section
));
14030 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14032 ctf_dump_state_t
*s
= NULL
;
14035 printf ("\n %s:\n", *thing
);
14036 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14037 (void *) " ")) != NULL
)
14039 printf ("%s\n", item
);
14043 if (ctf_errno (ctf
))
14045 error (_("Iteration failed: %s, %s\n"), *thing
,
14046 ctf_errmsg (ctf_errno (ctf
)));
14052 ctf_file_close (ctf
);
14053 ctf_file_close (parent
);
14062 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14063 const Elf_Internal_Shdr
* sec
,
14066 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14068 Filedata
* filedata
= (Filedata
*) data
;
14070 if (section
->start
!= NULL
)
14072 /* If it is already loaded, do nothing. */
14073 if (streq (section
->filename
, filedata
->file_name
))
14075 free (section
->start
);
14078 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14079 section
->address
= sec
->sh_addr
;
14080 section
->user_data
= NULL
;
14081 section
->filename
= filedata
->file_name
;
14082 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14084 sec
->sh_size
, buf
);
14085 if (section
->start
== NULL
)
14089 unsigned char *start
= section
->start
;
14090 dwarf_size_type size
= sec
->sh_size
;
14091 dwarf_size_type uncompressed_size
= 0;
14093 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14095 Elf_Internal_Chdr chdr
;
14096 unsigned int compression_header_size
;
14098 if (size
< (is_32bit_elf
14099 ? sizeof (Elf32_External_Chdr
)
14100 : sizeof (Elf64_External_Chdr
)))
14102 warn (_("compressed section %s is too small to contain a compression header"),
14107 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14109 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14111 warn (_("section '%s' has unsupported compress type: %d\n"),
14112 section
->name
, chdr
.ch_type
);
14115 uncompressed_size
= chdr
.ch_size
;
14116 start
+= compression_header_size
;
14117 size
-= compression_header_size
;
14119 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14121 /* Read the zlib header. In this case, it should be "ZLIB"
14122 followed by the uncompressed section size, 8 bytes in
14123 big-endian order. */
14124 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14125 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14126 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14127 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14128 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14129 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14130 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14131 uncompressed_size
+= start
[11];
14136 if (uncompressed_size
)
14138 if (uncompress_section_contents (&start
, uncompressed_size
,
14141 /* Free the compressed buffer, update the section buffer
14142 and the section size if uncompress is successful. */
14143 free (section
->start
);
14144 section
->start
= start
;
14148 error (_("Unable to decompress section %s\n"),
14149 printable_section_name (filedata
, sec
));
14154 section
->size
= size
;
14157 if (section
->start
== NULL
)
14160 if (debug_displays
[debug
].relocate
)
14162 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14163 & section
->reloc_info
, & section
->num_relocs
))
14168 section
->reloc_info
= NULL
;
14169 section
->num_relocs
= 0;
14175 /* If this is not NULL, load_debug_section will only look for sections
14176 within the list of sections given here. */
14177 static unsigned int * section_subset
= NULL
;
14180 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14182 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14183 Elf_Internal_Shdr
* sec
;
14184 Filedata
* filedata
= (Filedata
*) data
;
14186 /* Without section headers we cannot find any sections. */
14187 if (filedata
->section_headers
== NULL
)
14190 if (filedata
->string_table
== NULL
14191 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14192 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14194 Elf_Internal_Shdr
* strs
;
14196 /* Read in the string table, so that we have section names to scan. */
14197 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14199 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14201 filedata
->string_table
14202 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14203 1, strs
->sh_size
, _("string table"));
14205 filedata
->string_table_length
14206 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14210 /* Locate the debug section. */
14211 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14213 section
->name
= section
->uncompressed_name
;
14216 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14218 section
->name
= section
->compressed_name
;
14223 /* If we're loading from a subset of sections, and we've loaded
14224 a section matching this name before, it's likely that it's a
14226 if (section_subset
!= NULL
)
14227 free_debug_section (debug
);
14229 return load_specific_debug_section (debug
, sec
, data
);
14233 free_debug_section (enum dwarf_section_display_enum debug
)
14235 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14237 if (section
->start
== NULL
)
14240 free ((char *) section
->start
);
14241 section
->start
= NULL
;
14242 section
->address
= 0;
14247 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14249 char * name
= SECTION_NAME (section
);
14250 const char * print_name
= printable_section_name (filedata
, section
);
14251 bfd_size_type length
;
14252 bfd_boolean result
= TRUE
;
14255 length
= section
->sh_size
;
14258 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14261 if (section
->sh_type
== SHT_NOBITS
)
14263 /* There is no point in dumping the contents of a debugging section
14264 which has the NOBITS type - the bits in the file will be random.
14265 This can happen when a file containing a .eh_frame section is
14266 stripped with the --only-keep-debug command line option. */
14267 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14272 if (const_strneq (name
, ".gnu.linkonce.wi."))
14273 name
= ".debug_info";
14275 /* See if we know how to display the contents of this section. */
14276 for (i
= 0; i
< max
; i
++)
14278 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14279 struct dwarf_section_display
* display
= debug_displays
+ i
;
14280 struct dwarf_section
* sec
= & display
->section
;
14282 if (streq (sec
->uncompressed_name
, name
)
14283 || (id
== line
&& const_strneq (name
, ".debug_line."))
14284 || streq (sec
->compressed_name
, name
))
14286 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14289 free_debug_section (id
);
14291 if (i
== line
&& const_strneq (name
, ".debug_line."))
14293 else if (streq (sec
->uncompressed_name
, name
))
14294 sec
->name
= sec
->uncompressed_name
;
14296 sec
->name
= sec
->compressed_name
;
14298 if (load_specific_debug_section (id
, section
, filedata
))
14300 /* If this debug section is part of a CU/TU set in a .dwp file,
14301 restrict load_debug_section to the sections in that set. */
14302 section_subset
= find_cu_tu_set (filedata
, shndx
);
14304 result
&= display
->display (sec
, filedata
);
14306 section_subset
= NULL
;
14308 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14309 free_debug_section (id
);
14317 printf (_("Unrecognized debug section: %s\n"), print_name
);
14324 /* Set DUMP_SECTS for all sections where dumps were requested
14325 based on section name. */
14328 initialise_dumps_byname (Filedata
* filedata
)
14330 struct dump_list_entry
* cur
;
14332 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14335 bfd_boolean any
= FALSE
;
14337 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14338 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14340 request_dump_bynumber (filedata
, i
, cur
->type
);
14345 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14351 process_section_contents (Filedata
* filedata
)
14353 Elf_Internal_Shdr
* section
;
14355 bfd_boolean res
= TRUE
;
14360 initialise_dumps_byname (filedata
);
14362 for (i
= 0, section
= filedata
->section_headers
;
14363 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14366 dump_type dump
= filedata
->dump_sects
[i
];
14368 #ifdef SUPPORT_DISASSEMBLY
14369 if (dump
& DISASS_DUMP
)
14371 if (! disassemble_section (section
, filedata
))
14375 if (dump
& HEX_DUMP
)
14377 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14381 if (dump
& RELOC_DUMP
)
14383 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14387 if (dump
& STRING_DUMP
)
14389 if (! dump_section_as_strings (section
, filedata
))
14393 if (dump
& DEBUG_DUMP
)
14395 if (! display_debug_section (i
, section
, filedata
))
14399 if (dump
& CTF_DUMP
)
14401 if (! dump_section_as_ctf (section
, filedata
))
14406 /* Check to see if the user requested a
14407 dump of a section that does not exist. */
14408 while (i
< filedata
->num_dump_sects
)
14410 if (filedata
->dump_sects
[i
])
14412 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14422 process_mips_fpe_exception (int mask
)
14426 bfd_boolean first
= TRUE
;
14428 if (mask
& OEX_FPU_INEX
)
14429 fputs ("INEX", stdout
), first
= FALSE
;
14430 if (mask
& OEX_FPU_UFLO
)
14431 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14432 if (mask
& OEX_FPU_OFLO
)
14433 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14434 if (mask
& OEX_FPU_DIV0
)
14435 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14436 if (mask
& OEX_FPU_INVAL
)
14437 printf ("%sINVAL", first
? "" : "|");
14440 fputs ("0", stdout
);
14443 /* Display's the value of TAG at location P. If TAG is
14444 greater than 0 it is assumed to be an unknown tag, and
14445 a message is printed to this effect. Otherwise it is
14446 assumed that a message has already been printed.
14448 If the bottom bit of TAG is set it assumed to have a
14449 string value, otherwise it is assumed to have an integer
14452 Returns an updated P pointing to the first unread byte
14453 beyond the end of TAG's value.
14455 Reads at or beyond END will not be made. */
14457 static unsigned char *
14458 display_tag_value (signed int tag
,
14460 const unsigned char * const end
)
14465 printf (" Tag_unknown_%d: ", tag
);
14469 warn (_("<corrupt tag>\n"));
14473 /* PR 17531 file: 027-19978-0.004. */
14474 size_t maxlen
= (end
- p
) - 1;
14479 print_symbol ((int) maxlen
, (const char *) p
);
14480 p
+= strnlen ((char *) p
, maxlen
) + 1;
14484 printf (_("<corrupt string tag>"));
14485 p
= (unsigned char *) end
;
14493 val
= read_uleb128 (p
, &len
, end
);
14495 printf ("%ld (0x%lx)\n", val
, val
);
14502 /* ARC ABI attributes section. */
14504 static unsigned char *
14505 display_arc_attribute (unsigned char * p
,
14506 const unsigned char * const end
)
14512 tag
= read_uleb128 (p
, &len
, end
);
14517 case Tag_ARC_PCS_config
:
14518 val
= read_uleb128 (p
, &len
, end
);
14520 printf (" Tag_ARC_PCS_config: ");
14524 printf (_("Absent/Non standard\n"));
14527 printf (_("Bare metal/mwdt\n"));
14530 printf (_("Bare metal/newlib\n"));
14533 printf (_("Linux/uclibc\n"));
14536 printf (_("Linux/glibc\n"));
14539 printf (_("Unknown\n"));
14544 case Tag_ARC_CPU_base
:
14545 val
= read_uleb128 (p
, &len
, end
);
14547 printf (" Tag_ARC_CPU_base: ");
14552 printf (_("Absent\n"));
14554 case TAG_CPU_ARC6xx
:
14555 printf ("ARC6xx\n");
14557 case TAG_CPU_ARC7xx
:
14558 printf ("ARC7xx\n");
14560 case TAG_CPU_ARCEM
:
14561 printf ("ARCEM\n");
14563 case TAG_CPU_ARCHS
:
14564 printf ("ARCHS\n");
14569 case Tag_ARC_CPU_variation
:
14570 val
= read_uleb128 (p
, &len
, end
);
14572 printf (" Tag_ARC_CPU_variation: ");
14576 if (val
> 0 && val
< 16)
14577 printf ("Core%d\n", val
);
14579 printf ("Unknown\n");
14583 printf (_("Absent\n"));
14588 case Tag_ARC_CPU_name
:
14589 printf (" Tag_ARC_CPU_name: ");
14590 p
= display_tag_value (-1, p
, end
);
14593 case Tag_ARC_ABI_rf16
:
14594 val
= read_uleb128 (p
, &len
, end
);
14596 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14599 case Tag_ARC_ABI_osver
:
14600 val
= read_uleb128 (p
, &len
, end
);
14602 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14605 case Tag_ARC_ABI_pic
:
14606 case Tag_ARC_ABI_sda
:
14607 val
= read_uleb128 (p
, &len
, end
);
14609 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14610 : " Tag_ARC_ABI_pic: ");
14614 printf (_("Absent\n"));
14623 printf (_("Unknown\n"));
14628 case Tag_ARC_ABI_tls
:
14629 val
= read_uleb128 (p
, &len
, end
);
14631 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14634 case Tag_ARC_ABI_enumsize
:
14635 val
= read_uleb128 (p
, &len
, end
);
14637 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14641 case Tag_ARC_ABI_exceptions
:
14642 val
= read_uleb128 (p
, &len
, end
);
14644 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14648 case Tag_ARC_ABI_double_size
:
14649 val
= read_uleb128 (p
, &len
, end
);
14651 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14654 case Tag_ARC_ISA_config
:
14655 printf (" Tag_ARC_ISA_config: ");
14656 p
= display_tag_value (-1, p
, end
);
14659 case Tag_ARC_ISA_apex
:
14660 printf (" Tag_ARC_ISA_apex: ");
14661 p
= display_tag_value (-1, p
, end
);
14664 case Tag_ARC_ISA_mpy_option
:
14665 val
= read_uleb128 (p
, &len
, end
);
14667 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14670 case Tag_ARC_ATR_version
:
14671 val
= read_uleb128 (p
, &len
, end
);
14673 printf (" Tag_ARC_ATR_version: %d\n", val
);
14677 return display_tag_value (tag
& 1, p
, end
);
14683 /* ARM EABI attributes section. */
14688 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14690 const char ** table
;
14691 } arm_attr_public_tag
;
14693 static const char * arm_attr_tag_CPU_arch
[] =
14694 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14695 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14696 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14697 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14698 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14699 {"No", "Thumb-1", "Thumb-2", "Yes"};
14700 static const char * arm_attr_tag_FP_arch
[] =
14701 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14702 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14703 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14704 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14705 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14706 "NEON for ARMv8.1"};
14707 static const char * arm_attr_tag_PCS_config
[] =
14708 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14709 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14710 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14711 {"V6", "SB", "TLS", "Unused"};
14712 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14713 {"Absolute", "PC-relative", "SB-relative", "None"};
14714 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14715 {"Absolute", "PC-relative", "None"};
14716 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14717 {"None", "direct", "GOT-indirect"};
14718 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14719 {"None", "??? 1", "2", "??? 3", "4"};
14720 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14721 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14722 {"Unused", "Needed", "Sign only"};
14723 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14724 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14725 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14726 {"Unused", "Finite", "RTABI", "IEEE 754"};
14727 static const char * arm_attr_tag_ABI_enum_size
[] =
14728 {"Unused", "small", "int", "forced to int"};
14729 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14730 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14731 static const char * arm_attr_tag_ABI_VFP_args
[] =
14732 {"AAPCS", "VFP registers", "custom", "compatible"};
14733 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14734 {"AAPCS", "WMMX registers", "custom"};
14735 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14736 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14737 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14738 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14739 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14740 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14741 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14742 static const char * arm_attr_tag_FP_HP_extension
[] =
14743 {"Not Allowed", "Allowed"};
14744 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14745 {"None", "IEEE 754", "Alternative Format"};
14746 static const char * arm_attr_tag_DSP_extension
[] =
14747 {"Follow architecture", "Allowed"};
14748 static const char * arm_attr_tag_MPextension_use
[] =
14749 {"Not Allowed", "Allowed"};
14750 static const char * arm_attr_tag_DIV_use
[] =
14751 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14752 "Allowed in v7-A with integer division extension"};
14753 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14754 static const char * arm_attr_tag_Virtualization_use
[] =
14755 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14756 "TrustZone and Virtualization Extensions"};
14757 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14758 {"Not Allowed", "Allowed"};
14760 static const char * arm_attr_tag_MVE_arch
[] =
14761 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14763 #define LOOKUP(id, name) \
14764 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14765 static arm_attr_public_tag arm_attr_public_tags
[] =
14767 {4, "CPU_raw_name", 1, NULL
},
14768 {5, "CPU_name", 1, NULL
},
14769 LOOKUP(6, CPU_arch
),
14770 {7, "CPU_arch_profile", 0, NULL
},
14771 LOOKUP(8, ARM_ISA_use
),
14772 LOOKUP(9, THUMB_ISA_use
),
14773 LOOKUP(10, FP_arch
),
14774 LOOKUP(11, WMMX_arch
),
14775 LOOKUP(12, Advanced_SIMD_arch
),
14776 LOOKUP(13, PCS_config
),
14777 LOOKUP(14, ABI_PCS_R9_use
),
14778 LOOKUP(15, ABI_PCS_RW_data
),
14779 LOOKUP(16, ABI_PCS_RO_data
),
14780 LOOKUP(17, ABI_PCS_GOT_use
),
14781 LOOKUP(18, ABI_PCS_wchar_t
),
14782 LOOKUP(19, ABI_FP_rounding
),
14783 LOOKUP(20, ABI_FP_denormal
),
14784 LOOKUP(21, ABI_FP_exceptions
),
14785 LOOKUP(22, ABI_FP_user_exceptions
),
14786 LOOKUP(23, ABI_FP_number_model
),
14787 {24, "ABI_align_needed", 0, NULL
},
14788 {25, "ABI_align_preserved", 0, NULL
},
14789 LOOKUP(26, ABI_enum_size
),
14790 LOOKUP(27, ABI_HardFP_use
),
14791 LOOKUP(28, ABI_VFP_args
),
14792 LOOKUP(29, ABI_WMMX_args
),
14793 LOOKUP(30, ABI_optimization_goals
),
14794 LOOKUP(31, ABI_FP_optimization_goals
),
14795 {32, "compatibility", 0, NULL
},
14796 LOOKUP(34, CPU_unaligned_access
),
14797 LOOKUP(36, FP_HP_extension
),
14798 LOOKUP(38, ABI_FP_16bit_format
),
14799 LOOKUP(42, MPextension_use
),
14800 LOOKUP(44, DIV_use
),
14801 LOOKUP(46, DSP_extension
),
14802 LOOKUP(48, MVE_arch
),
14803 {64, "nodefaults", 0, NULL
},
14804 {65, "also_compatible_with", 0, NULL
},
14805 LOOKUP(66, T2EE_use
),
14806 {67, "conformance", 1, NULL
},
14807 LOOKUP(68, Virtualization_use
),
14808 LOOKUP(70, MPextension_use_legacy
)
14812 static unsigned char *
14813 display_arm_attribute (unsigned char * p
,
14814 const unsigned char * const end
)
14819 arm_attr_public_tag
* attr
;
14823 tag
= read_uleb128 (p
, &len
, end
);
14826 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14828 if (arm_attr_public_tags
[i
].tag
== tag
)
14830 attr
= &arm_attr_public_tags
[i
];
14837 printf (" Tag_%s: ", attr
->name
);
14838 switch (attr
->type
)
14843 case 7: /* Tag_CPU_arch_profile. */
14844 val
= read_uleb128 (p
, &len
, end
);
14848 case 0: printf (_("None\n")); break;
14849 case 'A': printf (_("Application\n")); break;
14850 case 'R': printf (_("Realtime\n")); break;
14851 case 'M': printf (_("Microcontroller\n")); break;
14852 case 'S': printf (_("Application or Realtime\n")); break;
14853 default: printf ("??? (%d)\n", val
); break;
14857 case 24: /* Tag_align_needed. */
14858 val
= read_uleb128 (p
, &len
, end
);
14862 case 0: printf (_("None\n")); break;
14863 case 1: printf (_("8-byte\n")); break;
14864 case 2: printf (_("4-byte\n")); break;
14865 case 3: printf ("??? 3\n"); break;
14868 printf (_("8-byte and up to %d-byte extended\n"),
14871 printf ("??? (%d)\n", val
);
14876 case 25: /* Tag_align_preserved. */
14877 val
= read_uleb128 (p
, &len
, end
);
14881 case 0: printf (_("None\n")); break;
14882 case 1: printf (_("8-byte, except leaf SP\n")); break;
14883 case 2: printf (_("8-byte\n")); break;
14884 case 3: printf ("??? 3\n"); break;
14887 printf (_("8-byte and up to %d-byte extended\n"),
14890 printf ("??? (%d)\n", val
);
14895 case 32: /* Tag_compatibility. */
14897 val
= read_uleb128 (p
, &len
, end
);
14899 printf (_("flag = %d, vendor = "), val
);
14902 size_t maxlen
= (end
- p
) - 1;
14904 print_symbol ((int) maxlen
, (const char *) p
);
14905 p
+= strnlen ((char *) p
, maxlen
) + 1;
14909 printf (_("<corrupt>"));
14910 p
= (unsigned char *) end
;
14916 case 64: /* Tag_nodefaults. */
14917 /* PR 17531: file: 001-505008-0.01. */
14920 printf (_("True\n"));
14923 case 65: /* Tag_also_compatible_with. */
14924 val
= read_uleb128 (p
, &len
, end
);
14926 if (val
== 6 /* Tag_CPU_arch. */)
14928 val
= read_uleb128 (p
, &len
, end
);
14930 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14931 printf ("??? (%d)\n", val
);
14933 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14937 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14942 printf (_("<unknown: %d>\n"), tag
);
14948 return display_tag_value (-1, p
, end
);
14950 return display_tag_value (0, p
, end
);
14953 assert (attr
->type
& 0x80);
14954 val
= read_uleb128 (p
, &len
, end
);
14956 type
= attr
->type
& 0x7f;
14958 printf ("??? (%d)\n", val
);
14960 printf ("%s\n", attr
->table
[val
]);
14965 return display_tag_value (tag
, p
, end
);
14968 static unsigned char *
14969 display_gnu_attribute (unsigned char * p
,
14970 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14971 const unsigned char * const end
)
14977 tag
= read_uleb128 (p
, &len
, end
);
14980 /* Tag_compatibility is the only generic GNU attribute defined at
14984 val
= read_uleb128 (p
, &len
, end
);
14987 printf (_("flag = %d, vendor = "), val
);
14990 printf (_("<corrupt>\n"));
14991 warn (_("corrupt vendor attribute\n"));
14997 size_t maxlen
= (end
- p
) - 1;
14999 print_symbol ((int) maxlen
, (const char *) p
);
15000 p
+= strnlen ((char *) p
, maxlen
) + 1;
15004 printf (_("<corrupt>"));
15005 p
= (unsigned char *) end
;
15012 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15013 return display_proc_gnu_attribute (p
, tag
, end
);
15015 return display_tag_value (tag
, p
, end
);
15018 static unsigned char *
15019 display_power_gnu_attribute (unsigned char * p
,
15021 const unsigned char * const end
)
15026 if (tag
== Tag_GNU_Power_ABI_FP
)
15028 val
= read_uleb128 (p
, &len
, end
);
15030 printf (" Tag_GNU_Power_ABI_FP: ");
15033 printf (_("<corrupt>\n"));
15038 printf ("(%#x), ", val
);
15043 printf (_("unspecified hard/soft float, "));
15046 printf (_("hard float, "));
15049 printf (_("soft float, "));
15052 printf (_("single-precision hard float, "));
15059 printf (_("unspecified long double\n"));
15062 printf (_("128-bit IBM long double\n"));
15065 printf (_("64-bit long double\n"));
15068 printf (_("128-bit IEEE long double\n"));
15074 if (tag
== Tag_GNU_Power_ABI_Vector
)
15076 val
= read_uleb128 (p
, &len
, end
);
15078 printf (" Tag_GNU_Power_ABI_Vector: ");
15081 printf (_("<corrupt>\n"));
15086 printf ("(%#x), ", val
);
15091 printf (_("unspecified\n"));
15094 printf (_("generic\n"));
15097 printf ("AltiVec\n");
15106 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15108 val
= read_uleb128 (p
, &len
, end
);
15110 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15113 printf (_("<corrupt>\n"));
15118 printf ("(%#x), ", val
);
15123 printf (_("unspecified\n"));
15126 printf ("r3/r4\n");
15129 printf (_("memory\n"));
15138 return display_tag_value (tag
& 1, p
, end
);
15141 static unsigned char *
15142 display_s390_gnu_attribute (unsigned char * p
,
15144 const unsigned char * const end
)
15149 if (tag
== Tag_GNU_S390_ABI_Vector
)
15151 val
= read_uleb128 (p
, &len
, end
);
15153 printf (" Tag_GNU_S390_ABI_Vector: ");
15158 printf (_("any\n"));
15161 printf (_("software\n"));
15164 printf (_("hardware\n"));
15167 printf ("??? (%d)\n", val
);
15173 return display_tag_value (tag
& 1, p
, end
);
15177 display_sparc_hwcaps (unsigned int mask
)
15181 bfd_boolean first
= TRUE
;
15183 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15184 fputs ("mul32", stdout
), first
= FALSE
;
15185 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15186 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15187 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15188 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15189 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15190 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15191 if (mask
& ELF_SPARC_HWCAP_POPC
)
15192 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15193 if (mask
& ELF_SPARC_HWCAP_VIS
)
15194 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15195 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15196 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15197 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15198 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15199 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15200 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15201 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15202 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15203 if (mask
& ELF_SPARC_HWCAP_HPC
)
15204 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15205 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15206 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15207 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15208 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15209 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15210 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15211 if (mask
& ELF_SPARC_HWCAP_IMA
)
15212 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15213 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15214 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15217 fputc ('0', stdout
);
15218 fputc ('\n', stdout
);
15222 display_sparc_hwcaps2 (unsigned int mask
)
15226 bfd_boolean first
= TRUE
;
15228 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15229 fputs ("fjathplus", stdout
), first
= FALSE
;
15230 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15231 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15232 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15233 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15234 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15235 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15236 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15237 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15238 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15239 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15240 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15241 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15242 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15243 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15244 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15245 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15246 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15247 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15248 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15249 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15252 fputc ('0', stdout
);
15253 fputc ('\n', stdout
);
15256 static unsigned char *
15257 display_sparc_gnu_attribute (unsigned char * p
,
15259 const unsigned char * const end
)
15264 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15266 val
= read_uleb128 (p
, &len
, end
);
15268 printf (" Tag_GNU_Sparc_HWCAPS: ");
15269 display_sparc_hwcaps (val
);
15272 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15274 val
= read_uleb128 (p
, &len
, end
);
15276 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15277 display_sparc_hwcaps2 (val
);
15281 return display_tag_value (tag
, p
, end
);
15285 print_mips_fp_abi_value (unsigned int val
)
15289 case Val_GNU_MIPS_ABI_FP_ANY
:
15290 printf (_("Hard or soft float\n"));
15292 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15293 printf (_("Hard float (double precision)\n"));
15295 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15296 printf (_("Hard float (single precision)\n"));
15298 case Val_GNU_MIPS_ABI_FP_SOFT
:
15299 printf (_("Soft float\n"));
15301 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15302 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15304 case Val_GNU_MIPS_ABI_FP_XX
:
15305 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15307 case Val_GNU_MIPS_ABI_FP_64
:
15308 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15310 case Val_GNU_MIPS_ABI_FP_64A
:
15311 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15313 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15314 printf (_("NaN 2008 compatibility\n"));
15317 printf ("??? (%d)\n", val
);
15322 static unsigned char *
15323 display_mips_gnu_attribute (unsigned char * p
,
15325 const unsigned char * const end
)
15327 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15332 val
= read_uleb128 (p
, &len
, end
);
15334 printf (" Tag_GNU_MIPS_ABI_FP: ");
15336 print_mips_fp_abi_value (val
);
15341 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15346 val
= read_uleb128 (p
, &len
, end
);
15348 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15352 case Val_GNU_MIPS_ABI_MSA_ANY
:
15353 printf (_("Any MSA or not\n"));
15355 case Val_GNU_MIPS_ABI_MSA_128
:
15356 printf (_("128-bit MSA\n"));
15359 printf ("??? (%d)\n", val
);
15365 return display_tag_value (tag
& 1, p
, end
);
15368 static unsigned char *
15369 display_tic6x_attribute (unsigned char * p
,
15370 const unsigned char * const end
)
15376 tag
= read_uleb128 (p
, &len
, end
);
15382 val
= read_uleb128 (p
, &len
, end
);
15384 printf (" Tag_ISA: ");
15388 case C6XABI_Tag_ISA_none
:
15389 printf (_("None\n"));
15391 case C6XABI_Tag_ISA_C62X
:
15394 case C6XABI_Tag_ISA_C67X
:
15397 case C6XABI_Tag_ISA_C67XP
:
15398 printf ("C67x+\n");
15400 case C6XABI_Tag_ISA_C64X
:
15403 case C6XABI_Tag_ISA_C64XP
:
15404 printf ("C64x+\n");
15406 case C6XABI_Tag_ISA_C674X
:
15407 printf ("C674x\n");
15410 printf ("??? (%d)\n", val
);
15415 case Tag_ABI_wchar_t
:
15416 val
= read_uleb128 (p
, &len
, end
);
15418 printf (" Tag_ABI_wchar_t: ");
15422 printf (_("Not used\n"));
15425 printf (_("2 bytes\n"));
15428 printf (_("4 bytes\n"));
15431 printf ("??? (%d)\n", val
);
15436 case Tag_ABI_stack_align_needed
:
15437 val
= read_uleb128 (p
, &len
, end
);
15439 printf (" Tag_ABI_stack_align_needed: ");
15443 printf (_("8-byte\n"));
15446 printf (_("16-byte\n"));
15449 printf ("??? (%d)\n", val
);
15454 case Tag_ABI_stack_align_preserved
:
15455 val
= read_uleb128 (p
, &len
, end
);
15457 printf (" Tag_ABI_stack_align_preserved: ");
15461 printf (_("8-byte\n"));
15464 printf (_("16-byte\n"));
15467 printf ("??? (%d)\n", val
);
15473 val
= read_uleb128 (p
, &len
, end
);
15475 printf (" Tag_ABI_DSBT: ");
15479 printf (_("DSBT addressing not used\n"));
15482 printf (_("DSBT addressing used\n"));
15485 printf ("??? (%d)\n", val
);
15491 val
= read_uleb128 (p
, &len
, end
);
15493 printf (" Tag_ABI_PID: ");
15497 printf (_("Data addressing position-dependent\n"));
15500 printf (_("Data addressing position-independent, GOT near DP\n"));
15503 printf (_("Data addressing position-independent, GOT far from DP\n"));
15506 printf ("??? (%d)\n", val
);
15512 val
= read_uleb128 (p
, &len
, end
);
15514 printf (" Tag_ABI_PIC: ");
15518 printf (_("Code addressing position-dependent\n"));
15521 printf (_("Code addressing position-independent\n"));
15524 printf ("??? (%d)\n", val
);
15529 case Tag_ABI_array_object_alignment
:
15530 val
= read_uleb128 (p
, &len
, end
);
15532 printf (" Tag_ABI_array_object_alignment: ");
15536 printf (_("8-byte\n"));
15539 printf (_("4-byte\n"));
15542 printf (_("16-byte\n"));
15545 printf ("??? (%d)\n", val
);
15550 case Tag_ABI_array_object_align_expected
:
15551 val
= read_uleb128 (p
, &len
, end
);
15553 printf (" Tag_ABI_array_object_align_expected: ");
15557 printf (_("8-byte\n"));
15560 printf (_("4-byte\n"));
15563 printf (_("16-byte\n"));
15566 printf ("??? (%d)\n", val
);
15571 case Tag_ABI_compatibility
:
15573 val
= read_uleb128 (p
, &len
, end
);
15575 printf (" Tag_ABI_compatibility: ");
15576 printf (_("flag = %d, vendor = "), val
);
15579 size_t maxlen
= (end
- p
) - 1;
15581 print_symbol ((int) maxlen
, (const char *) p
);
15582 p
+= strnlen ((char *) p
, maxlen
) + 1;
15586 printf (_("<corrupt>"));
15587 p
= (unsigned char *) end
;
15593 case Tag_ABI_conformance
:
15595 printf (" Tag_ABI_conformance: \"");
15598 size_t maxlen
= (end
- p
) - 1;
15600 print_symbol ((int) maxlen
, (const char *) p
);
15601 p
+= strnlen ((char *) p
, maxlen
) + 1;
15605 printf (_("<corrupt>"));
15606 p
= (unsigned char *) end
;
15613 return display_tag_value (tag
, p
, end
);
15617 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15619 unsigned long addr
= 0;
15620 size_t bytes
= end
- p
;
15627 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15629 printf (" 0x%8.8lx ", addr
);
15631 for (j
= 0; j
< 16; j
++)
15634 printf ("%2.2x", p
[j
]);
15642 for (j
= 0; j
< lbytes
; j
++)
15645 if (k
>= ' ' && k
< 0x7f)
15661 static unsigned char *
15662 display_msp430x_attribute (unsigned char * p
,
15663 const unsigned char * const end
)
15669 tag
= read_uleb128 (p
, & len
, end
);
15674 case OFBA_MSPABI_Tag_ISA
:
15675 val
= read_uleb128 (p
, &len
, end
);
15677 printf (" Tag_ISA: ");
15680 case 0: printf (_("None\n")); break;
15681 case 1: printf (_("MSP430\n")); break;
15682 case 2: printf (_("MSP430X\n")); break;
15683 default: printf ("??? (%d)\n", val
); break;
15687 case OFBA_MSPABI_Tag_Code_Model
:
15688 val
= read_uleb128 (p
, &len
, end
);
15690 printf (" Tag_Code_Model: ");
15693 case 0: printf (_("None\n")); break;
15694 case 1: printf (_("Small\n")); break;
15695 case 2: printf (_("Large\n")); break;
15696 default: printf ("??? (%d)\n", val
); break;
15700 case OFBA_MSPABI_Tag_Data_Model
:
15701 val
= read_uleb128 (p
, &len
, end
);
15703 printf (" Tag_Data_Model: ");
15706 case 0: printf (_("None\n")); break;
15707 case 1: printf (_("Small\n")); break;
15708 case 2: printf (_("Large\n")); break;
15709 case 3: printf (_("Restricted Large\n")); break;
15710 default: printf ("??? (%d)\n", val
); break;
15715 printf (_(" <unknown tag %d>: "), tag
);
15722 size_t maxlen
= (end
- p
) - 1;
15724 print_symbol ((int) maxlen
, (const char *) p
);
15725 p
+= strnlen ((char *) p
, maxlen
) + 1;
15729 printf (_("<corrupt>"));
15730 p
= (unsigned char *) end
;
15736 val
= read_uleb128 (p
, &len
, end
);
15738 printf ("%d (0x%x)\n", val
, val
);
15747 static unsigned char *
15748 display_msp430_gnu_attribute (unsigned char * p
,
15750 const unsigned char * const end
)
15752 if (tag
== Tag_GNU_MSP430_Data_Region
)
15757 val
= read_uleb128 (p
, &len
, end
);
15759 printf (" Tag_GNU_MSP430_Data_Region: ");
15763 case Val_GNU_MSP430_Data_Region_Any
:
15764 printf (_("Any Region\n"));
15766 case Val_GNU_MSP430_Data_Region_Lower
:
15767 printf (_("Lower Region Only\n"));
15770 printf ("??? (%d)\n", val
);
15774 return display_tag_value (tag
& 1, p
, end
);
15777 struct riscv_attr_tag_t
{
15782 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15784 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15787 T(priv_spec_minor
),
15788 T(priv_spec_revision
),
15789 T(unaligned_access
),
15794 static unsigned char *
15795 display_riscv_attribute (unsigned char *p
,
15796 const unsigned char * const end
)
15801 struct riscv_attr_tag_t
*attr
= NULL
;
15804 tag
= read_uleb128 (p
, &len
, end
);
15807 /* Find the name of attribute. */
15808 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15810 if (riscv_attr_tag
[i
].tag
== tag
)
15812 attr
= &riscv_attr_tag
[i
];
15818 printf (" %s: ", attr
->name
);
15820 return display_tag_value (tag
, p
, end
);
15824 case Tag_RISCV_priv_spec
:
15825 case Tag_RISCV_priv_spec_minor
:
15826 case Tag_RISCV_priv_spec_revision
:
15827 val
= read_uleb128 (p
, &len
, end
);
15829 printf (_("%d\n"), val
);
15831 case Tag_RISCV_unaligned_access
:
15832 val
= read_uleb128 (p
, &len
, end
);
15837 printf (_("No unaligned access\n"));
15840 printf (_("Unaligned access\n"));
15844 case Tag_RISCV_stack_align
:
15845 val
= read_uleb128 (p
, &len
, end
);
15847 printf (_("%d-bytes\n"), val
);
15849 case Tag_RISCV_arch
:
15850 p
= display_tag_value (-1, p
, end
);
15853 return display_tag_value (tag
, p
, end
);
15860 process_attributes (Filedata
* filedata
,
15861 const char * public_name
,
15862 unsigned int proc_type
,
15863 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15864 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15866 Elf_Internal_Shdr
* sect
;
15868 bfd_boolean res
= TRUE
;
15870 /* Find the section header so that we get the size. */
15871 for (i
= 0, sect
= filedata
->section_headers
;
15872 i
< filedata
->file_header
.e_shnum
;
15875 unsigned char * contents
;
15878 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15881 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15882 sect
->sh_size
, _("attributes"));
15883 if (contents
== NULL
)
15890 /* The first character is the version of the attributes.
15891 Currently only version 1, (aka 'A') is recognised here. */
15894 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15899 bfd_vma section_len
;
15901 section_len
= sect
->sh_size
- 1;
15904 while (section_len
> 0)
15907 unsigned int namelen
;
15908 bfd_boolean public_section
;
15909 bfd_boolean gnu_section
;
15911 if (section_len
<= 4)
15913 error (_("Tag section ends prematurely\n"));
15917 attr_len
= byte_get (p
, 4);
15920 if (attr_len
> section_len
)
15922 error (_("Bad attribute length (%u > %u)\n"),
15923 (unsigned) attr_len
, (unsigned) section_len
);
15924 attr_len
= section_len
;
15927 /* PR 17531: file: 001-101425-0.004 */
15928 else if (attr_len
< 5)
15930 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15935 section_len
-= attr_len
;
15938 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15939 if (namelen
== 0 || namelen
>= attr_len
)
15941 error (_("Corrupt attribute section name\n"));
15946 printf (_("Attribute Section: "));
15947 print_symbol (INT_MAX
, (const char *) p
);
15950 if (public_name
&& streq ((char *) p
, public_name
))
15951 public_section
= TRUE
;
15953 public_section
= FALSE
;
15955 if (streq ((char *) p
, "gnu"))
15956 gnu_section
= TRUE
;
15958 gnu_section
= FALSE
;
15961 attr_len
-= namelen
;
15963 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15968 unsigned char * end
;
15970 /* PR binutils/17531: Safe handling of corrupt files. */
15973 error (_("Unused bytes at end of section\n"));
15980 size
= byte_get (p
, 4);
15981 if (size
> attr_len
)
15983 error (_("Bad subsection length (%u > %u)\n"),
15984 (unsigned) size
, (unsigned) attr_len
);
15988 /* PR binutils/17531: Safe handling of corrupt files. */
15991 error (_("Bad subsection length (%u < 6)\n"),
15999 end
= p
+ size
- 1;
16000 assert (end
<= contents
+ sect
->sh_size
);
16006 printf (_("File Attributes\n"));
16009 printf (_("Section Attributes:"));
16012 printf (_("Symbol Attributes:"));
16013 /* Fall through. */
16019 val
= read_uleb128 (p
, &j
, end
);
16023 printf (" %d", val
);
16028 printf (_("Unknown tag: %d\n"), tag
);
16029 public_section
= FALSE
;
16033 if (public_section
&& display_pub_attribute
!= NULL
)
16036 p
= display_pub_attribute (p
, end
);
16039 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16042 p
= display_gnu_attribute (p
,
16043 display_proc_gnu_attribute
,
16049 printf (_(" Unknown attribute:\n"));
16050 display_raw_attribute (p
, end
);
16065 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16066 Print the Address, Access and Initial fields of an entry at VMA ADDR
16067 and return the VMA of the next entry, or -1 if there was a problem.
16068 Does not read from DATA_END or beyond. */
16071 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16072 unsigned char * data_end
)
16075 print_vma (addr
, LONG_HEX
);
16077 if (addr
< pltgot
+ 0xfff0)
16078 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16080 printf ("%10s", "");
16083 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16087 unsigned char * from
= data
+ addr
- pltgot
;
16089 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16091 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16092 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16093 return (bfd_vma
) -1;
16097 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16098 print_vma (entry
, LONG_HEX
);
16101 return addr
+ (is_32bit_elf
? 4 : 8);
16104 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16105 PLTGOT. Print the Address and Initial fields of an entry at VMA
16106 ADDR and return the VMA of the next entry. */
16109 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16112 print_vma (addr
, LONG_HEX
);
16115 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16120 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16121 print_vma (entry
, LONG_HEX
);
16123 return addr
+ (is_32bit_elf
? 4 : 8);
16127 print_mips_ases (unsigned int mask
)
16129 if (mask
& AFL_ASE_DSP
)
16130 fputs ("\n\tDSP ASE", stdout
);
16131 if (mask
& AFL_ASE_DSPR2
)
16132 fputs ("\n\tDSP R2 ASE", stdout
);
16133 if (mask
& AFL_ASE_DSPR3
)
16134 fputs ("\n\tDSP R3 ASE", stdout
);
16135 if (mask
& AFL_ASE_EVA
)
16136 fputs ("\n\tEnhanced VA Scheme", stdout
);
16137 if (mask
& AFL_ASE_MCU
)
16138 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16139 if (mask
& AFL_ASE_MDMX
)
16140 fputs ("\n\tMDMX ASE", stdout
);
16141 if (mask
& AFL_ASE_MIPS3D
)
16142 fputs ("\n\tMIPS-3D ASE", stdout
);
16143 if (mask
& AFL_ASE_MT
)
16144 fputs ("\n\tMT ASE", stdout
);
16145 if (mask
& AFL_ASE_SMARTMIPS
)
16146 fputs ("\n\tSmartMIPS ASE", stdout
);
16147 if (mask
& AFL_ASE_VIRT
)
16148 fputs ("\n\tVZ ASE", stdout
);
16149 if (mask
& AFL_ASE_MSA
)
16150 fputs ("\n\tMSA ASE", stdout
);
16151 if (mask
& AFL_ASE_MIPS16
)
16152 fputs ("\n\tMIPS16 ASE", stdout
);
16153 if (mask
& AFL_ASE_MICROMIPS
)
16154 fputs ("\n\tMICROMIPS ASE", stdout
);
16155 if (mask
& AFL_ASE_XPA
)
16156 fputs ("\n\tXPA ASE", stdout
);
16157 if (mask
& AFL_ASE_MIPS16E2
)
16158 fputs ("\n\tMIPS16e2 ASE", stdout
);
16159 if (mask
& AFL_ASE_CRC
)
16160 fputs ("\n\tCRC ASE", stdout
);
16161 if (mask
& AFL_ASE_GINV
)
16162 fputs ("\n\tGINV ASE", stdout
);
16163 if (mask
& AFL_ASE_LOONGSON_MMI
)
16164 fputs ("\n\tLoongson MMI ASE", stdout
);
16165 if (mask
& AFL_ASE_LOONGSON_CAM
)
16166 fputs ("\n\tLoongson CAM ASE", stdout
);
16167 if (mask
& AFL_ASE_LOONGSON_EXT
)
16168 fputs ("\n\tLoongson EXT ASE", stdout
);
16169 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16170 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16172 fprintf (stdout
, "\n\t%s", _("None"));
16173 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16174 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16178 print_mips_isa_ext (unsigned int isa_ext
)
16183 fputs (_("None"), stdout
);
16186 fputs ("RMI XLR", stdout
);
16188 case AFL_EXT_OCTEON3
:
16189 fputs ("Cavium Networks Octeon3", stdout
);
16191 case AFL_EXT_OCTEON2
:
16192 fputs ("Cavium Networks Octeon2", stdout
);
16194 case AFL_EXT_OCTEONP
:
16195 fputs ("Cavium Networks OcteonP", stdout
);
16197 case AFL_EXT_OCTEON
:
16198 fputs ("Cavium Networks Octeon", stdout
);
16201 fputs ("Toshiba R5900", stdout
);
16204 fputs ("MIPS R4650", stdout
);
16207 fputs ("LSI R4010", stdout
);
16210 fputs ("NEC VR4100", stdout
);
16213 fputs ("Toshiba R3900", stdout
);
16215 case AFL_EXT_10000
:
16216 fputs ("MIPS R10000", stdout
);
16219 fputs ("Broadcom SB-1", stdout
);
16222 fputs ("NEC VR4111/VR4181", stdout
);
16225 fputs ("NEC VR4120", stdout
);
16228 fputs ("NEC VR5400", stdout
);
16231 fputs ("NEC VR5500", stdout
);
16233 case AFL_EXT_LOONGSON_2E
:
16234 fputs ("ST Microelectronics Loongson 2E", stdout
);
16236 case AFL_EXT_LOONGSON_2F
:
16237 fputs ("ST Microelectronics Loongson 2F", stdout
);
16239 case AFL_EXT_INTERAPTIV_MR2
:
16240 fputs ("Imagination interAptiv MR2", stdout
);
16243 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16248 get_mips_reg_size (int reg_size
)
16250 return (reg_size
== AFL_REG_NONE
) ? 0
16251 : (reg_size
== AFL_REG_32
) ? 32
16252 : (reg_size
== AFL_REG_64
) ? 64
16253 : (reg_size
== AFL_REG_128
) ? 128
16258 process_mips_specific (Filedata
* filedata
)
16260 Elf_Internal_Dyn
* entry
;
16261 Elf_Internal_Shdr
*sect
= NULL
;
16262 size_t liblist_offset
= 0;
16263 size_t liblistno
= 0;
16264 size_t conflictsno
= 0;
16265 size_t options_offset
= 0;
16266 size_t conflicts_offset
= 0;
16267 size_t pltrelsz
= 0;
16269 bfd_vma pltgot
= 0;
16270 bfd_vma mips_pltgot
= 0;
16271 bfd_vma jmprel
= 0;
16272 bfd_vma local_gotno
= 0;
16273 bfd_vma gotsym
= 0;
16274 bfd_vma symtabno
= 0;
16275 bfd_boolean res
= TRUE
;
16277 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16278 display_mips_gnu_attribute
))
16281 sect
= find_section (filedata
, ".MIPS.abiflags");
16285 Elf_External_ABIFlags_v0
*abiflags_ext
;
16286 Elf_Internal_ABIFlags_v0 abiflags_in
;
16288 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16290 error (_("Corrupt MIPS ABI Flags section.\n"));
16295 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16296 sect
->sh_size
, _("MIPS ABI Flags section"));
16299 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16300 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16301 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16302 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16303 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16304 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16305 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16306 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16307 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16308 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16309 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16311 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16312 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16313 if (abiflags_in
.isa_rev
> 1)
16314 printf ("r%d", abiflags_in
.isa_rev
);
16315 printf ("\nGPR size: %d",
16316 get_mips_reg_size (abiflags_in
.gpr_size
));
16317 printf ("\nCPR1 size: %d",
16318 get_mips_reg_size (abiflags_in
.cpr1_size
));
16319 printf ("\nCPR2 size: %d",
16320 get_mips_reg_size (abiflags_in
.cpr2_size
));
16321 fputs ("\nFP ABI: ", stdout
);
16322 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16323 fputs ("ISA Extension: ", stdout
);
16324 print_mips_isa_ext (abiflags_in
.isa_ext
);
16325 fputs ("\nASEs:", stdout
);
16326 print_mips_ases (abiflags_in
.ases
);
16327 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16328 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16329 fputc ('\n', stdout
);
16330 free (abiflags_ext
);
16335 /* We have a lot of special sections. Thanks SGI! */
16336 if (dynamic_section
== NULL
)
16338 /* No dynamic information available. See if there is static GOT. */
16339 sect
= find_section (filedata
, ".got");
16342 unsigned char *data_end
;
16343 unsigned char *data
;
16347 pltgot
= sect
->sh_addr
;
16350 addr_size
= (is_32bit_elf
? 4 : 8);
16351 end
= pltgot
+ sect
->sh_size
;
16353 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16355 _("Global Offset Table data"));
16356 /* PR 12855: Null data is handled gracefully throughout. */
16357 data_end
= data
+ (end
- pltgot
);
16359 printf (_("\nStatic GOT:\n"));
16360 printf (_(" Canonical gp value: "));
16361 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16364 /* In a dynamic binary GOT[0] is reserved for the dynamic
16365 loader to store the lazy resolver pointer, however in
16366 a static binary it may well have been omitted and GOT
16367 reduced to a table of addresses.
16368 PR 21344: Check for the entry being fully available
16369 before fetching it. */
16371 && data
+ ent
- pltgot
+ addr_size
<= data_end
16372 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16374 printf (_(" Reserved entries:\n"));
16375 printf (_(" %*s %10s %*s\n"),
16376 addr_size
* 2, _("Address"), _("Access"),
16377 addr_size
* 2, _("Value"));
16378 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16380 if (ent
== (bfd_vma
) -1)
16381 goto sgot_print_fail
;
16383 /* Check for the MSB of GOT[1] being set, identifying a
16384 GNU object. This entry will be used by some runtime
16385 loaders, to store the module pointer. Otherwise this
16386 is an ordinary local entry.
16387 PR 21344: Check for the entry being fully available
16388 before fetching it. */
16390 && data
+ ent
- pltgot
+ addr_size
<= data_end
16391 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16392 >> (addr_size
* 8 - 1)) != 0)
16394 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16396 if (ent
== (bfd_vma
) -1)
16397 goto sgot_print_fail
;
16402 if (data
!= NULL
&& ent
< end
)
16404 printf (_(" Local entries:\n"));
16405 printf (" %*s %10s %*s\n",
16406 addr_size
* 2, _("Address"), _("Access"),
16407 addr_size
* 2, _("Value"));
16410 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16412 if (ent
== (bfd_vma
) -1)
16413 goto sgot_print_fail
;
16425 for (entry
= dynamic_section
;
16426 /* PR 17531 file: 012-50589-0.004. */
16427 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16429 switch (entry
->d_tag
)
16431 case DT_MIPS_LIBLIST
:
16433 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16434 liblistno
* sizeof (Elf32_External_Lib
));
16436 case DT_MIPS_LIBLISTNO
:
16437 liblistno
= entry
->d_un
.d_val
;
16439 case DT_MIPS_OPTIONS
:
16440 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16442 case DT_MIPS_CONFLICT
:
16444 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16445 conflictsno
* sizeof (Elf32_External_Conflict
));
16447 case DT_MIPS_CONFLICTNO
:
16448 conflictsno
= entry
->d_un
.d_val
;
16451 pltgot
= entry
->d_un
.d_ptr
;
16453 case DT_MIPS_LOCAL_GOTNO
:
16454 local_gotno
= entry
->d_un
.d_val
;
16456 case DT_MIPS_GOTSYM
:
16457 gotsym
= entry
->d_un
.d_val
;
16459 case DT_MIPS_SYMTABNO
:
16460 symtabno
= entry
->d_un
.d_val
;
16462 case DT_MIPS_PLTGOT
:
16463 mips_pltgot
= entry
->d_un
.d_ptr
;
16466 pltrel
= entry
->d_un
.d_val
;
16469 pltrelsz
= entry
->d_un
.d_val
;
16472 jmprel
= entry
->d_un
.d_ptr
;
16478 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16480 Elf32_External_Lib
* elib
;
16483 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16485 sizeof (Elf32_External_Lib
),
16486 _("liblist section data"));
16489 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16490 "\nSection '.liblist' contains %lu entries:\n",
16491 (unsigned long) liblistno
),
16492 (unsigned long) liblistno
);
16493 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16496 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16503 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16504 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16505 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16506 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16507 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16509 tmp
= gmtime (&atime
);
16510 snprintf (timebuf
, sizeof (timebuf
),
16511 "%04u-%02u-%02uT%02u:%02u:%02u",
16512 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16513 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16515 printf ("%3lu: ", (unsigned long) cnt
);
16516 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16517 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16519 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16520 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16521 liblist
.l_version
);
16523 if (liblist
.l_flags
== 0)
16527 static const struct
16534 { " EXACT_MATCH", LL_EXACT_MATCH
},
16535 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16536 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16537 { " EXPORTS", LL_EXPORTS
},
16538 { " DELAY_LOAD", LL_DELAY_LOAD
},
16539 { " DELTA", LL_DELTA
}
16541 int flags
= liblist
.l_flags
;
16544 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16545 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16547 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16548 flags
^= l_flags_vals
[fcnt
].bit
;
16551 printf (" %#x", (unsigned int) flags
);
16563 if (options_offset
!= 0)
16565 Elf_External_Options
* eopt
;
16568 sect
= filedata
->section_headers
;
16570 /* Find the section header so that we get the size. */
16571 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16572 /* PR 17533 file: 012-277276-0.004. */
16575 error (_("No MIPS_OPTIONS header found\n"));
16579 if (sect
->sh_size
< sizeof (* eopt
))
16581 error (_("The MIPS options section is too small.\n"));
16585 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16586 sect
->sh_size
, _("options"));
16589 Elf_Internal_Options
* iopt
;
16590 Elf_Internal_Options
* option
;
16591 Elf_Internal_Options
* iopt_end
;
16593 iopt
= (Elf_Internal_Options
*)
16594 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16597 error (_("Out of memory allocating space for MIPS options\n"));
16603 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16605 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16607 Elf_External_Options
* eoption
;
16609 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16611 option
->kind
= BYTE_GET (eoption
->kind
);
16612 option
->size
= BYTE_GET (eoption
->size
);
16613 option
->section
= BYTE_GET (eoption
->section
);
16614 option
->info
= BYTE_GET (eoption
->info
);
16616 /* PR 17531: file: ffa0fa3b. */
16617 if (option
->size
< sizeof (* eopt
)
16618 || offset
+ option
->size
> sect
->sh_size
)
16620 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16623 offset
+= option
->size
;
16629 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16630 "\nSection '%s' contains %d entries:\n",
16632 printable_section_name (filedata
, sect
), cnt
);
16641 switch (option
->kind
)
16644 /* This shouldn't happen. */
16645 printf (" NULL %d %lx", option
->section
, option
->info
);
16649 printf (" REGINFO ");
16650 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16652 Elf32_External_RegInfo
* ereg
;
16653 Elf32_RegInfo reginfo
;
16656 if (option
+ 2 > iopt_end
)
16658 printf (_("<corrupt>\n"));
16659 error (_("Truncated MIPS REGINFO option\n"));
16664 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16666 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16667 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16668 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16669 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16670 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16671 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16673 printf ("GPR %08lx GP 0x%lx\n",
16674 reginfo
.ri_gprmask
,
16675 (unsigned long) reginfo
.ri_gp_value
);
16676 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16677 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16678 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16683 Elf64_External_RegInfo
* ereg
;
16684 Elf64_Internal_RegInfo reginfo
;
16686 if (option
+ 2 > iopt_end
)
16688 printf (_("<corrupt>\n"));
16689 error (_("Truncated MIPS REGINFO option\n"));
16694 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16695 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16696 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16697 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16698 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16699 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16700 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16702 printf ("GPR %08lx GP 0x",
16703 reginfo
.ri_gprmask
);
16704 printf_vma (reginfo
.ri_gp_value
);
16707 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16708 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16709 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16714 case ODK_EXCEPTIONS
:
16715 fputs (" EXCEPTIONS fpe_min(", stdout
);
16716 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16717 fputs (") fpe_max(", stdout
);
16718 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16719 fputs (")", stdout
);
16721 if (option
->info
& OEX_PAGE0
)
16722 fputs (" PAGE0", stdout
);
16723 if (option
->info
& OEX_SMM
)
16724 fputs (" SMM", stdout
);
16725 if (option
->info
& OEX_FPDBUG
)
16726 fputs (" FPDBUG", stdout
);
16727 if (option
->info
& OEX_DISMISS
)
16728 fputs (" DISMISS", stdout
);
16732 fputs (" PAD ", stdout
);
16733 if (option
->info
& OPAD_PREFIX
)
16734 fputs (" PREFIX", stdout
);
16735 if (option
->info
& OPAD_POSTFIX
)
16736 fputs (" POSTFIX", stdout
);
16737 if (option
->info
& OPAD_SYMBOL
)
16738 fputs (" SYMBOL", stdout
);
16742 fputs (" HWPATCH ", stdout
);
16743 if (option
->info
& OHW_R4KEOP
)
16744 fputs (" R4KEOP", stdout
);
16745 if (option
->info
& OHW_R8KPFETCH
)
16746 fputs (" R8KPFETCH", stdout
);
16747 if (option
->info
& OHW_R5KEOP
)
16748 fputs (" R5KEOP", stdout
);
16749 if (option
->info
& OHW_R5KCVTL
)
16750 fputs (" R5KCVTL", stdout
);
16754 fputs (" FILL ", stdout
);
16755 /* XXX Print content of info word? */
16759 fputs (" TAGS ", stdout
);
16760 /* XXX Print content of info word? */
16764 fputs (" HWAND ", stdout
);
16765 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16766 fputs (" R4KEOP_CHECKED", stdout
);
16767 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16768 fputs (" R4KEOP_CLEAN", stdout
);
16772 fputs (" HWOR ", stdout
);
16773 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16774 fputs (" R4KEOP_CHECKED", stdout
);
16775 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16776 fputs (" R4KEOP_CLEAN", stdout
);
16780 printf (" GP_GROUP %#06lx self-contained %#06lx",
16781 option
->info
& OGP_GROUP
,
16782 (option
->info
& OGP_SELF
) >> 16);
16786 printf (" IDENT %#06lx self-contained %#06lx",
16787 option
->info
& OGP_GROUP
,
16788 (option
->info
& OGP_SELF
) >> 16);
16792 /* This shouldn't happen. */
16793 printf (" %3d ??? %d %lx",
16794 option
->kind
, option
->section
, option
->info
);
16798 len
= sizeof (* eopt
);
16799 while (len
< option
->size
)
16801 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16803 if (ISPRINT (datum
))
16804 printf ("%c", datum
);
16806 printf ("\\%03o", datum
);
16809 fputs ("\n", stdout
);
16811 offset
+= option
->size
;
16821 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16823 Elf32_Conflict
* iconf
;
16826 if (dynamic_symbols
== NULL
)
16828 error (_("conflict list found without a dynamic symbol table\n"));
16832 /* PR 21345 - print a slightly more helpful error message
16833 if we are sure that the cmalloc will fail. */
16834 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16836 error (_("Overlarge number of conflicts detected: %lx\n"),
16837 (long) conflictsno
);
16841 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16844 error (_("Out of memory allocating space for dynamic conflicts\n"));
16850 Elf32_External_Conflict
* econf32
;
16852 econf32
= (Elf32_External_Conflict
*)
16853 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16854 sizeof (* econf32
), _("conflict"));
16858 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16859 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16865 Elf64_External_Conflict
* econf64
;
16867 econf64
= (Elf64_External_Conflict
*)
16868 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16869 sizeof (* econf64
), _("conflict"));
16873 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16874 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16879 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16880 "\nSection '.conflict' contains %lu entries:\n",
16881 (unsigned long) conflictsno
),
16882 (unsigned long) conflictsno
);
16883 puts (_(" Num: Index Value Name"));
16885 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16887 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16889 if (iconf
[cnt
] >= num_dynamic_syms
)
16890 printf (_("<corrupt symbol index>"));
16893 Elf_Internal_Sym
* psym
;
16895 psym
= & dynamic_symbols
[iconf
[cnt
]];
16896 print_vma (psym
->st_value
, FULL_HEX
);
16898 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16899 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16901 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16909 if (pltgot
!= 0 && local_gotno
!= 0)
16911 bfd_vma ent
, local_end
, global_end
;
16913 unsigned char * data
;
16914 unsigned char * data_end
;
16918 addr_size
= (is_32bit_elf
? 4 : 8);
16919 local_end
= pltgot
+ local_gotno
* addr_size
;
16921 /* PR binutils/17533 file: 012-111227-0.004 */
16922 if (symtabno
< gotsym
)
16924 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16925 (unsigned long) gotsym
, (unsigned long) symtabno
);
16929 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16930 /* PR 17531: file: 54c91a34. */
16931 if (global_end
< local_end
)
16933 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16937 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16938 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16939 global_end
- pltgot
, 1,
16940 _("Global Offset Table data"));
16941 /* PR 12855: Null data is handled gracefully throughout. */
16942 data_end
= data
+ (global_end
- pltgot
);
16944 printf (_("\nPrimary GOT:\n"));
16945 printf (_(" Canonical gp value: "));
16946 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16949 printf (_(" Reserved entries:\n"));
16950 printf (_(" %*s %10s %*s Purpose\n"),
16951 addr_size
* 2, _("Address"), _("Access"),
16952 addr_size
* 2, _("Initial"));
16953 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16954 printf (_(" Lazy resolver\n"));
16955 if (ent
== (bfd_vma
) -1)
16956 goto got_print_fail
;
16958 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16959 This entry will be used by some runtime loaders, to store the
16960 module pointer. Otherwise this is an ordinary local entry.
16961 PR 21344: Check for the entry being fully available before
16964 && data
+ ent
- pltgot
+ addr_size
<= data_end
16965 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16966 >> (addr_size
* 8 - 1)) != 0)
16968 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16969 printf (_(" Module pointer (GNU extension)\n"));
16970 if (ent
== (bfd_vma
) -1)
16971 goto got_print_fail
;
16975 if (data
!= NULL
&& ent
< local_end
)
16977 printf (_(" Local entries:\n"));
16978 printf (" %*s %10s %*s\n",
16979 addr_size
* 2, _("Address"), _("Access"),
16980 addr_size
* 2, _("Initial"));
16981 while (ent
< local_end
)
16983 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16985 if (ent
== (bfd_vma
) -1)
16986 goto got_print_fail
;
16991 if (data
!= NULL
&& gotsym
< symtabno
)
16995 printf (_(" Global entries:\n"));
16996 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16997 addr_size
* 2, _("Address"),
16999 addr_size
* 2, _("Initial"),
17000 addr_size
* 2, _("Sym.Val."),
17002 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17003 _("Ndx"), _("Name"));
17005 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17007 for (i
= gotsym
; i
< symtabno
; i
++)
17009 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17012 if (dynamic_symbols
== NULL
)
17013 printf (_("<no dynamic symbols>"));
17014 else if (i
< num_dynamic_syms
)
17016 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17018 print_vma (psym
->st_value
, LONG_HEX
);
17019 printf (" %-7s %3s ",
17020 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17021 get_symbol_index_type (filedata
, psym
->st_shndx
));
17023 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17024 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17026 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17029 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17030 (unsigned long) i
);
17033 if (ent
== (bfd_vma
) -1)
17044 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17047 size_t offset
, rel_offset
;
17048 unsigned long count
, i
;
17049 unsigned char * data
;
17050 int addr_size
, sym_width
;
17051 Elf_Internal_Rela
* rels
;
17053 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17054 if (pltrel
== DT_RELA
)
17056 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17061 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17066 addr_size
= (is_32bit_elf
? 4 : 8);
17067 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17069 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17070 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17071 1, _("Procedure Linkage Table data"));
17075 printf ("\nPLT GOT:\n\n");
17076 printf (_(" Reserved entries:\n"));
17077 printf (_(" %*s %*s Purpose\n"),
17078 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17079 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17080 printf (_(" PLT lazy resolver\n"));
17081 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17082 printf (_(" Module pointer\n"));
17085 printf (_(" Entries:\n"));
17086 printf (" %*s %*s %*s %-7s %3s %s\n",
17087 addr_size
* 2, _("Address"),
17088 addr_size
* 2, _("Initial"),
17089 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17090 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17091 for (i
= 0; i
< count
; i
++)
17093 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17095 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17098 if (idx
>= num_dynamic_syms
)
17099 printf (_("<corrupt symbol index: %lu>"), idx
);
17102 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17104 print_vma (psym
->st_value
, LONG_HEX
);
17105 printf (" %-7s %3s ",
17106 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17107 get_symbol_index_type (filedata
, psym
->st_shndx
));
17108 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17109 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17111 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17126 process_nds32_specific (Filedata
* filedata
)
17128 Elf_Internal_Shdr
*sect
= NULL
;
17130 sect
= find_section (filedata
, ".nds32_e_flags");
17133 unsigned int *flag
;
17135 printf ("\nNDS32 elf flags section:\n");
17136 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17137 sect
->sh_size
, _("NDS32 elf flags section"));
17142 switch ((*flag
) & 0x3)
17145 printf ("(VEC_SIZE):\tNo entry.\n");
17148 printf ("(VEC_SIZE):\t4 bytes\n");
17151 printf ("(VEC_SIZE):\t16 bytes\n");
17154 printf ("(VEC_SIZE):\treserved\n");
17163 process_gnu_liblist (Filedata
* filedata
)
17165 Elf_Internal_Shdr
* section
;
17166 Elf_Internal_Shdr
* string_sec
;
17167 Elf32_External_Lib
* elib
;
17169 size_t strtab_size
;
17171 unsigned long num_liblist
;
17173 bfd_boolean res
= TRUE
;
17178 for (i
= 0, section
= filedata
->section_headers
;
17179 i
< filedata
->file_header
.e_shnum
;
17182 switch (section
->sh_type
)
17184 case SHT_GNU_LIBLIST
:
17185 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17188 elib
= (Elf32_External_Lib
*)
17189 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17190 _("liblist section data"));
17198 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17199 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17200 string_sec
->sh_size
,
17201 _("liblist string table"));
17203 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17210 strtab_size
= string_sec
->sh_size
;
17212 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17213 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17214 "\nLibrary list section '%s' contains %lu entries:\n",
17216 printable_section_name (filedata
, section
),
17219 puts (_(" Library Time Stamp Checksum Version Flags"));
17221 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17229 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17230 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17231 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17232 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17233 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17235 tmp
= gmtime (&atime
);
17236 snprintf (timebuf
, sizeof (timebuf
),
17237 "%04u-%02u-%02uT%02u:%02u:%02u",
17238 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17239 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17241 printf ("%3lu: ", (unsigned long) cnt
);
17243 printf ("%-20s", liblist
.l_name
< strtab_size
17244 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17246 printf ("%-20.20s", liblist
.l_name
< strtab_size
17247 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17248 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17249 liblist
.l_version
, liblist
.l_flags
);
17260 static const char *
17261 get_note_type (Filedata
* filedata
, unsigned e_type
)
17263 static char buff
[64];
17265 if (filedata
->file_header
.e_type
== ET_CORE
)
17269 return _("NT_AUXV (auxiliary vector)");
17271 return _("NT_PRSTATUS (prstatus structure)");
17273 return _("NT_FPREGSET (floating point registers)");
17275 return _("NT_PRPSINFO (prpsinfo structure)");
17276 case NT_TASKSTRUCT
:
17277 return _("NT_TASKSTRUCT (task structure)");
17279 return _("NT_PRXFPREG (user_xfpregs structure)");
17281 return _("NT_PPC_VMX (ppc Altivec registers)");
17283 return _("NT_PPC_VSX (ppc VSX registers)");
17285 return _("NT_PPC_TAR (ppc TAR register)");
17287 return _("NT_PPC_PPR (ppc PPR register)");
17289 return _("NT_PPC_DSCR (ppc DSCR register)");
17291 return _("NT_PPC_EBB (ppc EBB registers)");
17293 return _("NT_PPC_PMU (ppc PMU registers)");
17294 case NT_PPC_TM_CGPR
:
17295 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17296 case NT_PPC_TM_CFPR
:
17297 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17298 case NT_PPC_TM_CVMX
:
17299 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17300 case NT_PPC_TM_CVSX
:
17301 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17302 case NT_PPC_TM_SPR
:
17303 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17304 case NT_PPC_TM_CTAR
:
17305 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17306 case NT_PPC_TM_CPPR
:
17307 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17308 case NT_PPC_TM_CDSCR
:
17309 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17311 return _("NT_386_TLS (x86 TLS information)");
17312 case NT_386_IOPERM
:
17313 return _("NT_386_IOPERM (x86 I/O permissions)");
17314 case NT_X86_XSTATE
:
17315 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17316 case NT_S390_HIGH_GPRS
:
17317 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17318 case NT_S390_TIMER
:
17319 return _("NT_S390_TIMER (s390 timer register)");
17320 case NT_S390_TODCMP
:
17321 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17322 case NT_S390_TODPREG
:
17323 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17325 return _("NT_S390_CTRS (s390 control registers)");
17326 case NT_S390_PREFIX
:
17327 return _("NT_S390_PREFIX (s390 prefix register)");
17328 case NT_S390_LAST_BREAK
:
17329 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17330 case NT_S390_SYSTEM_CALL
:
17331 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17333 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17334 case NT_S390_VXRS_LOW
:
17335 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17336 case NT_S390_VXRS_HIGH
:
17337 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17338 case NT_S390_GS_CB
:
17339 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17340 case NT_S390_GS_BC
:
17341 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17343 return _("NT_ARM_VFP (arm VFP registers)");
17345 return _("NT_ARM_TLS (AArch TLS registers)");
17346 case NT_ARM_HW_BREAK
:
17347 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17348 case NT_ARM_HW_WATCH
:
17349 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17351 return _("NT_PSTATUS (pstatus structure)");
17353 return _("NT_FPREGS (floating point registers)");
17355 return _("NT_PSINFO (psinfo structure)");
17357 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17359 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17360 case NT_WIN32PSTATUS
:
17361 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17363 return _("NT_SIGINFO (siginfo_t data)");
17365 return _("NT_FILE (mapped files)");
17373 return _("NT_VERSION (version)");
17375 return _("NT_ARCH (architecture)");
17376 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17378 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17384 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17389 print_core_note (Elf_Internal_Note
*pnote
)
17391 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17392 bfd_vma count
, page_size
;
17393 unsigned char *descdata
, *filenames
, *descend
;
17395 if (pnote
->type
!= NT_FILE
)
17405 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17406 /* Still "successful". */
17411 if (pnote
->descsz
< 2 * addr_size
)
17413 error (_(" Malformed note - too short for header\n"));
17417 descdata
= (unsigned char *) pnote
->descdata
;
17418 descend
= descdata
+ pnote
->descsz
;
17420 if (descdata
[pnote
->descsz
- 1] != '\0')
17422 error (_(" Malformed note - does not end with \\0\n"));
17426 count
= byte_get (descdata
, addr_size
);
17427 descdata
+= addr_size
;
17429 page_size
= byte_get (descdata
, addr_size
);
17430 descdata
+= addr_size
;
17432 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17433 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17435 error (_(" Malformed note - too short for supplied file count\n"));
17439 printf (_(" Page size: "));
17440 print_vma (page_size
, DEC
);
17443 printf (_(" %*s%*s%*s\n"),
17444 (int) (2 + 2 * addr_size
), _("Start"),
17445 (int) (4 + 2 * addr_size
), _("End"),
17446 (int) (4 + 2 * addr_size
), _("Page Offset"));
17447 filenames
= descdata
+ count
* 3 * addr_size
;
17448 while (count
-- > 0)
17450 bfd_vma start
, end
, file_ofs
;
17452 if (filenames
== descend
)
17454 error (_(" Malformed note - filenames end too early\n"));
17458 start
= byte_get (descdata
, addr_size
);
17459 descdata
+= addr_size
;
17460 end
= byte_get (descdata
, addr_size
);
17461 descdata
+= addr_size
;
17462 file_ofs
= byte_get (descdata
, addr_size
);
17463 descdata
+= addr_size
;
17466 print_vma (start
, FULL_HEX
);
17468 print_vma (end
, FULL_HEX
);
17470 print_vma (file_ofs
, FULL_HEX
);
17471 printf ("\n %s\n", filenames
);
17473 filenames
+= 1 + strlen ((char *) filenames
);
17479 static const char *
17480 get_gnu_elf_note_type (unsigned e_type
)
17482 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17485 case NT_GNU_ABI_TAG
:
17486 return _("NT_GNU_ABI_TAG (ABI version tag)");
17488 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17489 case NT_GNU_BUILD_ID
:
17490 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17491 case NT_GNU_GOLD_VERSION
:
17492 return _("NT_GNU_GOLD_VERSION (gold version)");
17493 case NT_GNU_PROPERTY_TYPE_0
:
17494 return _("NT_GNU_PROPERTY_TYPE_0");
17495 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17496 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17497 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17498 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17501 static char buff
[64];
17503 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17510 decode_x86_compat_isa (unsigned int bitmask
)
17514 unsigned int bit
= bitmask
& (- bitmask
);
17519 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17522 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17525 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17528 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17531 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17534 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17537 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17540 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17543 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17546 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17549 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17552 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17553 printf ("AVX512F");
17555 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17556 printf ("AVX512CD");
17558 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17559 printf ("AVX512ER");
17561 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17562 printf ("AVX512PF");
17564 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17565 printf ("AVX512VL");
17567 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17568 printf ("AVX512DQ");
17570 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17571 printf ("AVX512BW");
17574 printf (_("<unknown: %x>"), bit
);
17583 decode_x86_isa (unsigned int bitmask
)
17587 printf (_("<None>"));
17593 unsigned int bit
= bitmask
& (- bitmask
);
17598 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17601 case GNU_PROPERTY_X86_ISA_1_SSE
:
17604 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17607 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17610 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17613 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17616 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17619 case GNU_PROPERTY_X86_ISA_1_AVX
:
17622 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17625 case GNU_PROPERTY_X86_ISA_1_FMA
:
17628 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17629 printf ("AVX512F");
17631 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17632 printf ("AVX512CD");
17634 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17635 printf ("AVX512ER");
17637 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17638 printf ("AVX512PF");
17640 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17641 printf ("AVX512VL");
17643 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17644 printf ("AVX512DQ");
17646 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17647 printf ("AVX512BW");
17649 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17650 printf ("AVX512_4FMAPS");
17652 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17653 printf ("AVX512_4VNNIW");
17655 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17656 printf ("AVX512_BITALG");
17658 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17659 printf ("AVX512_IFMA");
17661 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17662 printf ("AVX512_VBMI");
17664 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17665 printf ("AVX512_VBMI2");
17667 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17668 printf ("AVX512_VNNI");
17670 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17671 printf ("AVX512_BF16");
17674 printf (_("<unknown: %x>"), bit
);
17683 decode_x86_feature_1 (unsigned int bitmask
)
17687 printf (_("<None>"));
17693 unsigned int bit
= bitmask
& (- bitmask
);
17698 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17701 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17705 printf (_("<unknown: %x>"), bit
);
17714 decode_x86_feature_2 (unsigned int bitmask
)
17718 printf (_("<None>"));
17724 unsigned int bit
= bitmask
& (- bitmask
);
17729 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17732 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17735 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17738 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17741 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17744 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17747 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17750 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17753 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17754 printf ("XSAVEOPT");
17756 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17760 printf (_("<unknown: %x>"), bit
);
17769 decode_aarch64_feature_1_and (unsigned int bitmask
)
17773 unsigned int bit
= bitmask
& (- bitmask
);
17778 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17782 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17787 printf (_("<unknown: %x>"), bit
);
17796 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17798 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17799 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17800 unsigned int size
= is_32bit_elf
? 4 : 8;
17802 printf (_(" Properties: "));
17804 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17806 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17810 while (ptr
< ptr_end
)
17814 unsigned int datasz
;
17816 if ((size_t) (ptr_end
- ptr
) < 8)
17818 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17822 type
= byte_get (ptr
, 4);
17823 datasz
= byte_get (ptr
+ 4, 4);
17827 if (datasz
> (size_t) (ptr_end
- ptr
))
17829 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17834 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17836 if (filedata
->file_header
.e_machine
== EM_X86_64
17837 || filedata
->file_header
.e_machine
== EM_IAMCU
17838 || filedata
->file_header
.e_machine
== EM_386
)
17840 unsigned int bitmask
;
17843 bitmask
= byte_get (ptr
, 4);
17849 case GNU_PROPERTY_X86_ISA_1_USED
:
17851 printf (_("x86 ISA used: <corrupt length: %#x> "),
17855 printf ("x86 ISA used: ");
17856 decode_x86_isa (bitmask
);
17860 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17862 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17866 printf ("x86 ISA needed: ");
17867 decode_x86_isa (bitmask
);
17871 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17873 printf (_("x86 feature: <corrupt length: %#x> "),
17877 printf ("x86 feature: ");
17878 decode_x86_feature_1 (bitmask
);
17882 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17884 printf (_("x86 feature used: <corrupt length: %#x> "),
17888 printf ("x86 feature used: ");
17889 decode_x86_feature_2 (bitmask
);
17893 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17895 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17898 printf ("x86 feature needed: ");
17899 decode_x86_feature_2 (bitmask
);
17903 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17905 printf (_("x86 ISA used: <corrupt length: %#x> "),
17909 printf ("x86 ISA used: ");
17910 decode_x86_compat_isa (bitmask
);
17914 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17916 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17920 printf ("x86 ISA needed: ");
17921 decode_x86_compat_isa (bitmask
);
17929 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
17931 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
17933 printf ("AArch64 feature: ");
17935 printf (_("<corrupt length: %#x> "), datasz
);
17937 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
17946 case GNU_PROPERTY_STACK_SIZE
:
17947 printf (_("stack size: "));
17948 if (datasz
!= size
)
17949 printf (_("<corrupt length: %#x> "), datasz
);
17951 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17954 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17955 printf ("no copy on protected ");
17957 printf (_("<corrupt length: %#x> "), datasz
);
17965 if (type
< GNU_PROPERTY_LOPROC
)
17966 printf (_("<unknown type %#x data: "), type
);
17967 else if (type
< GNU_PROPERTY_LOUSER
)
17968 printf (_("<procesor-specific type %#x data: "), type
);
17970 printf (_("<application-specific type %#x data: "), type
);
17971 for (j
= 0; j
< datasz
; ++j
)
17972 printf ("%02x ", ptr
[j
] & 0xff);
17976 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17977 if (ptr
== ptr_end
)
17990 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17992 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17993 switch (pnote
->type
)
17995 case NT_GNU_BUILD_ID
:
17999 printf (_(" Build ID: "));
18000 for (i
= 0; i
< pnote
->descsz
; ++i
)
18001 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18006 case NT_GNU_ABI_TAG
:
18008 unsigned long os
, major
, minor
, subminor
;
18009 const char *osname
;
18011 /* PR 17531: file: 030-599401-0.004. */
18012 if (pnote
->descsz
< 16)
18014 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18018 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18019 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18020 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18021 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18025 case GNU_ABI_TAG_LINUX
:
18028 case GNU_ABI_TAG_HURD
:
18031 case GNU_ABI_TAG_SOLARIS
:
18032 osname
= "Solaris";
18034 case GNU_ABI_TAG_FREEBSD
:
18035 osname
= "FreeBSD";
18037 case GNU_ABI_TAG_NETBSD
:
18040 case GNU_ABI_TAG_SYLLABLE
:
18041 osname
= "Syllable";
18043 case GNU_ABI_TAG_NACL
:
18047 osname
= "Unknown";
18051 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18052 major
, minor
, subminor
);
18056 case NT_GNU_GOLD_VERSION
:
18060 printf (_(" Version: "));
18061 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18062 printf ("%c", pnote
->descdata
[i
]);
18069 unsigned long num_entries
, mask
;
18071 /* Hardware capabilities information. Word 0 is the number of entries.
18072 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18073 is a series of entries, where each entry is a single byte followed
18074 by a nul terminated string. The byte gives the bit number to test
18075 if enabled in the bitmask. */
18076 printf (_(" Hardware Capabilities: "));
18077 if (pnote
->descsz
< 8)
18079 error (_("<corrupt GNU_HWCAP>\n"));
18082 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18083 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18084 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18085 /* FIXME: Add code to display the entries... */
18089 case NT_GNU_PROPERTY_TYPE_0
:
18090 print_gnu_property_note (filedata
, pnote
);
18094 /* Handle unrecognised types. An error message should have already been
18095 created by get_gnu_elf_note_type(), so all that we need to do is to
18096 display the data. */
18100 printf (_(" Description data: "));
18101 for (i
= 0; i
< pnote
->descsz
; ++i
)
18102 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18111 static const char *
18112 get_v850_elf_note_type (enum v850_notes n_type
)
18114 static char buff
[64];
18118 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18119 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18120 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18121 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18122 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18123 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18125 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18131 print_v850_note (Elf_Internal_Note
* pnote
)
18135 if (pnote
->descsz
!= 4)
18138 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18142 printf (_("not set\n"));
18146 switch (pnote
->type
)
18148 case V850_NOTE_ALIGNMENT
:
18151 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18152 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18156 case V850_NOTE_DATA_SIZE
:
18159 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18160 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18164 case V850_NOTE_FPU_INFO
:
18167 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18168 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18172 case V850_NOTE_MMU_INFO
:
18173 case V850_NOTE_CACHE_INFO
:
18174 case V850_NOTE_SIMD_INFO
:
18175 if (val
== EF_RH850_SIMD
)
18177 printf (_("yes\n"));
18183 /* An 'unknown note type' message will already have been displayed. */
18187 printf (_("unknown value: %x\n"), val
);
18192 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18194 unsigned int version
;
18196 switch (pnote
->type
)
18198 case NT_NETBSD_IDENT
:
18199 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18200 if ((version
/ 10000) % 100)
18201 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18202 version
, version
/ 100000000, (version
/ 1000000) % 100,
18203 (version
/ 10000) % 100 > 26 ? "Z" : "",
18204 'A' + (version
/ 10000) % 26);
18206 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18207 version
, version
/ 100000000, (version
/ 1000000) % 100,
18208 (version
/ 100) % 100);
18211 case NT_NETBSD_MARCH
:
18212 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18216 #ifdef NT_NETBSD_PAX
18217 case NT_NETBSD_PAX
:
18218 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18219 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18220 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18221 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18222 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18223 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18224 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18225 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18230 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18236 static const char *
18237 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18241 case NT_FREEBSD_THRMISC
:
18242 return _("NT_THRMISC (thrmisc structure)");
18243 case NT_FREEBSD_PROCSTAT_PROC
:
18244 return _("NT_PROCSTAT_PROC (proc data)");
18245 case NT_FREEBSD_PROCSTAT_FILES
:
18246 return _("NT_PROCSTAT_FILES (files data)");
18247 case NT_FREEBSD_PROCSTAT_VMMAP
:
18248 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18249 case NT_FREEBSD_PROCSTAT_GROUPS
:
18250 return _("NT_PROCSTAT_GROUPS (groups data)");
18251 case NT_FREEBSD_PROCSTAT_UMASK
:
18252 return _("NT_PROCSTAT_UMASK (umask data)");
18253 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18254 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18255 case NT_FREEBSD_PROCSTAT_OSREL
:
18256 return _("NT_PROCSTAT_OSREL (osreldate data)");
18257 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18258 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18259 case NT_FREEBSD_PROCSTAT_AUXV
:
18260 return _("NT_PROCSTAT_AUXV (auxv data)");
18261 case NT_FREEBSD_PTLWPINFO
:
18262 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18264 return get_note_type (filedata
, e_type
);
18267 static const char *
18268 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18270 static char buff
[64];
18274 case NT_NETBSDCORE_PROCINFO
:
18275 /* NetBSD core "procinfo" structure. */
18276 return _("NetBSD procinfo structure");
18278 #ifdef NT_NETBSDCORE_AUXV
18279 case NT_NETBSDCORE_AUXV
:
18280 return _("NetBSD ELF auxiliary vector data");
18284 /* As of Jan 2002 there are no other machine-independent notes
18285 defined for NetBSD core files. If the note type is less
18286 than the start of the machine-dependent note types, we don't
18289 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18291 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18297 switch (filedata
->file_header
.e_machine
)
18299 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18300 and PT_GETFPREGS == mach+2. */
18305 case EM_SPARC32PLUS
:
18309 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18310 return _("PT_GETREGS (reg structure)");
18311 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18312 return _("PT_GETFPREGS (fpreg structure)");
18318 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18319 There's also old PT___GETREGS40 == mach + 1 for old reg
18320 structure which lacks GBR. */
18324 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18325 return _("PT___GETREGS40 (old reg structure)");
18326 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18327 return _("PT_GETREGS (reg structure)");
18328 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18329 return _("PT_GETFPREGS (fpreg structure)");
18335 /* On all other arch's, PT_GETREGS == mach+1 and
18336 PT_GETFPREGS == mach+3. */
18340 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18341 return _("PT_GETREGS (reg structure)");
18342 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18343 return _("PT_GETFPREGS (fpreg structure)");
18349 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18350 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18354 static const char *
18355 get_stapsdt_note_type (unsigned e_type
)
18357 static char buff
[64];
18362 return _("NT_STAPSDT (SystemTap probe descriptors)");
18368 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18373 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18375 size_t len
, maxlen
;
18376 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18377 char *data
= pnote
->descdata
;
18378 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18379 bfd_vma pc
, base_addr
, semaphore
;
18380 char *provider
, *probe
, *arg_fmt
;
18382 if (pnote
->descsz
< (addr_size
* 3))
18383 goto stapdt_note_too_small
;
18385 pc
= byte_get ((unsigned char *) data
, addr_size
);
18388 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18391 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18394 if (data
>= data_end
)
18395 goto stapdt_note_too_small
;
18396 maxlen
= data_end
- data
;
18397 len
= strnlen (data
, maxlen
);
18404 goto stapdt_note_too_small
;
18406 if (data
>= data_end
)
18407 goto stapdt_note_too_small
;
18408 maxlen
= data_end
- data
;
18409 len
= strnlen (data
, maxlen
);
18416 goto stapdt_note_too_small
;
18418 if (data
>= data_end
)
18419 goto stapdt_note_too_small
;
18420 maxlen
= data_end
- data
;
18421 len
= strnlen (data
, maxlen
);
18428 goto stapdt_note_too_small
;
18430 printf (_(" Provider: %s\n"), provider
);
18431 printf (_(" Name: %s\n"), probe
);
18432 printf (_(" Location: "));
18433 print_vma (pc
, FULL_HEX
);
18434 printf (_(", Base: "));
18435 print_vma (base_addr
, FULL_HEX
);
18436 printf (_(", Semaphore: "));
18437 print_vma (semaphore
, FULL_HEX
);
18439 printf (_(" Arguments: %s\n"), arg_fmt
);
18441 return data
== data_end
;
18443 stapdt_note_too_small
:
18444 printf (_(" <corrupt - note is too small>\n"));
18445 error (_("corrupt stapdt note - the data size is too small\n"));
18449 static const char *
18450 get_ia64_vms_note_type (unsigned e_type
)
18452 static char buff
[64];
18457 return _("NT_VMS_MHD (module header)");
18459 return _("NT_VMS_LNM (language name)");
18461 return _("NT_VMS_SRC (source files)");
18463 return "NT_VMS_TITLE";
18465 return _("NT_VMS_EIDC (consistency check)");
18466 case NT_VMS_FPMODE
:
18467 return _("NT_VMS_FPMODE (FP mode)");
18468 case NT_VMS_LINKTIME
:
18469 return "NT_VMS_LINKTIME";
18470 case NT_VMS_IMGNAM
:
18471 return _("NT_VMS_IMGNAM (image name)");
18473 return _("NT_VMS_IMGID (image id)");
18474 case NT_VMS_LINKID
:
18475 return _("NT_VMS_LINKID (link id)");
18476 case NT_VMS_IMGBID
:
18477 return _("NT_VMS_IMGBID (build id)");
18478 case NT_VMS_GSTNAM
:
18479 return _("NT_VMS_GSTNAM (sym table name)");
18480 case NT_VMS_ORIG_DYN
:
18481 return "NT_VMS_ORIG_DYN";
18482 case NT_VMS_PATCHTIME
:
18483 return "NT_VMS_PATCHTIME";
18485 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18491 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18493 int maxlen
= pnote
->descsz
;
18495 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18496 goto desc_size_fail
;
18498 switch (pnote
->type
)
18502 goto desc_size_fail
;
18504 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18506 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18507 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18508 if (l
+ 34 < maxlen
)
18510 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18511 if (l
+ 35 < maxlen
)
18512 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18514 printf (_(" Module version : <missing>\n"));
18518 printf (_(" Module name : <missing>\n"));
18519 printf (_(" Module version : <missing>\n"));
18524 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18528 case NT_VMS_FPMODE
:
18529 printf (_(" Floating Point mode: "));
18531 goto desc_size_fail
;
18532 /* FIXME: Generate an error if descsz > 8 ? */
18534 printf ("0x%016" BFD_VMA_FMT
"x\n",
18535 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18538 case NT_VMS_LINKTIME
:
18539 printf (_(" Link time: "));
18541 goto desc_size_fail
;
18542 /* FIXME: Generate an error if descsz > 8 ? */
18545 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18549 case NT_VMS_PATCHTIME
:
18550 printf (_(" Patch time: "));
18552 goto desc_size_fail
;
18553 /* FIXME: Generate an error if descsz > 8 ? */
18556 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18560 case NT_VMS_ORIG_DYN
:
18562 goto desc_size_fail
;
18564 printf (_(" Major id: %u, minor id: %u\n"),
18565 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18566 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18567 printf (_(" Last modified : "));
18569 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18570 printf (_("\n Link flags : "));
18571 printf ("0x%016" BFD_VMA_FMT
"x\n",
18572 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18573 printf (_(" Header flags: 0x%08x\n"),
18574 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18575 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18579 case NT_VMS_IMGNAM
:
18580 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18583 case NT_VMS_GSTNAM
:
18584 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18588 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18591 case NT_VMS_LINKID
:
18592 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18602 printf (_(" <corrupt - data size is too small>\n"));
18603 error (_("corrupt IA64 note: data size is too small\n"));
18607 /* Find the symbol associated with a build attribute that is attached
18608 to address OFFSET. If PNAME is non-NULL then store the name of
18609 the symbol (if found) in the provided pointer, Returns NULL if a
18610 symbol could not be found. */
18612 static Elf_Internal_Sym
*
18613 get_symbol_for_build_attribute (Filedata
* filedata
,
18614 unsigned long offset
,
18615 bfd_boolean is_open_attr
,
18616 const char ** pname
)
18618 static Filedata
* saved_filedata
= NULL
;
18619 static char * strtab
;
18620 static unsigned long strtablen
;
18621 static Elf_Internal_Sym
* symtab
;
18622 static unsigned long nsyms
;
18623 Elf_Internal_Sym
* saved_sym
= NULL
;
18624 Elf_Internal_Sym
* sym
;
18626 if (filedata
->section_headers
!= NULL
18627 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18629 Elf_Internal_Shdr
* symsec
;
18631 /* Load the symbol and string sections. */
18632 for (symsec
= filedata
->section_headers
;
18633 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18636 if (symsec
->sh_type
== SHT_SYMTAB
)
18638 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18640 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18642 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18644 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18645 1, strtab_sec
->sh_size
,
18646 _("string table"));
18647 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18651 saved_filedata
= filedata
;
18654 if (symtab
== NULL
|| strtab
== NULL
)
18657 /* Find a symbol whose value matches offset. */
18658 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18659 if (sym
->st_value
== offset
)
18661 if (sym
->st_name
>= strtablen
)
18662 /* Huh ? This should not happen. */
18665 if (strtab
[sym
->st_name
] == 0)
18668 /* The AArch64 and ARM architectures define mapping symbols
18669 (eg $d, $x, $t) which we want to ignore. */
18670 if (strtab
[sym
->st_name
] == '$'
18671 && strtab
[sym
->st_name
+ 1] != 0
18672 && strtab
[sym
->st_name
+ 2] == 0)
18677 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18678 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18679 FUNC symbols entirely. */
18680 switch (ELF_ST_TYPE (sym
->st_info
))
18687 /* If the symbol has a size associated
18688 with it then we can stop searching. */
18689 sym
= symtab
+ nsyms
;
18694 /* Ignore function symbols. */
18701 switch (ELF_ST_BIND (sym
->st_info
))
18704 if (saved_sym
== NULL
18705 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18710 if (saved_sym
== NULL
)
18720 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18728 if (saved_sym
&& pname
)
18729 * pname
= strtab
+ saved_sym
->st_name
;
18734 /* Returns true iff addr1 and addr2 are in the same section. */
18737 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18739 Elf_Internal_Shdr
* a1
;
18740 Elf_Internal_Shdr
* a2
;
18742 a1
= find_section_by_address (filedata
, addr1
);
18743 a2
= find_section_by_address (filedata
, addr2
);
18745 return a1
== a2
&& a1
!= NULL
;
18749 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18750 Filedata
* filedata
)
18752 static unsigned long global_offset
= 0;
18753 static unsigned long global_end
= 0;
18754 static unsigned long func_offset
= 0;
18755 static unsigned long func_end
= 0;
18757 Elf_Internal_Sym
* sym
;
18759 unsigned long start
;
18761 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18763 switch (pnote
->descsz
)
18766 /* A zero-length description means that the range of
18767 the previous note of the same type should be used. */
18770 if (global_end
> global_offset
)
18771 printf (_(" Applies to region from %#lx to %#lx\n"),
18772 global_offset
, global_end
);
18774 printf (_(" Applies to region from %#lx\n"), global_offset
);
18778 if (func_end
> func_offset
)
18779 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18781 printf (_(" Applies to region from %#lx\n"), func_offset
);
18786 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18793 /* FIXME: We should check that version 3+ notes are being used here... */
18794 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18795 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18799 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18805 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18806 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18810 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18811 printf (_(" <invalid descsz>"));
18816 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18817 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18818 in order to avoid them being confused with the start address of the
18819 first function in the file... */
18820 if (sym
== NULL
&& is_open_attr
)
18821 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18824 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18825 end
= start
+ sym
->st_size
;
18829 /* FIXME: Need to properly allow for section alignment.
18830 16 is just the alignment used on x86_64. */
18832 && start
> BFD_ALIGN (global_end
, 16)
18833 /* Build notes are not guaranteed to be organised in order of
18834 increasing address, but we should find the all of the notes
18835 for one section in the same place. */
18836 && same_section (filedata
, start
, global_end
))
18837 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18838 global_end
+ 1, start
- 1);
18840 printf (_(" Applies to region from %#lx"), start
);
18841 global_offset
= start
;
18845 printf (_(" to %#lx"), end
);
18851 printf (_(" Applies to region from %#lx"), start
);
18852 func_offset
= start
;
18856 printf (_(" to %#lx"), end
);
18862 printf (_(" (%s)"), name
);
18869 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18871 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18872 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18873 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18875 char name_attribute
;
18876 const char * expected_types
;
18877 const char * name
= pnote
->namedata
;
18881 if (name
== NULL
|| pnote
->namesz
< 2)
18883 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18884 print_symbol (-20, _(" <corrupt name>"));
18893 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18894 if (name
[0] == 'G' && name
[1] == 'A')
18896 if (pnote
->namesz
< 4)
18898 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18899 print_symbol (-20, _(" <corrupt name>"));
18908 switch ((name_type
= * name
))
18910 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18911 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18912 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18913 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18914 printf ("%c", * name
);
18918 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18919 print_symbol (-20, _("<unknown name type>"));
18926 switch ((name_attribute
= * name
))
18928 case GNU_BUILD_ATTRIBUTE_VERSION
:
18929 text
= _("<version>");
18930 expected_types
= string_expected
;
18933 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18934 text
= _("<stack prot>");
18935 expected_types
= "!+*";
18938 case GNU_BUILD_ATTRIBUTE_RELRO
:
18939 text
= _("<relro>");
18940 expected_types
= bool_expected
;
18943 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18944 text
= _("<stack size>");
18945 expected_types
= number_expected
;
18948 case GNU_BUILD_ATTRIBUTE_TOOL
:
18949 text
= _("<tool>");
18950 expected_types
= string_expected
;
18953 case GNU_BUILD_ATTRIBUTE_ABI
:
18955 expected_types
= "$*";
18958 case GNU_BUILD_ATTRIBUTE_PIC
:
18960 expected_types
= number_expected
;
18963 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18964 text
= _("<short enum>");
18965 expected_types
= bool_expected
;
18969 if (ISPRINT (* name
))
18971 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18973 if (len
> left
&& ! do_wide
)
18975 printf ("%.*s:", len
, name
);
18981 static char tmpbuf
[128];
18983 error (_("unrecognised byte in name field: %d\n"), * name
);
18984 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18988 expected_types
= "*$!+";
18993 left
-= printf ("%s", text
);
18995 if (strchr (expected_types
, name_type
) == NULL
)
18996 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18998 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19000 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19001 (unsigned long) pnote
->namesz
,
19002 (long) (name
- pnote
->namedata
));
19006 if (left
< 1 && ! do_wide
)
19011 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19013 unsigned int bytes
;
19014 unsigned long long val
= 0;
19015 unsigned int shift
= 0;
19016 char * decoded
= NULL
;
19018 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19020 /* The -1 is because the name field is always 0 terminated, and we
19021 want to be able to ensure that the shift in the while loop below
19022 will not overflow. */
19025 if (bytes
> sizeof (val
))
19027 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19029 bytes
= sizeof (val
);
19031 /* We do not bother to warn if bytes == 0 as this can
19032 happen with some early versions of the gcc plugin. */
19036 unsigned long byte
= (* name
++) & 0xff;
19038 val
|= byte
<< shift
;
19042 switch (name_attribute
)
19044 case GNU_BUILD_ATTRIBUTE_PIC
:
19047 case 0: decoded
= "static"; break;
19048 case 1: decoded
= "pic"; break;
19049 case 2: decoded
= "PIC"; break;
19050 case 3: decoded
= "pie"; break;
19051 case 4: decoded
= "PIE"; break;
19055 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19058 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19059 case 0: decoded
= "off"; break;
19060 case 1: decoded
= "on"; break;
19061 case 2: decoded
= "all"; break;
19062 case 3: decoded
= "strong"; break;
19063 case 4: decoded
= "explicit"; break;
19071 if (decoded
!= NULL
)
19073 print_symbol (-left
, decoded
);
19084 left
-= printf ("0x%llx", val
);
19086 left
-= printf ("0x%-.*llx", left
, val
);
19090 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19091 left
-= print_symbol (- left
, name
);
19093 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19094 left
-= print_symbol (- left
, "true");
19096 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19097 left
-= print_symbol (- left
, "false");
19101 if (do_wide
&& left
> 0)
19102 printf ("%-*s", left
, " ");
19107 /* Note that by the ELF standard, the name field is already null byte
19108 terminated, and namesz includes the terminating null byte.
19109 I.E. the value of namesz for the name "FSF" is 4.
19111 If the value of namesz is zero, there is no name present. */
19114 process_note (Elf_Internal_Note
* pnote
,
19115 Filedata
* filedata
)
19117 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19120 if (pnote
->namesz
== 0)
19121 /* If there is no note name, then use the default set of
19122 note type strings. */
19123 nt
= get_note_type (filedata
, pnote
->type
);
19125 else if (const_strneq (pnote
->namedata
, "GNU"))
19126 /* GNU-specific object file notes. */
19127 nt
= get_gnu_elf_note_type (pnote
->type
);
19129 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19130 /* FreeBSD-specific core file notes. */
19131 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19133 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19134 /* NetBSD-specific core file notes. */
19135 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19137 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19138 /* NetBSD-specific core file notes. */
19139 return process_netbsd_elf_note (pnote
);
19141 else if (const_strneq (pnote
->namedata
, "PaX"))
19142 /* NetBSD-specific core file notes. */
19143 return process_netbsd_elf_note (pnote
);
19145 else if (strneq (pnote
->namedata
, "SPU/", 4))
19147 /* SPU-specific core file notes. */
19148 nt
= pnote
->namedata
+ 4;
19152 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19153 /* VMS/ia64-specific file notes. */
19154 nt
= get_ia64_vms_note_type (pnote
->type
);
19156 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19157 nt
= get_stapsdt_note_type (pnote
->type
);
19160 /* Don't recognize this note name; just use the default set of
19161 note type strings. */
19162 nt
= get_note_type (filedata
, pnote
->type
);
19166 if (((const_strneq (pnote
->namedata
, "GA")
19167 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19168 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19169 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19170 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19171 print_gnu_build_attribute_name (pnote
);
19173 print_symbol (-20, name
);
19176 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19178 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19180 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19181 return print_ia64_vms_note (pnote
);
19182 else if (const_strneq (pnote
->namedata
, "GNU"))
19183 return print_gnu_note (filedata
, pnote
);
19184 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19185 return print_stapsdt_note (pnote
);
19186 else if (const_strneq (pnote
->namedata
, "CORE"))
19187 return print_core_note (pnote
);
19188 else if (((const_strneq (pnote
->namedata
, "GA")
19189 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19190 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19191 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19192 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19193 return print_gnu_build_attribute_description (pnote
, filedata
);
19199 printf (_(" description data: "));
19200 for (i
= 0; i
< pnote
->descsz
; i
++)
19201 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19213 process_notes_at (Filedata
* filedata
,
19214 Elf_Internal_Shdr
* section
,
19219 Elf_External_Note
* pnotes
;
19220 Elf_External_Note
* external
;
19222 bfd_boolean res
= TRUE
;
19229 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19232 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19237 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19240 if (pnotes
== NULL
)
19246 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19248 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19249 (unsigned long) offset
, (unsigned long) length
);
19251 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19252 specifies that notes should be aligned to 4 bytes in 32-bit
19253 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19254 we also support 4 byte alignment in 64-bit objects. If section
19255 alignment is less than 4, we treate alignment as 4 bytes. */
19258 else if (align
!= 4 && align
!= 8)
19260 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19265 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19267 end
= (char *) pnotes
+ length
;
19268 while ((char *) external
< end
)
19270 Elf_Internal_Note inote
;
19273 char * temp
= NULL
;
19274 size_t data_remaining
= end
- (char *) external
;
19276 if (!is_ia64_vms (filedata
))
19278 /* PR binutils/15191
19279 Make sure that there is enough data to read. */
19280 min_notesz
= offsetof (Elf_External_Note
, name
);
19281 if (data_remaining
< min_notesz
)
19283 warn (ngettext ("Corrupt note: only %ld byte remains, "
19284 "not enough for a full note\n",
19285 "Corrupt note: only %ld bytes remain, "
19286 "not enough for a full note\n",
19288 (long) data_remaining
);
19291 data_remaining
-= min_notesz
;
19293 inote
.type
= BYTE_GET (external
->type
);
19294 inote
.namesz
= BYTE_GET (external
->namesz
);
19295 inote
.namedata
= external
->name
;
19296 inote
.descsz
= BYTE_GET (external
->descsz
);
19297 inote
.descdata
= ((char *) external
19298 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19299 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19300 next
= ((char *) external
19301 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19305 Elf64_External_VMS_Note
*vms_external
;
19307 /* PR binutils/15191
19308 Make sure that there is enough data to read. */
19309 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19310 if (data_remaining
< min_notesz
)
19312 warn (ngettext ("Corrupt note: only %ld byte remains, "
19313 "not enough for a full note\n",
19314 "Corrupt note: only %ld bytes remain, "
19315 "not enough for a full note\n",
19317 (long) data_remaining
);
19320 data_remaining
-= min_notesz
;
19322 vms_external
= (Elf64_External_VMS_Note
*) external
;
19323 inote
.type
= BYTE_GET (vms_external
->type
);
19324 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19325 inote
.namedata
= vms_external
->name
;
19326 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19327 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19328 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19329 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19332 /* PR 17531: file: 3443835e. */
19333 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19334 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19335 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19336 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19337 || ((size_t) (next
- inote
.descdata
)
19338 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19340 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19341 (unsigned long) ((char *) external
- (char *) pnotes
));
19342 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19343 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19347 external
= (Elf_External_Note
*) next
;
19349 /* Verify that name is null terminated. It appears that at least
19350 one version of Linux (RedHat 6.0) generates corefiles that don't
19351 comply with the ELF spec by failing to include the null byte in
19353 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19355 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19357 temp
= (char *) malloc (inote
.namesz
+ 1);
19360 error (_("Out of memory allocating space for inote name\n"));
19365 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19366 inote
.namedata
= temp
;
19368 inote
.namedata
[inote
.namesz
] = 0;
19371 if (! process_note (& inote
, filedata
))
19387 process_corefile_note_segments (Filedata
* filedata
)
19389 Elf_Internal_Phdr
* segment
;
19391 bfd_boolean res
= TRUE
;
19393 if (! get_program_headers (filedata
))
19396 for (i
= 0, segment
= filedata
->program_headers
;
19397 i
< filedata
->file_header
.e_phnum
;
19400 if (segment
->p_type
== PT_NOTE
)
19401 if (! process_notes_at (filedata
, NULL
,
19402 (bfd_vma
) segment
->p_offset
,
19403 (bfd_vma
) segment
->p_filesz
,
19404 (bfd_vma
) segment
->p_align
))
19412 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19414 Elf_External_Note
* pnotes
;
19415 Elf_External_Note
* external
;
19417 bfd_boolean res
= TRUE
;
19422 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19424 if (pnotes
== NULL
)
19428 end
= (char*) pnotes
+ length
;
19430 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19431 (unsigned long) offset
, (unsigned long) length
);
19433 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19435 Elf_External_Note
* next
;
19436 Elf_Internal_Note inote
;
19438 inote
.type
= BYTE_GET (external
->type
);
19439 inote
.namesz
= BYTE_GET (external
->namesz
);
19440 inote
.namedata
= external
->name
;
19441 inote
.descsz
= BYTE_GET (external
->descsz
);
19442 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19443 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19445 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19447 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19448 inote
.descdata
= inote
.namedata
;
19452 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19454 if ( ((char *) next
> end
)
19455 || ((char *) next
< (char *) pnotes
))
19457 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19458 (unsigned long) ((char *) external
- (char *) pnotes
));
19459 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19460 inote
.type
, inote
.namesz
, inote
.descsz
);
19466 /* Prevent out-of-bounds indexing. */
19467 if ( inote
.namedata
+ inote
.namesz
> end
19468 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19470 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19471 (unsigned long) ((char *) external
- (char *) pnotes
));
19472 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19473 inote
.type
, inote
.namesz
, inote
.descsz
);
19477 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19479 if (! print_v850_note (& inote
))
19482 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19483 inote
.namesz
, inote
.descsz
);
19493 process_note_sections (Filedata
* filedata
)
19495 Elf_Internal_Shdr
* section
;
19497 unsigned int n
= 0;
19498 bfd_boolean res
= TRUE
;
19500 for (i
= 0, section
= filedata
->section_headers
;
19501 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19504 if (section
->sh_type
== SHT_NOTE
)
19506 if (! process_notes_at (filedata
, section
,
19507 (bfd_vma
) section
->sh_offset
,
19508 (bfd_vma
) section
->sh_size
,
19509 (bfd_vma
) section
->sh_addralign
))
19514 if (( filedata
->file_header
.e_machine
== EM_V800
19515 || filedata
->file_header
.e_machine
== EM_V850
19516 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19517 && section
->sh_type
== SHT_RENESAS_INFO
)
19519 if (! process_v850_notes (filedata
,
19520 (bfd_vma
) section
->sh_offset
,
19521 (bfd_vma
) section
->sh_size
))
19528 /* Try processing NOTE segments instead. */
19529 return process_corefile_note_segments (filedata
);
19535 process_notes (Filedata
* filedata
)
19537 /* If we have not been asked to display the notes then do nothing. */
19541 if (filedata
->file_header
.e_type
!= ET_CORE
)
19542 return process_note_sections (filedata
);
19544 /* No program headers means no NOTE segment. */
19545 if (filedata
->file_header
.e_phnum
> 0)
19546 return process_corefile_note_segments (filedata
);
19548 printf (_("No note segments present in the core file.\n"));
19552 static unsigned char *
19553 display_public_gnu_attributes (unsigned char * start
,
19554 const unsigned char * const end
)
19556 printf (_(" Unknown GNU attribute: %s\n"), start
);
19558 start
+= strnlen ((char *) start
, end
- start
);
19559 display_raw_attribute (start
, end
);
19561 return (unsigned char *) end
;
19564 static unsigned char *
19565 display_generic_attribute (unsigned char * start
,
19567 const unsigned char * const end
)
19570 return (unsigned char *) end
;
19572 return display_tag_value (tag
, start
, end
);
19576 process_arch_specific (Filedata
* filedata
)
19581 switch (filedata
->file_header
.e_machine
)
19584 case EM_ARC_COMPACT
:
19585 case EM_ARC_COMPACT2
:
19586 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19587 display_arc_attribute
,
19588 display_generic_attribute
);
19590 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19591 display_arm_attribute
,
19592 display_generic_attribute
);
19595 case EM_MIPS_RS3_LE
:
19596 return process_mips_specific (filedata
);
19599 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19600 display_msp430x_attribute
,
19601 display_msp430_gnu_attribute
);
19604 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19605 display_riscv_attribute
,
19606 display_generic_attribute
);
19609 return process_nds32_specific (filedata
);
19613 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19614 display_power_gnu_attribute
);
19618 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19619 display_s390_gnu_attribute
);
19622 case EM_SPARC32PLUS
:
19624 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19625 display_sparc_gnu_attribute
);
19628 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19629 display_tic6x_attribute
,
19630 display_generic_attribute
);
19633 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19634 display_public_gnu_attributes
,
19635 display_generic_attribute
);
19640 get_file_header (Filedata
* filedata
)
19642 /* Read in the identity array. */
19643 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19646 /* Determine how to read the rest of the header. */
19647 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19652 byte_get
= byte_get_little_endian
;
19653 byte_put
= byte_put_little_endian
;
19656 byte_get
= byte_get_big_endian
;
19657 byte_put
= byte_put_big_endian
;
19661 /* For now we only support 32 bit and 64 bit ELF files. */
19662 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19664 /* Read in the rest of the header. */
19667 Elf32_External_Ehdr ehdr32
;
19669 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19672 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19673 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19674 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19675 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19676 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19677 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19678 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19679 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19680 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19681 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19682 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19683 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19684 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19688 Elf64_External_Ehdr ehdr64
;
19690 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19691 we will not be able to cope with the 64bit data found in
19692 64 ELF files. Detect this now and abort before we start
19693 overwriting things. */
19694 if (sizeof (bfd_vma
) < 8)
19696 error (_("This instance of readelf has been built without support for a\n\
19697 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19701 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19704 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19705 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19706 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19707 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19708 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19709 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19710 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19711 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19712 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19713 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19714 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19715 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19716 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19719 if (filedata
->file_header
.e_shoff
)
19721 /* There may be some extensions in the first section header. Don't
19722 bomb if we can't read it. */
19724 get_32bit_section_headers (filedata
, TRUE
);
19726 get_64bit_section_headers (filedata
, TRUE
);
19733 close_file (Filedata
* filedata
)
19737 if (filedata
->handle
)
19738 fclose (filedata
->handle
);
19744 close_debug_file (void * data
)
19746 close_file ((Filedata
*) data
);
19750 open_file (const char * pathname
)
19752 struct stat statbuf
;
19753 Filedata
* filedata
= NULL
;
19755 if (stat (pathname
, & statbuf
) < 0
19756 || ! S_ISREG (statbuf
.st_mode
))
19759 filedata
= calloc (1, sizeof * filedata
);
19760 if (filedata
== NULL
)
19763 filedata
->handle
= fopen (pathname
, "rb");
19764 if (filedata
->handle
== NULL
)
19767 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19768 filedata
->file_name
= pathname
;
19770 if (! get_file_header (filedata
))
19773 if (filedata
->file_header
.e_shoff
)
19777 /* Read the section headers again, this time for real. */
19779 res
= get_32bit_section_headers (filedata
, FALSE
);
19781 res
= get_64bit_section_headers (filedata
, FALSE
);
19792 if (filedata
->handle
)
19793 fclose (filedata
->handle
);
19800 open_debug_file (const char * pathname
)
19802 return open_file (pathname
);
19805 /* Process one ELF object file according to the command line options.
19806 This file may actually be stored in an archive. The file is
19807 positioned at the start of the ELF object. Returns TRUE if no
19808 problems were encountered, FALSE otherwise. */
19811 process_object (Filedata
* filedata
)
19813 bfd_boolean have_separate_files
;
19815 bfd_boolean res
= TRUE
;
19817 if (! get_file_header (filedata
))
19819 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19823 /* Initialise per file variables. */
19824 for (i
= ARRAY_SIZE (version_info
); i
--;)
19825 version_info
[i
] = 0;
19827 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19828 dynamic_info
[i
] = 0;
19829 dynamic_info_DT_GNU_HASH
= 0;
19830 dynamic_info_DT_MIPS_XHASH
= 0;
19832 /* Process the file. */
19834 printf (_("\nFile: %s\n"), filedata
->file_name
);
19836 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19837 Note we do this even if cmdline_dump_sects is empty because we
19838 must make sure that the dump_sets array is zeroed out before each
19839 object file is processed. */
19840 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19841 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19843 if (cmdline
.num_dump_sects
> 0)
19845 if (filedata
->num_dump_sects
== 0)
19846 /* A sneaky way of allocating the dump_sects array. */
19847 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19849 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19850 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19851 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19854 if (! process_file_header (filedata
))
19857 if (! process_section_headers (filedata
))
19859 /* Without loaded section headers we cannot process lots of things. */
19860 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19862 if (! do_using_dynamic
)
19863 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19866 if (! process_section_groups (filedata
))
19867 /* Without loaded section groups we cannot process unwind. */
19870 if (process_program_headers (filedata
))
19871 process_dynamic_section (filedata
);
19875 if (! process_relocs (filedata
))
19878 if (! process_unwind (filedata
))
19881 if (! process_symbol_table (filedata
))
19884 if (! process_syminfo (filedata
))
19887 if (! process_version_sections (filedata
))
19890 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19891 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19893 have_separate_files
= FALSE
;
19895 if (! process_section_contents (filedata
))
19898 if (have_separate_files
)
19902 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19904 if (! process_section_headers (d
->handle
))
19906 else if (! process_section_contents (d
->handle
))
19910 /* The file handles are closed by the call to free_debug_memory() below. */
19913 if (! process_notes (filedata
))
19916 if (! process_gnu_liblist (filedata
))
19919 if (! process_arch_specific (filedata
))
19922 free (filedata
->program_headers
);
19923 filedata
->program_headers
= NULL
;
19925 free (filedata
->section_headers
);
19926 filedata
->section_headers
= NULL
;
19928 free (filedata
->string_table
);
19929 filedata
->string_table
= NULL
;
19930 filedata
->string_table_length
= 0;
19932 if (dynamic_strings
)
19934 free (dynamic_strings
);
19935 dynamic_strings
= NULL
;
19936 dynamic_strings_length
= 0;
19939 if (dynamic_symbols
)
19941 free (dynamic_symbols
);
19942 dynamic_symbols
= NULL
;
19943 num_dynamic_syms
= 0;
19946 if (dynamic_syminfo
)
19948 free (dynamic_syminfo
);
19949 dynamic_syminfo
= NULL
;
19952 if (dynamic_section
)
19954 free (dynamic_section
);
19955 dynamic_section
= NULL
;
19958 if (section_headers_groups
)
19960 free (section_headers_groups
);
19961 section_headers_groups
= NULL
;
19964 if (section_groups
)
19966 struct group_list
* g
;
19967 struct group_list
* next
;
19969 for (i
= 0; i
< group_count
; i
++)
19971 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19978 free (section_groups
);
19979 section_groups
= NULL
;
19982 free_debug_memory ();
19987 /* Process an ELF archive.
19988 On entry the file is positioned just after the ARMAG string.
19989 Returns TRUE upon success, FALSE otherwise. */
19992 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19994 struct archive_info arch
;
19995 struct archive_info nested_arch
;
19997 bfd_boolean ret
= TRUE
;
20001 /* The ARCH structure is used to hold information about this archive. */
20002 arch
.file_name
= NULL
;
20004 arch
.index_array
= NULL
;
20005 arch
.sym_table
= NULL
;
20006 arch
.longnames
= NULL
;
20008 /* The NESTED_ARCH structure is used as a single-item cache of information
20009 about a nested archive (when members of a thin archive reside within
20010 another regular archive file). */
20011 nested_arch
.file_name
= NULL
;
20012 nested_arch
.file
= NULL
;
20013 nested_arch
.index_array
= NULL
;
20014 nested_arch
.sym_table
= NULL
;
20015 nested_arch
.longnames
= NULL
;
20017 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20018 is_thin_archive
, do_archive_index
) != 0)
20024 if (do_archive_index
)
20026 if (arch
.sym_table
== NULL
)
20027 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20030 unsigned long i
, l
;
20031 unsigned long current_pos
;
20033 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20034 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20036 current_pos
= ftell (filedata
->handle
);
20038 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20040 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20042 char * member_name
;
20044 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20046 if (member_name
!= NULL
)
20048 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20050 if (qualified_name
!= NULL
)
20052 printf (_("Contents of binary %s at offset "), qualified_name
);
20053 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20055 free (qualified_name
);
20060 if (l
>= arch
.sym_size
)
20062 error (_("%s: end of the symbol table reached before the end of the index\n"),
20063 filedata
->file_name
);
20067 /* PR 17531: file: 0b6630b2. */
20068 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20069 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20072 if (arch
.uses_64bit_indices
)
20077 if (l
< arch
.sym_size
)
20079 error (ngettext ("%s: %ld byte remains in the symbol table, "
20080 "but without corresponding entries in "
20081 "the index table\n",
20082 "%s: %ld bytes remain in the symbol table, "
20083 "but without corresponding entries in "
20084 "the index table\n",
20085 arch
.sym_size
- l
),
20086 filedata
->file_name
, arch
.sym_size
- l
);
20090 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20092 error (_("%s: failed to seek back to start of object files in the archive\n"),
20093 filedata
->file_name
);
20099 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20100 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20101 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20102 && !do_section_groups
&& !do_dyn_syms
)
20104 ret
= TRUE
; /* Archive index only. */
20113 char * qualified_name
;
20115 /* Read the next archive header. */
20116 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20118 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20121 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20122 if (got
!= sizeof arch
.arhdr
)
20126 /* PR 24049 - we cannot use filedata->file_name as this will
20127 have already been freed. */
20128 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20133 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20135 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20140 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20142 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20143 if (archive_file_size
& 01)
20144 ++archive_file_size
;
20146 name
= get_archive_member_name (&arch
, &nested_arch
);
20149 error (_("%s: bad archive file name\n"), arch
.file_name
);
20153 namelen
= strlen (name
);
20155 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20156 if (qualified_name
== NULL
)
20158 error (_("%s: bad archive file name\n"), arch
.file_name
);
20163 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20165 /* This is a proxy for an external member of a thin archive. */
20166 Filedata
* member_filedata
;
20167 char * member_file_name
= adjust_relative_path
20168 (filedata
->file_name
, name
, namelen
);
20170 if (member_file_name
== NULL
)
20176 member_filedata
= open_file (member_file_name
);
20177 if (member_filedata
== NULL
)
20179 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20180 free (member_file_name
);
20185 archive_file_offset
= arch
.nested_member_origin
;
20186 member_filedata
->file_name
= qualified_name
;
20188 if (! process_object (member_filedata
))
20191 close_file (member_filedata
);
20192 free (member_file_name
);
20194 else if (is_thin_archive
)
20196 Filedata thin_filedata
;
20198 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20200 /* PR 15140: Allow for corrupt thin archives. */
20201 if (nested_arch
.file
== NULL
)
20203 error (_("%s: contains corrupt thin archive: %s\n"),
20204 qualified_name
, name
);
20209 /* This is a proxy for a member of a nested archive. */
20210 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20212 /* The nested archive file will have been opened and setup by
20213 get_archive_member_name. */
20214 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20216 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20221 thin_filedata
.handle
= nested_arch
.file
;
20222 thin_filedata
.file_name
= qualified_name
;
20224 if (! process_object (& thin_filedata
))
20229 archive_file_offset
= arch
.next_arhdr_offset
;
20230 arch
.next_arhdr_offset
+= archive_file_size
;
20232 filedata
->file_name
= qualified_name
;
20233 if (! process_object (filedata
))
20237 if (filedata
->dump_sects
!= NULL
)
20239 free (filedata
->dump_sects
);
20240 filedata
->dump_sects
= NULL
;
20241 filedata
->num_dump_sects
= 0;
20244 free (qualified_name
);
20248 if (nested_arch
.file
!= NULL
)
20249 fclose (nested_arch
.file
);
20250 release_archive (&nested_arch
);
20251 release_archive (&arch
);
20257 process_file (char * file_name
)
20259 Filedata
* filedata
= NULL
;
20260 struct stat statbuf
;
20261 char armag
[SARMAG
];
20262 bfd_boolean ret
= TRUE
;
20264 if (stat (file_name
, &statbuf
) < 0)
20266 if (errno
== ENOENT
)
20267 error (_("'%s': No such file\n"), file_name
);
20269 error (_("Could not locate '%s'. System error message: %s\n"),
20270 file_name
, strerror (errno
));
20274 if (! S_ISREG (statbuf
.st_mode
))
20276 error (_("'%s' is not an ordinary file\n"), file_name
);
20280 filedata
= calloc (1, sizeof * filedata
);
20281 if (filedata
== NULL
)
20283 error (_("Out of memory allocating file data structure\n"));
20287 filedata
->file_name
= file_name
;
20288 filedata
->handle
= fopen (file_name
, "rb");
20289 if (filedata
->handle
== NULL
)
20291 error (_("Input file '%s' is not readable.\n"), file_name
);
20296 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20298 error (_("%s: Failed to read file's magic number\n"), file_name
);
20299 fclose (filedata
->handle
);
20304 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20306 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20308 if (! process_archive (filedata
, FALSE
))
20311 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20313 if ( ! process_archive (filedata
, TRUE
))
20318 if (do_archive_index
)
20319 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20322 rewind (filedata
->handle
);
20323 archive_file_size
= archive_file_offset
= 0;
20325 if (! process_object (filedata
))
20329 fclose (filedata
->handle
);
20335 #ifdef SUPPORT_DISASSEMBLY
20336 /* Needed by the i386 disassembler. For extra credit, someone could
20337 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20341 print_address (unsigned int addr
, FILE * outfile
)
20343 fprintf (outfile
,"0x%8.8x", addr
);
20346 /* Needed by the i386 disassembler. */
20349 db_task_printsym (unsigned int addr
)
20351 print_address (addr
, stderr
);
20356 main (int argc
, char ** argv
)
20360 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20361 setlocale (LC_MESSAGES
, "");
20363 #if defined (HAVE_SETLOCALE)
20364 setlocale (LC_CTYPE
, "");
20366 bindtextdomain (PACKAGE
, LOCALEDIR
);
20367 textdomain (PACKAGE
);
20369 expandargv (&argc
, &argv
);
20371 cmdline
.file_name
= "<cmdline>";
20372 parse_args (& cmdline
, argc
, argv
);
20374 if (optind
< (argc
- 1))
20376 else if (optind
>= argc
)
20378 warn (_("Nothing to do.\n"));
20383 while (optind
< argc
)
20384 if (! process_file (argv
[optind
++]))
20387 if (cmdline
.dump_sects
!= NULL
)
20388 free (cmdline
.dump_sects
);
20390 free (dump_ctf_symtab_name
);
20391 free (dump_ctf_strtab_name
);
20392 free (dump_ctf_parent_name
);
20394 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;