1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2021 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. */
50 /* Define BFD64 here, even if our default architecture is 32 bit ELF
51 as this will allow us to read in and parse 64bit and 32bit ELF files.
52 Only do this if we believe that the compiler can support a 64 bit
53 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/csky.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/s12z.h"
125 #include "elf/mcore.h"
127 #include "elf/metag.h"
128 #include "elf/microblaze.h"
129 #include "elf/mips.h"
130 #include "elf/mmix.h"
131 #include "elf/mn10200.h"
132 #include "elf/mn10300.h"
133 #include "elf/moxie.h"
135 #include "elf/msp430.h"
136 #include "elf/nds32.h"
138 #include "elf/nios2.h"
139 #include "elf/or1k.h"
142 #include "elf/ppc64.h"
144 #include "elf/riscv.h"
145 #include "elf/rl78.h"
147 #include "elf/s390.h"
148 #include "elf/score.h"
150 #include "elf/sparc.h"
152 #include "elf/tic6x.h"
153 #include "elf/tilegx.h"
154 #include "elf/tilepro.h"
155 #include "elf/v850.h"
157 #include "elf/visium.h"
158 #include "elf/wasm32.h"
159 #include "elf/x86-64.h"
160 #include "elf/xc16x.h"
161 #include "elf/xgate.h"
162 #include "elf/xstormy16.h"
163 #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 /* A dynamic array of flags indicating for which sections a dump
200 has been requested via command line switches. */
203 dump_type
* dump_sects
;
204 unsigned int num_dump_sects
;
207 static struct dump_data cmdline
;
209 static struct dump_list_entry
* dump_sects_byname
;
211 char * program_name
= "readelf";
213 static bool show_name
= false;
214 static bool do_dynamic
= false;
215 static bool do_syms
= false;
216 static bool do_dyn_syms
= false;
217 static bool do_lto_syms
= false;
218 static bool do_reloc
= false;
219 static bool do_sections
= false;
220 static bool do_section_groups
= false;
221 static bool do_section_details
= false;
222 static bool do_segments
= false;
223 static bool do_unwind
= false;
224 static bool do_using_dynamic
= false;
225 static bool do_header
= false;
226 static bool do_dump
= false;
227 static bool do_version
= false;
228 static bool do_histogram
= false;
229 static bool do_debugging
= false;
230 static bool do_ctf
= false;
231 static bool do_arch
= false;
232 static bool do_notes
= false;
233 static bool do_archive_index
= false;
234 static bool check_all
= false;
235 static bool is_32bit_elf
= false;
236 static bool decompress_dumps
= false;
237 static bool do_not_show_symbol_truncation
= false;
238 static bool do_demangle
= false; /* Pretty print C++ symbol names. */
239 static bool process_links
= false;
240 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
242 static char *dump_ctf_parent_name
;
243 static char *dump_ctf_symtab_name
;
244 static char *dump_ctf_strtab_name
;
248 struct group_list
* next
;
249 unsigned int section_index
;
254 struct group_list
* root
;
255 unsigned int group_index
;
258 typedef struct filedata
260 const char * file_name
;
263 bfd_size_type file_size
;
264 Elf_Internal_Ehdr file_header
;
265 Elf_Internal_Shdr
* section_headers
;
266 Elf_Internal_Phdr
* program_headers
;
268 unsigned long string_table_length
;
269 unsigned long archive_file_offset
;
270 unsigned long archive_file_size
;
271 unsigned long dynamic_addr
;
272 bfd_size_type dynamic_size
;
274 Elf_Internal_Dyn
* dynamic_section
;
275 Elf_Internal_Shdr
* dynamic_strtab_section
;
276 char * dynamic_strings
;
277 unsigned long dynamic_strings_length
;
278 Elf_Internal_Shdr
* dynamic_symtab_section
;
279 unsigned long num_dynamic_syms
;
280 Elf_Internal_Sym
* dynamic_symbols
;
281 bfd_vma version_info
[16];
282 unsigned int dynamic_syminfo_nent
;
283 Elf_Internal_Syminfo
* dynamic_syminfo
;
284 unsigned long dynamic_syminfo_offset
;
285 bfd_size_type nbuckets
;
286 bfd_size_type nchains
;
289 bfd_size_type ngnubuckets
;
290 bfd_size_type ngnuchains
;
291 bfd_vma
* gnubuckets
;
295 char * program_interpreter
;
296 bfd_vma dynamic_info
[DT_ENCODING
];
297 bfd_vma dynamic_info_DT_GNU_HASH
;
298 bfd_vma dynamic_info_DT_MIPS_XHASH
;
299 elf_section_list
* symtab_shndx_list
;
301 struct group
* section_groups
;
302 struct group
** section_headers_groups
;
303 /* A dynamic array of flags indicating for which sections a dump of
304 some kind has been requested. It is reset on a per-object file
305 basis and then initialised from the cmdline_dump_sects array,
306 the results of interpreting the -w switch, and the
307 dump_sects_byname list. */
308 struct dump_data dump
;
311 /* How to print a vma value. */
312 typedef enum print_mode
324 /* Versioned symbol info. */
325 enum versioned_symbol_info
332 static const char * get_symbol_version_string
333 (Filedata
*, bool, const char *, unsigned long, unsigned,
334 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
338 #define SECTION_NAME(X) \
339 (filedata->string_table + (X)->sh_name)
341 #define SECTION_NAME_VALID(X) \
343 && filedata->string_table != NULL \
344 && (X)->sh_name < filedata->string_table_length)
346 #define SECTION_NAME_PRINT(X) \
347 ((X) == NULL ? _("<none>") \
348 : filedata->string_table == NULL ? _("<no-strings>") \
349 : (X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
350 : filedata->string_table + (X)->sh_name)
352 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
354 #define GET_ELF_SYMBOLS(file, section, sym_count) \
355 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
356 : get_64bit_elf_symbols (file, section, sym_count))
358 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
359 (strtab != NULL && offset < strtab_size)
360 #define VALID_DYNAMIC_NAME(filedata, offset) \
361 VALID_SYMBOL_NAME (filedata->dynamic_strings, \
362 filedata->dynamic_strings_length, offset)
363 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
364 already been called and verified that the string exists. */
365 #define GET_DYNAMIC_NAME(filedata, offset) \
366 (filedata->dynamic_strings + offset)
368 #define REMOVE_ARCH_BITS(ADDR) \
371 if (filedata->file_header.e_machine == EM_ARM) \
376 /* Get the correct GNU hash section name. */
377 #define GNU_HASH_SECTION_NAME(filedata) \
378 filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
380 /* Print a BFD_VMA to an internal buffer, for use in error messages.
381 BFD_FMA_FMT can't be used in translated strings. */
384 bfd_vmatoa (char *fmtch
, bfd_vma value
)
386 /* bfd_vmatoa is used more then once in a printf call for output.
387 Cycle through an array of buffers. */
388 static int buf_pos
= 0;
389 static struct bfd_vmatoa_buf
396 ret
= buf
[buf_pos
++].place
;
397 buf_pos
%= ARRAY_SIZE (buf
);
399 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
400 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
404 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
405 OFFSET + the offset of the current archive member, if we are examining an
406 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
407 allocate a buffer using malloc and fill that. In either case return the
408 pointer to the start of the retrieved data or NULL if something went wrong.
409 If something does go wrong and REASON is not NULL then emit an error
410 message using REASON as part of the context. */
413 get_data (void * var
,
415 unsigned long offset
,
421 bfd_size_type amt
= size
* nmemb
;
423 if (size
== 0 || nmemb
== 0)
426 /* If the size_t type is smaller than the bfd_size_type, eg because
427 you are building a 32-bit tool on a 64-bit host, then make sure
428 that when the sizes are cast to (size_t) no information is lost. */
429 if ((size_t) size
!= size
430 || (size_t) nmemb
!= nmemb
431 || (size_t) amt
!= amt
)
434 error (_("Size truncation prevents reading %s"
435 " elements of size %s for %s\n"),
436 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
440 /* Check for size overflow. */
441 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
444 error (_("Size overflow prevents reading %s"
445 " elements of size %s for %s\n"),
446 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
450 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
451 attempting to allocate memory when the read is bound to fail. */
452 if (filedata
->archive_file_offset
> filedata
->file_size
453 || offset
> filedata
->file_size
- filedata
->archive_file_offset
454 || amt
> filedata
->file_size
- filedata
->archive_file_offset
- offset
)
457 error (_("Reading %s bytes extends past end of file for %s\n"),
458 bfd_vmatoa ("u", amt
), reason
);
462 if (fseek (filedata
->handle
, filedata
->archive_file_offset
+ offset
,
466 error (_("Unable to seek to 0x%lx for %s\n"),
467 filedata
->archive_file_offset
+ offset
, reason
);
474 /* + 1 so that we can '\0' terminate invalid string table sections. */
475 mvar
= malloc ((size_t) amt
+ 1);
480 error (_("Out of memory allocating %s bytes for %s\n"),
481 bfd_vmatoa ("u", amt
), reason
);
485 ((char *) mvar
)[amt
] = '\0';
488 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
491 error (_("Unable to read in %s bytes of %s\n"),
492 bfd_vmatoa ("u", amt
), reason
);
501 /* Print a VMA value in the MODE specified.
502 Returns the number of characters displayed. */
505 print_vma (bfd_vma vma
, print_mode mode
)
517 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
524 return printf ("%5" BFD_VMA_FMT
"d", vma
);
530 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
533 return printf ("%" BFD_VMA_FMT
"d", vma
);
536 return printf ("%" BFD_VMA_FMT
"u", vma
);
539 /* FIXME: Report unrecognised mode ? */
544 /* Display a symbol on stdout. Handles the display of control characters and
545 multibye characters (assuming the host environment supports them).
547 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
549 If truncation will happen and do_not_show_symbol_truncation is FALSE then display
550 abs(WIDTH) - 5 characters followed by "[...]".
552 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
553 padding as necessary.
555 Returns the number of emitted characters. */
558 print_symbol (signed int width
, const char * symbol
)
560 bool extra_padding
= false;
561 bool do_dots
= false;
562 signed int num_printed
= 0;
563 #ifdef HAVE_MBSTATE_T
566 unsigned int width_remaining
;
567 const void * alloced_symbol
= NULL
;
571 /* Keep the width positive. This helps the code below. */
573 extra_padding
= true;
579 /* Set the remaining width to a very large value.
580 This simplifies the code below. */
581 width_remaining
= INT_MAX
;
584 width_remaining
= width
;
585 if (! do_not_show_symbol_truncation
586 && (int) strlen (symbol
) > width
)
588 width_remaining
-= 5;
589 if ((int) width_remaining
< 0)
595 #ifdef HAVE_MBSTATE_T
596 /* Initialise the multibyte conversion state. */
597 memset (& state
, 0, sizeof (state
));
600 if (do_demangle
&& *symbol
)
602 const char * res
= cplus_demangle (symbol
, demangle_flags
);
605 alloced_symbol
= symbol
= res
;
608 while (width_remaining
)
611 const char c
= *symbol
++;
616 /* Do not print control characters directly as they can affect terminal
617 settings. Such characters usually appear in the names generated
618 by the assembler for local labels. */
621 if (width_remaining
< 2)
624 printf ("^%c", c
+ 0x40);
625 width_remaining
-= 2;
628 else if (ISPRINT (c
))
636 #ifdef HAVE_MBSTATE_T
639 /* Let printf do the hard work of displaying multibyte characters. */
640 printf ("%.1s", symbol
- 1);
644 #ifdef HAVE_MBSTATE_T
645 /* Try to find out how many bytes made up the character that was
646 just printed. Advance the symbol pointer past the bytes that
648 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
652 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
658 num_printed
+= printf ("[...]");
660 if (extra_padding
&& num_printed
< width
)
662 /* Fill in the remaining spaces. */
663 printf ("%-*s", width
- num_printed
, " ");
667 free ((void *) alloced_symbol
);
671 /* Returns a pointer to a static buffer containing a printable version of
672 the given section's name. Like print_symbol, except that it does not try
673 to print multibyte characters, it just interprets them as hex values. */
676 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
678 #define MAX_PRINT_SEC_NAME_LEN 256
679 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
680 const char * name
= SECTION_NAME_PRINT (sec
);
681 char * buf
= sec_name_buf
;
683 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
685 while ((c
= * name
++) != 0)
696 else if (ISPRINT (c
))
703 static char hex
[17] = "0123456789ABCDEF";
708 * buf
++ = hex
[(c
& 0xf0) >> 4];
709 * buf
++ = hex
[c
& 0x0f];
723 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
725 if (ndx
>= filedata
->file_header
.e_shnum
)
726 return _("<corrupt>");
728 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
731 /* Return a pointer to section NAME, or NULL if no such section exists. */
733 static Elf_Internal_Shdr
*
734 find_section (Filedata
* filedata
, const char * name
)
738 if (filedata
->section_headers
== NULL
)
741 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
742 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
743 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
744 return filedata
->section_headers
+ i
;
749 /* Return a pointer to a section containing ADDR, or NULL if no such
752 static Elf_Internal_Shdr
*
753 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
757 if (filedata
->section_headers
== NULL
)
760 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
762 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
764 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
771 static Elf_Internal_Shdr
*
772 find_section_by_type (Filedata
* filedata
, unsigned int type
)
776 if (filedata
->section_headers
== NULL
)
779 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
781 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
783 if (sec
->sh_type
== type
)
790 /* Return a pointer to section NAME, or NULL if no such section exists,
791 restricted to the list of sections given in SET. */
793 static Elf_Internal_Shdr
*
794 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
798 if (filedata
->section_headers
== NULL
)
803 while ((i
= *set
++) > 0)
805 /* See PR 21156 for a reproducer. */
806 if (i
>= filedata
->file_header
.e_shnum
)
807 continue; /* FIXME: Should we issue an error message ? */
809 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
810 && streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
811 return filedata
->section_headers
+ i
;
815 return find_section (filedata
, name
);
818 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
819 This OS has so many departures from the ELF standard that we test it at
823 is_ia64_vms (Filedata
* filedata
)
825 return filedata
->file_header
.e_machine
== EM_IA_64
826 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
829 /* Guess the relocation size commonly used by the specific machines. */
832 guess_is_rela (unsigned int e_machine
)
836 /* Targets that use REL relocations. */
853 /* Targets that use RELA relocations. */
857 case EM_ADAPTEVA_EPIPHANY
:
859 case EM_ALTERA_NIOS2
:
862 case EM_ARC_COMPACT2
:
883 case EM_LATTICEMICO32
:
892 case EM_CYGNUS_MN10200
:
894 case EM_CYGNUS_MN10300
:
930 case EM_MICROBLAZE_OLD
:
952 warn (_("Don't know about relocations on this machine architecture\n"));
957 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
958 Returns TRUE upon success, FALSE otherwise. If successful then a
959 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
960 and the number of relocs loaded is placed in *NRELASP. It is the caller's
961 responsibility to free the allocated buffer. */
964 slurp_rela_relocs (Filedata
* filedata
,
965 unsigned long rel_offset
,
966 unsigned long rel_size
,
967 Elf_Internal_Rela
** relasp
,
968 unsigned long * nrelasp
)
970 Elf_Internal_Rela
* relas
;
976 Elf32_External_Rela
* erelas
;
978 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
979 rel_size
, _("32-bit relocation data"));
983 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
985 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
986 sizeof (Elf_Internal_Rela
));
991 error (_("out of memory parsing relocs\n"));
995 for (i
= 0; i
< nrelas
; i
++)
997 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
998 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
999 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1006 Elf64_External_Rela
* erelas
;
1008 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
1009 rel_size
, _("64-bit relocation data"));
1013 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
1015 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
1016 sizeof (Elf_Internal_Rela
));
1021 error (_("out of memory parsing relocs\n"));
1025 for (i
= 0; i
< nrelas
; i
++)
1027 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
1028 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
1029 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
1031 /* The #ifdef BFD64 below is to prevent a compile time
1032 warning. We know that if we do not have a 64 bit data
1033 type that we will never execute this code anyway. */
1035 if (filedata
->file_header
.e_machine
== EM_MIPS
1036 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1038 /* In little-endian objects, r_info isn't really a
1039 64-bit little-endian value: it has a 32-bit
1040 little-endian symbol index followed by four
1041 individual byte fields. Reorder INFO
1043 bfd_vma inf
= relas
[i
].r_info
;
1044 inf
= (((inf
& 0xffffffff) << 32)
1045 | ((inf
>> 56) & 0xff)
1046 | ((inf
>> 40) & 0xff00)
1047 | ((inf
>> 24) & 0xff0000)
1048 | ((inf
>> 8) & 0xff000000));
1049 relas
[i
].r_info
= inf
;
1062 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1063 Returns TRUE upon success, FALSE otherwise. If successful then a
1064 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1065 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1066 responsibility to free the allocated buffer. */
1069 slurp_rel_relocs (Filedata
* filedata
,
1070 unsigned long rel_offset
,
1071 unsigned long rel_size
,
1072 Elf_Internal_Rela
** relsp
,
1073 unsigned long * nrelsp
)
1075 Elf_Internal_Rela
* rels
;
1081 Elf32_External_Rel
* erels
;
1083 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1084 rel_size
, _("32-bit relocation data"));
1088 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1090 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1095 error (_("out of memory parsing relocs\n"));
1099 for (i
= 0; i
< nrels
; i
++)
1101 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1102 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1103 rels
[i
].r_addend
= 0;
1110 Elf64_External_Rel
* erels
;
1112 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1113 rel_size
, _("64-bit relocation data"));
1117 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1119 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1124 error (_("out of memory parsing relocs\n"));
1128 for (i
= 0; i
< nrels
; i
++)
1130 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1131 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1132 rels
[i
].r_addend
= 0;
1134 /* The #ifdef BFD64 below is to prevent a compile time
1135 warning. We know that if we do not have a 64 bit data
1136 type that we will never execute this code anyway. */
1138 if (filedata
->file_header
.e_machine
== EM_MIPS
1139 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1141 /* In little-endian objects, r_info isn't really a
1142 64-bit little-endian value: it has a 32-bit
1143 little-endian symbol index followed by four
1144 individual byte fields. Reorder INFO
1146 bfd_vma inf
= rels
[i
].r_info
;
1147 inf
= (((inf
& 0xffffffff) << 32)
1148 | ((inf
>> 56) & 0xff)
1149 | ((inf
>> 40) & 0xff00)
1150 | ((inf
>> 24) & 0xff0000)
1151 | ((inf
>> 8) & 0xff000000));
1152 rels
[i
].r_info
= inf
;
1165 /* Returns the reloc type extracted from the reloc info field. */
1168 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1171 return ELF32_R_TYPE (reloc_info
);
1173 switch (filedata
->file_header
.e_machine
)
1176 /* Note: We assume that reloc_info has already been adjusted for us. */
1177 return ELF64_MIPS_R_TYPE (reloc_info
);
1180 return ELF64_R_TYPE_ID (reloc_info
);
1183 return ELF64_R_TYPE (reloc_info
);
1187 /* Return the symbol index extracted from the reloc info field. */
1190 get_reloc_symindex (bfd_vma reloc_info
)
1192 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1196 uses_msp430x_relocs (Filedata
* filedata
)
1199 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1200 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1201 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1202 /* TI compiler uses ELFOSABI_NONE. */
1203 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1206 /* Display the contents of the relocation data found at the specified
1210 dump_relocations (Filedata
* filedata
,
1211 unsigned long rel_offset
,
1212 unsigned long rel_size
,
1213 Elf_Internal_Sym
* symtab
,
1214 unsigned long nsyms
,
1216 unsigned long strtablen
,
1221 Elf_Internal_Rela
* rels
;
1224 if (is_rela
== UNKNOWN
)
1225 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1229 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1234 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1243 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1245 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1250 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1252 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1260 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1262 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1267 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1269 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1273 for (i
= 0; i
< rel_size
; i
++)
1278 bfd_vma symtab_index
;
1281 offset
= rels
[i
].r_offset
;
1282 inf
= rels
[i
].r_info
;
1284 type
= get_reloc_type (filedata
, inf
);
1285 symtab_index
= get_reloc_symindex (inf
);
1289 printf ("%8.8lx %8.8lx ",
1290 (unsigned long) offset
& 0xffffffff,
1291 (unsigned long) inf
& 0xffffffff);
1296 ? "%16.16" BFD_VMA_FMT
"x %16.16" BFD_VMA_FMT
"x "
1297 : "%12.12" BFD_VMA_FMT
"x %12.12" BFD_VMA_FMT
"x ",
1301 switch (filedata
->file_header
.e_machine
)
1308 rtype
= elf_aarch64_reloc_type (type
);
1312 case EM_CYGNUS_M32R
:
1313 rtype
= elf_m32r_reloc_type (type
);
1318 rtype
= elf_i386_reloc_type (type
);
1323 rtype
= elf_m68hc11_reloc_type (type
);
1327 rtype
= elf_s12z_reloc_type (type
);
1331 rtype
= elf_m68k_reloc_type (type
);
1335 rtype
= elf_i960_reloc_type (type
);
1340 rtype
= elf_avr_reloc_type (type
);
1343 case EM_OLD_SPARCV9
:
1344 case EM_SPARC32PLUS
:
1347 rtype
= elf_sparc_reloc_type (type
);
1351 rtype
= elf_spu_reloc_type (type
);
1355 rtype
= v800_reloc_type (type
);
1358 case EM_CYGNUS_V850
:
1359 rtype
= v850_reloc_type (type
);
1363 case EM_CYGNUS_D10V
:
1364 rtype
= elf_d10v_reloc_type (type
);
1368 case EM_CYGNUS_D30V
:
1369 rtype
= elf_d30v_reloc_type (type
);
1373 rtype
= elf_dlx_reloc_type (type
);
1377 rtype
= elf_sh_reloc_type (type
);
1381 case EM_CYGNUS_MN10300
:
1382 rtype
= elf_mn10300_reloc_type (type
);
1386 case EM_CYGNUS_MN10200
:
1387 rtype
= elf_mn10200_reloc_type (type
);
1391 case EM_CYGNUS_FR30
:
1392 rtype
= elf_fr30_reloc_type (type
);
1396 rtype
= elf_frv_reloc_type (type
);
1400 rtype
= elf_csky_reloc_type (type
);
1404 rtype
= elf_ft32_reloc_type (type
);
1408 rtype
= elf_mcore_reloc_type (type
);
1412 rtype
= elf_mmix_reloc_type (type
);
1416 rtype
= elf_moxie_reloc_type (type
);
1420 if (uses_msp430x_relocs (filedata
))
1422 rtype
= elf_msp430x_reloc_type (type
);
1427 rtype
= elf_msp430_reloc_type (type
);
1431 rtype
= elf_nds32_reloc_type (type
);
1435 rtype
= elf_ppc_reloc_type (type
);
1439 rtype
= elf_ppc64_reloc_type (type
);
1443 case EM_MIPS_RS3_LE
:
1444 rtype
= elf_mips_reloc_type (type
);
1448 rtype
= elf_riscv_reloc_type (type
);
1452 rtype
= elf_alpha_reloc_type (type
);
1456 rtype
= elf_arm_reloc_type (type
);
1460 case EM_ARC_COMPACT
:
1461 case EM_ARC_COMPACT2
:
1462 rtype
= elf_arc_reloc_type (type
);
1466 rtype
= elf_hppa_reloc_type (type
);
1472 rtype
= elf_h8_reloc_type (type
);
1476 rtype
= elf_or1k_reloc_type (type
);
1481 rtype
= elf_pj_reloc_type (type
);
1484 rtype
= elf_ia64_reloc_type (type
);
1488 rtype
= elf_cris_reloc_type (type
);
1492 rtype
= elf_i860_reloc_type (type
);
1498 rtype
= elf_x86_64_reloc_type (type
);
1502 rtype
= i370_reloc_type (type
);
1507 rtype
= elf_s390_reloc_type (type
);
1511 rtype
= elf_score_reloc_type (type
);
1515 rtype
= elf_xstormy16_reloc_type (type
);
1519 rtype
= elf_crx_reloc_type (type
);
1523 rtype
= elf_vax_reloc_type (type
);
1527 rtype
= elf_visium_reloc_type (type
);
1531 rtype
= elf_bpf_reloc_type (type
);
1534 case EM_ADAPTEVA_EPIPHANY
:
1535 rtype
= elf_epiphany_reloc_type (type
);
1540 rtype
= elf_ip2k_reloc_type (type
);
1544 rtype
= elf_iq2000_reloc_type (type
);
1549 rtype
= elf_xtensa_reloc_type (type
);
1552 case EM_LATTICEMICO32
:
1553 rtype
= elf_lm32_reloc_type (type
);
1558 rtype
= elf_m32c_reloc_type (type
);
1562 rtype
= elf_mt_reloc_type (type
);
1566 rtype
= elf_bfin_reloc_type (type
);
1570 rtype
= elf_mep_reloc_type (type
);
1574 rtype
= elf_cr16_reloc_type (type
);
1578 case EM_MICROBLAZE_OLD
:
1579 rtype
= elf_microblaze_reloc_type (type
);
1583 rtype
= elf_rl78_reloc_type (type
);
1587 rtype
= elf_rx_reloc_type (type
);
1591 rtype
= elf_metag_reloc_type (type
);
1596 rtype
= elf_xc16x_reloc_type (type
);
1600 rtype
= elf_tic6x_reloc_type (type
);
1604 rtype
= elf_tilegx_reloc_type (type
);
1608 rtype
= elf_tilepro_reloc_type (type
);
1611 case EM_WEBASSEMBLY
:
1612 rtype
= elf_wasm32_reloc_type (type
);
1616 rtype
= elf_xgate_reloc_type (type
);
1619 case EM_ALTERA_NIOS2
:
1620 rtype
= elf_nios2_reloc_type (type
);
1624 rtype
= elf_pru_reloc_type (type
);
1628 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1629 rtype
= elf_nfp3200_reloc_type (type
);
1631 rtype
= elf_nfp_reloc_type (type
);
1635 rtype
= elf_z80_reloc_type (type
);
1640 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1642 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1644 if (filedata
->file_header
.e_machine
== EM_ALPHA
1646 && streq (rtype
, "R_ALPHA_LITUSE")
1649 switch (rels
[i
].r_addend
)
1651 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1652 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1653 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1654 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1655 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1656 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1657 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1658 default: rtype
= NULL
;
1662 printf (" (%s)", rtype
);
1666 printf (_("<unknown addend: %lx>"),
1667 (unsigned long) rels
[i
].r_addend
);
1671 else if (symtab_index
)
1673 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1675 error (_(" bad symbol index: %08lx in reloc\n"),
1676 (unsigned long) symtab_index
);
1681 Elf_Internal_Sym
* psym
;
1682 const char * version_string
;
1683 enum versioned_symbol_info sym_info
;
1684 unsigned short vna_other
;
1686 psym
= symtab
+ symtab_index
;
1689 = get_symbol_version_string (filedata
, is_dynsym
,
1698 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1702 unsigned int width
= is_32bit_elf
? 8 : 14;
1704 /* Relocations against GNU_IFUNC symbols do not use the value
1705 of the symbol as the address to relocate against. Instead
1706 they invoke the function named by the symbol and use its
1707 result as the address for relocation.
1709 To indicate this to the user, do not display the value of
1710 the symbol in the "Symbols's Value" field. Instead show
1711 its name followed by () as a hint that the symbol is
1715 || psym
->st_name
== 0
1716 || psym
->st_name
>= strtablen
)
1719 name
= strtab
+ psym
->st_name
;
1721 len
= print_symbol (width
, name
);
1723 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1725 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1729 print_vma (psym
->st_value
, LONG_HEX
);
1731 printf (is_32bit_elf
? " " : " ");
1734 if (psym
->st_name
== 0)
1736 const char * sec_name
= "<null>";
1739 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1741 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1742 sec_name
= SECTION_NAME_PRINT (filedata
->section_headers
1744 else if (psym
->st_shndx
== SHN_ABS
)
1746 else if (psym
->st_shndx
== SHN_COMMON
)
1747 sec_name
= "COMMON";
1748 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1749 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1750 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1751 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1752 sec_name
= "SCOMMON";
1753 else if (filedata
->file_header
.e_machine
== EM_MIPS
1754 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1755 sec_name
= "SUNDEF";
1756 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1757 || filedata
->file_header
.e_machine
== EM_L1OM
1758 || filedata
->file_header
.e_machine
== EM_K1OM
)
1759 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1760 sec_name
= "LARGE_COMMON";
1761 else if (filedata
->file_header
.e_machine
== EM_IA_64
1762 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1763 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1764 sec_name
= "ANSI_COM";
1765 else if (is_ia64_vms (filedata
)
1766 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1767 sec_name
= "VMS_SYMVEC";
1770 sprintf (name_buf
, "<section 0x%x>",
1771 (unsigned int) psym
->st_shndx
);
1772 sec_name
= name_buf
;
1775 print_symbol (22, sec_name
);
1777 else if (strtab
== NULL
)
1778 printf (_("<string table index: %3ld>"), psym
->st_name
);
1779 else if (psym
->st_name
>= strtablen
)
1781 error (_("<corrupt string table index: %3ld>\n"),
1787 print_symbol (22, strtab
+ psym
->st_name
);
1789 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1795 bfd_vma off
= rels
[i
].r_addend
;
1797 if ((bfd_signed_vma
) off
< 0)
1798 printf (" - %" BFD_VMA_FMT
"x", - off
);
1800 printf (" + %" BFD_VMA_FMT
"x", off
);
1806 bfd_vma off
= rels
[i
].r_addend
;
1808 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1809 if ((bfd_signed_vma
) off
< 0)
1810 printf ("-%" BFD_VMA_FMT
"x", - off
);
1812 printf ("%" BFD_VMA_FMT
"x", off
);
1815 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1817 && streq (rtype
, "R_SPARC_OLO10"))
1818 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1823 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1825 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1826 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1827 const char * rtype2
= elf_mips_reloc_type (type2
);
1828 const char * rtype3
= elf_mips_reloc_type (type3
);
1830 printf (" Type2: ");
1833 printf (_("unrecognized: %-7lx"),
1834 (unsigned long) type2
& 0xffffffff);
1836 printf ("%-17.17s", rtype2
);
1838 printf ("\n Type3: ");
1841 printf (_("unrecognized: %-7lx"),
1842 (unsigned long) type3
& 0xffffffff);
1844 printf ("%-17.17s", rtype3
);
1857 get_aarch64_dynamic_type (unsigned long type
)
1861 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1862 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1863 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1870 get_mips_dynamic_type (unsigned long type
)
1874 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1875 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1876 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1877 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1878 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1879 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1880 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1881 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1882 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1883 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1884 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1885 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1886 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1887 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1888 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1889 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1890 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1891 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1892 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1893 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1894 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1895 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1896 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1897 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1898 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1899 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1900 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1901 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1902 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1903 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1904 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1905 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1906 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1907 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1908 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1909 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1910 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1911 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1912 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1913 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1914 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1915 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1916 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1917 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1918 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1919 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1920 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1927 get_sparc64_dynamic_type (unsigned long type
)
1931 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1938 get_ppc_dynamic_type (unsigned long type
)
1942 case DT_PPC_GOT
: return "PPC_GOT";
1943 case DT_PPC_OPT
: return "PPC_OPT";
1950 get_ppc64_dynamic_type (unsigned long type
)
1954 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1955 case DT_PPC64_OPD
: return "PPC64_OPD";
1956 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1957 case DT_PPC64_OPT
: return "PPC64_OPT";
1964 get_parisc_dynamic_type (unsigned long type
)
1968 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1969 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1970 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1971 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1972 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1973 case DT_HP_PREINIT
: return "HP_PREINIT";
1974 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1975 case DT_HP_NEEDED
: return "HP_NEEDED";
1976 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1977 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1978 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1979 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1980 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1981 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1982 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1983 case DT_HP_FILTERED
: return "HP_FILTERED";
1984 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1985 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1986 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1987 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1988 case DT_PLT
: return "PLT";
1989 case DT_PLT_SIZE
: return "PLT_SIZE";
1990 case DT_DLT
: return "DLT";
1991 case DT_DLT_SIZE
: return "DLT_SIZE";
1998 get_ia64_dynamic_type (unsigned long type
)
2002 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
2003 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
2004 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
2005 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
2006 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
2007 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
2008 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
2009 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
2010 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
2011 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
2012 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
2013 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
2014 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
2015 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
2016 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
2017 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
2018 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
2019 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
2020 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
2021 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
2022 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
2023 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
2024 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
2025 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
2026 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
2027 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
2028 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
2029 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
2030 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
2031 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
2032 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
2039 get_solaris_section_type (unsigned long type
)
2043 case 0x6fffffee: return "SUNW_ancillary";
2044 case 0x6fffffef: return "SUNW_capchain";
2045 case 0x6ffffff0: return "SUNW_capinfo";
2046 case 0x6ffffff1: return "SUNW_symsort";
2047 case 0x6ffffff2: return "SUNW_tlssort";
2048 case 0x6ffffff3: return "SUNW_LDYNSYM";
2049 case 0x6ffffff4: return "SUNW_dof";
2050 case 0x6ffffff5: return "SUNW_cap";
2051 case 0x6ffffff6: return "SUNW_SIGNATURE";
2052 case 0x6ffffff7: return "SUNW_ANNOTATE";
2053 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2054 case 0x6ffffff9: return "SUNW_DEBUG";
2055 case 0x6ffffffa: return "SUNW_move";
2056 case 0x6ffffffb: return "SUNW_COMDAT";
2057 case 0x6ffffffc: return "SUNW_syminfo";
2058 case 0x6ffffffd: return "SUNW_verdef";
2059 case 0x6ffffffe: return "SUNW_verneed";
2060 case 0x6fffffff: return "SUNW_versym";
2061 case 0x70000000: return "SPARC_GOTDATA";
2062 default: return NULL
;
2067 get_alpha_dynamic_type (unsigned long type
)
2071 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2072 default: return NULL
;
2077 get_score_dynamic_type (unsigned long type
)
2081 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2082 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2083 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2084 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2085 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2086 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2087 default: return NULL
;
2092 get_tic6x_dynamic_type (unsigned long type
)
2096 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2097 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2098 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2099 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2100 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2101 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2102 default: return NULL
;
2107 get_nios2_dynamic_type (unsigned long type
)
2111 case DT_NIOS2_GP
: return "NIOS2_GP";
2112 default: return NULL
;
2117 get_solaris_dynamic_type (unsigned long type
)
2121 case 0x6000000d: return "SUNW_AUXILIARY";
2122 case 0x6000000e: return "SUNW_RTLDINF";
2123 case 0x6000000f: return "SUNW_FILTER";
2124 case 0x60000010: return "SUNW_CAP";
2125 case 0x60000011: return "SUNW_SYMTAB";
2126 case 0x60000012: return "SUNW_SYMSZ";
2127 case 0x60000013: return "SUNW_SORTENT";
2128 case 0x60000014: return "SUNW_SYMSORT";
2129 case 0x60000015: return "SUNW_SYMSORTSZ";
2130 case 0x60000016: return "SUNW_TLSSORT";
2131 case 0x60000017: return "SUNW_TLSSORTSZ";
2132 case 0x60000018: return "SUNW_CAPINFO";
2133 case 0x60000019: return "SUNW_STRPAD";
2134 case 0x6000001a: return "SUNW_CAPCHAIN";
2135 case 0x6000001b: return "SUNW_LDMACH";
2136 case 0x6000001d: return "SUNW_CAPCHAINENT";
2137 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2138 case 0x60000021: return "SUNW_PARENT";
2139 case 0x60000023: return "SUNW_ASLR";
2140 case 0x60000025: return "SUNW_RELAX";
2141 case 0x60000029: return "SUNW_NXHEAP";
2142 case 0x6000002b: return "SUNW_NXSTACK";
2144 case 0x70000001: return "SPARC_REGISTER";
2145 case 0x7ffffffd: return "AUXILIARY";
2146 case 0x7ffffffe: return "USED";
2147 case 0x7fffffff: return "FILTER";
2149 default: return NULL
;
2154 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2156 static char buff
[64];
2160 case DT_NULL
: return "NULL";
2161 case DT_NEEDED
: return "NEEDED";
2162 case DT_PLTRELSZ
: return "PLTRELSZ";
2163 case DT_PLTGOT
: return "PLTGOT";
2164 case DT_HASH
: return "HASH";
2165 case DT_STRTAB
: return "STRTAB";
2166 case DT_SYMTAB
: return "SYMTAB";
2167 case DT_RELA
: return "RELA";
2168 case DT_RELASZ
: return "RELASZ";
2169 case DT_RELAENT
: return "RELAENT";
2170 case DT_STRSZ
: return "STRSZ";
2171 case DT_SYMENT
: return "SYMENT";
2172 case DT_INIT
: return "INIT";
2173 case DT_FINI
: return "FINI";
2174 case DT_SONAME
: return "SONAME";
2175 case DT_RPATH
: return "RPATH";
2176 case DT_SYMBOLIC
: return "SYMBOLIC";
2177 case DT_REL
: return "REL";
2178 case DT_RELSZ
: return "RELSZ";
2179 case DT_RELENT
: return "RELENT";
2180 case DT_PLTREL
: return "PLTREL";
2181 case DT_DEBUG
: return "DEBUG";
2182 case DT_TEXTREL
: return "TEXTREL";
2183 case DT_JMPREL
: return "JMPREL";
2184 case DT_BIND_NOW
: return "BIND_NOW";
2185 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2186 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2187 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2188 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2189 case DT_RUNPATH
: return "RUNPATH";
2190 case DT_FLAGS
: return "FLAGS";
2192 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2193 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2194 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2196 case DT_CHECKSUM
: return "CHECKSUM";
2197 case DT_PLTPADSZ
: return "PLTPADSZ";
2198 case DT_MOVEENT
: return "MOVEENT";
2199 case DT_MOVESZ
: return "MOVESZ";
2200 case DT_FEATURE
: return "FEATURE";
2201 case DT_POSFLAG_1
: return "POSFLAG_1";
2202 case DT_SYMINSZ
: return "SYMINSZ";
2203 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2205 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2206 case DT_CONFIG
: return "CONFIG";
2207 case DT_DEPAUDIT
: return "DEPAUDIT";
2208 case DT_AUDIT
: return "AUDIT";
2209 case DT_PLTPAD
: return "PLTPAD";
2210 case DT_MOVETAB
: return "MOVETAB";
2211 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2213 case DT_VERSYM
: return "VERSYM";
2215 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2216 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2217 case DT_RELACOUNT
: return "RELACOUNT";
2218 case DT_RELCOUNT
: return "RELCOUNT";
2219 case DT_FLAGS_1
: return "FLAGS_1";
2220 case DT_VERDEF
: return "VERDEF";
2221 case DT_VERDEFNUM
: return "VERDEFNUM";
2222 case DT_VERNEED
: return "VERNEED";
2223 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2225 case DT_AUXILIARY
: return "AUXILIARY";
2226 case DT_USED
: return "USED";
2227 case DT_FILTER
: return "FILTER";
2229 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2230 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2231 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2232 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2233 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2234 case DT_GNU_HASH
: return "GNU_HASH";
2235 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2238 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2240 const char * result
;
2242 switch (filedata
->file_header
.e_machine
)
2245 result
= get_aarch64_dynamic_type (type
);
2248 case EM_MIPS_RS3_LE
:
2249 result
= get_mips_dynamic_type (type
);
2252 result
= get_sparc64_dynamic_type (type
);
2255 result
= get_ppc_dynamic_type (type
);
2258 result
= get_ppc64_dynamic_type (type
);
2261 result
= get_ia64_dynamic_type (type
);
2264 result
= get_alpha_dynamic_type (type
);
2267 result
= get_score_dynamic_type (type
);
2270 result
= get_tic6x_dynamic_type (type
);
2272 case EM_ALTERA_NIOS2
:
2273 result
= get_nios2_dynamic_type (type
);
2276 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2277 result
= get_solaris_dynamic_type (type
);
2286 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2288 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2289 || (filedata
->file_header
.e_machine
== EM_PARISC
2290 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2292 const char * result
;
2294 switch (filedata
->file_header
.e_machine
)
2297 result
= get_parisc_dynamic_type (type
);
2300 result
= get_ia64_dynamic_type (type
);
2303 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2304 result
= get_solaris_dynamic_type (type
);
2313 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2317 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2324 get_file_type (unsigned e_type
)
2326 static char buff
[64];
2330 case ET_NONE
: return _("NONE (None)");
2331 case ET_REL
: return _("REL (Relocatable file)");
2332 case ET_EXEC
: return _("EXEC (Executable file)");
2333 case ET_DYN
: return _("DYN (Shared object file)");
2334 case ET_CORE
: return _("CORE (Core file)");
2337 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2338 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2339 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2340 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2342 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2348 get_machine_name (unsigned e_machine
)
2350 static char buff
[64]; /* XXX */
2354 /* Please keep this switch table sorted by increasing EM_ value. */
2356 case EM_NONE
: return _("None");
2357 case EM_M32
: return "WE32100";
2358 case EM_SPARC
: return "Sparc";
2359 case EM_386
: return "Intel 80386";
2360 case EM_68K
: return "MC68000";
2361 case EM_88K
: return "MC88000";
2362 case EM_IAMCU
: return "Intel MCU";
2363 case EM_860
: return "Intel 80860";
2364 case EM_MIPS
: return "MIPS R3000";
2365 case EM_S370
: return "IBM System/370";
2367 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2368 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2369 case EM_PARISC
: return "HPPA";
2370 case EM_VPP550
: return "Fujitsu VPP500";
2371 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2372 case EM_960
: return "Intel 80960";
2373 case EM_PPC
: return "PowerPC";
2375 case EM_PPC64
: return "PowerPC64";
2377 case EM_S390
: return "IBM S/390";
2378 case EM_SPU
: return "SPU";
2380 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2381 case EM_FR20
: return "Fujitsu FR20";
2382 case EM_RH32
: return "TRW RH32";
2383 case EM_MCORE
: return "MCORE";
2385 case EM_ARM
: return "ARM";
2386 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2387 case EM_SH
: return "Renesas / SuperH SH";
2388 case EM_SPARCV9
: return "Sparc v9";
2389 case EM_TRICORE
: return "Siemens Tricore";
2390 case EM_ARC
: return "ARC";
2391 case EM_H8_300
: return "Renesas H8/300";
2392 case EM_H8_300H
: return "Renesas H8/300H";
2393 case EM_H8S
: return "Renesas H8S";
2394 case EM_H8_500
: return "Renesas H8/500";
2396 case EM_IA_64
: return "Intel IA-64";
2397 case EM_MIPS_X
: return "Stanford MIPS-X";
2398 case EM_COLDFIRE
: return "Motorola Coldfire";
2399 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2400 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2401 case EM_PCP
: return "Siemens PCP";
2402 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2403 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2404 case EM_STARCORE
: return "Motorola Star*Core processor";
2405 case EM_ME16
: return "Toyota ME16 processor";
2407 case EM_ST100
: return "STMicroelectronics ST100 processor";
2408 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2409 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2410 case EM_PDSP
: return "Sony DSP processor";
2411 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2412 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2413 case EM_FX66
: return "Siemens FX66 microcontroller";
2414 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2415 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2416 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2418 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2419 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2420 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2421 case EM_SVX
: return "Silicon Graphics SVx";
2422 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2423 case EM_VAX
: return "Digital VAX";
2424 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2425 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2426 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2427 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2429 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2430 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2431 case EM_PRISM
: return "Vitesse Prism";
2433 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2434 case EM_CYGNUS_FR30
:
2435 case EM_FR30
: return "Fujitsu FR30";
2436 case EM_CYGNUS_D10V
:
2437 case EM_D10V
: return "d10v";
2438 case EM_CYGNUS_D30V
:
2439 case EM_D30V
: return "d30v";
2440 case EM_CYGNUS_V850
:
2441 case EM_V850
: return "Renesas V850";
2442 case EM_CYGNUS_M32R
:
2443 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2444 case EM_CYGNUS_MN10300
:
2445 case EM_MN10300
: return "mn10300";
2447 case EM_CYGNUS_MN10200
:
2448 case EM_MN10200
: return "mn10200";
2449 case EM_PJ
: return "picoJava";
2450 case EM_OR1K
: return "OpenRISC 1000";
2451 case EM_ARC_COMPACT
: return "ARCompact";
2453 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2454 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2455 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2456 case EM_NS32K
: return "National Semiconductor 32000 series";
2457 case EM_TPC
: return "Tenor Network TPC processor";
2458 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2460 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2462 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2463 case EM_MAX
: return "MAX Processor";
2464 case EM_CR
: return "National Semiconductor CompactRISC";
2465 case EM_F2MC16
: return "Fujitsu F2MC16";
2466 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2467 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2468 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2469 case EM_SEP
: return "Sharp embedded microprocessor";
2470 case EM_ARCA
: return "Arca RISC microprocessor";
2472 case EM_UNICORE
: return "Unicore";
2473 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2474 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2475 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2476 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2477 case EM_XGATE
: return "Motorola XGATE embedded processor";
2479 case EM_XC16X
: return "Infineon Technologies xc16x";
2480 case EM_M16C
: return "Renesas M16C series microprocessors";
2481 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2482 case EM_CE
: return "Freescale Communication Engine RISC core";
2484 case EM_M32C
: return "Renesas M32c";
2486 case EM_TSK3000
: return "Altium TSK3000 core";
2487 case EM_RS08
: return "Freescale RS08 embedded processor";
2488 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2489 case EM_SCORE
: return "SUNPLUS S+Core";
2490 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2491 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2492 case EM_LATTICEMICO32
: return "Lattice Mico32";
2493 case EM_SE_C17
: return "Seiko Epson C17 family";
2495 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2496 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2497 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2498 case EM_TI_PRU
: return "TI PRU I/O processor";
2500 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2501 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2502 case EM_R32C
: return "Renesas R32C series microprocessors";
2503 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2504 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2505 case EM_8051
: return "Intel 8051 and variants";
2506 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2507 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2508 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2509 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2511 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2512 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2513 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2514 case EM_RX
: return "Renesas RX";
2515 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2516 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2517 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2520 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2521 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2522 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2524 case EM_L1OM
: return "Intel L1OM";
2525 case EM_K1OM
: return "Intel K1OM";
2526 case EM_INTEL182
: return "Intel (reserved)";
2527 case EM_AARCH64
: return "AArch64";
2528 case EM_ARM184
: return "ARM (reserved)";
2529 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2530 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2531 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2532 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2534 case EM_CUDA
: return "NVIDIA CUDA architecture";
2535 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2536 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2537 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2538 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2539 case EM_ARC_COMPACT2
: return "ARCv2";
2540 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2541 case EM_RL78
: return "Renesas RL78";
2542 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2543 case EM_78K0R
: return "Renesas 78K0R";
2545 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2546 case EM_BA1
: return "Beyond BA1 CPU architecture";
2547 case EM_BA2
: return "Beyond BA2 CPU architecture";
2548 case EM_XCORE
: return "XMOS xCORE processor family";
2549 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2550 case EM_INTELGT
: return "Intel Graphics Technology";
2552 case EM_KM32
: return "KM211 KM32 32-bit processor";
2553 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2554 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2555 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2556 case EM_KVARC
: return "KM211 KVARC processor";
2557 case EM_CDP
: return "Paneve CDP architecture family";
2558 case EM_COGE
: return "Cognitive Smart Memory Processor";
2559 case EM_COOL
: return "Bluechip Systems CoolEngine";
2560 case EM_NORC
: return "Nanoradio Optimized RISC";
2561 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2563 case EM_Z80
: return "Zilog Z80";
2564 case EM_VISIUM
: return "CDS VISIUMcore processor";
2565 case EM_FT32
: return "FTDI Chip FT32";
2566 case EM_MOXIE
: return "Moxie";
2567 case EM_AMDGPU
: return "AMD GPU";
2568 /* 230 (all reserved) */
2570 case EM_RISCV
: return "RISC-V";
2571 case EM_LANAI
: return "Lanai 32-bit processor";
2572 case EM_CEVA
: return "CEVA Processor Architecture Family";
2573 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2574 case EM_BPF
: return "Linux BPF";
2575 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2576 case EM_IMG1
: return "Imagination Technologies";
2578 case EM_NFP
: return "Netronome Flow Processor";
2579 case EM_VE
: return "NEC Vector Engine";
2580 case EM_CSKY
: return "C-SKY";
2581 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2582 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2583 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2584 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2585 case EM_65816
: return "WDC 65816/65C816";
2586 case EM_LOONGARCH
: return "Loongson Loongarch";
2587 case EM_KF32
: return "ChipON KungFu32";
2589 /* Large numbers... */
2590 case EM_MT
: return "Morpho Techologies MT processor";
2591 case EM_ALPHA
: return "Alpha";
2592 case EM_WEBASSEMBLY
: return "Web Assembly";
2593 case EM_DLX
: return "OpenDLX";
2594 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2595 case EM_IQ2000
: return "Vitesse IQ2000";
2597 case EM_NIOS32
: return "Altera Nios";
2598 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2599 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2600 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2601 case EM_S12Z
: return "Freescale S12Z";
2604 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2610 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2612 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2613 other compilers don't specify an architecture type in the e_flags, and
2614 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2615 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2618 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2619 but also sets a specific architecture type in the e_flags field.
2621 However, when decoding the flags we don't worry if we see an
2622 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2623 ARCEM architecture type. */
2625 switch (e_flags
& EF_ARC_MACH_MSK
)
2627 /* We only expect these to occur for EM_ARC_COMPACT2. */
2628 case EF_ARC_CPU_ARCV2EM
:
2629 strcat (buf
, ", ARC EM");
2631 case EF_ARC_CPU_ARCV2HS
:
2632 strcat (buf
, ", ARC HS");
2635 /* We only expect these to occur for EM_ARC_COMPACT. */
2636 case E_ARC_MACH_ARC600
:
2637 strcat (buf
, ", ARC600");
2639 case E_ARC_MACH_ARC601
:
2640 strcat (buf
, ", ARC601");
2642 case E_ARC_MACH_ARC700
:
2643 strcat (buf
, ", ARC700");
2646 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2647 new ELF with new architecture being read by an old version of
2648 readelf, or (c) An ELF built with non-GNU compiler that does not
2649 set the architecture in the e_flags. */
2651 if (e_machine
== EM_ARC_COMPACT
)
2652 strcat (buf
, ", Unknown ARCompact");
2654 strcat (buf
, ", Unknown ARC");
2658 switch (e_flags
& EF_ARC_OSABI_MSK
)
2660 case E_ARC_OSABI_ORIG
:
2661 strcat (buf
, ", (ABI:legacy)");
2663 case E_ARC_OSABI_V2
:
2664 strcat (buf
, ", (ABI:v2)");
2666 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2667 case E_ARC_OSABI_V3
:
2668 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2670 case E_ARC_OSABI_V4
:
2671 strcat (buf
, ", v4 ABI");
2674 strcat (buf
, ", unrecognised ARC OSABI flag");
2680 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2683 bool unknown
= false;
2685 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2686 e_flags
&= ~ EF_ARM_EABIMASK
;
2688 /* Handle "generic" ARM flags. */
2689 if (e_flags
& EF_ARM_RELEXEC
)
2691 strcat (buf
, ", relocatable executable");
2692 e_flags
&= ~ EF_ARM_RELEXEC
;
2695 if (e_flags
& EF_ARM_PIC
)
2697 strcat (buf
, ", position independent");
2698 e_flags
&= ~ EF_ARM_PIC
;
2701 /* Now handle EABI specific flags. */
2705 strcat (buf
, ", <unrecognized EABI>");
2710 case EF_ARM_EABI_VER1
:
2711 strcat (buf
, ", Version1 EABI");
2716 /* Process flags one bit at a time. */
2717 flag
= e_flags
& - e_flags
;
2722 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2723 strcat (buf
, ", sorted symbol tables");
2733 case EF_ARM_EABI_VER2
:
2734 strcat (buf
, ", Version2 EABI");
2739 /* Process flags one bit at a time. */
2740 flag
= e_flags
& - e_flags
;
2745 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2746 strcat (buf
, ", sorted symbol tables");
2749 case EF_ARM_DYNSYMSUSESEGIDX
:
2750 strcat (buf
, ", dynamic symbols use segment index");
2753 case EF_ARM_MAPSYMSFIRST
:
2754 strcat (buf
, ", mapping symbols precede others");
2764 case EF_ARM_EABI_VER3
:
2765 strcat (buf
, ", Version3 EABI");
2768 case EF_ARM_EABI_VER4
:
2769 strcat (buf
, ", Version4 EABI");
2774 /* Process flags one bit at a time. */
2775 flag
= e_flags
& - e_flags
;
2781 strcat (buf
, ", BE8");
2785 strcat (buf
, ", LE8");
2795 case EF_ARM_EABI_VER5
:
2796 strcat (buf
, ", Version5 EABI");
2801 /* Process flags one bit at a time. */
2802 flag
= e_flags
& - e_flags
;
2808 strcat (buf
, ", BE8");
2812 strcat (buf
, ", LE8");
2815 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2816 strcat (buf
, ", soft-float ABI");
2819 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2820 strcat (buf
, ", hard-float ABI");
2830 case EF_ARM_EABI_UNKNOWN
:
2831 strcat (buf
, ", GNU EABI");
2836 /* Process flags one bit at a time. */
2837 flag
= e_flags
& - e_flags
;
2842 case EF_ARM_INTERWORK
:
2843 strcat (buf
, ", interworking enabled");
2846 case EF_ARM_APCS_26
:
2847 strcat (buf
, ", uses APCS/26");
2850 case EF_ARM_APCS_FLOAT
:
2851 strcat (buf
, ", uses APCS/float");
2855 strcat (buf
, ", position independent");
2859 strcat (buf
, ", 8 bit structure alignment");
2862 case EF_ARM_NEW_ABI
:
2863 strcat (buf
, ", uses new ABI");
2866 case EF_ARM_OLD_ABI
:
2867 strcat (buf
, ", uses old ABI");
2870 case EF_ARM_SOFT_FLOAT
:
2871 strcat (buf
, ", software FP");
2874 case EF_ARM_VFP_FLOAT
:
2875 strcat (buf
, ", VFP");
2878 case EF_ARM_MAVERICK_FLOAT
:
2879 strcat (buf
, ", Maverick FP");
2890 strcat (buf
,_(", <unknown>"));
2894 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2896 --size
; /* Leave space for null terminator. */
2898 switch (e_flags
& EF_AVR_MACH
)
2900 case E_AVR_MACH_AVR1
:
2901 strncat (buf
, ", avr:1", size
);
2903 case E_AVR_MACH_AVR2
:
2904 strncat (buf
, ", avr:2", size
);
2906 case E_AVR_MACH_AVR25
:
2907 strncat (buf
, ", avr:25", size
);
2909 case E_AVR_MACH_AVR3
:
2910 strncat (buf
, ", avr:3", size
);
2912 case E_AVR_MACH_AVR31
:
2913 strncat (buf
, ", avr:31", size
);
2915 case E_AVR_MACH_AVR35
:
2916 strncat (buf
, ", avr:35", size
);
2918 case E_AVR_MACH_AVR4
:
2919 strncat (buf
, ", avr:4", size
);
2921 case E_AVR_MACH_AVR5
:
2922 strncat (buf
, ", avr:5", size
);
2924 case E_AVR_MACH_AVR51
:
2925 strncat (buf
, ", avr:51", size
);
2927 case E_AVR_MACH_AVR6
:
2928 strncat (buf
, ", avr:6", size
);
2930 case E_AVR_MACH_AVRTINY
:
2931 strncat (buf
, ", avr:100", size
);
2933 case E_AVR_MACH_XMEGA1
:
2934 strncat (buf
, ", avr:101", size
);
2936 case E_AVR_MACH_XMEGA2
:
2937 strncat (buf
, ", avr:102", size
);
2939 case E_AVR_MACH_XMEGA3
:
2940 strncat (buf
, ", avr:103", size
);
2942 case E_AVR_MACH_XMEGA4
:
2943 strncat (buf
, ", avr:104", size
);
2945 case E_AVR_MACH_XMEGA5
:
2946 strncat (buf
, ", avr:105", size
);
2948 case E_AVR_MACH_XMEGA6
:
2949 strncat (buf
, ", avr:106", size
);
2951 case E_AVR_MACH_XMEGA7
:
2952 strncat (buf
, ", avr:107", size
);
2955 strncat (buf
, ", avr:<unknown>", size
);
2959 size
-= strlen (buf
);
2960 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2961 strncat (buf
, ", link-relax", size
);
2965 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2971 bool has_fpu
= false;
2974 static const char *ABI_STRINGS
[] =
2976 "ABI v0", /* use r5 as return register; only used in N1213HC */
2977 "ABI v1", /* use r0 as return register */
2978 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2979 "ABI v2fp", /* for FPU */
2983 static const char *VER_STRINGS
[] =
2985 "Andes ELF V1.3 or older",
2989 static const char *ARCH_STRINGS
[] =
2998 abi
= EF_NDS_ABI
& e_flags
;
2999 arch
= EF_NDS_ARCH
& e_flags
;
3000 config
= EF_NDS_INST
& e_flags
;
3001 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3003 memset (buf
, 0, size
);
3010 case E_NDS_ABI_V2FP
:
3011 case E_NDS_ABI_AABI
:
3012 case E_NDS_ABI_V2FP_PLUS
:
3013 /* In case there are holes in the array. */
3014 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3018 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3024 case E_NDS32_ELF_VER_1_2
:
3025 case E_NDS32_ELF_VER_1_3
:
3026 case E_NDS32_ELF_VER_1_4
:
3027 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3031 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3035 if (E_NDS_ABI_V0
== abi
)
3037 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3038 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3039 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3046 case E_NDS_ARCH_STAR_V1_0
:
3047 case E_NDS_ARCH_STAR_V2_0
:
3048 case E_NDS_ARCH_STAR_V3_0
:
3049 case E_NDS_ARCH_STAR_V3_M
:
3050 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3054 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3055 /* ARCH version determines how the e_flags are interpreted.
3056 If it is unknown, we cannot proceed. */
3060 /* Newer ABI; Now handle architecture specific flags. */
3061 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3063 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3064 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3066 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3067 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3069 if (config
& E_NDS32_HAS_DIV_INST
)
3070 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3072 if (config
& E_NDS32_HAS_16BIT_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3077 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3079 if (version
<= E_NDS32_ELF_VER_1_3
)
3080 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3082 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3085 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3088 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3091 if (config
& E_NDS32_HAS_16BIT_INST
)
3093 if (version
<= E_NDS32_ELF_VER_1_3
)
3094 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3096 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3100 if (config
& E_NDS32_HAS_EXT_INST
)
3101 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3103 if (config
& E_NDS32_HAS_EXT2_INST
)
3104 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3106 if (config
& E_NDS32_HAS_FPU_INST
)
3109 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3112 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3115 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3118 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3121 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3126 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3128 case E_NDS32_FPU_REG_8SP_4DP
:
3129 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3131 case E_NDS32_FPU_REG_16SP_8DP
:
3132 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3134 case E_NDS32_FPU_REG_32SP_16DP
:
3135 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3137 case E_NDS32_FPU_REG_32SP_32DP
:
3138 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3143 if (config
& E_NDS32_HAS_AUDIO_INST
)
3144 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3146 if (config
& E_NDS32_HAS_STRING_INST
)
3147 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3149 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3150 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3152 if (config
& E_NDS32_HAS_VIDEO_INST
)
3154 if (version
<= E_NDS32_ELF_VER_1_3
)
3155 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3157 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3160 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3161 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3163 if (config
& E_NDS32_HAS_L2C_INST
)
3164 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3168 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3170 static char buf
[1024];
3181 case EM_ARC_COMPACT2
:
3182 case EM_ARC_COMPACT
:
3183 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3187 decode_ARM_machine_flags (e_flags
, buf
);
3191 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3195 if (e_flags
& EF_BFIN_PIC
)
3196 strcat (buf
, ", PIC");
3198 if (e_flags
& EF_BFIN_FDPIC
)
3199 strcat (buf
, ", FDPIC");
3201 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3202 strcat (buf
, ", code in L1");
3204 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3205 strcat (buf
, ", data in L1");
3210 switch (e_flags
& EF_FRV_CPU_MASK
)
3212 case EF_FRV_CPU_GENERIC
:
3216 strcat (buf
, ", fr???");
3219 case EF_FRV_CPU_FR300
:
3220 strcat (buf
, ", fr300");
3223 case EF_FRV_CPU_FR400
:
3224 strcat (buf
, ", fr400");
3226 case EF_FRV_CPU_FR405
:
3227 strcat (buf
, ", fr405");
3230 case EF_FRV_CPU_FR450
:
3231 strcat (buf
, ", fr450");
3234 case EF_FRV_CPU_FR500
:
3235 strcat (buf
, ", fr500");
3237 case EF_FRV_CPU_FR550
:
3238 strcat (buf
, ", fr550");
3241 case EF_FRV_CPU_SIMPLE
:
3242 strcat (buf
, ", simple");
3244 case EF_FRV_CPU_TOMCAT
:
3245 strcat (buf
, ", tomcat");
3251 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3252 strcat (buf
, ", m68000");
3253 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3254 strcat (buf
, ", cpu32");
3255 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3256 strcat (buf
, ", fido_a");
3259 char const * isa
= _("unknown");
3260 char const * mac
= _("unknown mac");
3261 char const * additional
= NULL
;
3263 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3265 case EF_M68K_CF_ISA_A_NODIV
:
3267 additional
= ", nodiv";
3269 case EF_M68K_CF_ISA_A
:
3272 case EF_M68K_CF_ISA_A_PLUS
:
3275 case EF_M68K_CF_ISA_B_NOUSP
:
3277 additional
= ", nousp";
3279 case EF_M68K_CF_ISA_B
:
3282 case EF_M68K_CF_ISA_C
:
3285 case EF_M68K_CF_ISA_C_NODIV
:
3287 additional
= ", nodiv";
3290 strcat (buf
, ", cf, isa ");
3293 strcat (buf
, additional
);
3294 if (e_flags
& EF_M68K_CF_FLOAT
)
3295 strcat (buf
, ", float");
3296 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3301 case EF_M68K_CF_MAC
:
3304 case EF_M68K_CF_EMAC
:
3307 case EF_M68K_CF_EMAC_B
:
3320 switch (e_flags
& EF_MEP_CPU_MASK
)
3322 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3323 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3324 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3325 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3326 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3327 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3328 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3331 switch (e_flags
& EF_MEP_COP_MASK
)
3333 case EF_MEP_COP_NONE
: break;
3334 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3335 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3336 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3337 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3338 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3341 if (e_flags
& EF_MEP_LIBRARY
)
3342 strcat (buf
, ", Built for Library");
3344 if (e_flags
& EF_MEP_INDEX_MASK
)
3345 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3346 e_flags
& EF_MEP_INDEX_MASK
);
3348 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3349 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3350 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3354 if (e_flags
& EF_PPC_EMB
)
3355 strcat (buf
, ", emb");
3357 if (e_flags
& EF_PPC_RELOCATABLE
)
3358 strcat (buf
, _(", relocatable"));
3360 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3361 strcat (buf
, _(", relocatable-lib"));
3365 if (e_flags
& EF_PPC64_ABI
)
3367 char abi
[] = ", abiv0";
3369 abi
[6] += e_flags
& EF_PPC64_ABI
;
3375 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3376 strcat (buf
, ", RH850 ABI");
3378 if (e_flags
& EF_V800_850E3
)
3379 strcat (buf
, ", V3 architecture");
3381 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3382 strcat (buf
, ", FPU not used");
3384 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3385 strcat (buf
, ", regmode: COMMON");
3387 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3388 strcat (buf
, ", r4 not used");
3390 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3391 strcat (buf
, ", r30 not used");
3393 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3394 strcat (buf
, ", r5 not used");
3396 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3397 strcat (buf
, ", r2 not used");
3399 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3401 switch (e_flags
& - e_flags
)
3403 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3404 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3405 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3406 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3407 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3408 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3409 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3410 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3411 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3412 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3413 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3414 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3421 case EM_CYGNUS_V850
:
3422 switch (e_flags
& EF_V850_ARCH
)
3424 case E_V850E3V5_ARCH
:
3425 strcat (buf
, ", v850e3v5");
3427 case E_V850E2V3_ARCH
:
3428 strcat (buf
, ", v850e2v3");
3431 strcat (buf
, ", v850e2");
3434 strcat (buf
, ", v850e1");
3437 strcat (buf
, ", v850e");
3440 strcat (buf
, ", v850");
3443 strcat (buf
, _(", unknown v850 architecture variant"));
3449 case EM_CYGNUS_M32R
:
3450 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3451 strcat (buf
, ", m32r");
3455 case EM_MIPS_RS3_LE
:
3456 if (e_flags
& EF_MIPS_NOREORDER
)
3457 strcat (buf
, ", noreorder");
3459 if (e_flags
& EF_MIPS_PIC
)
3460 strcat (buf
, ", pic");
3462 if (e_flags
& EF_MIPS_CPIC
)
3463 strcat (buf
, ", cpic");
3465 if (e_flags
& EF_MIPS_UCODE
)
3466 strcat (buf
, ", ugen_reserved");
3468 if (e_flags
& EF_MIPS_ABI2
)
3469 strcat (buf
, ", abi2");
3471 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3472 strcat (buf
, ", odk first");
3474 if (e_flags
& EF_MIPS_32BITMODE
)
3475 strcat (buf
, ", 32bitmode");
3477 if (e_flags
& EF_MIPS_NAN2008
)
3478 strcat (buf
, ", nan2008");
3480 if (e_flags
& EF_MIPS_FP64
)
3481 strcat (buf
, ", fp64");
3483 switch ((e_flags
& EF_MIPS_MACH
))
3485 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3486 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3487 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3488 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3489 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3490 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3491 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3492 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3493 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3494 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3495 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3496 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3497 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3498 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3499 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3500 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3501 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3502 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3503 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3504 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3505 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3507 /* We simply ignore the field in this case to avoid confusion:
3508 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3511 default: strcat (buf
, _(", unknown CPU")); break;
3514 switch ((e_flags
& EF_MIPS_ABI
))
3516 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3517 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3518 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3519 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3521 /* We simply ignore the field in this case to avoid confusion:
3522 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3523 This means it is likely to be an o32 file, but not for
3526 default: strcat (buf
, _(", unknown ABI")); break;
3529 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3530 strcat (buf
, ", mdmx");
3532 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3533 strcat (buf
, ", mips16");
3535 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3536 strcat (buf
, ", micromips");
3538 switch ((e_flags
& EF_MIPS_ARCH
))
3540 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3541 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3542 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3543 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3544 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3545 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3546 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3547 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3548 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3549 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3550 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3551 default: strcat (buf
, _(", unknown ISA")); break;
3556 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3560 switch (EF_NFP_MACH (e_flags
))
3562 case E_NFP_MACH_3200
:
3563 strcat (buf
, ", NFP-32xx");
3565 case E_NFP_MACH_6000
:
3566 strcat (buf
, ", NFP-6xxx");
3572 if (e_flags
& EF_RISCV_RVC
)
3573 strcat (buf
, ", RVC");
3575 if (e_flags
& EF_RISCV_RVE
)
3576 strcat (buf
, ", RVE");
3578 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3580 case EF_RISCV_FLOAT_ABI_SOFT
:
3581 strcat (buf
, ", soft-float ABI");
3584 case EF_RISCV_FLOAT_ABI_SINGLE
:
3585 strcat (buf
, ", single-float ABI");
3588 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3589 strcat (buf
, ", double-float ABI");
3592 case EF_RISCV_FLOAT_ABI_QUAD
:
3593 strcat (buf
, ", quad-float ABI");
3599 switch ((e_flags
& EF_SH_MACH_MASK
))
3601 case EF_SH1
: strcat (buf
, ", sh1"); break;
3602 case EF_SH2
: strcat (buf
, ", sh2"); break;
3603 case EF_SH3
: strcat (buf
, ", sh3"); break;
3604 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3605 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3606 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3607 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3608 case EF_SH4
: strcat (buf
, ", sh4"); break;
3609 case EF_SH5
: strcat (buf
, ", sh5"); break;
3610 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3611 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3612 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3613 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3614 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3615 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3616 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3617 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3618 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3619 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3620 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3621 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3622 default: strcat (buf
, _(", unknown ISA")); break;
3625 if (e_flags
& EF_SH_PIC
)
3626 strcat (buf
, ", pic");
3628 if (e_flags
& EF_SH_FDPIC
)
3629 strcat (buf
, ", fdpic");
3633 if (e_flags
& EF_OR1K_NODELAY
)
3634 strcat (buf
, ", no delay");
3638 if (e_flags
& EF_SPARC_32PLUS
)
3639 strcat (buf
, ", v8+");
3641 if (e_flags
& EF_SPARC_SUN_US1
)
3642 strcat (buf
, ", ultrasparcI");
3644 if (e_flags
& EF_SPARC_SUN_US3
)
3645 strcat (buf
, ", ultrasparcIII");
3647 if (e_flags
& EF_SPARC_HAL_R1
)
3648 strcat (buf
, ", halr1");
3650 if (e_flags
& EF_SPARC_LEDATA
)
3651 strcat (buf
, ", ledata");
3653 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3654 strcat (buf
, ", tso");
3656 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3657 strcat (buf
, ", pso");
3659 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3660 strcat (buf
, ", rmo");
3664 switch (e_flags
& EF_PARISC_ARCH
)
3666 case EFA_PARISC_1_0
:
3667 strcpy (buf
, ", PA-RISC 1.0");
3669 case EFA_PARISC_1_1
:
3670 strcpy (buf
, ", PA-RISC 1.1");
3672 case EFA_PARISC_2_0
:
3673 strcpy (buf
, ", PA-RISC 2.0");
3678 if (e_flags
& EF_PARISC_TRAPNIL
)
3679 strcat (buf
, ", trapnil");
3680 if (e_flags
& EF_PARISC_EXT
)
3681 strcat (buf
, ", ext");
3682 if (e_flags
& EF_PARISC_LSB
)
3683 strcat (buf
, ", lsb");
3684 if (e_flags
& EF_PARISC_WIDE
)
3685 strcat (buf
, ", wide");
3686 if (e_flags
& EF_PARISC_NO_KABP
)
3687 strcat (buf
, ", no kabp");
3688 if (e_flags
& EF_PARISC_LAZYSWAP
)
3689 strcat (buf
, ", lazyswap");
3694 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3695 strcat (buf
, ", new calling convention");
3697 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3698 strcat (buf
, ", gnu calling convention");
3702 if ((e_flags
& EF_IA_64_ABI64
))
3703 strcat (buf
, ", 64-bit");
3705 strcat (buf
, ", 32-bit");
3706 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3707 strcat (buf
, ", reduced fp model");
3708 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3709 strcat (buf
, ", no function descriptors, constant gp");
3710 else if ((e_flags
& EF_IA_64_CONS_GP
))
3711 strcat (buf
, ", constant gp");
3712 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3713 strcat (buf
, ", absolute");
3714 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3716 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3717 strcat (buf
, ", vms_linkages");
3718 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3720 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3722 case EF_IA_64_VMS_COMCOD_WARNING
:
3723 strcat (buf
, ", warning");
3725 case EF_IA_64_VMS_COMCOD_ERROR
:
3726 strcat (buf
, ", error");
3728 case EF_IA_64_VMS_COMCOD_ABORT
:
3729 strcat (buf
, ", abort");
3732 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3733 e_flags
& EF_IA_64_VMS_COMCOD
);
3734 strcat (buf
, ", <unknown>");
3740 if ((e_flags
& EF_VAX_NONPIC
))
3741 strcat (buf
, ", non-PIC");
3742 if ((e_flags
& EF_VAX_DFLOAT
))
3743 strcat (buf
, ", D-Float");
3744 if ((e_flags
& EF_VAX_GFLOAT
))
3745 strcat (buf
, ", G-Float");
3749 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3750 strcat (buf
, ", mcm");
3751 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3752 strcat (buf
, ", mcm24");
3753 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3754 strcat (buf
, ", gr6");
3758 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3760 case E_FLAG_RL78_ANY_CPU
: break;
3761 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3762 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3763 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3765 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3766 strcat (buf
, ", 64-bit doubles");
3770 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3771 strcat (buf
, ", 64-bit doubles");
3772 if (e_flags
& E_FLAG_RX_DSP
)
3773 strcat (buf
, ", dsp");
3774 if (e_flags
& E_FLAG_RX_PID
)
3775 strcat (buf
, ", pid");
3776 if (e_flags
& E_FLAG_RX_ABI
)
3777 strcat (buf
, ", RX ABI");
3778 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3779 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3780 ? ", uses String instructions" : ", bans String instructions");
3781 if (e_flags
& E_FLAG_RX_V2
)
3782 strcat (buf
, ", V2");
3783 if (e_flags
& E_FLAG_RX_V3
)
3784 strcat (buf
, ", V3");
3788 if (e_flags
& EF_S390_HIGH_GPRS
)
3789 strcat (buf
, ", highgprs");
3793 if ((e_flags
& EF_C6000_REL
))
3794 strcat (buf
, ", relocatable module");
3798 strcat (buf
, _(": architecture variant: "));
3799 switch (e_flags
& EF_MSP430_MACH
)
3801 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3802 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3803 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3804 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3805 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3806 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3807 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3808 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3809 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3810 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3811 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3812 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3813 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3814 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3815 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3817 strcat (buf
, _(": unknown")); break;
3820 if (e_flags
& ~ EF_MSP430_MACH
)
3821 strcat (buf
, _(": unknown extra flag bits also present"));
3825 switch (e_flags
& EF_Z80_MACH_MSK
)
3827 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3828 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3829 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3830 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3831 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3832 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3833 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3835 strcat (buf
, _(", unknown")); break;
3845 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3847 static char buff
[32];
3851 case ELFOSABI_NONE
: return "UNIX - System V";
3852 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3853 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3854 case ELFOSABI_GNU
: return "UNIX - GNU";
3855 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3856 case ELFOSABI_AIX
: return "UNIX - AIX";
3857 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3858 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3859 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3860 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3861 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3862 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3863 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3864 case ELFOSABI_AROS
: return "AROS";
3865 case ELFOSABI_FENIXOS
: return "FenixOS";
3866 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3867 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3870 switch (filedata
->file_header
.e_machine
)
3875 case ELFOSABI_ARM
: return "ARM";
3876 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3887 case ELFOSABI_STANDALONE
: return _("Standalone App");
3896 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3897 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3906 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3912 get_aarch64_segment_type (unsigned long type
)
3916 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3917 default: return NULL
;
3922 get_arm_segment_type (unsigned long type
)
3926 case PT_ARM_EXIDX
: return "EXIDX";
3927 default: return NULL
;
3932 get_s390_segment_type (unsigned long type
)
3936 case PT_S390_PGSTE
: return "S390_PGSTE";
3937 default: return NULL
;
3942 get_mips_segment_type (unsigned long type
)
3946 case PT_MIPS_REGINFO
: return "REGINFO";
3947 case PT_MIPS_RTPROC
: return "RTPROC";
3948 case PT_MIPS_OPTIONS
: return "OPTIONS";
3949 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3950 default: return NULL
;
3955 get_parisc_segment_type (unsigned long type
)
3959 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3960 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3961 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3962 default: return NULL
;
3967 get_ia64_segment_type (unsigned long type
)
3971 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3972 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3973 default: return NULL
;
3978 get_tic6x_segment_type (unsigned long type
)
3982 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3983 default: return NULL
;
3988 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3990 if (e_machine
== EM_PARISC
)
3993 case PT_HP_TLS
: return "HP_TLS";
3994 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3995 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3996 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3997 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3998 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3999 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
4000 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4001 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4002 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4003 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4004 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4005 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4006 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4007 case PT_HP_STACK
: return "HP_STACK";
4008 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4009 default: return NULL
;
4012 if (e_machine
== EM_IA_64
)
4015 case PT_HP_TLS
: return "HP_TLS";
4016 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4017 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4018 case PT_IA_64_HP_STACK
: return "HP_STACK";
4019 default: return NULL
;
4026 get_solaris_segment_type (unsigned long type
)
4030 case 0x6464e550: return "PT_SUNW_UNWIND";
4031 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4032 case 0x6ffffff7: return "PT_LOSUNW";
4033 case 0x6ffffffa: return "PT_SUNWBSS";
4034 case 0x6ffffffb: return "PT_SUNWSTACK";
4035 case 0x6ffffffc: return "PT_SUNWDTRACE";
4036 case 0x6ffffffd: return "PT_SUNWCAP";
4037 case 0x6fffffff: return "PT_HISUNW";
4038 default: return NULL
;
4043 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4045 static char buff
[32];
4049 case PT_NULL
: return "NULL";
4050 case PT_LOAD
: return "LOAD";
4051 case PT_DYNAMIC
: return "DYNAMIC";
4052 case PT_INTERP
: return "INTERP";
4053 case PT_NOTE
: return "NOTE";
4054 case PT_SHLIB
: return "SHLIB";
4055 case PT_PHDR
: return "PHDR";
4056 case PT_TLS
: return "TLS";
4057 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4058 case PT_GNU_STACK
: return "GNU_STACK";
4059 case PT_GNU_RELRO
: return "GNU_RELRO";
4060 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4062 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4063 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4064 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4067 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4069 const char * result
;
4071 switch (filedata
->file_header
.e_machine
)
4074 result
= get_aarch64_segment_type (p_type
);
4077 result
= get_arm_segment_type (p_type
);
4080 case EM_MIPS_RS3_LE
:
4081 result
= get_mips_segment_type (p_type
);
4084 result
= get_parisc_segment_type (p_type
);
4087 result
= get_ia64_segment_type (p_type
);
4090 result
= get_tic6x_segment_type (p_type
);
4094 result
= get_s390_segment_type (p_type
);
4104 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4106 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4108 const char * result
= NULL
;
4110 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4113 case ELFOSABI_FREEBSD
:
4114 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4116 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4121 result
= get_hpux_segment_type (p_type
,
4122 filedata
->file_header
.e_machine
);
4124 case ELFOSABI_SOLARIS
:
4125 result
= get_solaris_segment_type (p_type
);
4133 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4136 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4143 get_arc_section_type_name (unsigned int sh_type
)
4147 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4155 get_mips_section_type_name (unsigned int sh_type
)
4159 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4160 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4161 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4162 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4163 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4164 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4165 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4166 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4167 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4168 case SHT_MIPS_RELD
: return "MIPS_RELD";
4169 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4170 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4171 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4172 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4173 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4174 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4175 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4176 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4177 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4178 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4179 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4180 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4181 case SHT_MIPS_LINE
: return "MIPS_LINE";
4182 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4183 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4184 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4185 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4186 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4187 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4188 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4189 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4190 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4191 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4192 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4193 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4194 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4195 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4196 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4197 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4198 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4199 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4207 get_parisc_section_type_name (unsigned int sh_type
)
4211 case SHT_PARISC_EXT
: return "PARISC_EXT";
4212 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4213 case SHT_PARISC_DOC
: return "PARISC_DOC";
4214 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4215 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4216 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4217 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4218 default: return NULL
;
4223 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4225 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4226 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4227 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4231 case SHT_IA_64_EXT
: return "IA_64_EXT";
4232 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4233 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4234 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4235 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4236 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4237 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4238 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4239 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4240 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4248 get_x86_64_section_type_name (unsigned int sh_type
)
4252 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4253 default: return NULL
;
4258 get_aarch64_section_type_name (unsigned int sh_type
)
4262 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4263 default: return NULL
;
4268 get_arm_section_type_name (unsigned int sh_type
)
4272 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4273 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4274 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4275 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4276 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4277 default: return NULL
;
4282 get_tic6x_section_type_name (unsigned int sh_type
)
4286 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4287 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4288 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4289 case SHT_TI_ICODE
: return "TI_ICODE";
4290 case SHT_TI_XREF
: return "TI_XREF";
4291 case SHT_TI_HANDLER
: return "TI_HANDLER";
4292 case SHT_TI_INITINFO
: return "TI_INITINFO";
4293 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4294 default: return NULL
;
4299 get_msp430_section_type_name (unsigned int sh_type
)
4303 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4304 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4305 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4306 default: return NULL
;
4311 get_nfp_section_type_name (unsigned int sh_type
)
4315 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4316 case SHT_NFP_INITREG
: return "NFP_INITREG";
4317 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4318 default: return NULL
;
4323 get_v850_section_type_name (unsigned int sh_type
)
4327 case SHT_V850_SCOMMON
: return "V850 Small Common";
4328 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4329 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4330 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4331 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4332 default: return NULL
;
4337 get_riscv_section_type_name (unsigned int sh_type
)
4341 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4342 default: return NULL
;
4347 get_csky_section_type_name (unsigned int sh_type
)
4351 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4352 default: return NULL
;
4357 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4359 static char buff
[32];
4360 const char * result
;
4364 case SHT_NULL
: return "NULL";
4365 case SHT_PROGBITS
: return "PROGBITS";
4366 case SHT_SYMTAB
: return "SYMTAB";
4367 case SHT_STRTAB
: return "STRTAB";
4368 case SHT_RELA
: return "RELA";
4369 case SHT_HASH
: return "HASH";
4370 case SHT_DYNAMIC
: return "DYNAMIC";
4371 case SHT_NOTE
: return "NOTE";
4372 case SHT_NOBITS
: return "NOBITS";
4373 case SHT_REL
: return "REL";
4374 case SHT_SHLIB
: return "SHLIB";
4375 case SHT_DYNSYM
: return "DYNSYM";
4376 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4377 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4378 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4379 case SHT_GNU_HASH
: return "GNU_HASH";
4380 case SHT_GROUP
: return "GROUP";
4381 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4382 case SHT_GNU_verdef
: return "VERDEF";
4383 case SHT_GNU_verneed
: return "VERNEED";
4384 case SHT_GNU_versym
: return "VERSYM";
4385 case 0x6ffffff0: return "VERSYM";
4386 case 0x6ffffffc: return "VERDEF";
4387 case 0x7ffffffd: return "AUXILIARY";
4388 case 0x7fffffff: return "FILTER";
4389 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4392 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4394 switch (filedata
->file_header
.e_machine
)
4397 case EM_ARC_COMPACT
:
4398 case EM_ARC_COMPACT2
:
4399 result
= get_arc_section_type_name (sh_type
);
4402 case EM_MIPS_RS3_LE
:
4403 result
= get_mips_section_type_name (sh_type
);
4406 result
= get_parisc_section_type_name (sh_type
);
4409 result
= get_ia64_section_type_name (filedata
, sh_type
);
4414 result
= get_x86_64_section_type_name (sh_type
);
4417 result
= get_aarch64_section_type_name (sh_type
);
4420 result
= get_arm_section_type_name (sh_type
);
4423 result
= get_tic6x_section_type_name (sh_type
);
4426 result
= get_msp430_section_type_name (sh_type
);
4429 result
= get_nfp_section_type_name (sh_type
);
4433 case EM_CYGNUS_V850
:
4434 result
= get_v850_section_type_name (sh_type
);
4437 result
= get_riscv_section_type_name (sh_type
);
4440 result
= get_csky_section_type_name (sh_type
);
4450 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4452 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4454 switch (filedata
->file_header
.e_machine
)
4457 result
= get_ia64_section_type_name (filedata
, sh_type
);
4460 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4461 result
= get_solaris_section_type (sh_type
);
4466 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4467 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4468 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4469 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4481 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4483 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4485 switch (filedata
->file_header
.e_machine
)
4489 case EM_CYGNUS_V850
:
4490 result
= get_v850_section_type_name (sh_type
);
4500 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4503 /* This message is probably going to be displayed in a 15
4504 character wide field, so put the hex value first. */
4505 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4511 enum long_option_values
4513 OPTION_DEBUG_DUMP
= 512,
4523 OPTION_WITH_SYMBOL_VERSIONS
,
4524 OPTION_RECURSE_LIMIT
,
4525 OPTION_NO_RECURSE_LIMIT
,
4526 OPTION_NO_DEMANGLING
4529 static struct option options
[] =
4531 /* Note - This table is alpha-sorted on the 'val'
4532 field in order to make adding new options easier. */
4533 {"arch-specific", no_argument
, 0, 'A'},
4534 {"all", no_argument
, 0, 'a'},
4535 {"demangle", optional_argument
, 0, 'C'},
4536 {"archive-index", no_argument
, 0, 'c'},
4537 {"use-dynamic", no_argument
, 0, 'D'},
4538 {"dynamic", no_argument
, 0, 'd'},
4539 {"headers", no_argument
, 0, 'e'},
4540 {"section-groups", no_argument
, 0, 'g'},
4541 {"help", no_argument
, 0, 'H'},
4542 {"file-header", no_argument
, 0, 'h'},
4543 {"histogram", no_argument
, 0, 'I'},
4544 {"lint", no_argument
, 0, 'L'},
4545 {"enable-checks", no_argument
, 0, 'L'},
4546 {"program-headers", no_argument
, 0, 'l'},
4547 {"segments", no_argument
, 0, 'l'},
4548 {"full-section-name",no_argument
, 0, 'N'},
4549 {"notes", no_argument
, 0, 'n'},
4550 {"process-links", no_argument
, 0, 'P'},
4551 {"string-dump", required_argument
, 0, 'p'},
4552 {"relocated-dump", required_argument
, 0, 'R'},
4553 {"relocs", no_argument
, 0, 'r'},
4554 {"section-headers", no_argument
, 0, 'S'},
4555 {"sections", no_argument
, 0, 'S'},
4556 {"symbols", no_argument
, 0, 's'},
4557 {"syms", no_argument
, 0, 's'},
4558 {"silent-truncation",no_argument
, 0, 'T'},
4559 {"section-details", no_argument
, 0, 't'},
4560 {"unwind", no_argument
, 0, 'u'},
4561 {"version-info", no_argument
, 0, 'V'},
4562 {"version", no_argument
, 0, 'v'},
4563 {"wide", no_argument
, 0, 'W'},
4564 {"hex-dump", required_argument
, 0, 'x'},
4565 {"decompress", no_argument
, 0, 'z'},
4567 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4568 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4569 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4570 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4571 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4572 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4573 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4574 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4575 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4576 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4577 #ifdef ENABLE_LIBCTF
4578 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4579 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4580 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4581 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4584 {0, no_argument
, 0, 0}
4588 usage (FILE * stream
)
4590 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4591 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4592 fprintf (stream
, _(" Options are:\n\
4593 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4594 -h --file-header Display the ELF file header\n\
4595 -l --program-headers Display the program headers\n\
4596 --segments An alias for --program-headers\n\
4597 -S --section-headers Display the sections' header\n\
4598 --sections An alias for --section-headers\n\
4599 -g --section-groups Display the section groups\n\
4600 -t --section-details Display the section details\n\
4601 -e --headers Equivalent to: -h -l -S\n\
4602 -s --syms Display the symbol table\n\
4603 --symbols An alias for --syms\n\
4604 --dyn-syms Display the dynamic symbol table\n\
4605 --lto-syms Display LTO symbol tables\n\
4606 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4607 The STYLE, if specified, can be `auto' (the default),\n\
4608 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4610 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4611 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4612 --no-recurse-limit Disable a demangling recursion limit\n\
4613 -n --notes Display the core notes (if present)\n\
4614 -r --relocs Display the relocations (if present)\n\
4615 -u --unwind Display the unwind info (if present)\n\
4616 -d --dynamic Display the dynamic section (if present)\n\
4617 -V --version-info Display the version sections (if present)\n\
4618 -A --arch-specific Display architecture specific information (if any)\n\
4619 -c --archive-index Display the symbol/file index in an archive\n\
4620 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4621 -L --lint|--enable-checks Display warning messages for possible problems\n\
4622 -x --hex-dump=<number|name>\n\
4623 Dump the contents of section <number|name> as bytes\n\
4624 -p --string-dump=<number|name>\n\
4625 Dump the contents of section <number|name> as strings\n\
4626 -R --relocated-dump=<number|name>\n\
4627 Dump the contents of section <number|name> as relocated bytes\n\
4628 -z --decompress Decompress section before dumping it\n\
4629 -w[lLiaprmfFsoORtUuTgAc] or\n\
4630 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4631 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4632 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4634 Display the contents of DWARF debug sections\n\
4635 -wk,--debug-dump=links Display the contents of sections that link to separate debuginfo files\n\
4636 -P,--process-links Display the contents of non-debug sections in separate debuginfo files. (Implies -wK)\n"));
4637 #if DEFAULT_FOR_FOLLOW_LINKS
4638 fprintf (stream
, _("\
4639 -wK,--debug-dump=follow-links Follow links to separate debug info files (default)\n\
4640 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files\n\
4643 fprintf (stream
, _("\
4644 -wK,--debug-dump=follow-links Follow links to separate debug info files\n\
4645 -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files (default)\n\
4648 fprintf (stream
, _("\
4649 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4650 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4652 #ifdef ENABLE_LIBCTF
4653 fprintf (stream
, _("\
4654 --ctf=<number|name> Display CTF info from section <number|name>\n\
4655 --ctf-parent=<number|name>\n\
4656 Use section <number|name> as the CTF parent\n\n\
4657 --ctf-symbols=<number|name>\n\
4658 Use section <number|name> as the CTF external symtab\n\n\
4659 --ctf-strings=<number|name>\n\
4660 Use section <number|name> as the CTF external strtab\n\n"));
4663 #ifdef SUPPORT_DISASSEMBLY
4664 fprintf (stream
, _("\
4665 -i --instruction-dump=<number|name>\n\
4666 Disassemble the contents of section <number|name>\n"));
4668 fprintf (stream
, _("\
4669 -I --histogram Display histogram of bucket list lengths\n\
4670 -W --wide Allow output width to exceed 80 characters\n\
4671 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4672 @<file> Read options from <file>\n\
4673 -H --help Display this information\n\
4674 -v --version Display the version number of readelf\n"));
4676 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4677 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4679 exit (stream
== stdout
? 0 : 1);
4682 /* Record the fact that the user wants the contents of section number
4683 SECTION to be displayed using the method(s) encoded as flags bits
4684 in TYPE. Note, TYPE can be zero if we are creating the array for
4688 request_dump_bynumber (struct dump_data
*dumpdata
,
4689 unsigned int section
, dump_type type
)
4691 if (section
>= dumpdata
->num_dump_sects
)
4693 dump_type
* new_dump_sects
;
4695 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4696 sizeof (* new_dump_sects
));
4698 if (new_dump_sects
== NULL
)
4699 error (_("Out of memory allocating dump request table.\n"));
4702 if (dumpdata
->dump_sects
)
4704 /* Copy current flag settings. */
4705 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4706 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4708 free (dumpdata
->dump_sects
);
4711 dumpdata
->dump_sects
= new_dump_sects
;
4712 dumpdata
->num_dump_sects
= section
+ 1;
4716 if (dumpdata
->dump_sects
)
4717 dumpdata
->dump_sects
[section
] |= type
;
4720 /* Request a dump by section name. */
4723 request_dump_byname (const char * section
, dump_type type
)
4725 struct dump_list_entry
* new_request
;
4727 new_request
= (struct dump_list_entry
*)
4728 malloc (sizeof (struct dump_list_entry
));
4730 error (_("Out of memory allocating dump request table.\n"));
4732 new_request
->name
= strdup (section
);
4733 if (!new_request
->name
)
4734 error (_("Out of memory allocating dump request table.\n"));
4736 new_request
->type
= type
;
4738 new_request
->next
= dump_sects_byname
;
4739 dump_sects_byname
= new_request
;
4743 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4749 section
= strtoul (optarg
, & cp
, 0);
4751 if (! *cp
&& section
>= 0)
4752 request_dump_bynumber (dumpdata
, section
, type
);
4754 request_dump_byname (optarg
, type
);
4758 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4765 while ((c
= getopt_long
4766 (argc
, argv
, "ACDHILNPR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4784 do_section_groups
= true;
4787 do_histogram
= true;
4793 do_section_groups
= true;
4798 do_section_details
= true;
4809 do_using_dynamic
= true;
4833 do_histogram
= true;
4839 do_archive_index
= true;
4845 process_links
= true;
4846 do_follow_links
= true;
4849 request_dump (dumpdata
, HEX_DUMP
);
4852 request_dump (dumpdata
, STRING_DUMP
);
4855 request_dump (dumpdata
, RELOC_DUMP
);
4858 decompress_dumps
= true;
4864 do_debugging
= true;
4865 dwarf_select_sections_all ();
4869 do_debugging
= false;
4870 dwarf_select_sections_by_letters (optarg
);
4873 case OPTION_DEBUG_DUMP
:
4876 do_debugging
= true;
4879 do_debugging
= false;
4880 dwarf_select_sections_by_names (optarg
);
4883 case OPTION_DWARF_DEPTH
:
4887 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4890 case OPTION_DWARF_START
:
4894 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4897 case OPTION_DWARF_CHECK
:
4900 case OPTION_CTF_DUMP
:
4902 request_dump (dumpdata
, CTF_DUMP
);
4904 case OPTION_CTF_SYMBOLS
:
4905 free (dump_ctf_symtab_name
);
4906 dump_ctf_symtab_name
= strdup (optarg
);
4908 case OPTION_CTF_STRINGS
:
4909 free (dump_ctf_strtab_name
);
4910 dump_ctf_strtab_name
= strdup (optarg
);
4912 case OPTION_CTF_PARENT
:
4913 free (dump_ctf_parent_name
);
4914 dump_ctf_parent_name
= strdup (optarg
);
4916 case OPTION_DYN_SYMS
:
4919 case OPTION_LTO_SYMS
:
4922 #ifdef SUPPORT_DISASSEMBLY
4924 request_dump (dumpdata
, DISASS_DUMP
);
4928 print_version (program_name
);
4937 do_not_show_symbol_truncation
= true;
4943 enum demangling_styles style
;
4945 style
= cplus_demangle_name_to_style (optarg
);
4946 if (style
== unknown_demangling
)
4947 error (_("unknown demangling style `%s'"), optarg
);
4949 cplus_demangle_set_style (style
);
4952 case OPTION_NO_DEMANGLING
:
4953 do_demangle
= false;
4955 case OPTION_RECURSE_LIMIT
:
4956 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4958 case OPTION_NO_RECURSE_LIMIT
:
4959 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4961 case OPTION_WITH_SYMBOL_VERSIONS
:
4962 /* Ignored for backward compatibility. */
4966 /* xgettext:c-format */
4967 error (_("Invalid option '-%c'\n"), c
);
4974 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4975 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4976 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4977 && !do_section_groups
&& !do_archive_index
4978 && !do_dyn_syms
&& !do_lto_syms
)
4983 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= true;
4984 do_segments
= do_header
= do_dump
= do_version
= true;
4985 do_histogram
= do_debugging
= do_arch
= do_notes
= true;
4986 do_section_groups
= do_archive_index
= do_dyn_syms
= true;
4995 get_elf_class (unsigned int elf_class
)
4997 static char buff
[32];
5001 case ELFCLASSNONE
: return _("none");
5002 case ELFCLASS32
: return "ELF32";
5003 case ELFCLASS64
: return "ELF64";
5005 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
5011 get_data_encoding (unsigned int encoding
)
5013 static char buff
[32];
5017 case ELFDATANONE
: return _("none");
5018 case ELFDATA2LSB
: return _("2's complement, little endian");
5019 case ELFDATA2MSB
: return _("2's complement, big endian");
5021 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5026 /* Decode the data held in 'filedata->file_header'. */
5029 process_file_header (Filedata
* filedata
)
5031 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5033 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5034 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5035 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5036 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5039 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5043 if (! filedata
->is_separate
)
5044 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5050 if (filedata
->is_separate
)
5051 printf (_("ELF Header in linked file '%s':\n"), filedata
->file_name
);
5053 printf (_("ELF Header:\n"));
5054 printf (_(" Magic: "));
5055 for (i
= 0; i
< EI_NIDENT
; i
++)
5056 printf ("%2.2x ", header
->e_ident
[i
]);
5058 printf (_(" Class: %s\n"),
5059 get_elf_class (header
->e_ident
[EI_CLASS
]));
5060 printf (_(" Data: %s\n"),
5061 get_data_encoding (header
->e_ident
[EI_DATA
]));
5062 printf (_(" Version: %d%s\n"),
5063 header
->e_ident
[EI_VERSION
],
5064 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5066 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5069 printf (_(" OS/ABI: %s\n"),
5070 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5071 printf (_(" ABI Version: %d\n"),
5072 header
->e_ident
[EI_ABIVERSION
]);
5073 printf (_(" Type: %s\n"),
5074 get_file_type (header
->e_type
));
5075 printf (_(" Machine: %s\n"),
5076 get_machine_name (header
->e_machine
));
5077 printf (_(" Version: 0x%lx\n"),
5080 printf (_(" Entry point address: "));
5081 print_vma (header
->e_entry
, PREFIX_HEX
);
5082 printf (_("\n Start of program headers: "));
5083 print_vma (header
->e_phoff
, DEC
);
5084 printf (_(" (bytes into file)\n Start of section headers: "));
5085 print_vma (header
->e_shoff
, DEC
);
5086 printf (_(" (bytes into file)\n"));
5088 printf (_(" Flags: 0x%lx%s\n"),
5090 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5091 printf (_(" Size of this header: %u (bytes)\n"),
5093 printf (_(" Size of program headers: %u (bytes)\n"),
5094 header
->e_phentsize
);
5095 printf (_(" Number of program headers: %u"),
5097 if (filedata
->section_headers
!= NULL
5098 && header
->e_phnum
== PN_XNUM
5099 && filedata
->section_headers
[0].sh_info
!= 0)
5101 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5102 printf (" (%u)", header
->e_phnum
);
5104 putc ('\n', stdout
);
5105 printf (_(" Size of section headers: %u (bytes)\n"),
5106 header
->e_shentsize
);
5107 printf (_(" Number of section headers: %u"),
5109 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5111 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5112 printf (" (%u)", header
->e_shnum
);
5114 putc ('\n', stdout
);
5115 printf (_(" Section header string table index: %u"),
5116 header
->e_shstrndx
);
5117 if (filedata
->section_headers
!= NULL
5118 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5120 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5121 printf (" (%u)", header
->e_shstrndx
);
5123 if (header
->e_shstrndx
!= SHN_UNDEF
5124 && header
->e_shstrndx
>= header
->e_shnum
)
5126 header
->e_shstrndx
= SHN_UNDEF
;
5127 printf (_(" <corrupt: out of range>"));
5129 putc ('\n', stdout
);
5132 if (filedata
->section_headers
!= NULL
)
5134 if (header
->e_phnum
== PN_XNUM
5135 && filedata
->section_headers
[0].sh_info
!= 0)
5136 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5137 if (header
->e_shnum
== SHN_UNDEF
)
5138 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5139 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5140 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5141 if (header
->e_shstrndx
>= header
->e_shnum
)
5142 header
->e_shstrndx
= SHN_UNDEF
;
5143 free (filedata
->section_headers
);
5144 filedata
->section_headers
= NULL
;
5150 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5151 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5154 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5156 Elf32_External_Phdr
* phdrs
;
5157 Elf32_External_Phdr
* external
;
5158 Elf_Internal_Phdr
* internal
;
5160 unsigned int size
= filedata
->file_header
.e_phentsize
;
5161 unsigned int num
= filedata
->file_header
.e_phnum
;
5163 /* PR binutils/17531: Cope with unexpected section header sizes. */
5164 if (size
== 0 || num
== 0)
5166 if (size
< sizeof * phdrs
)
5168 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5171 if (size
> sizeof * phdrs
)
5172 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5174 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5175 size
, num
, _("program headers"));
5179 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5180 i
< filedata
->file_header
.e_phnum
;
5181 i
++, internal
++, external
++)
5183 internal
->p_type
= BYTE_GET (external
->p_type
);
5184 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5185 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5186 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5187 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5188 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5189 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5190 internal
->p_align
= BYTE_GET (external
->p_align
);
5197 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5198 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5201 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5203 Elf64_External_Phdr
* phdrs
;
5204 Elf64_External_Phdr
* external
;
5205 Elf_Internal_Phdr
* internal
;
5207 unsigned int size
= filedata
->file_header
.e_phentsize
;
5208 unsigned int num
= filedata
->file_header
.e_phnum
;
5210 /* PR binutils/17531: Cope with unexpected section header sizes. */
5211 if (size
== 0 || num
== 0)
5213 if (size
< sizeof * phdrs
)
5215 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5218 if (size
> sizeof * phdrs
)
5219 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5221 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5222 size
, num
, _("program headers"));
5226 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5227 i
< filedata
->file_header
.e_phnum
;
5228 i
++, internal
++, external
++)
5230 internal
->p_type
= BYTE_GET (external
->p_type
);
5231 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5232 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5233 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5234 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5235 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5236 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5237 internal
->p_align
= BYTE_GET (external
->p_align
);
5244 /* Returns TRUE if the program headers were read into `program_headers'. */
5247 get_program_headers (Filedata
* filedata
)
5249 Elf_Internal_Phdr
* phdrs
;
5251 /* Check cache of prior read. */
5252 if (filedata
->program_headers
!= NULL
)
5255 /* Be kind to memory checkers by looking for
5256 e_phnum values which we know must be invalid. */
5257 if (filedata
->file_header
.e_phnum
5258 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5259 >= filedata
->file_size
)
5261 error (_("Too many program headers - %#x - the file is not that big\n"),
5262 filedata
->file_header
.e_phnum
);
5266 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5267 sizeof (Elf_Internal_Phdr
));
5270 error (_("Out of memory reading %u program headers\n"),
5271 filedata
->file_header
.e_phnum
);
5276 ? get_32bit_program_headers (filedata
, phdrs
)
5277 : get_64bit_program_headers (filedata
, phdrs
))
5279 filedata
->program_headers
= phdrs
;
5287 /* Returns TRUE if the program headers were loaded. */
5290 process_program_headers (Filedata
* filedata
)
5292 Elf_Internal_Phdr
* segment
;
5294 Elf_Internal_Phdr
* previous_load
= NULL
;
5296 filedata
->dynamic_addr
= 0;
5297 filedata
->dynamic_size
= 0;
5299 if (filedata
->file_header
.e_phnum
== 0)
5301 /* PR binutils/12467. */
5302 if (filedata
->file_header
.e_phoff
!= 0)
5304 warn (_("possibly corrupt ELF header - it has a non-zero program"
5305 " header offset, but no program headers\n"));
5308 else if (do_segments
)
5310 if (filedata
->is_separate
)
5311 printf (_("\nThere are no program headers in linked file '%s'.\n"),
5312 filedata
->file_name
);
5314 printf (_("\nThere are no program headers in this file.\n"));
5319 if (do_segments
&& !do_header
)
5321 if (filedata
->is_separate
)
5322 printf ("\nIn linked file '%s' the ELF file type is %s\n",
5323 filedata
->file_name
,
5324 get_file_type (filedata
->file_header
.e_type
));
5326 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5327 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5328 printf (ngettext ("There is %d program header, starting at offset %s\n",
5329 "There are %d program headers, starting at offset %s\n",
5330 filedata
->file_header
.e_phnum
),
5331 filedata
->file_header
.e_phnum
,
5332 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5335 if (! get_program_headers (filedata
))
5340 if (filedata
->file_header
.e_phnum
> 1)
5341 printf (_("\nProgram Headers:\n"));
5343 printf (_("\nProgram Headers:\n"));
5347 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5350 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5354 (_(" Type Offset VirtAddr PhysAddr\n"));
5356 (_(" FileSiz MemSiz Flags Align\n"));
5360 for (i
= 0, segment
= filedata
->program_headers
;
5361 i
< filedata
->file_header
.e_phnum
;
5366 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5370 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5371 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5372 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5373 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5374 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5376 (segment
->p_flags
& PF_R
? 'R' : ' '),
5377 (segment
->p_flags
& PF_W
? 'W' : ' '),
5378 (segment
->p_flags
& PF_X
? 'E' : ' '));
5379 printf ("%#lx", (unsigned long) segment
->p_align
);
5383 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5384 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5387 print_vma (segment
->p_offset
, FULL_HEX
);
5391 print_vma (segment
->p_vaddr
, FULL_HEX
);
5393 print_vma (segment
->p_paddr
, FULL_HEX
);
5396 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5397 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5400 print_vma (segment
->p_filesz
, FULL_HEX
);
5404 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5405 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5408 print_vma (segment
->p_memsz
, FULL_HEX
);
5412 (segment
->p_flags
& PF_R
? 'R' : ' '),
5413 (segment
->p_flags
& PF_W
? 'W' : ' '),
5414 (segment
->p_flags
& PF_X
? 'E' : ' '));
5416 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5417 printf ("%#lx", (unsigned long) segment
->p_align
);
5420 print_vma (segment
->p_align
, PREFIX_HEX
);
5425 print_vma (segment
->p_offset
, FULL_HEX
);
5427 print_vma (segment
->p_vaddr
, FULL_HEX
);
5429 print_vma (segment
->p_paddr
, FULL_HEX
);
5431 print_vma (segment
->p_filesz
, FULL_HEX
);
5433 print_vma (segment
->p_memsz
, FULL_HEX
);
5435 (segment
->p_flags
& PF_R
? 'R' : ' '),
5436 (segment
->p_flags
& PF_W
? 'W' : ' '),
5437 (segment
->p_flags
& PF_X
? 'E' : ' '));
5438 print_vma (segment
->p_align
, PREFIX_HEX
);
5441 putc ('\n', stdout
);
5444 switch (segment
->p_type
)
5447 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5448 required by the ELF standard, several programs, including the Linux
5449 kernel, make use of non-ordered segments. */
5451 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5452 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5454 if (segment
->p_memsz
< segment
->p_filesz
)
5455 error (_("the segment's file size is larger than its memory size\n"));
5456 previous_load
= segment
;
5460 /* PR 20815 - Verify that the program header is loaded into memory. */
5461 if (i
> 0 && previous_load
!= NULL
)
5462 error (_("the PHDR segment must occur before any LOAD segment\n"));
5463 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5467 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5469 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5470 if (load
->p_type
== PT_LOAD
5471 && load
->p_offset
<= segment
->p_offset
5472 && (load
->p_offset
+ load
->p_filesz
5473 >= segment
->p_offset
+ segment
->p_filesz
)
5474 && load
->p_vaddr
<= segment
->p_vaddr
5475 && (load
->p_vaddr
+ load
->p_filesz
5476 >= segment
->p_vaddr
+ segment
->p_filesz
))
5479 if (j
== filedata
->file_header
.e_phnum
)
5480 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5485 if (filedata
->dynamic_addr
)
5486 error (_("more than one dynamic segment\n"));
5488 /* By default, assume that the .dynamic section is the first
5489 section in the DYNAMIC segment. */
5490 filedata
->dynamic_addr
= segment
->p_offset
;
5491 filedata
->dynamic_size
= segment
->p_filesz
;
5493 /* Try to locate the .dynamic section. If there is
5494 a section header table, we can easily locate it. */
5495 if (filedata
->section_headers
!= NULL
)
5497 Elf_Internal_Shdr
* sec
;
5499 sec
= find_section (filedata
, ".dynamic");
5500 if (sec
== NULL
|| sec
->sh_size
== 0)
5502 /* A corresponding .dynamic section is expected, but on
5503 IA-64/OpenVMS it is OK for it to be missing. */
5504 if (!is_ia64_vms (filedata
))
5505 error (_("no .dynamic section in the dynamic segment\n"));
5509 if (sec
->sh_type
== SHT_NOBITS
)
5511 filedata
->dynamic_size
= 0;
5515 filedata
->dynamic_addr
= sec
->sh_offset
;
5516 filedata
->dynamic_size
= sec
->sh_size
;
5518 /* The PT_DYNAMIC segment, which is used by the run-time
5519 loader, should exactly match the .dynamic section. */
5521 && (filedata
->dynamic_addr
!= segment
->p_offset
5522 || filedata
->dynamic_size
!= segment
->p_filesz
))
5524 the .dynamic section is not the same as the dynamic segment\n"));
5527 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5528 segment. Check this after matching against the section headers
5529 so we don't warn on debuginfo file (which have NOBITS .dynamic
5531 if (filedata
->dynamic_addr
> filedata
->file_size
5532 || (filedata
->dynamic_size
5533 > filedata
->file_size
- filedata
->dynamic_addr
))
5535 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5536 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5541 if (segment
->p_offset
>= filedata
->file_size
5542 || segment
->p_filesz
> filedata
->file_size
- segment
->p_offset
5543 || segment
->p_filesz
- 1 >= (size_t) -2
5544 || fseek (filedata
->handle
,
5545 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5547 error (_("Unable to find program interpreter name\n"));
5550 size_t len
= segment
->p_filesz
;
5551 free (filedata
->program_interpreter
);
5552 filedata
->program_interpreter
= xmalloc (len
+ 1);
5553 len
= fread (filedata
->program_interpreter
, 1, len
,
5555 filedata
->program_interpreter
[len
] = 0;
5558 printf (_(" [Requesting program interpreter: %s]\n"),
5559 filedata
->program_interpreter
);
5566 && filedata
->section_headers
!= NULL
5567 && filedata
->string_table
!= NULL
)
5569 printf (_("\n Section to Segment mapping:\n"));
5570 printf (_(" Segment Sections...\n"));
5572 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5575 Elf_Internal_Shdr
* section
;
5577 segment
= filedata
->program_headers
+ i
;
5578 section
= filedata
->section_headers
+ 1;
5580 printf (" %2.2d ", i
);
5582 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5584 if (!ELF_TBSS_SPECIAL (section
, segment
)
5585 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5586 printf ("%s ", printable_section_name (filedata
, section
));
5597 /* Find the file offset corresponding to VMA by using the program headers. */
5600 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5602 Elf_Internal_Phdr
* seg
;
5604 if (! get_program_headers (filedata
))
5606 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5610 for (seg
= filedata
->program_headers
;
5611 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5614 if (seg
->p_type
!= PT_LOAD
)
5617 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5618 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5619 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5622 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5623 (unsigned long) vma
);
5628 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5629 If PROBE is true, this is just a probe and we do not generate any error
5630 messages if the load fails. */
5633 get_32bit_section_headers (Filedata
* filedata
, bool probe
)
5635 Elf32_External_Shdr
* shdrs
;
5636 Elf_Internal_Shdr
* internal
;
5638 unsigned int size
= filedata
->file_header
.e_shentsize
;
5639 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5641 /* PR binutils/17531: Cope with unexpected section header sizes. */
5642 if (size
== 0 || num
== 0)
5644 if (size
< sizeof * shdrs
)
5647 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5650 if (!probe
&& size
> sizeof * shdrs
)
5651 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5653 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5655 probe
? NULL
: _("section headers"));
5659 free (filedata
->section_headers
);
5660 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5661 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5662 if (filedata
->section_headers
== NULL
)
5665 error (_("Out of memory reading %u section headers\n"), num
);
5670 for (i
= 0, internal
= filedata
->section_headers
;
5674 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5675 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5676 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5677 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5678 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5679 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5680 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5681 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5682 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5683 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5684 if (!probe
&& internal
->sh_link
> num
)
5685 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5686 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5687 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5694 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5697 get_64bit_section_headers (Filedata
* filedata
, bool probe
)
5699 Elf64_External_Shdr
* shdrs
;
5700 Elf_Internal_Shdr
* internal
;
5702 unsigned int size
= filedata
->file_header
.e_shentsize
;
5703 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5705 /* PR binutils/17531: Cope with unexpected section header sizes. */
5706 if (size
== 0 || num
== 0)
5709 if (size
< sizeof * shdrs
)
5712 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5716 if (! probe
&& size
> sizeof * shdrs
)
5717 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5719 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5720 filedata
->file_header
.e_shoff
,
5722 probe
? NULL
: _("section headers"));
5726 free (filedata
->section_headers
);
5727 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5728 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5729 if (filedata
->section_headers
== NULL
)
5732 error (_("Out of memory reading %u section headers\n"), num
);
5737 for (i
= 0, internal
= filedata
->section_headers
;
5741 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5742 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5743 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5744 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5745 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5746 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5747 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5748 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5749 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5750 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5751 if (!probe
&& internal
->sh_link
> num
)
5752 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5753 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5754 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5761 static Elf_Internal_Sym
*
5762 get_32bit_elf_symbols (Filedata
* filedata
,
5763 Elf_Internal_Shdr
* section
,
5764 unsigned long * num_syms_return
)
5766 unsigned long number
= 0;
5767 Elf32_External_Sym
* esyms
= NULL
;
5768 Elf_External_Sym_Shndx
* shndx
= NULL
;
5769 Elf_Internal_Sym
* isyms
= NULL
;
5770 Elf_Internal_Sym
* psym
;
5772 elf_section_list
* entry
;
5774 if (section
->sh_size
== 0)
5776 if (num_syms_return
!= NULL
)
5777 * num_syms_return
= 0;
5781 /* Run some sanity checks first. */
5782 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5784 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5785 printable_section_name (filedata
, section
),
5786 (unsigned long) section
->sh_entsize
);
5790 if (section
->sh_size
> filedata
->file_size
)
5792 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5793 printable_section_name (filedata
, section
),
5794 (unsigned long) section
->sh_size
);
5798 number
= section
->sh_size
/ section
->sh_entsize
;
5800 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5802 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5803 (unsigned long) section
->sh_size
,
5804 printable_section_name (filedata
, section
),
5805 (unsigned long) section
->sh_entsize
);
5809 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5810 section
->sh_size
, _("symbols"));
5815 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5817 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5822 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5826 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5827 entry
->hdr
->sh_offset
,
5828 1, entry
->hdr
->sh_size
,
5829 _("symbol table section indices"));
5833 /* PR17531: file: heap-buffer-overflow */
5834 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5836 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5837 printable_section_name (filedata
, entry
->hdr
),
5838 (unsigned long) entry
->hdr
->sh_size
,
5839 (unsigned long) section
->sh_size
);
5844 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5848 error (_("Out of memory reading %lu symbols\n"),
5849 (unsigned long) number
);
5853 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5855 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5856 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5857 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5858 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5859 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5861 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5862 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5863 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5864 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5865 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5872 if (num_syms_return
!= NULL
)
5873 * num_syms_return
= isyms
== NULL
? 0 : number
;
5878 static Elf_Internal_Sym
*
5879 get_64bit_elf_symbols (Filedata
* filedata
,
5880 Elf_Internal_Shdr
* section
,
5881 unsigned long * num_syms_return
)
5883 unsigned long number
= 0;
5884 Elf64_External_Sym
* esyms
= NULL
;
5885 Elf_External_Sym_Shndx
* shndx
= NULL
;
5886 Elf_Internal_Sym
* isyms
= NULL
;
5887 Elf_Internal_Sym
* psym
;
5889 elf_section_list
* entry
;
5891 if (section
->sh_size
== 0)
5893 if (num_syms_return
!= NULL
)
5894 * num_syms_return
= 0;
5898 /* Run some sanity checks first. */
5899 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5901 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5902 printable_section_name (filedata
, section
),
5903 (unsigned long) section
->sh_entsize
);
5907 if (section
->sh_size
> filedata
->file_size
)
5909 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5910 printable_section_name (filedata
, section
),
5911 (unsigned long) section
->sh_size
);
5915 number
= section
->sh_size
/ section
->sh_entsize
;
5917 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5919 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5920 (unsigned long) section
->sh_size
,
5921 printable_section_name (filedata
, section
),
5922 (unsigned long) section
->sh_entsize
);
5926 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5927 section
->sh_size
, _("symbols"));
5932 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5934 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5939 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5943 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5944 entry
->hdr
->sh_offset
,
5945 1, entry
->hdr
->sh_size
,
5946 _("symbol table section indices"));
5950 /* PR17531: file: heap-buffer-overflow */
5951 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5953 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5954 printable_section_name (filedata
, entry
->hdr
),
5955 (unsigned long) entry
->hdr
->sh_size
,
5956 (unsigned long) section
->sh_size
);
5961 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5965 error (_("Out of memory reading %lu symbols\n"),
5966 (unsigned long) number
);
5970 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5972 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5973 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5974 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5975 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5977 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5979 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5980 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5981 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5983 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5984 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5991 if (num_syms_return
!= NULL
)
5992 * num_syms_return
= isyms
== NULL
? 0 : number
;
5998 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
6000 static char buff
[1024];
6002 unsigned int field_size
= is_32bit_elf
? 8 : 16;
6004 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
6005 bfd_vma os_flags
= 0;
6006 bfd_vma proc_flags
= 0;
6007 bfd_vma unknown_flags
= 0;
6015 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
6016 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
6017 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
6018 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
6019 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
6020 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
6021 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
6022 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
6023 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
6024 /* 9 */ { STRING_COMMA_LEN ("TLS") },
6025 /* IA-64 specific. */
6026 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
6027 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
6028 /* IA-64 OpenVMS specific. */
6029 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
6030 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
6031 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
6032 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6033 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6034 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6036 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6037 /* SPARC specific. */
6038 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6039 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6041 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6042 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6043 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6045 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6047 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6049 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6052 if (do_section_details
)
6054 sprintf (buff
, "[%*.*lx]: ",
6055 field_size
, field_size
, (unsigned long) sh_flags
);
6056 p
+= field_size
+ 4;
6063 flag
= sh_flags
& - sh_flags
;
6066 if (do_section_details
)
6070 case SHF_WRITE
: sindex
= 0; break;
6071 case SHF_ALLOC
: sindex
= 1; break;
6072 case SHF_EXECINSTR
: sindex
= 2; break;
6073 case SHF_MERGE
: sindex
= 3; break;
6074 case SHF_STRINGS
: sindex
= 4; break;
6075 case SHF_INFO_LINK
: sindex
= 5; break;
6076 case SHF_LINK_ORDER
: sindex
= 6; break;
6077 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6078 case SHF_GROUP
: sindex
= 8; break;
6079 case SHF_TLS
: sindex
= 9; break;
6080 case SHF_EXCLUDE
: sindex
= 18; break;
6081 case SHF_COMPRESSED
: sindex
= 20; break;
6085 switch (filedata
->file_header
.e_machine
)
6088 if (flag
== SHF_IA_64_SHORT
)
6090 else if (flag
== SHF_IA_64_NORECOV
)
6093 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6096 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6097 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6098 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6099 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6100 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6101 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6112 case EM_OLD_SPARCV9
:
6113 case EM_SPARC32PLUS
:
6116 if (flag
== SHF_ORDERED
)
6123 case SHF_ENTRYSECT
: sindex
= 21; break;
6124 case SHF_ARM_PURECODE
: sindex
= 22; break;
6125 case SHF_COMDEF
: sindex
= 23; break;
6130 if (flag
== SHF_PPC_VLE
)
6137 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6140 case ELFOSABI_FREEBSD
:
6141 if (flag
== SHF_GNU_RETAIN
)
6145 if (flag
== SHF_GNU_MBIND
)
6146 /* We should not recognize SHF_GNU_MBIND for
6147 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6148 not set the EI_OSABI header byte. */
6159 if (p
!= buff
+ field_size
+ 4)
6161 if (size
< (10 + 2))
6163 warn (_("Internal error: not enough buffer room for section flag info"));
6164 return _("<unknown>");
6171 size
-= flags
[sindex
].len
;
6172 p
= stpcpy (p
, flags
[sindex
].str
);
6174 else if (flag
& SHF_MASKOS
)
6176 else if (flag
& SHF_MASKPROC
)
6179 unknown_flags
|= flag
;
6185 case SHF_WRITE
: *p
= 'W'; break;
6186 case SHF_ALLOC
: *p
= 'A'; break;
6187 case SHF_EXECINSTR
: *p
= 'X'; break;
6188 case SHF_MERGE
: *p
= 'M'; break;
6189 case SHF_STRINGS
: *p
= 'S'; break;
6190 case SHF_INFO_LINK
: *p
= 'I'; break;
6191 case SHF_LINK_ORDER
: *p
= 'L'; break;
6192 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6193 case SHF_GROUP
: *p
= 'G'; break;
6194 case SHF_TLS
: *p
= 'T'; break;
6195 case SHF_EXCLUDE
: *p
= 'E'; break;
6196 case SHF_COMPRESSED
: *p
= 'C'; break;
6199 if ((filedata
->file_header
.e_machine
== EM_X86_64
6200 || filedata
->file_header
.e_machine
== EM_L1OM
6201 || filedata
->file_header
.e_machine
== EM_K1OM
)
6202 && flag
== SHF_X86_64_LARGE
)
6204 else if (filedata
->file_header
.e_machine
== EM_ARM
6205 && flag
== SHF_ARM_PURECODE
)
6207 else if (filedata
->file_header
.e_machine
== EM_PPC
6208 && flag
== SHF_PPC_VLE
)
6210 else if (flag
& SHF_MASKOS
)
6212 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6215 case ELFOSABI_FREEBSD
:
6216 if (flag
== SHF_GNU_RETAIN
)
6223 if (flag
== SHF_GNU_MBIND
)
6225 /* We should not recognize SHF_GNU_MBIND for
6226 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6227 not set the EI_OSABI header byte. */
6234 sh_flags
&= ~SHF_MASKOS
;
6238 else if (flag
& SHF_MASKPROC
)
6241 sh_flags
&= ~ SHF_MASKPROC
;
6251 if (do_section_details
)
6255 size
-= 5 + field_size
;
6256 if (p
!= buff
+ field_size
+ 4)
6260 warn (_("Internal error: not enough buffer room for section flag info"));
6261 return _("<unknown>");
6267 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6268 (unsigned long) os_flags
);
6269 p
+= 5 + field_size
;
6273 size
-= 7 + field_size
;
6274 if (p
!= buff
+ field_size
+ 4)
6278 warn (_("Internal error: not enough buffer room for section flag info"));
6279 return _("<unknown>");
6285 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6286 (unsigned long) proc_flags
);
6287 p
+= 7 + field_size
;
6291 size
-= 10 + field_size
;
6292 if (p
!= buff
+ field_size
+ 4)
6296 warn (_("Internal error: not enough buffer room for section flag info"));
6297 return _("<unknown>");
6303 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6304 (unsigned long) unknown_flags
);
6305 p
+= 10 + field_size
;
6313 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6314 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6318 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6320 if (size
< sizeof (* echdr
))
6322 error (_("Compressed section is too small even for a compression header\n"));
6326 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6327 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6328 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6329 return sizeof (*echdr
);
6333 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6335 if (size
< sizeof (* echdr
))
6337 error (_("Compressed section is too small even for a compression header\n"));
6341 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6342 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6343 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6344 return sizeof (*echdr
);
6349 process_section_headers (Filedata
* filedata
)
6351 Elf_Internal_Shdr
* section
;
6354 free (filedata
->section_headers
);
6355 filedata
->section_headers
= NULL
;
6356 free (filedata
->dynamic_symbols
);
6357 filedata
->dynamic_symbols
= NULL
;
6358 filedata
->num_dynamic_syms
= 0;
6359 free (filedata
->dynamic_strings
);
6360 filedata
->dynamic_strings
= NULL
;
6361 filedata
->dynamic_strings_length
= 0;
6362 free (filedata
->dynamic_syminfo
);
6363 filedata
->dynamic_syminfo
= NULL
;
6364 while (filedata
->symtab_shndx_list
!= NULL
)
6366 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6367 free (filedata
->symtab_shndx_list
);
6368 filedata
->symtab_shndx_list
= next
;
6371 if (filedata
->file_header
.e_shnum
== 0)
6373 /* PR binutils/12467. */
6374 if (filedata
->file_header
.e_shoff
!= 0)
6376 warn (_("possibly corrupt ELF file header - it has a non-zero"
6377 " section header offset, but no section headers\n"));
6380 else if (do_sections
)
6381 printf (_("\nThere are no sections in this file.\n"));
6386 if (do_sections
&& !do_header
)
6388 if (filedata
->is_separate
&& process_links
)
6389 printf (_("In linked file '%s': "), filedata
->file_name
);
6390 if (! filedata
->is_separate
|| process_links
)
6391 printf (ngettext ("There is %d section header, "
6392 "starting at offset 0x%lx:\n",
6393 "There are %d section headers, "
6394 "starting at offset 0x%lx:\n",
6395 filedata
->file_header
.e_shnum
),
6396 filedata
->file_header
.e_shnum
,
6397 (unsigned long) filedata
->file_header
.e_shoff
);
6402 if (! get_32bit_section_headers (filedata
, false))
6407 if (! get_64bit_section_headers (filedata
, false))
6411 /* Read in the string table, so that we have names to display. */
6412 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6413 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6415 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6417 if (section
->sh_size
!= 0)
6419 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6420 1, section
->sh_size
,
6423 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6427 /* Scan the sections for the dynamic symbol table
6428 and dynamic string table and debug sections. */
6429 eh_addr_size
= is_32bit_elf
? 4 : 8;
6430 switch (filedata
->file_header
.e_machine
)
6433 case EM_MIPS_RS3_LE
:
6434 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6435 FDE addresses. However, the ABI also has a semi-official ILP32
6436 variant for which the normal FDE address size rules apply.
6438 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6439 section, where XX is the size of longs in bits. Unfortunately,
6440 earlier compilers provided no way of distinguishing ILP32 objects
6441 from LP64 objects, so if there's any doubt, we should assume that
6442 the official LP64 form is being used. */
6443 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6444 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6450 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6452 case E_H8_MACH_H8300
:
6453 case E_H8_MACH_H8300HN
:
6454 case E_H8_MACH_H8300SN
:
6455 case E_H8_MACH_H8300SXN
:
6458 case E_H8_MACH_H8300H
:
6459 case E_H8_MACH_H8300S
:
6460 case E_H8_MACH_H8300SX
:
6468 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6470 case EF_M32C_CPU_M16C
:
6477 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6480 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6481 if (section->sh_entsize != expected_entsize) \
6484 sprintf_vma (buf, section->sh_entsize); \
6485 /* Note: coded this way so that there is a single string for \
6487 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6488 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6489 (unsigned) expected_entsize); \
6490 section->sh_entsize = expected_entsize; \
6495 #define CHECK_ENTSIZE(section, i, type) \
6496 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6497 sizeof (Elf64_External_##type))
6499 for (i
= 0, section
= filedata
->section_headers
;
6500 i
< filedata
->file_header
.e_shnum
;
6503 char * name
= SECTION_NAME_PRINT (section
);
6505 /* Run some sanity checks on the headers and
6506 possibly fill in some file data as well. */
6507 switch (section
->sh_type
)
6510 if (filedata
->dynamic_symbols
!= NULL
)
6512 error (_("File contains multiple dynamic symbol tables\n"));
6516 CHECK_ENTSIZE (section
, i
, Sym
);
6517 filedata
->dynamic_symbols
6518 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6519 filedata
->dynamic_symtab_section
= section
;
6523 if (streq (name
, ".dynstr"))
6525 if (filedata
->dynamic_strings
!= NULL
)
6527 error (_("File contains multiple dynamic string tables\n"));
6531 filedata
->dynamic_strings
6532 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6533 1, section
->sh_size
, _("dynamic strings"));
6534 filedata
->dynamic_strings_length
6535 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6536 filedata
->dynamic_strtab_section
= section
;
6540 case SHT_SYMTAB_SHNDX
:
6542 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6544 entry
->hdr
= section
;
6545 entry
->next
= filedata
->symtab_shndx_list
;
6546 filedata
->symtab_shndx_list
= entry
;
6551 CHECK_ENTSIZE (section
, i
, Sym
);
6555 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6559 CHECK_ENTSIZE (section
, i
, Rel
);
6560 if (do_checks
&& section
->sh_size
== 0)
6561 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6565 CHECK_ENTSIZE (section
, i
, Rela
);
6566 if (do_checks
&& section
->sh_size
== 0)
6567 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6572 /* Having a zero sized section is not illegal according to the
6573 ELF standard, but it might be an indication that something
6574 is wrong. So issue a warning if we are running in lint mode. */
6575 if (do_checks
&& section
->sh_size
== 0)
6576 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6583 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6584 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6585 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6586 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
6588 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6589 && (startswith (name
, ".debug_")
6590 || startswith (name
, ".zdebug_")))
6593 name
+= sizeof (".zdebug_") - 1;
6595 name
+= sizeof (".debug_") - 1;
6598 || (do_debug_info
&& startswith (name
, "info"))
6599 || (do_debug_info
&& startswith (name
, "types"))
6600 || (do_debug_abbrevs
&& startswith (name
, "abbrev"))
6601 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6602 || (do_debug_lines
&& startswith (name
, "line."))
6603 || (do_debug_pubnames
&& startswith (name
, "pubnames"))
6604 || (do_debug_pubtypes
&& startswith (name
, "pubtypes"))
6605 || (do_debug_pubnames
&& startswith (name
, "gnu_pubnames"))
6606 || (do_debug_pubtypes
&& startswith (name
, "gnu_pubtypes"))
6607 || (do_debug_aranges
&& startswith (name
, "aranges"))
6608 || (do_debug_ranges
&& startswith (name
, "ranges"))
6609 || (do_debug_ranges
&& startswith (name
, "rnglists"))
6610 || (do_debug_frames
&& startswith (name
, "frame"))
6611 || (do_debug_macinfo
&& startswith (name
, "macinfo"))
6612 || (do_debug_macinfo
&& startswith (name
, "macro"))
6613 || (do_debug_str
&& startswith (name
, "str"))
6614 || (do_debug_links
&& startswith (name
, "sup"))
6615 || (do_debug_str_offsets
&& startswith (name
, "str_offsets"))
6616 || (do_debug_loc
&& startswith (name
, "loc"))
6617 || (do_debug_loc
&& startswith (name
, "loclists"))
6618 || (do_debug_addr
&& startswith (name
, "addr"))
6619 || (do_debug_cu_index
&& startswith (name
, "cu_index"))
6620 || (do_debug_cu_index
&& startswith (name
, "tu_index"))
6622 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6624 /* Linkonce section to be combined with .debug_info at link time. */
6625 else if ((do_debugging
|| do_debug_info
)
6626 && startswith (name
, ".gnu.linkonce.wi."))
6627 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6628 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6629 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6630 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6631 || streq (name
, ".debug_names")))
6632 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6633 /* Trace sections for Itanium VMS. */
6634 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6635 || do_trace_aranges
)
6636 && startswith (name
, ".trace_"))
6638 name
+= sizeof (".trace_") - 1;
6641 || (do_trace_info
&& streq (name
, "info"))
6642 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6643 || (do_trace_aranges
&& streq (name
, "aranges"))
6645 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6647 else if ((do_debugging
|| do_debug_links
)
6648 && (startswith (name
, ".gnu_debuglink")
6649 || startswith (name
, ".gnu_debugaltlink")))
6650 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6656 if (filedata
->is_separate
&& ! process_links
)
6659 if (filedata
->is_separate
)
6660 printf (_("\nSection Headers in linked file '%s':\n"), filedata
->file_name
);
6661 else if (filedata
->file_header
.e_shnum
> 1)
6662 printf (_("\nSection Headers:\n"));
6664 printf (_("\nSection Header:\n"));
6668 if (do_section_details
)
6670 printf (_(" [Nr] Name\n"));
6671 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6675 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6679 if (do_section_details
)
6681 printf (_(" [Nr] Name\n"));
6682 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6686 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6690 if (do_section_details
)
6692 printf (_(" [Nr] Name\n"));
6693 printf (_(" Type Address Offset Link\n"));
6694 printf (_(" Size EntSize Info Align\n"));
6698 printf (_(" [Nr] Name Type Address Offset\n"));
6699 printf (_(" Size EntSize Flags Link Info Align\n"));
6703 if (do_section_details
)
6704 printf (_(" Flags\n"));
6706 for (i
= 0, section
= filedata
->section_headers
;
6707 i
< filedata
->file_header
.e_shnum
;
6710 /* Run some sanity checks on the section header. */
6712 /* Check the sh_link field. */
6713 switch (section
->sh_type
)
6717 if (section
->sh_link
== 0
6718 && (filedata
->file_header
.e_type
== ET_EXEC
6719 || filedata
->file_header
.e_type
== ET_DYN
))
6720 /* A dynamic relocation section where all entries use a
6721 zero symbol index need not specify a symtab section. */
6724 case SHT_SYMTAB_SHNDX
:
6728 case SHT_GNU_versym
:
6729 if (section
->sh_link
== 0
6730 || section
->sh_link
>= filedata
->file_header
.e_shnum
6731 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6732 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6733 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6734 i
, section
->sh_link
);
6740 case SHT_GNU_verneed
:
6741 case SHT_GNU_verdef
:
6742 case SHT_GNU_LIBLIST
:
6743 if (section
->sh_link
== 0
6744 || section
->sh_link
>= filedata
->file_header
.e_shnum
6745 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6746 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6747 i
, section
->sh_link
);
6750 case SHT_INIT_ARRAY
:
6751 case SHT_FINI_ARRAY
:
6752 case SHT_PREINIT_ARRAY
:
6753 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6754 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6755 i
, section
->sh_link
);
6759 /* FIXME: Add support for target specific section types. */
6760 #if 0 /* Currently we do not check other section types as there are too
6761 many special cases. Stab sections for example have a type
6762 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6764 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6765 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6766 i
, section
->sh_link
);
6771 /* Check the sh_info field. */
6772 switch (section
->sh_type
)
6776 if (section
->sh_info
== 0
6777 && (filedata
->file_header
.e_type
== ET_EXEC
6778 || filedata
->file_header
.e_type
== ET_DYN
))
6779 /* Dynamic relocations apply to segments, so they do not
6780 need to specify the section they relocate. */
6782 if (section
->sh_info
== 0
6783 || section
->sh_info
>= filedata
->file_header
.e_shnum
6784 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6785 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6786 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6787 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6788 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6789 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6790 /* FIXME: Are other section types valid ? */
6791 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6792 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6793 i
, section
->sh_info
);
6798 case SHT_SYMTAB_SHNDX
:
6799 case SHT_INIT_ARRAY
:
6800 case SHT_FINI_ARRAY
:
6801 case SHT_PREINIT_ARRAY
:
6802 if (section
->sh_info
!= 0)
6803 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6804 i
, section
->sh_info
);
6810 /* A symbol index - we assume that it is valid. */
6814 /* FIXME: Add support for target specific section types. */
6815 if (section
->sh_type
== SHT_NOBITS
)
6816 /* NOBITS section headers with non-zero sh_info fields can be
6817 created when a binary is stripped of everything but its debug
6818 information. The stripped sections have their headers
6819 preserved but their types set to SHT_NOBITS. So do not check
6820 this type of section. */
6822 else if (section
->sh_flags
& SHF_INFO_LINK
)
6824 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6825 warn (_("[%2u]: Expected link to another section in info field"), i
);
6827 else if (section
->sh_type
< SHT_LOOS
6828 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6829 && section
->sh_info
!= 0)
6830 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6831 i
, section
->sh_info
);
6835 /* Check the sh_size field. */
6836 if (section
->sh_size
> filedata
->file_size
6837 && section
->sh_type
!= SHT_NOBITS
6838 && section
->sh_type
!= SHT_NULL
6839 && section
->sh_type
< SHT_LOOS
)
6840 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6842 printf (" [%2u] ", i
);
6843 if (do_section_details
)
6844 printf ("%s\n ", printable_section_name (filedata
, section
));
6846 print_symbol (-17, SECTION_NAME_PRINT (section
));
6848 printf (do_wide
? " %-15s " : " %-15.15s ",
6849 get_section_type_name (filedata
, section
->sh_type
));
6853 const char * link_too_big
= NULL
;
6855 print_vma (section
->sh_addr
, LONG_HEX
);
6857 printf ( " %6.6lx %6.6lx %2.2lx",
6858 (unsigned long) section
->sh_offset
,
6859 (unsigned long) section
->sh_size
,
6860 (unsigned long) section
->sh_entsize
);
6862 if (do_section_details
)
6863 fputs (" ", stdout
);
6865 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6867 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6870 /* The sh_link value is out of range. Normally this indicates
6871 an error but it can have special values in Solaris binaries. */
6872 switch (filedata
->file_header
.e_machine
)
6879 case EM_OLD_SPARCV9
:
6880 case EM_SPARC32PLUS
:
6883 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6884 link_too_big
= "BEFORE";
6885 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6886 link_too_big
= "AFTER";
6893 if (do_section_details
)
6895 if (link_too_big
!= NULL
&& * link_too_big
)
6896 printf ("<%s> ", link_too_big
);
6898 printf ("%2u ", section
->sh_link
);
6899 printf ("%3u %2lu\n", section
->sh_info
,
6900 (unsigned long) section
->sh_addralign
);
6903 printf ("%2u %3u %2lu\n",
6906 (unsigned long) section
->sh_addralign
);
6908 if (link_too_big
&& ! * link_too_big
)
6909 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6910 i
, section
->sh_link
);
6914 print_vma (section
->sh_addr
, LONG_HEX
);
6916 if ((long) section
->sh_offset
== section
->sh_offset
)
6917 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6921 print_vma (section
->sh_offset
, LONG_HEX
);
6924 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6925 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6929 print_vma (section
->sh_size
, LONG_HEX
);
6932 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6933 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6937 print_vma (section
->sh_entsize
, LONG_HEX
);
6940 if (do_section_details
)
6941 fputs (" ", stdout
);
6943 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6945 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6947 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6948 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6951 print_vma (section
->sh_addralign
, DEC
);
6955 else if (do_section_details
)
6958 print_vma (section
->sh_addr
, LONG_HEX
);
6959 if ((long) section
->sh_offset
== section
->sh_offset
)
6960 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6964 print_vma (section
->sh_offset
, LONG_HEX
);
6966 printf (" %u\n ", section
->sh_link
);
6967 print_vma (section
->sh_size
, LONG_HEX
);
6969 print_vma (section
->sh_entsize
, LONG_HEX
);
6971 printf (" %-16u %lu\n",
6973 (unsigned long) section
->sh_addralign
);
6978 print_vma (section
->sh_addr
, LONG_HEX
);
6979 if ((long) section
->sh_offset
== section
->sh_offset
)
6980 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6984 print_vma (section
->sh_offset
, LONG_HEX
);
6987 print_vma (section
->sh_size
, LONG_HEX
);
6989 print_vma (section
->sh_entsize
, LONG_HEX
);
6991 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6993 printf (" %2u %3u %lu\n",
6996 (unsigned long) section
->sh_addralign
);
6999 if (do_section_details
)
7001 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
7002 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
7004 /* Minimum section size is 12 bytes for 32-bit compression
7005 header + 12 bytes for compressed data header. */
7006 unsigned char buf
[24];
7008 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
7009 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
7010 sizeof (buf
), _("compression header")))
7012 Elf_Internal_Chdr chdr
;
7014 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
7015 printf (_(" [<corrupt>]\n"));
7018 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
7021 printf (_(" [<unknown>: 0x%x], "),
7023 print_vma (chdr
.ch_size
, LONG_HEX
);
7024 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
7031 if (!do_section_details
)
7033 /* The ordering of the letters shown here matches the ordering of the
7034 corresponding SHF_xxx values, and hence the order in which these
7035 letters will be displayed to the user. */
7036 printf (_("Key to Flags:\n\
7037 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
7038 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
7039 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
7040 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
7043 case ELFOSABI_FREEBSD
:
7044 printf (_("R (retain), "));
7047 printf (_("D (mbind), "));
7052 if (filedata
->file_header
.e_machine
== EM_X86_64
7053 || filedata
->file_header
.e_machine
== EM_L1OM
7054 || filedata
->file_header
.e_machine
== EM_K1OM
)
7055 printf (_("l (large), "));
7056 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7057 printf (_("y (purecode), "));
7058 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7059 printf (_("v (VLE), "));
7060 printf ("p (processor specific)\n");
7067 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7068 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7069 char **strtab
, unsigned long *strtablen
)
7073 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7075 if (*symtab
== NULL
)
7078 if (symsec
->sh_link
!= 0)
7080 Elf_Internal_Shdr
*strsec
;
7082 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7084 error (_("Bad sh_link in symbol table section\n"));
7091 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7093 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7094 1, strsec
->sh_size
, _("string table"));
7095 if (*strtab
== NULL
)
7102 *strtablen
= strsec
->sh_size
;
7108 get_group_flags (unsigned int flags
)
7110 static char buff
[128];
7114 else if (flags
== GRP_COMDAT
)
7117 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7119 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7120 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7121 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7122 ? _("<unknown>") : ""));
7128 process_section_groups (Filedata
* filedata
)
7130 Elf_Internal_Shdr
* section
;
7132 struct group
* group
;
7133 Elf_Internal_Shdr
* symtab_sec
;
7134 Elf_Internal_Shdr
* strtab_sec
;
7135 Elf_Internal_Sym
* symtab
;
7136 unsigned long num_syms
;
7140 /* Don't process section groups unless needed. */
7141 if (!do_unwind
&& !do_section_groups
)
7144 if (filedata
->file_header
.e_shnum
== 0)
7146 if (do_section_groups
)
7148 if (filedata
->is_separate
)
7149 printf (_("\nThere are no sections group in linked file '%s'.\n"),
7150 filedata
->file_name
);
7152 printf (_("\nThere are no section groups in this file.\n"));
7157 if (filedata
->section_headers
== NULL
)
7159 error (_("Section headers are not available!\n"));
7160 /* PR 13622: This can happen with a corrupt ELF header. */
7164 filedata
->section_headers_groups
7165 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7166 sizeof (struct group
*));
7168 if (filedata
->section_headers_groups
== NULL
)
7170 error (_("Out of memory reading %u section group headers\n"),
7171 filedata
->file_header
.e_shnum
);
7175 /* Scan the sections for the group section. */
7176 filedata
->group_count
= 0;
7177 for (i
= 0, section
= filedata
->section_headers
;
7178 i
< filedata
->file_header
.e_shnum
;
7180 if (section
->sh_type
== SHT_GROUP
)
7181 filedata
->group_count
++;
7183 if (filedata
->group_count
== 0)
7185 if (do_section_groups
)
7187 if (filedata
->is_separate
)
7188 printf (_("\nThere are no section groups in linked file '%s'.\n"),
7189 filedata
->file_name
);
7191 printf (_("\nThere are no section groups in this file.\n"));
7197 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7198 sizeof (struct group
));
7200 if (filedata
->section_groups
== NULL
)
7202 error (_("Out of memory reading %lu groups\n"),
7203 (unsigned long) filedata
->group_count
);
7214 if (filedata
->is_separate
)
7215 printf (_("Section groups in linked file '%s'\n"), filedata
->file_name
);
7217 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7218 i
< filedata
->file_header
.e_shnum
;
7221 if (section
->sh_type
== SHT_GROUP
)
7223 const char * name
= printable_section_name (filedata
, section
);
7224 const char * group_name
;
7225 unsigned char * start
;
7226 unsigned char * indices
;
7227 unsigned int entry
, j
, size
;
7228 Elf_Internal_Shdr
* sec
;
7229 Elf_Internal_Sym
* sym
;
7231 /* Get the symbol table. */
7232 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7233 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7236 error (_("Bad sh_link in group section `%s'\n"), name
);
7240 if (symtab_sec
!= sec
)
7244 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7249 error (_("Corrupt header in group section `%s'\n"), name
);
7253 if (section
->sh_info
>= num_syms
)
7255 error (_("Bad sh_info in group section `%s'\n"), name
);
7259 sym
= symtab
+ section
->sh_info
;
7261 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7263 if (sym
->st_shndx
== 0
7264 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7266 error (_("Bad sh_info in group section `%s'\n"), name
);
7270 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7279 /* Get the string table. */
7280 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7288 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7293 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7294 1, strtab_sec
->sh_size
,
7296 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7298 group_name
= sym
->st_name
< strtab_size
7299 ? strtab
+ sym
->st_name
: _("<corrupt>");
7302 /* PR 17531: file: loop. */
7303 if (section
->sh_entsize
> section
->sh_size
)
7305 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7306 printable_section_name (filedata
, section
),
7307 (unsigned long) section
->sh_entsize
,
7308 (unsigned long) section
->sh_size
);
7312 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7313 1, section
->sh_size
,
7319 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7320 entry
= byte_get (indices
, 4);
7323 if (do_section_groups
)
7325 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7326 get_group_flags (entry
), i
, name
, group_name
, size
);
7328 printf (_(" [Index] Name\n"));
7331 group
->group_index
= i
;
7333 for (j
= 0; j
< size
; j
++)
7335 struct group_list
* g
;
7337 entry
= byte_get (indices
, 4);
7340 if (entry
>= filedata
->file_header
.e_shnum
)
7342 static unsigned num_group_errors
= 0;
7344 if (num_group_errors
++ < 10)
7346 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7347 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7348 if (num_group_errors
== 10)
7349 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7354 if (filedata
->section_headers_groups
[entry
] != NULL
)
7358 static unsigned num_errs
= 0;
7360 if (num_errs
++ < 10)
7362 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7364 filedata
->section_headers_groups
[entry
]->group_index
);
7366 warn (_("Further error messages about already contained group sections suppressed\n"));
7372 /* Intel C/C++ compiler may put section 0 in a
7373 section group. We just warn it the first time
7374 and ignore it afterwards. */
7375 static bool warned
= false;
7378 error (_("section 0 in group section [%5u]\n"),
7379 filedata
->section_headers_groups
[entry
]->group_index
);
7385 filedata
->section_headers_groups
[entry
] = group
;
7387 if (do_section_groups
)
7389 sec
= filedata
->section_headers
+ entry
;
7390 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7393 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7394 g
->section_index
= entry
;
7395 g
->next
= group
->root
;
7410 /* Data used to display dynamic fixups. */
7412 struct ia64_vms_dynfixup
7414 bfd_vma needed_ident
; /* Library ident number. */
7415 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7416 bfd_vma fixup_needed
; /* Index of the library. */
7417 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7418 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7421 /* Data used to display dynamic relocations. */
7423 struct ia64_vms_dynimgrela
7425 bfd_vma img_rela_cnt
; /* Number of relocations. */
7426 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7429 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7433 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7434 struct ia64_vms_dynfixup
* fixup
,
7435 const char * strtab
,
7436 unsigned int strtab_sz
)
7438 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7440 const char * lib_name
;
7442 imfs
= get_data (NULL
, filedata
,
7443 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7444 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7445 _("dynamic section image fixups"));
7449 if (fixup
->needed
< strtab_sz
)
7450 lib_name
= strtab
+ fixup
->needed
;
7453 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7454 (unsigned long) fixup
->needed
);
7458 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7459 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7461 (_("Seg Offset Type SymVec DataType\n"));
7463 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7468 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7469 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7470 type
= BYTE_GET (imfs
[i
].type
);
7471 rtype
= elf_ia64_reloc_type (type
);
7473 printf (" 0x%08x ", type
);
7475 printf (" %-32s ", rtype
);
7476 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7477 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7484 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7487 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7489 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7492 imrs
= get_data (NULL
, filedata
,
7493 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7494 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7495 _("dynamic section image relocations"));
7499 printf (_("\nImage relocs\n"));
7501 (_("Seg Offset Type Addend Seg Sym Off\n"));
7503 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7508 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7509 printf ("%08" BFD_VMA_FMT
"x ",
7510 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7511 type
= BYTE_GET (imrs
[i
].type
);
7512 rtype
= elf_ia64_reloc_type (type
);
7514 printf ("0x%08x ", type
);
7516 printf ("%-31s ", rtype
);
7517 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7518 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7519 printf ("%08" BFD_VMA_FMT
"x\n",
7520 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7527 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7530 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7532 struct ia64_vms_dynfixup fixup
;
7533 struct ia64_vms_dynimgrela imgrela
;
7534 Elf_Internal_Dyn
*entry
;
7535 bfd_vma strtab_off
= 0;
7536 bfd_vma strtab_sz
= 0;
7537 char *strtab
= NULL
;
7540 memset (&fixup
, 0, sizeof (fixup
));
7541 memset (&imgrela
, 0, sizeof (imgrela
));
7543 /* Note: the order of the entries is specified by the OpenVMS specs. */
7544 for (entry
= filedata
->dynamic_section
;
7545 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7548 switch (entry
->d_tag
)
7550 case DT_IA_64_VMS_STRTAB_OFFSET
:
7551 strtab_off
= entry
->d_un
.d_val
;
7554 strtab_sz
= entry
->d_un
.d_val
;
7556 strtab
= get_data (NULL
, filedata
,
7557 filedata
->dynamic_addr
+ strtab_off
,
7558 1, strtab_sz
, _("dynamic string section"));
7563 case DT_IA_64_VMS_NEEDED_IDENT
:
7564 fixup
.needed_ident
= entry
->d_un
.d_val
;
7567 fixup
.needed
= entry
->d_un
.d_val
;
7569 case DT_IA_64_VMS_FIXUP_NEEDED
:
7570 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7572 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7573 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7575 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7576 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7577 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7580 case DT_IA_64_VMS_IMG_RELA_CNT
:
7581 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7583 case DT_IA_64_VMS_IMG_RELA_OFF
:
7584 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7585 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7606 dynamic_relocations
[] =
7608 { "REL", DT_REL
, DT_RELSZ
, false },
7609 { "RELA", DT_RELA
, DT_RELASZ
, true },
7610 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7613 /* Process the reloc section. */
7616 process_relocs (Filedata
* filedata
)
7618 unsigned long rel_size
;
7619 unsigned long rel_offset
;
7624 if (do_using_dynamic
)
7628 bool has_dynamic_reloc
;
7631 has_dynamic_reloc
= false;
7633 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7635 is_rela
= dynamic_relocations
[i
].rela
;
7636 name
= dynamic_relocations
[i
].name
;
7637 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7638 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7641 has_dynamic_reloc
= true;
7643 if (is_rela
== UNKNOWN
)
7645 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7646 switch (filedata
->dynamic_info
[DT_PLTREL
])
7659 if (filedata
->is_separate
)
7661 (_("\nIn linked file '%s' section '%s' at offset 0x%lx contains %ld bytes:\n"),
7662 filedata
->file_name
, name
, rel_offset
, rel_size
);
7665 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7666 name
, rel_offset
, rel_size
);
7669 dump_relocations (filedata
,
7670 offset_from_vma (filedata
, rel_offset
, rel_size
),
7672 filedata
->dynamic_symbols
,
7673 filedata
->num_dynamic_syms
,
7674 filedata
->dynamic_strings
,
7675 filedata
->dynamic_strings_length
,
7676 is_rela
, true /* is_dynamic */);
7680 if (is_ia64_vms (filedata
))
7681 if (process_ia64_vms_dynamic_relocs (filedata
))
7682 has_dynamic_reloc
= true;
7684 if (! has_dynamic_reloc
)
7686 if (filedata
->is_separate
)
7687 printf (_("\nThere are no dynamic relocations in linked file '%s'.\n"),
7688 filedata
->file_name
);
7690 printf (_("\nThere are no dynamic relocations in this file.\n"));
7695 Elf_Internal_Shdr
* section
;
7699 for (i
= 0, section
= filedata
->section_headers
;
7700 i
< filedata
->file_header
.e_shnum
;
7703 if ( section
->sh_type
!= SHT_RELA
7704 && section
->sh_type
!= SHT_REL
)
7707 rel_offset
= section
->sh_offset
;
7708 rel_size
= section
->sh_size
;
7713 unsigned long num_rela
;
7715 if (filedata
->is_separate
)
7716 printf (_("\nIn linked file '%s' relocation section "),
7717 filedata
->file_name
);
7719 printf (_("\nRelocation section "));
7721 if (filedata
->string_table
== NULL
)
7722 printf ("%d", section
->sh_name
);
7724 printf ("'%s'", printable_section_name (filedata
, section
));
7726 num_rela
= rel_size
/ section
->sh_entsize
;
7727 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7728 " at offset 0x%lx contains %lu entries:\n",
7730 rel_offset
, num_rela
);
7732 is_rela
= section
->sh_type
== SHT_RELA
;
7734 if (section
->sh_link
!= 0
7735 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7737 Elf_Internal_Shdr
* symsec
;
7738 Elf_Internal_Sym
* symtab
;
7739 unsigned long nsyms
;
7740 unsigned long strtablen
= 0;
7741 char * strtab
= NULL
;
7743 symsec
= filedata
->section_headers
+ section
->sh_link
;
7744 if (symsec
->sh_type
!= SHT_SYMTAB
7745 && symsec
->sh_type
!= SHT_DYNSYM
)
7748 if (!get_symtab (filedata
, symsec
,
7749 &symtab
, &nsyms
, &strtab
, &strtablen
))
7752 dump_relocations (filedata
, rel_offset
, rel_size
,
7753 symtab
, nsyms
, strtab
, strtablen
,
7755 symsec
->sh_type
== SHT_DYNSYM
);
7760 dump_relocations (filedata
, rel_offset
, rel_size
,
7761 NULL
, 0, NULL
, 0, is_rela
,
7762 false /* is_dynamic */);
7770 /* Users sometimes forget the -D option, so try to be helpful. */
7771 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7773 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7775 if (filedata
->is_separate
)
7776 printf (_("\nThere are no static relocations in linked file '%s'."),
7777 filedata
->file_name
);
7779 printf (_("\nThere are no static relocations in this file."));
7780 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7785 if (i
== ARRAY_SIZE (dynamic_relocations
))
7787 if (filedata
->is_separate
)
7788 printf (_("\nThere are no relocations in linked file '%s'.\n"),
7789 filedata
->file_name
);
7791 printf (_("\nThere are no relocations in this file.\n"));
7799 /* An absolute address consists of a section and an offset. If the
7800 section is NULL, the offset itself is the address, otherwise, the
7801 address equals to LOAD_ADDRESS(section) + offset. */
7805 unsigned short section
;
7809 /* Find the nearest symbol at or below ADDR. Returns the symbol
7810 name, if found, and the offset from the symbol to ADDR. */
7813 find_symbol_for_address (Filedata
* filedata
,
7814 Elf_Internal_Sym
* symtab
,
7815 unsigned long nsyms
,
7816 const char * strtab
,
7817 unsigned long strtab_size
,
7818 struct absaddr addr
,
7819 const char ** symname
,
7822 bfd_vma dist
= 0x100000;
7823 Elf_Internal_Sym
* sym
;
7824 Elf_Internal_Sym
* beg
;
7825 Elf_Internal_Sym
* end
;
7826 Elf_Internal_Sym
* best
= NULL
;
7828 REMOVE_ARCH_BITS (addr
.offset
);
7830 end
= symtab
+ nsyms
;
7836 sym
= beg
+ (end
- beg
) / 2;
7838 value
= sym
->st_value
;
7839 REMOVE_ARCH_BITS (value
);
7841 if (sym
->st_name
!= 0
7842 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7843 && addr
.offset
>= value
7844 && addr
.offset
- value
< dist
)
7847 dist
= addr
.offset
- value
;
7852 if (addr
.offset
< value
)
7860 *symname
= (best
->st_name
>= strtab_size
7861 ? _("<corrupt>") : strtab
+ best
->st_name
);
7867 *offset
= addr
.offset
;
7870 static /* signed */ int
7871 symcmp (const void *p
, const void *q
)
7873 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7874 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7876 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7879 /* Process the unwind section. */
7881 #include "unwind-ia64.h"
7883 struct ia64_unw_table_entry
7885 struct absaddr start
;
7887 struct absaddr info
;
7890 struct ia64_unw_aux_info
7892 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7893 unsigned long table_len
; /* Length of unwind table. */
7894 unsigned char * info
; /* Unwind info. */
7895 unsigned long info_size
; /* Size of unwind info. */
7896 bfd_vma info_addr
; /* Starting address of unwind info. */
7897 bfd_vma seg_base
; /* Starting address of segment. */
7898 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7899 unsigned long nsyms
; /* Number of symbols. */
7900 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7901 unsigned long nfuns
; /* Number of entries in funtab. */
7902 char * strtab
; /* The string table. */
7903 unsigned long strtab_size
; /* Size of string table. */
7907 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7909 struct ia64_unw_table_entry
* tp
;
7910 unsigned long j
, nfuns
;
7914 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7915 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7916 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7917 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7919 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7921 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7925 const unsigned char * dp
;
7926 const unsigned char * head
;
7927 const unsigned char * end
;
7928 const char * procname
;
7930 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7931 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7933 fputs ("\n<", stdout
);
7937 fputs (procname
, stdout
);
7940 printf ("+%lx", (unsigned long) offset
);
7943 fputs (">: [", stdout
);
7944 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7945 fputc ('-', stdout
);
7946 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7947 printf ("], info at +0x%lx\n",
7948 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7950 /* PR 17531: file: 86232b32. */
7951 if (aux
->info
== NULL
)
7954 offset
= tp
->info
.offset
;
7955 if (tp
->info
.section
)
7957 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7959 warn (_("Invalid section %u in table entry %ld\n"),
7960 tp
->info
.section
, (long) (tp
- aux
->table
));
7964 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7966 offset
-= aux
->info_addr
;
7967 /* PR 17531: file: 0997b4d1. */
7968 if (offset
>= aux
->info_size
7969 || aux
->info_size
- offset
< 8)
7971 warn (_("Invalid offset %lx in table entry %ld\n"),
7972 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7977 head
= aux
->info
+ offset
;
7978 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7980 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7981 (unsigned) UNW_VER (stamp
),
7982 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7983 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7984 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7985 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7987 if (UNW_VER (stamp
) != 1)
7989 printf (_("\tUnknown version.\n"));
7994 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7995 /* PR 17531: file: 16ceda89. */
7996 if (end
> aux
->info
+ aux
->info_size
)
7997 end
= aux
->info
+ aux
->info_size
;
7998 for (dp
= head
+ 8; dp
< end
;)
7999 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
8008 slurp_ia64_unwind_table (Filedata
* filedata
,
8009 struct ia64_unw_aux_info
* aux
,
8010 Elf_Internal_Shdr
* sec
)
8012 unsigned long size
, nrelas
, i
;
8013 Elf_Internal_Phdr
* seg
;
8014 struct ia64_unw_table_entry
* tep
;
8015 Elf_Internal_Shdr
* relsec
;
8016 Elf_Internal_Rela
* rela
;
8017 Elf_Internal_Rela
* rp
;
8018 unsigned char * table
;
8020 Elf_Internal_Sym
* sym
;
8021 const char * relname
;
8025 /* First, find the starting address of the segment that includes
8028 if (filedata
->file_header
.e_phnum
)
8030 if (! get_program_headers (filedata
))
8033 for (seg
= filedata
->program_headers
;
8034 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8037 if (seg
->p_type
!= PT_LOAD
)
8040 if (sec
->sh_addr
>= seg
->p_vaddr
8041 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8043 aux
->seg_base
= seg
->p_vaddr
;
8049 /* Second, build the unwind table from the contents of the unwind section: */
8050 size
= sec
->sh_size
;
8051 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8056 aux
->table_len
= size
/ (3 * eh_addr_size
);
8057 aux
->table
= (struct ia64_unw_table_entry
*)
8058 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
8061 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
8063 tep
->start
.section
= SHN_UNDEF
;
8064 tep
->end
.section
= SHN_UNDEF
;
8065 tep
->info
.section
= SHN_UNDEF
;
8066 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8067 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8068 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
8069 tep
->start
.offset
+= aux
->seg_base
;
8070 tep
->end
.offset
+= aux
->seg_base
;
8071 tep
->info
.offset
+= aux
->seg_base
;
8075 /* Third, apply any relocations to the unwind table: */
8076 for (relsec
= filedata
->section_headers
;
8077 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8080 if (relsec
->sh_type
!= SHT_RELA
8081 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8082 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8085 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8094 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8096 unsigned int sym_ndx
;
8097 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8098 relname
= elf_ia64_reloc_type (r_type
);
8100 /* PR 17531: file: 9fa67536. */
8101 if (relname
== NULL
)
8103 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8107 if (! startswith (relname
, "R_IA64_SEGREL"))
8109 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8113 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8115 /* PR 17531: file: 5bc8d9bf. */
8116 if (i
>= aux
->table_len
)
8118 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8122 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8123 if (sym_ndx
>= aux
->nsyms
)
8125 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8129 sym
= aux
->symtab
+ sym_ndx
;
8131 switch (rp
->r_offset
/ eh_addr_size
% 3)
8134 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8135 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8138 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8139 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8142 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8143 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8157 ia64_process_unwind (Filedata
* filedata
)
8159 Elf_Internal_Shdr
* sec
;
8160 Elf_Internal_Shdr
* unwsec
= NULL
;
8161 unsigned long i
, unwcount
= 0, unwstart
= 0;
8162 struct ia64_unw_aux_info aux
;
8165 memset (& aux
, 0, sizeof (aux
));
8167 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8169 if (sec
->sh_type
== SHT_SYMTAB
)
8173 error (_("Multiple symbol tables encountered\n"));
8179 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8180 &aux
.strtab
, &aux
.strtab_size
))
8183 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8188 printf (_("\nThere are no unwind sections in this file.\n"));
8190 while (unwcount
-- > 0)
8195 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8196 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8197 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8202 /* We have already counted the number of SHT_IA64_UNWIND
8203 sections so the loop above should never fail. */
8204 assert (unwsec
!= NULL
);
8207 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8209 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8211 /* We need to find which section group it is in. */
8212 struct group_list
* g
;
8214 if (filedata
->section_headers_groups
== NULL
8215 || filedata
->section_headers_groups
[i
] == NULL
)
8216 i
= filedata
->file_header
.e_shnum
;
8219 g
= filedata
->section_headers_groups
[i
]->root
;
8221 for (; g
!= NULL
; g
= g
->next
)
8223 sec
= filedata
->section_headers
+ g
->section_index
;
8225 if (SECTION_NAME_VALID (sec
)
8226 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8231 i
= filedata
->file_header
.e_shnum
;
8234 else if (SECTION_NAME_VALID (unwsec
)
8235 && startswith (SECTION_NAME (unwsec
),
8236 ELF_STRING_ia64_unwind_once
))
8238 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8239 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8240 suffix
= SECTION_NAME (unwsec
) + len
;
8241 for (i
= 0, sec
= filedata
->section_headers
;
8242 i
< filedata
->file_header
.e_shnum
;
8244 if (SECTION_NAME_VALID (sec
)
8245 && startswith (SECTION_NAME (sec
),
8246 ELF_STRING_ia64_unwind_info_once
)
8247 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8252 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8253 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8254 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8255 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8257 if (SECTION_NAME_VALID (unwsec
)
8258 && startswith (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
))
8259 suffix
= SECTION_NAME (unwsec
) + len
;
8260 for (i
= 0, sec
= filedata
->section_headers
;
8261 i
< filedata
->file_header
.e_shnum
;
8263 if (SECTION_NAME_VALID (sec
)
8264 && startswith (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
)
8265 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8269 if (i
== filedata
->file_header
.e_shnum
)
8271 printf (_("\nCould not find unwind info section for "));
8273 if (filedata
->string_table
== NULL
)
8274 printf ("%d", unwsec
->sh_name
);
8276 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8280 aux
.info_addr
= sec
->sh_addr
;
8281 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8284 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8286 printf (_("\nUnwind section "));
8288 if (filedata
->string_table
== NULL
)
8289 printf ("%d", unwsec
->sh_name
);
8291 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8293 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8294 (unsigned long) unwsec
->sh_offset
,
8295 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8297 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8298 && aux
.table_len
> 0)
8299 dump_ia64_unwind (filedata
, & aux
);
8301 free ((char *) aux
.table
);
8302 free ((char *) aux
.info
);
8309 free ((char *) aux
.strtab
);
8314 struct hppa_unw_table_entry
8316 struct absaddr start
;
8318 unsigned int Cannot_unwind
:1; /* 0 */
8319 unsigned int Millicode
:1; /* 1 */
8320 unsigned int Millicode_save_sr0
:1; /* 2 */
8321 unsigned int Region_description
:2; /* 3..4 */
8322 unsigned int reserved1
:1; /* 5 */
8323 unsigned int Entry_SR
:1; /* 6 */
8324 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8325 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8326 unsigned int Args_stored
:1; /* 16 */
8327 unsigned int Variable_Frame
:1; /* 17 */
8328 unsigned int Separate_Package_Body
:1; /* 18 */
8329 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8330 unsigned int Stack_Overflow_Check
:1; /* 20 */
8331 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8332 unsigned int Ada_Region
:1; /* 22 */
8333 unsigned int cxx_info
:1; /* 23 */
8334 unsigned int cxx_try_catch
:1; /* 24 */
8335 unsigned int sched_entry_seq
:1; /* 25 */
8336 unsigned int reserved2
:1; /* 26 */
8337 unsigned int Save_SP
:1; /* 27 */
8338 unsigned int Save_RP
:1; /* 28 */
8339 unsigned int Save_MRP_in_frame
:1; /* 29 */
8340 unsigned int extn_ptr_defined
:1; /* 30 */
8341 unsigned int Cleanup_defined
:1; /* 31 */
8343 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8344 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8345 unsigned int Large_frame
:1; /* 2 */
8346 unsigned int Pseudo_SP_Set
:1; /* 3 */
8347 unsigned int reserved4
:1; /* 4 */
8348 unsigned int Total_frame_size
:27; /* 5..31 */
8351 struct hppa_unw_aux_info
8353 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8354 unsigned long table_len
; /* Length of unwind table. */
8355 bfd_vma seg_base
; /* Starting address of segment. */
8356 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8357 unsigned long nsyms
; /* Number of symbols. */
8358 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8359 unsigned long nfuns
; /* Number of entries in funtab. */
8360 char * strtab
; /* The string table. */
8361 unsigned long strtab_size
; /* Size of string table. */
8365 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8367 struct hppa_unw_table_entry
* tp
;
8368 unsigned long j
, nfuns
;
8371 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8372 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8373 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8374 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8376 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8378 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8381 const char * procname
;
8383 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8384 aux
->strtab_size
, tp
->start
, &procname
,
8387 fputs ("\n<", stdout
);
8391 fputs (procname
, stdout
);
8394 printf ("+%lx", (unsigned long) offset
);
8397 fputs (">: [", stdout
);
8398 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8399 fputc ('-', stdout
);
8400 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8403 #define PF(_m) if (tp->_m) printf (#_m " ");
8404 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8407 PF(Millicode_save_sr0
);
8408 /* PV(Region_description); */
8414 PF(Separate_Package_Body
);
8415 PF(Frame_Extension_Millicode
);
8416 PF(Stack_Overflow_Check
);
8417 PF(Two_Instruction_SP_Increment
);
8421 PF(sched_entry_seq
);
8424 PF(Save_MRP_in_frame
);
8425 PF(extn_ptr_defined
);
8426 PF(Cleanup_defined
);
8427 PF(MPE_XL_interrupt_marker
);
8428 PF(HP_UX_interrupt_marker
);
8431 PV(Total_frame_size
);
8444 slurp_hppa_unwind_table (Filedata
* filedata
,
8445 struct hppa_unw_aux_info
* aux
,
8446 Elf_Internal_Shdr
* sec
)
8448 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8449 Elf_Internal_Phdr
* seg
;
8450 struct hppa_unw_table_entry
* tep
;
8451 Elf_Internal_Shdr
* relsec
;
8452 Elf_Internal_Rela
* rela
;
8453 Elf_Internal_Rela
* rp
;
8454 unsigned char * table
;
8456 Elf_Internal_Sym
* sym
;
8457 const char * relname
;
8459 /* First, find the starting address of the segment that includes
8461 if (filedata
->file_header
.e_phnum
)
8463 if (! get_program_headers (filedata
))
8466 for (seg
= filedata
->program_headers
;
8467 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8470 if (seg
->p_type
!= PT_LOAD
)
8473 if (sec
->sh_addr
>= seg
->p_vaddr
8474 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8476 aux
->seg_base
= seg
->p_vaddr
;
8482 /* Second, build the unwind table from the contents of the unwind
8484 size
= sec
->sh_size
;
8485 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8491 nentries
= size
/ unw_ent_size
;
8492 size
= unw_ent_size
* nentries
;
8494 aux
->table_len
= nentries
;
8495 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8496 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8498 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8500 unsigned int tmp1
, tmp2
;
8502 tep
->start
.section
= SHN_UNDEF
;
8503 tep
->end
.section
= SHN_UNDEF
;
8505 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8506 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8507 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8508 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8510 tep
->start
.offset
+= aux
->seg_base
;
8511 tep
->end
.offset
+= aux
->seg_base
;
8513 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8514 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8515 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8516 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8517 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8518 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8519 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8520 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8521 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8522 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8523 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8524 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8525 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8526 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8527 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8528 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8529 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8530 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8531 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8532 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8533 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8534 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8535 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8536 tep
->Cleanup_defined
= tmp1
& 0x1;
8538 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8539 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8540 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8541 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8542 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8543 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8547 /* Third, apply any relocations to the unwind table. */
8548 for (relsec
= filedata
->section_headers
;
8549 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8552 if (relsec
->sh_type
!= SHT_RELA
8553 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8554 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8557 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8561 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8563 unsigned int sym_ndx
;
8564 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8565 relname
= elf_hppa_reloc_type (r_type
);
8567 if (relname
== NULL
)
8569 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8573 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8574 if (! startswith (relname
, "R_PARISC_SEGREL"))
8576 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8580 i
= rp
->r_offset
/ unw_ent_size
;
8581 if (i
>= aux
->table_len
)
8583 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8587 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8588 if (sym_ndx
>= aux
->nsyms
)
8590 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8594 sym
= aux
->symtab
+ sym_ndx
;
8596 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8599 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8600 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8603 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8604 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8618 hppa_process_unwind (Filedata
* filedata
)
8620 struct hppa_unw_aux_info aux
;
8621 Elf_Internal_Shdr
* unwsec
= NULL
;
8622 Elf_Internal_Shdr
* sec
;
8626 if (filedata
->string_table
== NULL
)
8629 memset (& aux
, 0, sizeof (aux
));
8631 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8633 if (sec
->sh_type
== SHT_SYMTAB
)
8637 error (_("Multiple symbol tables encountered\n"));
8643 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8644 &aux
.strtab
, &aux
.strtab_size
))
8647 else if (SECTION_NAME_VALID (sec
)
8648 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8653 printf (_("\nThere are no unwind sections in this file.\n"));
8655 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8657 if (SECTION_NAME_VALID (sec
)
8658 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8660 unsigned long num_unwind
= sec
->sh_size
/ 16;
8662 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8663 "contains %lu entry:\n",
8664 "\nUnwind section '%s' at offset 0x%lx "
8665 "contains %lu entries:\n",
8667 printable_section_name (filedata
, sec
),
8668 (unsigned long) sec
->sh_offset
,
8671 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8674 if (res
&& aux
.table_len
> 0)
8676 if (! dump_hppa_unwind (filedata
, &aux
))
8680 free ((char *) aux
.table
);
8686 free ((char *) aux
.strtab
);
8693 unsigned char * data
; /* The unwind data. */
8694 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8695 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8696 unsigned long nrelas
; /* The number of relocations. */
8697 unsigned int rel_type
; /* REL or RELA ? */
8698 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8701 struct arm_unw_aux_info
8703 Filedata
* filedata
; /* The file containing the unwind sections. */
8704 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8705 unsigned long nsyms
; /* Number of symbols. */
8706 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8707 unsigned long nfuns
; /* Number of these symbols. */
8708 char * strtab
; /* The file's string table. */
8709 unsigned long strtab_size
; /* Size of string table. */
8713 arm_print_vma_and_name (Filedata
* filedata
,
8714 struct arm_unw_aux_info
* aux
,
8716 struct absaddr addr
)
8718 const char *procname
;
8721 if (addr
.section
== SHN_UNDEF
)
8724 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8725 aux
->strtab_size
, addr
, &procname
,
8728 print_vma (fn
, PREFIX_HEX
);
8732 fputs (" <", stdout
);
8733 fputs (procname
, stdout
);
8736 printf ("+0x%lx", (unsigned long) sym_offset
);
8737 fputc ('>', stdout
);
8744 arm_free_section (struct arm_section
*arm_sec
)
8746 free (arm_sec
->data
);
8747 free (arm_sec
->rela
);
8750 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8751 cached section and install SEC instead.
8752 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8753 and return its valued in * WORDP, relocating if necessary.
8754 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8755 relocation's offset in ADDR.
8756 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8757 into the string table of the symbol associated with the reloc. If no
8758 reloc was applied store -1 there.
8759 5) Return TRUE upon success, FALSE otherwise. */
8762 get_unwind_section_word (Filedata
* filedata
,
8763 struct arm_unw_aux_info
* aux
,
8764 struct arm_section
* arm_sec
,
8765 Elf_Internal_Shdr
* sec
,
8766 bfd_vma word_offset
,
8767 unsigned int * wordp
,
8768 struct absaddr
* addr
,
8771 Elf_Internal_Rela
*rp
;
8772 Elf_Internal_Sym
*sym
;
8773 const char * relname
;
8777 if (sec
== NULL
|| arm_sec
== NULL
)
8780 addr
->section
= SHN_UNDEF
;
8783 if (sym_name
!= NULL
)
8784 *sym_name
= (bfd_vma
) -1;
8786 /* If necessary, update the section cache. */
8787 if (sec
!= arm_sec
->sec
)
8789 Elf_Internal_Shdr
*relsec
;
8791 arm_free_section (arm_sec
);
8794 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8795 sec
->sh_size
, _("unwind data"));
8796 arm_sec
->rela
= NULL
;
8797 arm_sec
->nrelas
= 0;
8799 for (relsec
= filedata
->section_headers
;
8800 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8803 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8804 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8805 /* PR 15745: Check the section type as well. */
8806 || (relsec
->sh_type
!= SHT_REL
8807 && relsec
->sh_type
!= SHT_RELA
))
8810 arm_sec
->rel_type
= relsec
->sh_type
;
8811 if (relsec
->sh_type
== SHT_REL
)
8813 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8815 & arm_sec
->rela
, & arm_sec
->nrelas
))
8818 else /* relsec->sh_type == SHT_RELA */
8820 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8822 & arm_sec
->rela
, & arm_sec
->nrelas
))
8828 arm_sec
->next_rela
= arm_sec
->rela
;
8831 /* If there is no unwind data we can do nothing. */
8832 if (arm_sec
->data
== NULL
)
8835 /* If the offset is invalid then fail. */
8836 if (/* PR 21343 *//* PR 18879 */
8838 || word_offset
> (sec
->sh_size
- 4)
8839 || ((bfd_signed_vma
) word_offset
) < 0)
8842 /* Get the word at the required offset. */
8843 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8845 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8846 if (arm_sec
->rela
== NULL
)
8852 /* Look through the relocs to find the one that applies to the provided offset. */
8854 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8856 bfd_vma prelval
, offset
;
8858 if (rp
->r_offset
> word_offset
&& !wrapped
)
8863 if (rp
->r_offset
> word_offset
)
8866 if (rp
->r_offset
& 3)
8868 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8869 (unsigned long) rp
->r_offset
);
8873 if (rp
->r_offset
< word_offset
)
8876 /* PR 17531: file: 027-161405-0.004 */
8877 if (aux
->symtab
== NULL
)
8880 if (arm_sec
->rel_type
== SHT_REL
)
8882 offset
= word
& 0x7fffffff;
8883 if (offset
& 0x40000000)
8884 offset
|= ~ (bfd_vma
) 0x7fffffff;
8886 else if (arm_sec
->rel_type
== SHT_RELA
)
8887 offset
= rp
->r_addend
;
8890 error (_("Unknown section relocation type %d encountered\n"),
8895 /* PR 17531 file: 027-1241568-0.004. */
8896 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8898 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8899 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8903 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8904 offset
+= sym
->st_value
;
8905 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8907 /* Check that we are processing the expected reloc type. */
8908 if (filedata
->file_header
.e_machine
== EM_ARM
)
8910 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8911 if (relname
== NULL
)
8913 warn (_("Skipping unknown ARM relocation type: %d\n"),
8914 (int) ELF32_R_TYPE (rp
->r_info
));
8918 if (streq (relname
, "R_ARM_NONE"))
8921 if (! streq (relname
, "R_ARM_PREL31"))
8923 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8927 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8929 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8930 if (relname
== NULL
)
8932 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8933 (int) ELF32_R_TYPE (rp
->r_info
));
8937 if (streq (relname
, "R_C6000_NONE"))
8940 if (! streq (relname
, "R_C6000_PREL31"))
8942 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8950 /* This function currently only supports ARM and TI unwinders. */
8951 warn (_("Only TI and ARM unwinders are currently supported\n"));
8955 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8956 addr
->section
= sym
->st_shndx
;
8957 addr
->offset
= offset
;
8960 * sym_name
= sym
->st_name
;
8965 arm_sec
->next_rela
= rp
;
8970 static const char *tic6x_unwind_regnames
[16] =
8972 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8973 "A14", "A13", "A12", "A11", "A10",
8974 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8978 decode_tic6x_unwind_regmask (unsigned int mask
)
8982 for (i
= 12; mask
; mask
>>= 1, i
--)
8986 fputs (tic6x_unwind_regnames
[i
], stdout
);
8988 fputs (", ", stdout
);
8994 if (remaining == 0 && more_words) \
8997 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8998 data_offset, & word, & addr, NULL)) \
9004 #define GET_OP(OP) \
9009 (OP) = word >> 24; \
9014 printf (_("[Truncated opcode]\n")); \
9017 printf ("0x%02x ", OP)
9020 decode_arm_unwind_bytecode (Filedata
* filedata
,
9021 struct arm_unw_aux_info
* aux
,
9023 unsigned int remaining
,
9024 unsigned int more_words
,
9025 bfd_vma data_offset
,
9026 Elf_Internal_Shdr
* data_sec
,
9027 struct arm_section
* data_arm_sec
)
9029 struct absaddr addr
;
9032 /* Decode the unwinding instructions. */
9035 unsigned int op
, op2
;
9044 printf (" 0x%02x ", op
);
9046 if ((op
& 0xc0) == 0x00)
9048 int offset
= ((op
& 0x3f) << 2) + 4;
9050 printf (" vsp = vsp + %d", offset
);
9052 else if ((op
& 0xc0) == 0x40)
9054 int offset
= ((op
& 0x3f) << 2) + 4;
9056 printf (" vsp = vsp - %d", offset
);
9058 else if ((op
& 0xf0) == 0x80)
9061 if (op
== 0x80 && op2
== 0)
9062 printf (_("Refuse to unwind"));
9065 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
9070 for (i
= 0; i
< 12; i
++)
9071 if (mask
& (1 << i
))
9077 printf ("r%d", 4 + i
);
9082 else if ((op
& 0xf0) == 0x90)
9084 if (op
== 0x9d || op
== 0x9f)
9085 printf (_(" [Reserved]"));
9087 printf (" vsp = r%d", op
& 0x0f);
9089 else if ((op
& 0xf0) == 0xa0)
9091 int end
= 4 + (op
& 0x07);
9096 for (i
= 4; i
<= end
; i
++)
9112 else if (op
== 0xb0)
9113 printf (_(" finish"));
9114 else if (op
== 0xb1)
9117 if (op2
== 0 || (op2
& 0xf0) != 0)
9118 printf (_("[Spare]"));
9121 unsigned int mask
= op2
& 0x0f;
9126 for (i
= 0; i
< 12; i
++)
9127 if (mask
& (1 << i
))
9138 else if (op
== 0xb2)
9140 unsigned char buf
[9];
9141 unsigned int i
, len
;
9142 unsigned long offset
;
9144 for (i
= 0; i
< sizeof (buf
); i
++)
9147 if ((buf
[i
] & 0x80) == 0)
9150 if (i
== sizeof (buf
))
9152 error (_("corrupt change to vsp\n"));
9157 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9158 assert (len
== i
+ 1);
9159 offset
= offset
* 4 + 0x204;
9160 printf ("vsp = vsp + %ld", offset
);
9163 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9165 unsigned int first
, last
;
9172 printf ("pop {D%d", first
);
9174 printf ("-D%d", first
+ last
);
9177 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9179 unsigned int count
= op
& 0x07;
9183 printf ("-D%d", 8 + count
);
9186 else if (op
>= 0xc0 && op
<= 0xc5)
9188 unsigned int count
= op
& 0x07;
9190 printf (" pop {wR10");
9192 printf ("-wR%d", 10 + count
);
9195 else if (op
== 0xc6)
9197 unsigned int first
, last
;
9202 printf ("pop {wR%d", first
);
9204 printf ("-wR%d", first
+ last
);
9207 else if (op
== 0xc7)
9210 if (op2
== 0 || (op2
& 0xf0) != 0)
9211 printf (_("[Spare]"));
9214 unsigned int mask
= op2
& 0x0f;
9219 for (i
= 0; i
< 4; i
++)
9220 if (mask
& (1 << i
))
9226 printf ("wCGR%d", i
);
9233 printf (_(" [unsupported opcode]"));
9244 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9245 struct arm_unw_aux_info
* aux
,
9247 unsigned int remaining
,
9248 unsigned int more_words
,
9249 bfd_vma data_offset
,
9250 Elf_Internal_Shdr
* data_sec
,
9251 struct arm_section
* data_arm_sec
)
9253 struct absaddr addr
;
9255 /* Decode the unwinding instructions. */
9258 unsigned int op
, op2
;
9267 printf (" 0x%02x ", op
);
9269 if ((op
& 0xc0) == 0x00)
9271 int offset
= ((op
& 0x3f) << 3) + 8;
9272 printf (" sp = sp + %d", offset
);
9274 else if ((op
& 0xc0) == 0x80)
9277 if (op
== 0x80 && op2
== 0)
9278 printf (_("Refuse to unwind"));
9281 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9283 printf ("pop compact {");
9287 decode_tic6x_unwind_regmask (mask
);
9291 else if ((op
& 0xf0) == 0xc0)
9299 unsigned int offset
;
9303 /* Scan entire instruction first so that GET_OP output is not
9304 interleaved with disassembly. */
9306 for (i
= 0; nregs
< (op
& 0xf); i
++)
9312 regpos
[nregs
].offset
= i
* 2;
9313 regpos
[nregs
].reg
= reg
;
9320 regpos
[nregs
].offset
= i
* 2 + 1;
9321 regpos
[nregs
].reg
= reg
;
9326 printf (_("pop frame {"));
9329 printf (_("*corrupt* - no registers specified"));
9334 for (i
= i
* 2; i
> 0; i
--)
9336 if (regpos
[reg
].offset
== i
- 1)
9338 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9345 fputs (name
, stdout
);
9353 else if (op
== 0xd0)
9354 printf (" MOV FP, SP");
9355 else if (op
== 0xd1)
9356 printf (" __c6xabi_pop_rts");
9357 else if (op
== 0xd2)
9359 unsigned char buf
[9];
9360 unsigned int i
, len
;
9361 unsigned long offset
;
9363 for (i
= 0; i
< sizeof (buf
); i
++)
9366 if ((buf
[i
] & 0x80) == 0)
9369 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9370 if (i
== sizeof (buf
))
9372 warn (_("Corrupt stack pointer adjustment detected\n"));
9376 offset
= read_leb128 (buf
, buf
+ i
+ 1, false, &len
, NULL
);
9377 assert (len
== i
+ 1);
9378 offset
= offset
* 8 + 0x408;
9379 printf (_("sp = sp + %ld"), offset
);
9381 else if ((op
& 0xf0) == 0xe0)
9383 if ((op
& 0x0f) == 7)
9386 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9390 printf (_(" [unsupported opcode]"));
9399 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9403 offset
= word
& 0x7fffffff;
9404 if (offset
& 0x40000000)
9405 offset
|= ~ (bfd_vma
) 0x7fffffff;
9407 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9410 return offset
+ where
;
9414 decode_arm_unwind (Filedata
* filedata
,
9415 struct arm_unw_aux_info
* aux
,
9417 unsigned int remaining
,
9418 bfd_vma data_offset
,
9419 Elf_Internal_Shdr
* data_sec
,
9420 struct arm_section
* data_arm_sec
)
9423 unsigned int more_words
= 0;
9424 struct absaddr addr
;
9425 bfd_vma sym_name
= (bfd_vma
) -1;
9430 /* Fetch the first word.
9431 Note - when decoding an object file the address extracted
9432 here will always be 0. So we also pass in the sym_name
9433 parameter so that we can find the symbol associated with
9434 the personality routine. */
9435 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9436 & word
, & addr
, & sym_name
))
9443 addr
.section
= SHN_UNDEF
;
9447 if ((word
& 0x80000000) == 0)
9449 /* Expand prel31 for personality routine. */
9451 const char *procname
;
9453 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9454 printf (_(" Personality routine: "));
9456 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9457 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9459 procname
= aux
->strtab
+ sym_name
;
9460 print_vma (fn
, PREFIX_HEX
);
9463 fputs (" <", stdout
);
9464 fputs (procname
, stdout
);
9465 fputc ('>', stdout
);
9469 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9470 fputc ('\n', stdout
);
9472 /* The GCC personality routines use the standard compact
9473 encoding, starting with one byte giving the number of
9475 if (procname
!= NULL
9476 && (startswith (procname
, "__gcc_personality_v0")
9477 || startswith (procname
, "__gxx_personality_v0")
9478 || startswith (procname
, "__gcj_personality_v0")
9479 || startswith (procname
, "__gnu_objc_personality_v0")))
9486 printf (_(" [Truncated data]\n"));
9489 more_words
= word
>> 24;
9499 /* ARM EHABI Section 6.3:
9501 An exception-handling table entry for the compact model looks like:
9505 1 0 index Data for personalityRoutine[index] */
9507 if (filedata
->file_header
.e_machine
== EM_ARM
9508 && (word
& 0x70000000))
9510 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9514 per_index
= (word
>> 24) & 0x7f;
9515 printf (_(" Compact model index: %d\n"), per_index
);
9522 else if (per_index
< 3)
9524 more_words
= (word
>> 16) & 0xff;
9530 switch (filedata
->file_header
.e_machine
)
9535 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9536 data_offset
, data_sec
, data_arm_sec
))
9541 warn (_("Unknown ARM compact model index encountered\n"));
9542 printf (_(" [reserved]\n"));
9550 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9551 data_offset
, data_sec
, data_arm_sec
))
9554 else if (per_index
< 5)
9556 if (((word
>> 17) & 0x7f) == 0x7f)
9557 printf (_(" Restore stack from frame pointer\n"));
9559 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9560 printf (_(" Registers restored: "));
9562 printf (" (compact) ");
9563 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9565 printf (_(" Return register: %s\n"),
9566 tic6x_unwind_regnames
[word
& 0xf]);
9569 printf (_(" [reserved (%d)]\n"), per_index
);
9573 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9574 filedata
->file_header
.e_machine
);
9578 /* Decode the descriptors. Not implemented. */
9584 dump_arm_unwind (Filedata
* filedata
,
9585 struct arm_unw_aux_info
* aux
,
9586 Elf_Internal_Shdr
* exidx_sec
)
9588 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9589 unsigned int i
, exidx_len
;
9590 unsigned long j
, nfuns
;
9593 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9594 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9595 exidx_len
= exidx_sec
->sh_size
/ 8;
9597 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9598 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9599 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9600 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9602 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9604 for (i
= 0; i
< exidx_len
; i
++)
9606 unsigned int exidx_fn
, exidx_entry
;
9607 struct absaddr fn_addr
, entry_addr
;
9610 fputc ('\n', stdout
);
9612 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9613 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9614 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9615 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9618 arm_free_section (& exidx_arm_sec
);
9619 arm_free_section (& extab_arm_sec
);
9623 /* ARM EHABI, Section 5:
9624 An index table entry consists of 2 words.
9625 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9626 if (exidx_fn
& 0x80000000)
9628 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9632 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9634 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9635 fputs (": ", stdout
);
9637 if (exidx_entry
== 1)
9639 print_vma (exidx_entry
, PREFIX_HEX
);
9640 fputs (" [cantunwind]\n", stdout
);
9642 else if (exidx_entry
& 0x80000000)
9644 print_vma (exidx_entry
, PREFIX_HEX
);
9645 fputc ('\n', stdout
);
9646 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9650 bfd_vma table
, table_offset
= 0;
9651 Elf_Internal_Shdr
*table_sec
;
9653 fputs ("@", stdout
);
9654 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9655 print_vma (table
, PREFIX_HEX
);
9658 /* Locate the matching .ARM.extab. */
9659 if (entry_addr
.section
!= SHN_UNDEF
9660 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9662 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9663 table_offset
= entry_addr
.offset
;
9665 if (table_offset
> table_sec
->sh_size
9666 || ((bfd_signed_vma
) table_offset
) < 0)
9668 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9669 (unsigned long) table_offset
,
9670 printable_section_name (filedata
, table_sec
));
9677 table_sec
= find_section_by_address (filedata
, table
);
9678 if (table_sec
!= NULL
)
9679 table_offset
= table
- table_sec
->sh_addr
;
9682 if (table_sec
== NULL
)
9684 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9685 (unsigned long) table
);
9690 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9699 arm_free_section (&exidx_arm_sec
);
9700 arm_free_section (&extab_arm_sec
);
9705 /* Used for both ARM and C6X unwinding tables. */
9708 arm_process_unwind (Filedata
* filedata
)
9710 struct arm_unw_aux_info aux
;
9711 Elf_Internal_Shdr
*unwsec
= NULL
;
9712 Elf_Internal_Shdr
*sec
;
9714 unsigned int sec_type
;
9717 switch (filedata
->file_header
.e_machine
)
9720 sec_type
= SHT_ARM_EXIDX
;
9724 sec_type
= SHT_C6000_UNWIND
;
9728 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9729 filedata
->file_header
.e_machine
);
9733 if (filedata
->string_table
== NULL
)
9736 memset (& aux
, 0, sizeof (aux
));
9737 aux
.filedata
= filedata
;
9739 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9741 if (sec
->sh_type
== SHT_SYMTAB
)
9745 error (_("Multiple symbol tables encountered\n"));
9751 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9752 &aux
.strtab
, &aux
.strtab_size
))
9755 else if (sec
->sh_type
== sec_type
)
9760 printf (_("\nThere are no unwind sections in this file.\n"));
9762 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9764 if (sec
->sh_type
== sec_type
)
9766 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9767 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9768 "contains %lu entry:\n",
9769 "\nUnwind section '%s' at offset 0x%lx "
9770 "contains %lu entries:\n",
9772 printable_section_name (filedata
, sec
),
9773 (unsigned long) sec
->sh_offset
,
9776 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9782 free ((char *) aux
.strtab
);
9788 process_unwind (Filedata
* filedata
)
9790 struct unwind_handler
9792 unsigned int machtype
;
9793 bool (* handler
)(Filedata
*);
9796 { EM_ARM
, arm_process_unwind
},
9797 { EM_IA_64
, ia64_process_unwind
},
9798 { EM_PARISC
, hppa_process_unwind
},
9799 { EM_TI_C6000
, arm_process_unwind
},
9807 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9808 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9809 return handlers
[i
].handler (filedata
);
9811 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9812 get_machine_name (filedata
->file_header
.e_machine
));
9817 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9819 switch (entry
->d_tag
)
9821 case DT_AARCH64_BTI_PLT
:
9822 case DT_AARCH64_PAC_PLT
:
9825 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9832 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9834 switch (entry
->d_tag
)
9837 if (entry
->d_un
.d_val
== 0)
9841 static const char * opts
[] =
9843 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9844 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9845 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9846 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9852 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9853 if (entry
->d_un
.d_val
& (1 << cnt
))
9855 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9861 case DT_MIPS_IVERSION
:
9862 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9863 printf (_("Interface Version: %s"),
9864 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9868 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9869 /* Note: coded this way so that there is a single string for translation. */
9870 printf (_("<corrupt: %s>"), buf
);
9874 case DT_MIPS_TIME_STAMP
:
9878 time_t atime
= entry
->d_un
.d_val
;
9880 tmp
= gmtime (&atime
);
9881 /* PR 17531: file: 6accc532. */
9883 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9885 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9886 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9887 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9888 printf (_("Time Stamp: %s"), timebuf
);
9892 case DT_MIPS_RLD_VERSION
:
9893 case DT_MIPS_LOCAL_GOTNO
:
9894 case DT_MIPS_CONFLICTNO
:
9895 case DT_MIPS_LIBLISTNO
:
9896 case DT_MIPS_SYMTABNO
:
9897 case DT_MIPS_UNREFEXTNO
:
9898 case DT_MIPS_HIPAGENO
:
9899 case DT_MIPS_DELTA_CLASS_NO
:
9900 case DT_MIPS_DELTA_INSTANCE_NO
:
9901 case DT_MIPS_DELTA_RELOC_NO
:
9902 case DT_MIPS_DELTA_SYM_NO
:
9903 case DT_MIPS_DELTA_CLASSSYM_NO
:
9904 case DT_MIPS_COMPACT_SIZE
:
9905 print_vma (entry
->d_un
.d_val
, DEC
);
9909 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9910 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9911 /* Falls through. */
9914 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9920 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9922 switch (entry
->d_tag
)
9924 case DT_HP_DLD_FLAGS
:
9933 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9934 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9935 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9936 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9937 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9938 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9939 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9940 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9941 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9942 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9943 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9944 { DT_HP_GST
, "HP_GST" },
9945 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9946 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9947 { DT_HP_NODELETE
, "HP_NODELETE" },
9948 { DT_HP_GROUP
, "HP_GROUP" },
9949 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9953 bfd_vma val
= entry
->d_un
.d_val
;
9955 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9956 if (val
& flags
[cnt
].bit
)
9960 fputs (flags
[cnt
].str
, stdout
);
9962 val
^= flags
[cnt
].bit
;
9965 if (val
!= 0 || first
)
9969 print_vma (val
, HEX
);
9975 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9983 /* VMS vs Unix time offset and factor. */
9985 #define VMS_EPOCH_OFFSET 35067168000000000LL
9986 #define VMS_GRANULARITY_FACTOR 10000000
9988 #define INT64_MIN (-9223372036854775807LL - 1)
9991 /* Display a VMS time in a human readable format. */
9994 print_vms_time (bfd_int64_t vmstime
)
9996 struct tm
*tm
= NULL
;
9999 if (vmstime
>= INT64_MIN
+ VMS_EPOCH_OFFSET
)
10001 vmstime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
10003 if (unxtime
== vmstime
)
10004 tm
= gmtime (&unxtime
);
10007 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
10008 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
10009 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
10014 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
10016 switch (entry
->d_tag
)
10018 case DT_IA_64_PLT_RESERVE
:
10019 /* First 3 slots reserved. */
10020 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10022 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
10025 case DT_IA_64_VMS_LINKTIME
:
10027 print_vms_time (entry
->d_un
.d_val
);
10031 case DT_IA_64_VMS_LNKFLAGS
:
10032 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10033 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
10034 printf (" CALL_DEBUG");
10035 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
10036 printf (" NOP0BUFS");
10037 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
10038 printf (" P0IMAGE");
10039 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
10040 printf (" MKTHREADS");
10041 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
10042 printf (" UPCALLS");
10043 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
10044 printf (" IMGSTA");
10045 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
10046 printf (" INITIALIZE");
10047 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
10049 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
10050 printf (" EXE_INIT");
10051 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
10052 printf (" TBK_IN_IMG");
10053 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
10054 printf (" DBG_IN_IMG");
10055 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
10056 printf (" TBK_IN_DSF");
10057 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
10058 printf (" DBG_IN_DSF");
10059 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
10060 printf (" SIGNATURES");
10061 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
10062 printf (" REL_SEG_OFF");
10066 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
10073 get_32bit_dynamic_section (Filedata
* filedata
)
10075 Elf32_External_Dyn
* edyn
;
10076 Elf32_External_Dyn
* ext
;
10077 Elf_Internal_Dyn
* entry
;
10079 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
10080 filedata
->dynamic_addr
, 1,
10081 filedata
->dynamic_size
,
10082 _("dynamic section"));
10086 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10087 might not have the luxury of section headers. Look for the DT_NULL
10088 terminator to determine the number of entries. */
10089 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10090 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10093 filedata
->dynamic_nent
++;
10094 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10098 filedata
->dynamic_section
10099 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10100 if (filedata
->dynamic_section
== NULL
)
10102 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10103 (unsigned long) filedata
->dynamic_nent
);
10108 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10109 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10112 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10113 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10122 get_64bit_dynamic_section (Filedata
* filedata
)
10124 Elf64_External_Dyn
* edyn
;
10125 Elf64_External_Dyn
* ext
;
10126 Elf_Internal_Dyn
* entry
;
10128 /* Read in the data. */
10129 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10130 filedata
->dynamic_addr
, 1,
10131 filedata
->dynamic_size
,
10132 _("dynamic section"));
10136 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10137 might not have the luxury of section headers. Look for the DT_NULL
10138 terminator to determine the number of entries. */
10139 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10140 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10141 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10144 filedata
->dynamic_nent
++;
10145 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10149 filedata
->dynamic_section
10150 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10151 if (filedata
->dynamic_section
== NULL
)
10153 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10154 (unsigned long) filedata
->dynamic_nent
);
10159 /* Convert from external to internal formats. */
10160 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10161 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10164 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10165 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10174 print_dynamic_flags (bfd_vma flags
)
10182 flag
= flags
& - flags
;
10188 putc (' ', stdout
);
10192 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10193 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10194 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10195 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10196 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10197 default: fputs (_("unknown"), stdout
); break;
10204 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10206 unsigned char * e_data
;
10209 /* If the size_t type is smaller than the bfd_size_type, eg because
10210 you are building a 32-bit tool on a 64-bit host, then make sure
10211 that when (number) is cast to (size_t) no information is lost. */
10212 if (sizeof (size_t) < sizeof (bfd_size_type
)
10213 && (bfd_size_type
) ((size_t) number
) != number
)
10215 error (_("Size truncation prevents reading %s elements of size %u\n"),
10216 bfd_vmatoa ("u", number
), ent_size
);
10220 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10221 attempting to allocate memory when the read is bound to fail. */
10222 if (ent_size
* number
> filedata
->file_size
)
10224 error (_("Invalid number of dynamic entries: %s\n"),
10225 bfd_vmatoa ("u", number
));
10229 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10230 if (e_data
== NULL
)
10232 error (_("Out of memory reading %s dynamic entries\n"),
10233 bfd_vmatoa ("u", number
));
10237 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10239 error (_("Unable to read in %s bytes of dynamic data\n"),
10240 bfd_vmatoa ("u", number
* ent_size
));
10245 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10246 if (i_data
== NULL
)
10248 error (_("Out of memory allocating space for %s dynamic entries\n"),
10249 bfd_vmatoa ("u", number
));
10255 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10262 static unsigned long
10263 get_num_dynamic_syms (Filedata
* filedata
)
10265 unsigned long num_of_syms
= 0;
10267 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10268 return num_of_syms
;
10270 if (filedata
->dynamic_info
[DT_HASH
])
10272 unsigned char nb
[8];
10273 unsigned char nc
[8];
10274 unsigned int hash_ent_size
= 4;
10276 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10277 || filedata
->file_header
.e_machine
== EM_S390
10278 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10279 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10282 if (fseek (filedata
->handle
,
10283 (filedata
->archive_file_offset
10284 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10285 sizeof nb
+ sizeof nc
)),
10288 error (_("Unable to seek to start of dynamic information\n"));
10292 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10294 error (_("Failed to read in number of buckets\n"));
10298 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10300 error (_("Failed to read in number of chains\n"));
10304 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10305 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10307 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10309 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10311 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10314 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10315 num_of_syms
= filedata
->nchains
;
10318 if (num_of_syms
== 0)
10320 free (filedata
->buckets
);
10321 filedata
->buckets
= NULL
;
10322 free (filedata
->chains
);
10323 filedata
->chains
= NULL
;
10324 filedata
->nbuckets
= 0;
10328 if (filedata
->dynamic_info_DT_GNU_HASH
)
10330 unsigned char nb
[16];
10331 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10332 bfd_vma buckets_vma
;
10335 if (fseek (filedata
->handle
,
10336 (filedata
->archive_file_offset
10337 + offset_from_vma (filedata
,
10338 filedata
->dynamic_info_DT_GNU_HASH
,
10342 error (_("Unable to seek to start of dynamic information\n"));
10346 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10348 error (_("Failed to read in number of buckets\n"));
10352 filedata
->ngnubuckets
= byte_get (nb
, 4);
10353 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10354 bitmaskwords
= byte_get (nb
+ 8, 4);
10355 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10357 buckets_vma
+= bitmaskwords
* 4;
10359 buckets_vma
+= bitmaskwords
* 8;
10361 if (fseek (filedata
->handle
,
10362 (filedata
->archive_file_offset
10363 + offset_from_vma (filedata
, buckets_vma
, 4)),
10366 error (_("Unable to seek to start of dynamic information\n"));
10370 filedata
->gnubuckets
10371 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10373 if (filedata
->gnubuckets
== NULL
)
10376 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10377 if (filedata
->gnubuckets
[i
] != 0)
10379 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10382 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10383 maxchain
= filedata
->gnubuckets
[i
];
10386 if (maxchain
== 0xffffffff)
10389 maxchain
-= filedata
->gnusymidx
;
10391 if (fseek (filedata
->handle
,
10392 (filedata
->archive_file_offset
10393 + offset_from_vma (filedata
,
10394 buckets_vma
+ 4 * (filedata
->ngnubuckets
10399 error (_("Unable to seek to start of dynamic information\n"));
10405 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10407 error (_("Failed to determine last chain length\n"));
10411 if (maxchain
+ 1 == 0)
10416 while ((byte_get (nb
, 4) & 1) == 0);
10418 if (fseek (filedata
->handle
,
10419 (filedata
->archive_file_offset
10420 + offset_from_vma (filedata
, (buckets_vma
10421 + 4 * filedata
->ngnubuckets
),
10425 error (_("Unable to seek to start of dynamic information\n"));
10429 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10430 filedata
->ngnuchains
= maxchain
;
10432 if (filedata
->gnuchains
== NULL
)
10435 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10437 if (fseek (filedata
->handle
,
10438 (filedata
->archive_file_offset
10439 + offset_from_vma (filedata
, (buckets_vma
10440 + 4 * (filedata
->ngnubuckets
10444 error (_("Unable to seek to start of dynamic information\n"));
10448 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10449 if (filedata
->mipsxlat
== NULL
)
10453 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10454 if (filedata
->gnubuckets
[hn
] != 0)
10456 bfd_vma si
= filedata
->gnubuckets
[hn
];
10457 bfd_vma off
= si
- filedata
->gnusymidx
;
10461 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10463 if (off
< filedata
->ngnuchains
10464 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10465 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10469 if (si
>= num_of_syms
)
10470 num_of_syms
= si
+ 1;
10474 while (off
< filedata
->ngnuchains
10475 && (filedata
->gnuchains
[off
++] & 1) == 0);
10478 if (num_of_syms
== 0)
10481 free (filedata
->mipsxlat
);
10482 filedata
->mipsxlat
= NULL
;
10483 free (filedata
->gnuchains
);
10484 filedata
->gnuchains
= NULL
;
10485 free (filedata
->gnubuckets
);
10486 filedata
->gnubuckets
= NULL
;
10487 filedata
->ngnubuckets
= 0;
10488 filedata
->ngnuchains
= 0;
10492 return num_of_syms
;
10495 /* Parse and display the contents of the dynamic section. */
10498 process_dynamic_section (Filedata
* filedata
)
10500 Elf_Internal_Dyn
* entry
;
10502 if (filedata
->dynamic_size
== 0)
10506 if (filedata
->is_separate
)
10507 printf (_("\nThere is no dynamic section in linked file '%s'.\n"),
10508 filedata
->file_name
);
10510 printf (_("\nThere is no dynamic section in this file.\n"));
10518 if (! get_32bit_dynamic_section (filedata
))
10523 if (! get_64bit_dynamic_section (filedata
))
10527 /* Find the appropriate symbol table. */
10528 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10530 unsigned long num_of_syms
;
10532 for (entry
= filedata
->dynamic_section
;
10533 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10535 if (entry
->d_tag
== DT_SYMTAB
)
10536 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10537 else if (entry
->d_tag
== DT_SYMENT
)
10538 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10539 else if (entry
->d_tag
== DT_HASH
)
10540 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10541 else if (entry
->d_tag
== DT_GNU_HASH
)
10542 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10543 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10544 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10545 && entry
->d_tag
== DT_MIPS_XHASH
)
10547 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10548 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10551 num_of_syms
= get_num_dynamic_syms (filedata
);
10553 if (num_of_syms
!= 0
10554 && filedata
->dynamic_symbols
== NULL
10555 && filedata
->dynamic_info
[DT_SYMTAB
]
10556 && filedata
->dynamic_info
[DT_SYMENT
])
10558 Elf_Internal_Phdr
*seg
;
10559 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10561 if (! get_program_headers (filedata
))
10563 error (_("Cannot interpret virtual addresses "
10564 "without program headers.\n"));
10568 for (seg
= filedata
->program_headers
;
10569 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10572 if (seg
->p_type
!= PT_LOAD
)
10575 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10577 /* See PR 21379 for a reproducer. */
10578 error (_("Invalid PT_LOAD entry\n"));
10582 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10583 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10585 /* Since we do not know how big the symbol table is,
10586 we default to reading in up to the end of PT_LOAD
10587 segment and processing that. This is overkill, I
10588 know, but it should work. */
10589 Elf_Internal_Shdr section
;
10590 section
.sh_offset
= (vma
- seg
->p_vaddr
10592 section
.sh_size
= (num_of_syms
10593 * filedata
->dynamic_info
[DT_SYMENT
]);
10594 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10597 && filedata
->dynamic_symtab_section
!= NULL
10598 && ((filedata
->dynamic_symtab_section
->sh_offset
10599 != section
.sh_offset
)
10600 || (filedata
->dynamic_symtab_section
->sh_size
10601 != section
.sh_size
)
10602 || (filedata
->dynamic_symtab_section
->sh_entsize
10603 != section
.sh_entsize
)))
10605 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10607 section
.sh_name
= filedata
->string_table_length
;
10608 filedata
->dynamic_symbols
10609 = GET_ELF_SYMBOLS (filedata
, §ion
,
10610 &filedata
->num_dynamic_syms
);
10611 if (filedata
->dynamic_symbols
== NULL
10612 || filedata
->num_dynamic_syms
!= num_of_syms
)
10614 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10623 /* Similarly find a string table. */
10624 if (filedata
->dynamic_strings
== NULL
)
10625 for (entry
= filedata
->dynamic_section
;
10626 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10629 if (entry
->d_tag
== DT_STRTAB
)
10630 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10632 if (entry
->d_tag
== DT_STRSZ
)
10633 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10635 if (filedata
->dynamic_info
[DT_STRTAB
]
10636 && filedata
->dynamic_info
[DT_STRSZ
])
10638 unsigned long offset
;
10639 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10641 offset
= offset_from_vma (filedata
,
10642 filedata
->dynamic_info
[DT_STRTAB
],
10645 && filedata
->dynamic_strtab_section
10646 && ((filedata
->dynamic_strtab_section
->sh_offset
10647 != (file_ptr
) offset
)
10648 || (filedata
->dynamic_strtab_section
->sh_size
10651 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10653 filedata
->dynamic_strings
10654 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10655 _("dynamic string table"));
10656 if (filedata
->dynamic_strings
== NULL
)
10658 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10662 filedata
->dynamic_strings_length
= str_tab_len
;
10667 /* And find the syminfo section if available. */
10668 if (filedata
->dynamic_syminfo
== NULL
)
10670 unsigned long syminsz
= 0;
10672 for (entry
= filedata
->dynamic_section
;
10673 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10676 if (entry
->d_tag
== DT_SYMINENT
)
10678 /* Note: these braces are necessary to avoid a syntax
10679 error from the SunOS4 C compiler. */
10680 /* PR binutils/17531: A corrupt file can trigger this test.
10681 So do not use an assert, instead generate an error message. */
10682 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10683 error (_("Bad value (%d) for SYMINENT entry\n"),
10684 (int) entry
->d_un
.d_val
);
10686 else if (entry
->d_tag
== DT_SYMINSZ
)
10687 syminsz
= entry
->d_un
.d_val
;
10688 else if (entry
->d_tag
== DT_SYMINFO
)
10689 filedata
->dynamic_syminfo_offset
10690 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10693 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10695 Elf_External_Syminfo
* extsyminfo
;
10696 Elf_External_Syminfo
* extsym
;
10697 Elf_Internal_Syminfo
* syminfo
;
10699 /* There is a syminfo section. Read the data. */
10700 extsyminfo
= (Elf_External_Syminfo
*)
10701 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10702 1, syminsz
, _("symbol information"));
10706 if (filedata
->dynamic_syminfo
!= NULL
)
10708 error (_("Multiple dynamic symbol information sections found\n"));
10709 free (filedata
->dynamic_syminfo
);
10711 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10712 if (filedata
->dynamic_syminfo
== NULL
)
10714 error (_("Out of memory allocating %lu bytes "
10715 "for dynamic symbol info\n"),
10716 (unsigned long) syminsz
);
10720 filedata
->dynamic_syminfo_nent
10721 = syminsz
/ sizeof (Elf_External_Syminfo
);
10722 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10723 syminfo
< (filedata
->dynamic_syminfo
10724 + filedata
->dynamic_syminfo_nent
);
10725 ++syminfo
, ++extsym
)
10727 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10728 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10735 if (do_dynamic
&& filedata
->dynamic_addr
)
10737 if (filedata
->dynamic_nent
== 1)
10739 if (filedata
->is_separate
)
10740 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains 1 entry:\n"),
10741 filedata
->file_name
,
10742 filedata
->dynamic_addr
);
10744 printf (_("\nDynamic section at offset 0x%lx contains 1 entry:\n"),
10745 filedata
->dynamic_addr
);
10749 if (filedata
->is_separate
)
10750 printf (_("\nIn linked file '%s' the dynamic section at offset 0x%lx contains %lu entries:\n"),
10751 filedata
->file_name
,
10752 filedata
->dynamic_addr
,
10753 (unsigned long) filedata
->dynamic_nent
);
10755 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
10756 filedata
->dynamic_addr
,
10757 (unsigned long) filedata
->dynamic_nent
);
10761 printf (_(" Tag Type Name/Value\n"));
10763 for (entry
= filedata
->dynamic_section
;
10764 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10769 const char * dtype
;
10772 print_vma (entry
->d_tag
, FULL_HEX
);
10773 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10774 printf (" (%s)%*s", dtype
,
10775 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10778 switch (entry
->d_tag
)
10782 print_dynamic_flags (entry
->d_un
.d_val
);
10792 switch (entry
->d_tag
)
10795 printf (_("Auxiliary library"));
10799 printf (_("Filter library"));
10803 printf (_("Configuration file"));
10807 printf (_("Dependency audit library"));
10811 printf (_("Audit library"));
10815 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10816 printf (": [%s]\n",
10817 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10821 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10830 printf (_("Flags:"));
10832 if (entry
->d_un
.d_val
== 0)
10833 printf (_(" None\n"));
10836 unsigned long int val
= entry
->d_un
.d_val
;
10838 if (val
& DTF_1_PARINIT
)
10840 printf (" PARINIT");
10841 val
^= DTF_1_PARINIT
;
10843 if (val
& DTF_1_CONFEXP
)
10845 printf (" CONFEXP");
10846 val
^= DTF_1_CONFEXP
;
10849 printf (" %lx", val
);
10858 printf (_("Flags:"));
10860 if (entry
->d_un
.d_val
== 0)
10861 printf (_(" None\n"));
10864 unsigned long int val
= entry
->d_un
.d_val
;
10866 if (val
& DF_P1_LAZYLOAD
)
10868 printf (" LAZYLOAD");
10869 val
^= DF_P1_LAZYLOAD
;
10871 if (val
& DF_P1_GROUPPERM
)
10873 printf (" GROUPPERM");
10874 val
^= DF_P1_GROUPPERM
;
10877 printf (" %lx", val
);
10886 printf (_("Flags:"));
10887 if (entry
->d_un
.d_val
== 0)
10888 printf (_(" None\n"));
10891 unsigned long int val
= entry
->d_un
.d_val
;
10893 if (val
& DF_1_NOW
)
10898 if (val
& DF_1_GLOBAL
)
10900 printf (" GLOBAL");
10901 val
^= DF_1_GLOBAL
;
10903 if (val
& DF_1_GROUP
)
10908 if (val
& DF_1_NODELETE
)
10910 printf (" NODELETE");
10911 val
^= DF_1_NODELETE
;
10913 if (val
& DF_1_LOADFLTR
)
10915 printf (" LOADFLTR");
10916 val
^= DF_1_LOADFLTR
;
10918 if (val
& DF_1_INITFIRST
)
10920 printf (" INITFIRST");
10921 val
^= DF_1_INITFIRST
;
10923 if (val
& DF_1_NOOPEN
)
10925 printf (" NOOPEN");
10926 val
^= DF_1_NOOPEN
;
10928 if (val
& DF_1_ORIGIN
)
10930 printf (" ORIGIN");
10931 val
^= DF_1_ORIGIN
;
10933 if (val
& DF_1_DIRECT
)
10935 printf (" DIRECT");
10936 val
^= DF_1_DIRECT
;
10938 if (val
& DF_1_TRANS
)
10943 if (val
& DF_1_INTERPOSE
)
10945 printf (" INTERPOSE");
10946 val
^= DF_1_INTERPOSE
;
10948 if (val
& DF_1_NODEFLIB
)
10950 printf (" NODEFLIB");
10951 val
^= DF_1_NODEFLIB
;
10953 if (val
& DF_1_NODUMP
)
10955 printf (" NODUMP");
10956 val
^= DF_1_NODUMP
;
10958 if (val
& DF_1_CONFALT
)
10960 printf (" CONFALT");
10961 val
^= DF_1_CONFALT
;
10963 if (val
& DF_1_ENDFILTEE
)
10965 printf (" ENDFILTEE");
10966 val
^= DF_1_ENDFILTEE
;
10968 if (val
& DF_1_DISPRELDNE
)
10970 printf (" DISPRELDNE");
10971 val
^= DF_1_DISPRELDNE
;
10973 if (val
& DF_1_DISPRELPND
)
10975 printf (" DISPRELPND");
10976 val
^= DF_1_DISPRELPND
;
10978 if (val
& DF_1_NODIRECT
)
10980 printf (" NODIRECT");
10981 val
^= DF_1_NODIRECT
;
10983 if (val
& DF_1_IGNMULDEF
)
10985 printf (" IGNMULDEF");
10986 val
^= DF_1_IGNMULDEF
;
10988 if (val
& DF_1_NOKSYMS
)
10990 printf (" NOKSYMS");
10991 val
^= DF_1_NOKSYMS
;
10993 if (val
& DF_1_NOHDR
)
10998 if (val
& DF_1_EDITED
)
11000 printf (" EDITED");
11001 val
^= DF_1_EDITED
;
11003 if (val
& DF_1_NORELOC
)
11005 printf (" NORELOC");
11006 val
^= DF_1_NORELOC
;
11008 if (val
& DF_1_SYMINTPOSE
)
11010 printf (" SYMINTPOSE");
11011 val
^= DF_1_SYMINTPOSE
;
11013 if (val
& DF_1_GLOBAUDIT
)
11015 printf (" GLOBAUDIT");
11016 val
^= DF_1_GLOBAUDIT
;
11018 if (val
& DF_1_SINGLETON
)
11020 printf (" SINGLETON");
11021 val
^= DF_1_SINGLETON
;
11023 if (val
& DF_1_STUB
)
11028 if (val
& DF_1_PIE
)
11033 if (val
& DF_1_KMOD
)
11038 if (val
& DF_1_WEAKFILTER
)
11040 printf (" WEAKFILTER");
11041 val
^= DF_1_WEAKFILTER
;
11043 if (val
& DF_1_NOCOMMON
)
11045 printf (" NOCOMMON");
11046 val
^= DF_1_NOCOMMON
;
11049 printf (" %lx", val
);
11056 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11058 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
11078 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11084 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11085 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11091 switch (entry
->d_tag
)
11094 printf (_("Shared library: [%s]"), name
);
11096 if (filedata
->program_interpreter
11097 && streq (name
, filedata
->program_interpreter
))
11098 printf (_(" program interpreter"));
11102 printf (_("Library soname: [%s]"), name
);
11106 printf (_("Library rpath: [%s]"), name
);
11110 printf (_("Library runpath: [%s]"), name
);
11114 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11119 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11132 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11133 /* Fall through. */
11137 case DT_INIT_ARRAYSZ
:
11138 case DT_FINI_ARRAYSZ
:
11139 case DT_GNU_CONFLICTSZ
:
11140 case DT_GNU_LIBLISTSZ
:
11143 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11144 printf (_(" (bytes)\n"));
11149 case DT_VERNEEDNUM
:
11154 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11163 case DT_INIT_ARRAY
:
11164 case DT_FINI_ARRAY
:
11167 if (entry
->d_tag
== DT_USED
11168 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11170 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11174 printf (_("Not needed object: [%s]\n"), name
);
11179 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11185 /* The value of this entry is ignored. */
11190 case DT_GNU_PRELINKED
:
11194 time_t atime
= entry
->d_un
.d_val
;
11196 tmp
= gmtime (&atime
);
11197 /* PR 17533 file: 041-1244816-0.004. */
11199 printf (_("<corrupt time val: %lx"),
11200 (unsigned long) atime
);
11202 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11203 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11204 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11210 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11213 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11218 case DT_GNU_FLAGS_1
:
11221 printf (_("Flags:"));
11222 if (entry
->d_un
.d_val
== 0)
11223 printf (_(" None\n"));
11226 unsigned long int val
= entry
->d_un
.d_val
;
11228 if (val
& DF_GNU_1_UNIQUE
)
11230 printf (" UNIQUE");
11231 val
^= DF_GNU_1_UNIQUE
;
11234 printf (" %lx", val
);
11241 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11242 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11243 = entry
->d_un
.d_val
;
11247 switch (filedata
->file_header
.e_machine
)
11250 dynamic_section_aarch64_val (entry
);
11253 case EM_MIPS_RS3_LE
:
11254 dynamic_section_mips_val (filedata
, entry
);
11257 dynamic_section_parisc_val (entry
);
11260 dynamic_section_ia64_val (entry
);
11263 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11275 get_ver_flags (unsigned int flags
)
11277 static char buff
[128];
11284 if (flags
& VER_FLG_BASE
)
11285 strcat (buff
, "BASE");
11287 if (flags
& VER_FLG_WEAK
)
11289 if (flags
& VER_FLG_BASE
)
11290 strcat (buff
, " | ");
11292 strcat (buff
, "WEAK");
11295 if (flags
& VER_FLG_INFO
)
11297 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11298 strcat (buff
, " | ");
11300 strcat (buff
, "INFO");
11303 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11305 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11306 strcat (buff
, " | ");
11308 strcat (buff
, _("<unknown>"));
11314 /* Display the contents of the version sections. */
11317 process_version_sections (Filedata
* filedata
)
11319 Elf_Internal_Shdr
* section
;
11321 bool found
= false;
11326 for (i
= 0, section
= filedata
->section_headers
;
11327 i
< filedata
->file_header
.e_shnum
;
11330 switch (section
->sh_type
)
11332 case SHT_GNU_verdef
:
11334 Elf_External_Verdef
* edefs
;
11341 if (filedata
->is_separate
)
11342 printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\n",
11343 "\nIn linked file '%s' the version definition section '%s' contains %u entries:\n",
11345 filedata
->file_name
,
11346 printable_section_name (filedata
, section
),
11349 printf (ngettext ("\nVersion definition section '%s' "
11350 "contains %u entry:\n",
11351 "\nVersion definition section '%s' "
11352 "contains %u entries:\n",
11354 printable_section_name (filedata
, section
),
11357 printf (_(" Addr: 0x"));
11358 printf_vma (section
->sh_addr
);
11359 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11360 (unsigned long) section
->sh_offset
, section
->sh_link
,
11361 printable_section_name_from_index (filedata
, section
->sh_link
));
11363 edefs
= (Elf_External_Verdef
*)
11364 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11365 _("version definition section"));
11368 endbuf
= (char *) edefs
+ section
->sh_size
;
11370 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11373 Elf_External_Verdef
* edef
;
11374 Elf_Internal_Verdef ent
;
11375 Elf_External_Verdaux
* eaux
;
11376 Elf_Internal_Verdaux aux
;
11377 unsigned long isum
;
11380 vstart
= ((char *) edefs
) + idx
;
11381 if (vstart
+ sizeof (*edef
) > endbuf
)
11384 edef
= (Elf_External_Verdef
*) vstart
;
11386 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11387 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11388 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11389 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11390 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11391 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11392 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11394 printf (_(" %#06lx: Rev: %d Flags: %s"),
11395 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11397 printf (_(" Index: %d Cnt: %d "),
11398 ent
.vd_ndx
, ent
.vd_cnt
);
11400 /* Check for overflow. */
11401 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11404 vstart
+= ent
.vd_aux
;
11406 if (vstart
+ sizeof (*eaux
) > endbuf
)
11408 eaux
= (Elf_External_Verdaux
*) vstart
;
11410 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11411 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11413 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11414 printf (_("Name: %s\n"),
11415 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11417 printf (_("Name index: %ld\n"), aux
.vda_name
);
11419 isum
= idx
+ ent
.vd_aux
;
11421 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11423 if (aux
.vda_next
< sizeof (*eaux
)
11424 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11426 warn (_("Invalid vda_next field of %lx\n"),
11431 /* Check for overflow. */
11432 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11435 isum
+= aux
.vda_next
;
11436 vstart
+= aux
.vda_next
;
11438 if (vstart
+ sizeof (*eaux
) > endbuf
)
11440 eaux
= (Elf_External_Verdaux
*) vstart
;
11442 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11443 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11445 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11446 printf (_(" %#06lx: Parent %d: %s\n"),
11448 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11450 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11451 isum
, j
, aux
.vda_name
);
11454 if (j
< ent
.vd_cnt
)
11455 printf (_(" Version def aux past end of section\n"));
11458 file: id:000001,src:000172+005151,op:splice,rep:2. */
11459 if (ent
.vd_next
< sizeof (*edef
)
11460 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11462 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11463 cnt
= section
->sh_info
;
11466 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11469 idx
+= ent
.vd_next
;
11472 if (cnt
< section
->sh_info
)
11473 printf (_(" Version definition past end of section\n"));
11479 case SHT_GNU_verneed
:
11481 Elf_External_Verneed
* eneed
;
11488 if (filedata
->is_separate
)
11489 printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\n",
11490 "\nIn linked file '%s' the version needs section '%s' contains %u entries:\n",
11492 filedata
->file_name
,
11493 printable_section_name (filedata
, section
),
11496 printf (ngettext ("\nVersion needs section '%s' "
11497 "contains %u entry:\n",
11498 "\nVersion needs section '%s' "
11499 "contains %u entries:\n",
11501 printable_section_name (filedata
, section
),
11504 printf (_(" Addr: 0x"));
11505 printf_vma (section
->sh_addr
);
11506 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11507 (unsigned long) section
->sh_offset
, section
->sh_link
,
11508 printable_section_name_from_index (filedata
, section
->sh_link
));
11510 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11511 section
->sh_offset
, 1,
11513 _("Version Needs section"));
11516 endbuf
= (char *) eneed
+ section
->sh_size
;
11518 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11520 Elf_External_Verneed
* entry
;
11521 Elf_Internal_Verneed ent
;
11522 unsigned long isum
;
11526 vstart
= ((char *) eneed
) + idx
;
11527 if (vstart
+ sizeof (*entry
) > endbuf
)
11530 entry
= (Elf_External_Verneed
*) vstart
;
11532 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11533 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11534 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11535 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11536 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11538 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11540 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11541 printf (_(" File: %s"),
11542 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11544 printf (_(" File: %lx"), ent
.vn_file
);
11546 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11548 /* Check for overflow. */
11549 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11551 vstart
+= ent
.vn_aux
;
11553 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11555 Elf_External_Vernaux
* eaux
;
11556 Elf_Internal_Vernaux aux
;
11558 if (vstart
+ sizeof (*eaux
) > endbuf
)
11560 eaux
= (Elf_External_Vernaux
*) vstart
;
11562 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11563 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11564 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11565 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11566 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11568 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11569 printf (_(" %#06lx: Name: %s"),
11570 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11572 printf (_(" %#06lx: Name index: %lx"),
11573 isum
, aux
.vna_name
);
11575 printf (_(" Flags: %s Version: %d\n"),
11576 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11578 if (aux
.vna_next
< sizeof (*eaux
)
11579 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11581 warn (_("Invalid vna_next field of %lx\n"),
11586 /* Check for overflow. */
11587 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11589 isum
+= aux
.vna_next
;
11590 vstart
+= aux
.vna_next
;
11593 if (j
< ent
.vn_cnt
)
11594 warn (_("Missing Version Needs auxiliary information\n"));
11596 if (ent
.vn_next
< sizeof (*entry
)
11597 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11599 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11600 cnt
= section
->sh_info
;
11603 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11605 idx
+= ent
.vn_next
;
11608 if (cnt
< section
->sh_info
)
11609 warn (_("Missing Version Needs information\n"));
11615 case SHT_GNU_versym
:
11617 Elf_Internal_Shdr
* link_section
;
11620 unsigned char * edata
;
11621 unsigned short * data
;
11623 Elf_Internal_Sym
* symbols
;
11624 Elf_Internal_Shdr
* string_sec
;
11625 unsigned long num_syms
;
11628 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11631 link_section
= filedata
->section_headers
+ section
->sh_link
;
11632 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11634 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11639 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11640 if (symbols
== NULL
)
11643 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11645 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11646 string_sec
->sh_size
,
11647 _("version string table"));
11654 if (filedata
->is_separate
)
11655 printf (ngettext ("\nIn linked file '%s' the version symbols section '%s' contains %lu entry:\n",
11656 "\nIn linked file '%s' the version symbols section '%s' contains %lu entries:\n",
11658 filedata
->file_name
,
11659 printable_section_name (filedata
, section
),
11660 (unsigned long) total
);
11662 printf (ngettext ("\nVersion symbols section '%s' "
11663 "contains %lu entry:\n",
11664 "\nVersion symbols section '%s' "
11665 "contains %lu entries:\n",
11667 printable_section_name (filedata
, section
),
11668 (unsigned long) total
);
11670 printf (_(" Addr: 0x"));
11671 printf_vma (section
->sh_addr
);
11672 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11673 (unsigned long) section
->sh_offset
, section
->sh_link
,
11674 printable_section_name (filedata
, link_section
));
11676 off
= offset_from_vma (filedata
,
11677 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11678 total
* sizeof (short));
11679 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11680 sizeof (short), total
,
11681 _("version symbol data"));
11689 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11691 for (cnt
= total
; cnt
--;)
11692 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11697 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11701 char *invalid
= _("*invalid*");
11703 printf (" %03x:", cnt
);
11705 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11706 switch (data
[cnt
+ j
])
11709 fputs (_(" 0 (*local*) "), stdout
);
11713 fputs (_(" 1 (*global*) "), stdout
);
11717 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11718 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11720 /* If this index value is greater than the size of the symbols
11721 array, break to avoid an out-of-bounds read. */
11722 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11724 warn (_("invalid index into symbol array\n"));
11729 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11731 Elf_Internal_Verneed ivn
;
11732 unsigned long offset
;
11734 offset
= offset_from_vma
11736 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11737 sizeof (Elf_External_Verneed
));
11741 Elf_Internal_Vernaux ivna
;
11742 Elf_External_Verneed evn
;
11743 Elf_External_Vernaux evna
;
11744 unsigned long a_off
;
11746 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11747 _("version need")) == NULL
)
11750 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11751 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11753 a_off
= offset
+ ivn
.vn_aux
;
11757 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11758 1, _("version need aux (2)")) == NULL
)
11761 ivna
.vna_other
= 0;
11765 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11766 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11769 a_off
+= ivna
.vna_next
;
11771 while (ivna
.vna_other
!= data
[cnt
+ j
]
11772 && ivna
.vna_next
!= 0);
11774 if (ivna
.vna_other
== data
[cnt
+ j
])
11776 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11778 if (ivna
.vna_name
>= string_sec
->sh_size
)
11781 name
= strtab
+ ivna
.vna_name
;
11785 offset
+= ivn
.vn_next
;
11787 while (ivn
.vn_next
);
11790 if (data
[cnt
+ j
] != 0x8001
11791 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11793 Elf_Internal_Verdef ivd
;
11794 Elf_External_Verdef evd
;
11795 unsigned long offset
;
11797 offset
= offset_from_vma
11799 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11804 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11805 _("version def")) == NULL
)
11808 /* PR 17531: file: 046-1082287-0.004. */
11809 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11814 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11815 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11818 offset
+= ivd
.vd_next
;
11820 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11821 && ivd
.vd_next
!= 0);
11823 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11825 Elf_External_Verdaux evda
;
11826 Elf_Internal_Verdaux ivda
;
11828 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11830 if (get_data (&evda
, filedata
,
11831 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11833 _("version def aux")) == NULL
)
11836 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11838 if (ivda
.vda_name
>= string_sec
->sh_size
)
11840 else if (name
!= NULL
&& name
!= invalid
)
11841 name
= _("*both*");
11843 name
= strtab
+ ivda
.vda_name
;
11847 nn
+= printf ("(%s%-*s",
11849 12 - (int) strlen (name
),
11853 printf ("%*c", 18 - nn
, ' ');
11872 if (filedata
->is_separate
)
11873 printf (_("\nNo version information found in linked file '%s'.\n"),
11874 filedata
->file_name
);
11876 printf (_("\nNo version information found in this file.\n"));
11882 static const char *
11883 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11885 static char buff
[64];
11889 case STB_LOCAL
: return "LOCAL";
11890 case STB_GLOBAL
: return "GLOBAL";
11891 case STB_WEAK
: return "WEAK";
11893 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11894 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11896 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11898 if (binding
== STB_GNU_UNIQUE
11899 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11901 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11904 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11909 static const char *
11910 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11912 static char buff
[64];
11916 case STT_NOTYPE
: return "NOTYPE";
11917 case STT_OBJECT
: return "OBJECT";
11918 case STT_FUNC
: return "FUNC";
11919 case STT_SECTION
: return "SECTION";
11920 case STT_FILE
: return "FILE";
11921 case STT_COMMON
: return "COMMON";
11922 case STT_TLS
: return "TLS";
11923 case STT_RELC
: return "RELC";
11924 case STT_SRELC
: return "SRELC";
11926 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11928 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11929 return "THUMB_FUNC";
11931 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11934 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11935 return "PARISC_MILLI";
11937 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11939 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11941 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11943 if (type
== STT_HP_OPAQUE
)
11944 return "HP_OPAQUE";
11945 if (type
== STT_HP_STUB
)
11949 if (type
== STT_GNU_IFUNC
11950 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11951 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11954 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11957 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11962 static const char *
11963 get_symbol_visibility (unsigned int visibility
)
11965 switch (visibility
)
11967 case STV_DEFAULT
: return "DEFAULT";
11968 case STV_INTERNAL
: return "INTERNAL";
11969 case STV_HIDDEN
: return "HIDDEN";
11970 case STV_PROTECTED
: return "PROTECTED";
11972 error (_("Unrecognized visibility value: %u\n"), visibility
);
11973 return _("<unknown>");
11977 static const char *
11978 get_alpha_symbol_other (unsigned int other
)
11982 case STO_ALPHA_NOPV
: return "NOPV";
11983 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11985 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11986 return _("<unknown>");
11990 static const char *
11991 get_solaris_symbol_visibility (unsigned int visibility
)
11993 switch (visibility
)
11995 case 4: return "EXPORTED";
11996 case 5: return "SINGLETON";
11997 case 6: return "ELIMINATE";
11998 default: return get_symbol_visibility (visibility
);
12002 static const char *
12003 get_aarch64_symbol_other (unsigned int other
)
12005 static char buf
[32];
12007 if (other
& STO_AARCH64_VARIANT_PCS
)
12009 other
&= ~STO_AARCH64_VARIANT_PCS
;
12011 return "VARIANT_PCS";
12012 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
12018 static const char *
12019 get_mips_symbol_other (unsigned int other
)
12023 case STO_OPTIONAL
: return "OPTIONAL";
12024 case STO_MIPS_PLT
: return "MIPS PLT";
12025 case STO_MIPS_PIC
: return "MIPS PIC";
12026 case STO_MICROMIPS
: return "MICROMIPS";
12027 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
12028 case STO_MIPS16
: return "MIPS16";
12029 default: return NULL
;
12033 static const char *
12034 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
12036 if (is_ia64_vms (filedata
))
12038 static char res
[32];
12042 /* Function types is for images and .STB files only. */
12043 switch (filedata
->file_header
.e_type
)
12047 switch (VMS_ST_FUNC_TYPE (other
))
12049 case VMS_SFT_CODE_ADDR
:
12050 strcat (res
, " CA");
12052 case VMS_SFT_SYMV_IDX
:
12053 strcat (res
, " VEC");
12056 strcat (res
, " FD");
12058 case VMS_SFT_RESERVE
:
12059 strcat (res
, " RSV");
12062 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
12063 VMS_ST_FUNC_TYPE (other
));
12064 strcat (res
, " <unknown>");
12071 switch (VMS_ST_LINKAGE (other
))
12073 case VMS_STL_IGNORE
:
12074 strcat (res
, " IGN");
12076 case VMS_STL_RESERVE
:
12077 strcat (res
, " RSV");
12080 strcat (res
, " STD");
12083 strcat (res
, " LNK");
12086 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
12087 VMS_ST_LINKAGE (other
));
12088 strcat (res
, " <unknown>");
12100 static const char *
12101 get_ppc64_symbol_other (unsigned int other
)
12103 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
12106 other
>>= STO_PPC64_LOCAL_BIT
;
12109 static char buf
[64];
12111 other
= ppc64_decode_local_entry (other
);
12112 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
12118 static const char *
12119 get_symbol_other (Filedata
* filedata
, unsigned int other
)
12121 const char * result
= NULL
;
12122 static char buff
[64];
12127 switch (filedata
->file_header
.e_machine
)
12130 result
= get_alpha_symbol_other (other
);
12133 result
= get_aarch64_symbol_other (other
);
12136 result
= get_mips_symbol_other (other
);
12139 result
= get_ia64_symbol_other (filedata
, other
);
12142 result
= get_ppc64_symbol_other (other
);
12152 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
12156 static const char *
12157 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
12159 static char buff
[32];
12163 case SHN_UNDEF
: return "UND";
12164 case SHN_ABS
: return "ABS";
12165 case SHN_COMMON
: return "COM";
12167 if (type
== SHN_IA_64_ANSI_COMMON
12168 && filedata
->file_header
.e_machine
== EM_IA_64
12169 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12171 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12172 || filedata
->file_header
.e_machine
== EM_L1OM
12173 || filedata
->file_header
.e_machine
== EM_K1OM
)
12174 && type
== SHN_X86_64_LCOMMON
)
12175 return "LARGE_COM";
12176 else if ((type
== SHN_MIPS_SCOMMON
12177 && filedata
->file_header
.e_machine
== EM_MIPS
)
12178 || (type
== SHN_TIC6X_SCOMMON
12179 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12181 else if (type
== SHN_MIPS_SUNDEFINED
12182 && filedata
->file_header
.e_machine
== EM_MIPS
)
12184 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12185 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12186 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12187 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12188 else if (type
>= SHN_LORESERVE
)
12189 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12190 else if (filedata
->file_header
.e_shnum
!= 0
12191 && type
>= filedata
->file_header
.e_shnum
)
12192 sprintf (buff
, _("bad section index[%3d]"), type
);
12194 sprintf (buff
, "%3d", type
);
12201 static const char *
12202 get_symbol_version_string (Filedata
* filedata
,
12204 const char * strtab
,
12205 unsigned long int strtab_size
,
12207 Elf_Internal_Sym
* psym
,
12208 enum versioned_symbol_info
* sym_info
,
12209 unsigned short * vna_other
)
12211 unsigned char data
[2];
12212 unsigned short vers_data
;
12213 unsigned long offset
;
12214 unsigned short max_vd_ndx
;
12217 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12220 offset
= offset_from_vma (filedata
,
12221 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12222 sizeof data
+ si
* sizeof (vers_data
));
12224 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12225 sizeof (data
), 1, _("version data")) == NULL
)
12228 vers_data
= byte_get (data
, 2);
12230 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12233 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12236 /* Usually we'd only see verdef for defined symbols, and verneed for
12237 undefined symbols. However, symbols defined by the linker in
12238 .dynbss for variables copied from a shared library in order to
12239 avoid text relocations are defined yet have verneed. We could
12240 use a heuristic to detect the special case, for example, check
12241 for verneed first on symbols defined in SHT_NOBITS sections, but
12242 it is simpler and more reliable to just look for both verdef and
12243 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12245 if (psym
->st_shndx
!= SHN_UNDEF
12246 && vers_data
!= 0x8001
12247 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12249 Elf_Internal_Verdef ivd
;
12250 Elf_Internal_Verdaux ivda
;
12251 Elf_External_Verdaux evda
;
12254 off
= offset_from_vma (filedata
,
12255 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12256 sizeof (Elf_External_Verdef
));
12260 Elf_External_Verdef evd
;
12262 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12263 _("version def")) == NULL
)
12272 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12273 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12274 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12275 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12278 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12279 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12281 off
+= ivd
.vd_next
;
12283 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12285 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12287 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12290 off
-= ivd
.vd_next
;
12293 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12294 _("version def aux")) != NULL
)
12296 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12298 if (psym
->st_name
!= ivda
.vda_name
)
12299 return (ivda
.vda_name
< strtab_size
12300 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12305 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12307 Elf_External_Verneed evn
;
12308 Elf_Internal_Verneed ivn
;
12309 Elf_Internal_Vernaux ivna
;
12311 offset
= offset_from_vma (filedata
,
12312 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12316 unsigned long vna_off
;
12318 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12319 _("version need")) == NULL
)
12322 ivna
.vna_other
= 0;
12327 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12328 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12330 vna_off
= offset
+ ivn
.vn_aux
;
12334 Elf_External_Vernaux evna
;
12336 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12337 _("version need aux (3)")) == NULL
)
12340 ivna
.vna_other
= 0;
12345 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12346 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12347 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12350 vna_off
+= ivna
.vna_next
;
12352 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12354 if (ivna
.vna_other
== vers_data
)
12357 offset
+= ivn
.vn_next
;
12359 while (ivn
.vn_next
!= 0);
12361 if (ivna
.vna_other
== vers_data
)
12363 *sym_info
= symbol_undefined
;
12364 *vna_other
= ivna
.vna_other
;
12365 return (ivna
.vna_name
< strtab_size
12366 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12368 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12369 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12370 return _("<corrupt>");
12376 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12377 Elf_Internal_Sym
*symtab
,
12378 Elf_Internal_Shdr
*section
,
12379 char *strtab
, size_t strtab_size
)
12381 const char *version_string
;
12382 enum versioned_symbol_info sym_info
;
12383 unsigned short vna_other
;
12384 Elf_Internal_Sym
*psym
= symtab
+ si
;
12386 printf ("%6ld: ", si
);
12387 print_vma (psym
->st_value
, LONG_HEX
);
12389 print_vma (psym
->st_size
, DEC_5
);
12390 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12391 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12392 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12393 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12396 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12398 printf (" %-7s", get_symbol_visibility (vis
));
12399 /* Check to see if any other bits in the st_other field are set.
12400 Note - displaying this information disrupts the layout of the
12401 table being generated, but for the moment this case is very rare. */
12402 if (psym
->st_other
^ vis
)
12403 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12405 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12407 bool is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
, psym
->st_name
);
12408 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12411 = get_symbol_version_string (filedata
,
12413 || section
->sh_type
== SHT_DYNSYM
),
12414 strtab
, strtab_size
, si
,
12415 psym
, &sym_info
, &vna_other
);
12417 int len_avail
= 21;
12418 if (! do_wide
&& version_string
!= NULL
)
12422 len_avail
-= 1 + strlen (version_string
);
12424 if (sym_info
== symbol_undefined
)
12425 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12426 else if (sym_info
!= symbol_hidden
)
12430 print_symbol (len_avail
, sstr
);
12432 if (version_string
)
12434 if (sym_info
== symbol_undefined
)
12435 printf ("@%s (%d)", version_string
, vna_other
);
12437 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12443 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12445 && si
>= section
->sh_info
12446 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12447 && filedata
->file_header
.e_machine
!= EM_MIPS
12448 /* Solaris binaries have been found to violate this requirement as
12449 well. Not sure if this is a bug or an ABI requirement. */
12450 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12451 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12452 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12455 static const char *
12456 get_lto_kind (unsigned int kind
)
12460 case 0: return "DEF";
12461 case 1: return "WEAKDEF";
12462 case 2: return "UNDEF";
12463 case 3: return "WEAKUNDEF";
12464 case 4: return "COMMON";
12469 static char buffer
[30];
12470 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12471 sprintf (buffer
, "<unknown: %u>", kind
);
12475 static const char *
12476 get_lto_visibility (unsigned int visibility
)
12478 switch (visibility
)
12480 case 0: return "DEFAULT";
12481 case 1: return "PROTECTED";
12482 case 2: return "INTERNAL";
12483 case 3: return "HIDDEN";
12488 static char buffer
[30];
12489 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12490 sprintf (buffer
, "<unknown: %u>", visibility
);
12494 static const char *
12495 get_lto_sym_type (unsigned int sym_type
)
12499 case 0: return "UNKNOWN";
12500 case 1: return "FUNCTION";
12501 case 2: return "VARIABLE";
12506 static char buffer
[30];
12507 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12508 sprintf (buffer
, "<unknown: %u>", sym_type
);
12512 /* Display an LTO format symbol table.
12513 FIXME: The format of LTO symbol tables is not formalized.
12514 So this code could need changing in the future. */
12517 display_lto_symtab (Filedata
* filedata
,
12518 Elf_Internal_Shdr
* section
)
12520 if (section
->sh_size
== 0)
12522 if (filedata
->is_separate
)
12523 printf (_("\nThe LTO Symbol table section '%s' in linked file '%s' is empty!\n"),
12524 printable_section_name (filedata
, section
),
12525 filedata
->file_name
);
12527 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12528 printable_section_name (filedata
, section
));
12533 if (section
->sh_size
> filedata
->file_size
)
12535 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12536 printable_section_name (filedata
, section
),
12537 (unsigned long) section
->sh_size
);
12541 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12542 section
->sh_size
, 1, _("LTO symbols"));
12543 if (alloced_data
== NULL
)
12546 /* Look for extended data for the symbol table. */
12547 Elf_Internal_Shdr
* ext
;
12548 void * ext_data_orig
= NULL
;
12549 char * ext_data
= NULL
;
12550 char * ext_data_end
= NULL
;
12551 char * ext_name
= NULL
;
12553 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12554 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12555 && ext_name
!= NULL
/* Paranoia. */
12556 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12558 if (ext
->sh_size
< 3)
12559 error (_("LTO Symbol extension table '%s' is empty!\n"),
12560 printable_section_name (filedata
, ext
));
12563 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12565 _("LTO ext symbol data"));
12566 if (ext_data
!= NULL
)
12568 ext_data_end
= ext_data
+ ext
->sh_size
;
12569 if (* ext_data
++ != 1)
12570 error (_("Unexpected version number in symbol extension table\n"));
12575 const unsigned char * data
= (const unsigned char *) alloced_data
;
12576 const unsigned char * end
= data
+ section
->sh_size
;
12578 if (filedata
->is_separate
)
12579 printf (_("\nIn linked file '%s': "), filedata
->file_name
);
12583 if (ext_data_orig
!= NULL
)
12586 printf (_("LTO Symbol table '%s' and extension table '%s' contain:\n"),
12587 printable_section_name (filedata
, section
),
12588 printable_section_name (filedata
, ext
));
12591 printf (_("LTO Symbol table '%s'\n"),
12592 printable_section_name (filedata
, section
));
12593 printf (_(" and extension table '%s' contain:\n"),
12594 printable_section_name (filedata
, ext
));
12598 printf (_("LTO Symbol table '%s' contains:\n"),
12599 printable_section_name (filedata
, section
));
12601 /* FIXME: Add a wide version. */
12602 if (ext_data_orig
!= NULL
)
12603 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12605 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12607 /* FIXME: We do not handle style prefixes. */
12611 const unsigned char * sym_name
= data
;
12612 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12616 const unsigned char * comdat_key
= data
;
12617 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12621 if (data
+ 2 + 8 + 4 > end
)
12624 unsigned int kind
= *data
++;
12625 unsigned int visibility
= *data
++;
12627 elf_vma size
= byte_get (data
, 8);
12630 elf_vma slot
= byte_get (data
, 4);
12633 if (ext_data
!= NULL
)
12635 if (ext_data
< (ext_data_end
- 1))
12637 unsigned int sym_type
= * ext_data
++;
12638 unsigned int sec_kind
= * ext_data
++;
12640 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12641 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12642 get_lto_kind (kind
),
12643 get_lto_visibility (visibility
),
12646 get_lto_sym_type (sym_type
),
12648 print_symbol (6, (const char *) sym_name
);
12652 error (_("Ran out of LTO symbol extension data\n"));
12654 /* FIXME: return FAIL result ? */
12659 printf (" %10s %10s %11s %08lx %08lx _",
12660 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12661 get_lto_kind (kind
),
12662 get_lto_visibility (visibility
),
12665 print_symbol (21, (const char *) sym_name
);
12670 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12672 error (_("Data remains in the LTO symbol extension table\n"));
12676 free (alloced_data
);
12677 free (ext_data_orig
);
12682 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12683 free (alloced_data
);
12684 free (ext_data_orig
);
12689 /* Display LTO symbol tables. */
12692 process_lto_symbol_tables (Filedata
* filedata
)
12694 Elf_Internal_Shdr
* section
;
12701 if (filedata
->section_headers
== NULL
)
12704 for (i
= 0, section
= filedata
->section_headers
;
12705 i
< filedata
->file_header
.e_shnum
;
12707 if (SECTION_NAME_VALID (section
)
12708 && startswith (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12709 res
&= display_lto_symtab (filedata
, section
);
12714 /* Dump the symbol table. */
12717 process_symbol_table (Filedata
* filedata
)
12719 Elf_Internal_Shdr
* section
;
12721 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12724 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12726 && do_using_dynamic
12727 && filedata
->dynamic_strings
!= NULL
12728 && filedata
->dynamic_symbols
!= NULL
)
12732 if (filedata
->is_separate
)
12734 printf (ngettext ("\nIn linked file '%s' the dynamic symbol table contains %lu entry:\n",
12735 "\nIn linked file '%s' the dynamic symbol table contains %lu entries:\n",
12736 filedata
->num_dynamic_syms
),
12737 filedata
->file_name
,
12738 filedata
->num_dynamic_syms
);
12742 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12743 "\nSymbol table for image contains %lu entries:\n",
12744 filedata
->num_dynamic_syms
),
12745 filedata
->num_dynamic_syms
);
12748 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12750 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12752 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12753 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12754 filedata
->dynamic_strings
,
12755 filedata
->dynamic_strings_length
);
12757 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12758 && filedata
->section_headers
!= NULL
)
12762 for (i
= 0, section
= filedata
->section_headers
;
12763 i
< filedata
->file_header
.e_shnum
;
12766 char * strtab
= NULL
;
12767 unsigned long int strtab_size
= 0;
12768 Elf_Internal_Sym
* symtab
;
12769 unsigned long si
, num_syms
;
12771 if ((section
->sh_type
!= SHT_SYMTAB
12772 && section
->sh_type
!= SHT_DYNSYM
)
12774 && section
->sh_type
== SHT_SYMTAB
))
12777 if (section
->sh_entsize
== 0)
12779 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12780 printable_section_name (filedata
, section
));
12784 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12786 if (filedata
->is_separate
)
12787 printf (ngettext ("\nIn linked file '%s' symbol section '%s' contains %lu entry:\n",
12788 "\nIn linked file '%s' symbol section '%s' contains %lu entries:\n",
12790 filedata
->file_name
,
12791 printable_section_name (filedata
, section
),
12794 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12795 "\nSymbol table '%s' contains %lu entries:\n",
12797 printable_section_name (filedata
, section
),
12801 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12803 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12805 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12806 if (symtab
== NULL
)
12809 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12811 strtab
= filedata
->string_table
;
12812 strtab_size
= filedata
->string_table_length
;
12814 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12816 Elf_Internal_Shdr
* string_sec
;
12818 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12820 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12821 1, string_sec
->sh_size
,
12822 _("string table"));
12823 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12826 for (si
= 0; si
< num_syms
; si
++)
12827 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12828 strtab
, strtab_size
);
12831 if (strtab
!= filedata
->string_table
)
12837 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12839 if (do_histogram
&& filedata
->buckets
!= NULL
)
12841 unsigned long * lengths
;
12842 unsigned long * counts
;
12845 unsigned long maxlength
= 0;
12846 unsigned long nzero_counts
= 0;
12847 unsigned long nsyms
= 0;
12850 printf (ngettext ("\nHistogram for bucket list length "
12851 "(total of %lu bucket):\n",
12852 "\nHistogram for bucket list length "
12853 "(total of %lu buckets):\n",
12854 (unsigned long) filedata
->nbuckets
),
12855 (unsigned long) filedata
->nbuckets
);
12857 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12858 sizeof (*lengths
));
12859 if (lengths
== NULL
)
12861 error (_("Out of memory allocating space for histogram buckets\n"));
12864 visited
= xcmalloc (filedata
->nchains
, 1);
12865 memset (visited
, 0, filedata
->nchains
);
12867 printf (_(" Length Number %% of total Coverage\n"));
12868 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12870 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12873 if (maxlength
< ++lengths
[hn
])
12875 if (si
>= filedata
->nchains
|| visited
[si
])
12877 error (_("histogram chain is corrupt\n"));
12885 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12886 if (counts
== NULL
)
12889 error (_("Out of memory allocating space for histogram counts\n"));
12893 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12894 ++counts
[lengths
[hn
]];
12896 if (filedata
->nbuckets
> 0)
12899 printf (" 0 %-10lu (%5.1f%%)\n",
12900 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12901 for (i
= 1; i
<= maxlength
; ++i
)
12903 nzero_counts
+= counts
[i
] * i
;
12904 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12905 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12906 (nzero_counts
* 100.0) / nsyms
);
12914 free (filedata
->buckets
);
12915 filedata
->buckets
= NULL
;
12916 filedata
->nbuckets
= 0;
12917 free (filedata
->chains
);
12918 filedata
->chains
= NULL
;
12920 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12922 unsigned long * lengths
;
12923 unsigned long * counts
;
12925 unsigned long maxlength
= 0;
12926 unsigned long nzero_counts
= 0;
12927 unsigned long nsyms
= 0;
12929 printf (ngettext ("\nHistogram for `%s' bucket list length "
12930 "(total of %lu bucket):\n",
12931 "\nHistogram for `%s' bucket list length "
12932 "(total of %lu buckets):\n",
12933 (unsigned long) filedata
->ngnubuckets
),
12934 GNU_HASH_SECTION_NAME (filedata
),
12935 (unsigned long) filedata
->ngnubuckets
);
12937 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12938 sizeof (*lengths
));
12939 if (lengths
== NULL
)
12941 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12945 printf (_(" Length Number %% of total Coverage\n"));
12947 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12948 if (filedata
->gnubuckets
[hn
] != 0)
12950 bfd_vma off
, length
= 1;
12952 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12953 /* PR 17531 file: 010-77222-0.004. */
12954 off
< filedata
->ngnuchains
12955 && (filedata
->gnuchains
[off
] & 1) == 0;
12958 lengths
[hn
] = length
;
12959 if (length
> maxlength
)
12960 maxlength
= length
;
12964 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12965 if (counts
== NULL
)
12968 error (_("Out of memory allocating space for gnu histogram counts\n"));
12972 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12973 ++counts
[lengths
[hn
]];
12975 if (filedata
->ngnubuckets
> 0)
12978 printf (" 0 %-10lu (%5.1f%%)\n",
12979 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12980 for (j
= 1; j
<= maxlength
; ++j
)
12982 nzero_counts
+= counts
[j
] * j
;
12983 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12984 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12985 (nzero_counts
* 100.0) / nsyms
);
12992 free (filedata
->gnubuckets
);
12993 filedata
->gnubuckets
= NULL
;
12994 filedata
->ngnubuckets
= 0;
12995 free (filedata
->gnuchains
);
12996 filedata
->gnuchains
= NULL
;
12997 filedata
->ngnuchains
= 0;
12998 free (filedata
->mipsxlat
);
12999 filedata
->mipsxlat
= NULL
;
13003 free (filedata
->gnubuckets
);
13004 filedata
->gnubuckets
= NULL
;
13005 filedata
->ngnubuckets
= 0;
13006 free (filedata
->gnuchains
);
13007 filedata
->gnuchains
= NULL
;
13008 filedata
->ngnuchains
= 0;
13009 free (filedata
->mipsxlat
);
13010 filedata
->mipsxlat
= NULL
;
13011 free (filedata
->buckets
);
13012 filedata
->buckets
= NULL
;
13013 filedata
->nbuckets
= 0;
13014 free (filedata
->chains
);
13015 filedata
->chains
= NULL
;
13020 process_syminfo (Filedata
* filedata
)
13024 if (filedata
->dynamic_syminfo
== NULL
13026 /* No syminfo, this is ok. */
13029 /* There better should be a dynamic symbol section. */
13030 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
13033 if (filedata
->is_separate
)
13034 printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
13035 "\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entries:\n",
13036 filedata
->dynamic_syminfo_nent
),
13037 filedata
->file_name
,
13038 filedata
->dynamic_syminfo_offset
,
13039 filedata
->dynamic_syminfo_nent
);
13041 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
13042 "contains %d entry:\n",
13043 "\nDynamic info segment at offset 0x%lx "
13044 "contains %d entries:\n",
13045 filedata
->dynamic_syminfo_nent
),
13046 filedata
->dynamic_syminfo_offset
,
13047 filedata
->dynamic_syminfo_nent
);
13049 printf (_(" Num: Name BoundTo Flags\n"));
13050 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
13052 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
13054 printf ("%4d: ", i
);
13055 if (i
>= filedata
->num_dynamic_syms
)
13056 printf (_("<corrupt index>"));
13057 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
13058 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
13059 filedata
->dynamic_symbols
[i
].st_name
));
13061 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
13064 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
13066 case SYMINFO_BT_SELF
:
13067 fputs ("SELF ", stdout
);
13069 case SYMINFO_BT_PARENT
:
13070 fputs ("PARENT ", stdout
);
13073 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
13074 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
13075 && VALID_DYNAMIC_NAME (filedata
,
13076 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
13078 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
13079 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
13083 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
13087 if (flags
& SYMINFO_FLG_DIRECT
)
13088 printf (" DIRECT");
13089 if (flags
& SYMINFO_FLG_PASSTHRU
)
13090 printf (" PASSTHRU");
13091 if (flags
& SYMINFO_FLG_COPY
)
13093 if (flags
& SYMINFO_FLG_LAZYLOAD
)
13094 printf (" LAZYLOAD");
13102 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
13103 is contained by the region START .. END. The types of ADDR, START
13104 and END should all be the same. Note both ADDR + NELEM and END
13105 point to just beyond the end of the regions that are being tested. */
13106 #define IN_RANGE(START,END,ADDR,NELEM) \
13107 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
13109 /* Check to see if the given reloc needs to be handled in a target specific
13110 manner. If so then process the reloc and return TRUE otherwise return
13113 If called with reloc == NULL, then this is a signal that reloc processing
13114 for the current section has finished, and any saved state should be
13118 target_specific_reloc_handling (Filedata
* filedata
,
13119 Elf_Internal_Rela
* reloc
,
13120 unsigned char * start
,
13121 unsigned char * end
,
13122 Elf_Internal_Sym
* symtab
,
13123 unsigned long num_syms
)
13125 unsigned int reloc_type
= 0;
13126 unsigned long sym_index
= 0;
13130 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
13131 sym_index
= get_reloc_symindex (reloc
->r_info
);
13134 switch (filedata
->file_header
.e_machine
)
13137 case EM_MSP430_OLD
:
13139 static Elf_Internal_Sym
* saved_sym
= NULL
;
13147 switch (reloc_type
)
13149 case 10: /* R_MSP430_SYM_DIFF */
13150 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
13151 if (uses_msp430x_relocs (filedata
))
13153 /* Fall through. */
13154 case 21: /* R_MSP430X_SYM_DIFF */
13155 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
13157 if (sym_index
>= num_syms
)
13158 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
13161 saved_sym
= symtab
+ sym_index
;
13164 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13165 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
13166 goto handle_sym_diff
;
13168 case 5: /* R_MSP430_16_BYTE */
13169 case 9: /* R_MSP430_8 */
13170 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13171 if (uses_msp430x_relocs (filedata
))
13173 goto handle_sym_diff
;
13175 case 2: /* R_MSP430_ABS16 */
13176 case 15: /* R_MSP430X_ABS16 */
13177 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13178 if (! uses_msp430x_relocs (filedata
))
13180 goto handle_sym_diff
;
13183 if (saved_sym
!= NULL
)
13186 unsigned int reloc_size
= 0;
13188 switch (reloc_type
)
13190 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
13193 case 11: /* R_MSP430_GNU_SET_ULEB128 */
13194 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
13195 if (reloc
->r_offset
< (size_t) (end
- start
))
13196 read_leb128 (start
+ reloc
->r_offset
, end
, false,
13197 &reloc_size
, &leb_ret
);
13204 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13205 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13206 "ULEB128 value\n"),
13207 (long) reloc
->r_offset
);
13208 else if (sym_index
>= num_syms
)
13209 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13213 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13214 - saved_sym
->st_value
);
13216 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13217 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13220 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13221 (long) reloc
->r_offset
);
13230 if (saved_sym
!= NULL
)
13231 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13238 case EM_CYGNUS_MN10300
:
13240 static Elf_Internal_Sym
* saved_sym
= NULL
;
13248 switch (reloc_type
)
13250 case 34: /* R_MN10300_ALIGN */
13252 case 33: /* R_MN10300_SYM_DIFF */
13253 if (sym_index
>= num_syms
)
13254 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13257 saved_sym
= symtab
+ sym_index
;
13260 case 1: /* R_MN10300_32 */
13261 case 2: /* R_MN10300_16 */
13262 if (saved_sym
!= NULL
)
13264 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13267 if (sym_index
>= num_syms
)
13268 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13272 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13273 - saved_sym
->st_value
);
13275 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13276 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13278 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13279 (long) reloc
->r_offset
);
13287 if (saved_sym
!= NULL
)
13288 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13296 static bfd_vma saved_sym1
= 0;
13297 static bfd_vma saved_sym2
= 0;
13298 static bfd_vma value
;
13302 saved_sym1
= saved_sym2
= 0;
13306 switch (reloc_type
)
13308 case 0x80: /* R_RL78_SYM. */
13309 saved_sym1
= saved_sym2
;
13310 if (sym_index
>= num_syms
)
13311 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13315 saved_sym2
= symtab
[sym_index
].st_value
;
13316 saved_sym2
+= reloc
->r_addend
;
13320 case 0x83: /* R_RL78_OPsub. */
13321 value
= saved_sym1
- saved_sym2
;
13322 saved_sym2
= saved_sym1
= 0;
13326 case 0x41: /* R_RL78_ABS32. */
13327 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13328 byte_put (start
+ reloc
->r_offset
, value
, 4);
13330 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13331 (long) reloc
->r_offset
);
13335 case 0x43: /* R_RL78_ABS16. */
13336 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13337 byte_put (start
+ reloc
->r_offset
, value
, 2);
13339 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13340 (long) reloc
->r_offset
);
13354 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13355 DWARF debug sections. This is a target specific test. Note - we do not
13356 go through the whole including-target-headers-multiple-times route, (as
13357 we have already done with <elf/h8.h>) because this would become very
13358 messy and even then this function would have to contain target specific
13359 information (the names of the relocs instead of their numeric values).
13360 FIXME: This is not the correct way to solve this problem. The proper way
13361 is to have target specific reloc sizing and typing functions created by
13362 the reloc-macros.h header, in the same way that it already creates the
13363 reloc naming functions. */
13366 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13368 /* Please keep this table alpha-sorted for ease of visual lookup. */
13369 switch (filedata
->file_header
.e_machine
)
13373 return reloc_type
== 1; /* R_386_32. */
13375 return reloc_type
== 1; /* R_68K_32. */
13377 return reloc_type
== 1; /* R_860_32. */
13379 return reloc_type
== 2; /* R_960_32. */
13381 return (reloc_type
== 258
13382 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13384 return reloc_type
== 11; /* R_BPF_DATA_32 */
13385 case EM_ADAPTEVA_EPIPHANY
:
13386 return reloc_type
== 3;
13388 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13390 return reloc_type
== 1; /* R_ARC_32. */
13391 case EM_ARC_COMPACT
:
13392 case EM_ARC_COMPACT2
:
13393 return reloc_type
== 4; /* R_ARC_32. */
13395 return reloc_type
== 2; /* R_ARM_ABS32 */
13398 return reloc_type
== 1;
13400 return reloc_type
== 0x12; /* R_byte4_data. */
13402 return reloc_type
== 3; /* R_CRIS_32. */
13404 return reloc_type
== 3; /* R_CR16_NUM32. */
13406 return reloc_type
== 15; /* R_CRX_NUM32. */
13408 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13409 case EM_CYGNUS_FRV
:
13410 return reloc_type
== 1;
13411 case EM_CYGNUS_D10V
:
13413 return reloc_type
== 6; /* R_D10V_32. */
13414 case EM_CYGNUS_D30V
:
13416 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13418 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13419 case EM_CYGNUS_FR30
:
13421 return reloc_type
== 3; /* R_FR30_32. */
13423 return reloc_type
== 1; /* R_FT32_32. */
13427 return reloc_type
== 1; /* R_H8_DIR32. */
13429 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13430 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13431 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13432 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13435 return reloc_type
== 2; /* R_IP2K_32. */
13437 return reloc_type
== 2; /* R_IQ2000_32. */
13438 case EM_LATTICEMICO32
:
13439 return reloc_type
== 3; /* R_LM32_32. */
13442 return reloc_type
== 3; /* R_M32C_32. */
13444 return reloc_type
== 34; /* R_M32R_32_RELA. */
13447 return reloc_type
== 6; /* R_M68HC11_32. */
13449 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13450 reloc_type
== 6; /* R_S12Z_CW32. */
13452 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13453 case EM_CYGNUS_MEP
:
13454 return reloc_type
== 4; /* R_MEP_32. */
13456 return reloc_type
== 2; /* R_METAG_ADDR32. */
13457 case EM_MICROBLAZE
:
13458 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13460 return reloc_type
== 2; /* R_MIPS_32. */
13462 return reloc_type
== 4; /* R_MMIX_32. */
13463 case EM_CYGNUS_MN10200
:
13465 return reloc_type
== 1; /* R_MN10200_32. */
13466 case EM_CYGNUS_MN10300
:
13468 return reloc_type
== 1; /* R_MN10300_32. */
13470 return reloc_type
== 1; /* R_MOXIE_32. */
13471 case EM_MSP430_OLD
:
13473 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13475 return reloc_type
== 2; /* R_MT_32. */
13477 return reloc_type
== 20; /* R_NDS32_RELA. */
13478 case EM_ALTERA_NIOS2
:
13479 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13481 return reloc_type
== 1; /* R_NIOS_32. */
13483 return reloc_type
== 1; /* R_OR1K_32. */
13485 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13486 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13487 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13490 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13492 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13494 return reloc_type
== 1; /* R_PPC_ADDR32. */
13496 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13498 return reloc_type
== 1; /* R_RISCV_32. */
13500 return reloc_type
== 1; /* R_RL78_DIR32. */
13502 return reloc_type
== 1; /* R_RX_DIR32. */
13504 return reloc_type
== 1; /* R_I370_ADDR31. */
13507 return reloc_type
== 4; /* R_S390_32. */
13509 return reloc_type
== 8; /* R_SCORE_ABS32. */
13511 return reloc_type
== 1; /* R_SH_DIR32. */
13512 case EM_SPARC32PLUS
:
13515 return reloc_type
== 3 /* R_SPARC_32. */
13516 || reloc_type
== 23; /* R_SPARC_UA32. */
13518 return reloc_type
== 6; /* R_SPU_ADDR32 */
13520 return reloc_type
== 1; /* R_C6000_ABS32. */
13522 return reloc_type
== 2; /* R_TILEGX_32. */
13524 return reloc_type
== 1; /* R_TILEPRO_32. */
13525 case EM_CYGNUS_V850
:
13527 return reloc_type
== 6; /* R_V850_ABS32. */
13529 return reloc_type
== 0x33; /* R_V810_WORD. */
13531 return reloc_type
== 1; /* R_VAX_32. */
13533 return reloc_type
== 3; /* R_VISIUM_32. */
13534 case EM_WEBASSEMBLY
:
13535 return reloc_type
== 1; /* R_WASM32_32. */
13539 return reloc_type
== 10; /* R_X86_64_32. */
13542 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13544 return reloc_type
== 4; /* R_XGATE_32. */
13546 return reloc_type
== 1; /* R_XSTROMY16_32. */
13547 case EM_XTENSA_OLD
:
13549 return reloc_type
== 1; /* R_XTENSA_32. */
13551 return reloc_type
== 6; /* R_Z80_32. */
13554 static unsigned int prev_warn
= 0;
13556 /* Avoid repeating the same warning multiple times. */
13557 if (prev_warn
!= filedata
->file_header
.e_machine
)
13558 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13559 filedata
->file_header
.e_machine
);
13560 prev_warn
= filedata
->file_header
.e_machine
;
13566 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13567 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13570 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13572 switch (filedata
->file_header
.e_machine
)
13573 /* Please keep this table alpha-sorted for ease of visual lookup. */
13577 return reloc_type
== 2; /* R_386_PC32. */
13579 return reloc_type
== 4; /* R_68K_PC32. */
13581 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13582 case EM_ADAPTEVA_EPIPHANY
:
13583 return reloc_type
== 6;
13585 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13586 case EM_ARC_COMPACT
:
13587 case EM_ARC_COMPACT2
:
13588 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13590 return reloc_type
== 3; /* R_ARM_REL32 */
13593 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13594 case EM_MICROBLAZE
:
13595 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13597 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13599 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13601 return reloc_type
== 26; /* R_PPC_REL32. */
13603 return reloc_type
== 26; /* R_PPC64_REL32. */
13605 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13608 return reloc_type
== 5; /* R_390_PC32. */
13610 return reloc_type
== 2; /* R_SH_REL32. */
13611 case EM_SPARC32PLUS
:
13614 return reloc_type
== 6; /* R_SPARC_DISP32. */
13616 return reloc_type
== 13; /* R_SPU_REL32. */
13618 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13620 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13622 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13626 return reloc_type
== 2; /* R_X86_64_PC32. */
13628 return reloc_type
== 4; /* R_VAX_PCREL32. */
13629 case EM_XTENSA_OLD
:
13631 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13633 /* Do not abort or issue an error message here. Not all targets use
13634 pc-relative 32-bit relocs in their DWARF debug information and we
13635 have already tested for target coverage in is_32bit_abs_reloc. A
13636 more helpful warning message will be generated by apply_relocations
13637 anyway, so just return. */
13642 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13643 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13646 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13648 switch (filedata
->file_header
.e_machine
)
13651 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13653 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13655 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13656 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13658 return reloc_type
== 80; /* R_PARISC_DIR64. */
13660 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13662 return reloc_type
== 2; /* R_RISCV_64. */
13663 case EM_SPARC32PLUS
:
13666 return reloc_type
== 32 /* R_SPARC_64. */
13667 || reloc_type
== 54; /* R_SPARC_UA64. */
13671 return reloc_type
== 1; /* R_X86_64_64. */
13674 return reloc_type
== 22; /* R_S390_64. */
13676 return reloc_type
== 1; /* R_TILEGX_64. */
13678 return reloc_type
== 18; /* R_MIPS_64. */
13684 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13685 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13688 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13690 switch (filedata
->file_header
.e_machine
)
13693 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13695 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13697 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13698 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13700 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13702 return reloc_type
== 44; /* R_PPC64_REL64. */
13703 case EM_SPARC32PLUS
:
13706 return reloc_type
== 46; /* R_SPARC_DISP64. */
13710 return reloc_type
== 24; /* R_X86_64_PC64. */
13713 return reloc_type
== 23; /* R_S390_PC64. */
13715 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13721 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13722 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13725 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13727 switch (filedata
->file_header
.e_machine
)
13729 case EM_CYGNUS_MN10200
:
13731 return reloc_type
== 4; /* R_MN10200_24. */
13733 return reloc_type
== 5; /* R_FT32_20. */
13735 return reloc_type
== 5; /* R_Z80_24. */
13741 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13742 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13745 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13747 /* Please keep this table alpha-sorted for ease of visual lookup. */
13748 switch (filedata
->file_header
.e_machine
)
13751 case EM_ARC_COMPACT
:
13752 case EM_ARC_COMPACT2
:
13753 return reloc_type
== 2; /* R_ARC_16. */
13754 case EM_ADAPTEVA_EPIPHANY
:
13755 return reloc_type
== 5;
13758 return reloc_type
== 4; /* R_AVR_16. */
13759 case EM_CYGNUS_D10V
:
13761 return reloc_type
== 3; /* R_D10V_16. */
13763 return reloc_type
== 2; /* R_FT32_16. */
13767 return reloc_type
== R_H8_DIR16
;
13770 return reloc_type
== 1; /* R_IP2K_16. */
13773 return reloc_type
== 1; /* R_M32C_16 */
13774 case EM_CYGNUS_MN10200
:
13776 return reloc_type
== 2; /* R_MN10200_16. */
13777 case EM_CYGNUS_MN10300
:
13779 return reloc_type
== 2; /* R_MN10300_16. */
13781 if (uses_msp430x_relocs (filedata
))
13782 return reloc_type
== 2; /* R_MSP430_ABS16. */
13783 /* Fall through. */
13784 case EM_MSP430_OLD
:
13785 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13787 return reloc_type
== 19; /* R_NDS32_RELA. */
13788 case EM_ALTERA_NIOS2
:
13789 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13791 return reloc_type
== 9; /* R_NIOS_16. */
13793 return reloc_type
== 2; /* R_OR1K_16. */
13795 return reloc_type
== 55; /* R_RISCV_SET16. */
13797 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13799 return reloc_type
== 2; /* R_C6000_ABS16. */
13801 return reloc_type
== 2; /* R_VISIUM_16. */
13804 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13806 return reloc_type
== 3; /* R_XGATE_16. */
13808 return reloc_type
== 4; /* R_Z80_16. */
13814 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13815 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13818 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13820 switch (filedata
->file_header
.e_machine
)
13823 return reloc_type
== 54; /* R_RISCV_SET8. */
13825 return reloc_type
== 1; /* R_Z80_8. */
13831 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13832 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13835 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13837 switch (filedata
->file_header
.e_machine
)
13840 return reloc_type
== 53; /* R_RISCV_SET6. */
13846 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13847 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13850 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13852 /* Please keep this table alpha-sorted for ease of visual lookup. */
13853 switch (filedata
->file_header
.e_machine
)
13856 return reloc_type
== 35; /* R_RISCV_ADD32. */
13862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13863 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13866 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13868 /* Please keep this table alpha-sorted for ease of visual lookup. */
13869 switch (filedata
->file_header
.e_machine
)
13872 return reloc_type
== 39; /* R_RISCV_SUB32. */
13878 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13879 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13882 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13884 /* Please keep this table alpha-sorted for ease of visual lookup. */
13885 switch (filedata
->file_header
.e_machine
)
13888 return reloc_type
== 36; /* R_RISCV_ADD64. */
13894 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13895 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13898 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13900 /* Please keep this table alpha-sorted for ease of visual lookup. */
13901 switch (filedata
->file_header
.e_machine
)
13904 return reloc_type
== 40; /* R_RISCV_SUB64. */
13910 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13911 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13914 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13916 /* Please keep this table alpha-sorted for ease of visual lookup. */
13917 switch (filedata
->file_header
.e_machine
)
13920 return reloc_type
== 34; /* R_RISCV_ADD16. */
13926 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13927 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13930 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13932 /* Please keep this table alpha-sorted for ease of visual lookup. */
13933 switch (filedata
->file_header
.e_machine
)
13936 return reloc_type
== 38; /* R_RISCV_SUB16. */
13942 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13943 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13946 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13948 /* Please keep this table alpha-sorted for ease of visual lookup. */
13949 switch (filedata
->file_header
.e_machine
)
13952 return reloc_type
== 33; /* R_RISCV_ADD8. */
13958 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13959 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13962 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13964 /* Please keep this table alpha-sorted for ease of visual lookup. */
13965 switch (filedata
->file_header
.e_machine
)
13968 return reloc_type
== 37; /* R_RISCV_SUB8. */
13974 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13975 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13978 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13980 switch (filedata
->file_header
.e_machine
)
13983 return reloc_type
== 52; /* R_RISCV_SUB6. */
13989 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13990 relocation entries (possibly formerly used for SHT_GROUP sections). */
13993 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13995 switch (filedata
->file_header
.e_machine
)
13997 case EM_386
: /* R_386_NONE. */
13998 case EM_68K
: /* R_68K_NONE. */
13999 case EM_ADAPTEVA_EPIPHANY
:
14000 case EM_ALPHA
: /* R_ALPHA_NONE. */
14001 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
14002 case EM_ARC
: /* R_ARC_NONE. */
14003 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
14004 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
14005 case EM_ARM
: /* R_ARM_NONE. */
14006 case EM_C166
: /* R_XC16X_NONE. */
14007 case EM_CRIS
: /* R_CRIS_NONE. */
14008 case EM_FT32
: /* R_FT32_NONE. */
14009 case EM_IA_64
: /* R_IA64_NONE. */
14010 case EM_K1OM
: /* R_X86_64_NONE. */
14011 case EM_L1OM
: /* R_X86_64_NONE. */
14012 case EM_M32R
: /* R_M32R_NONE. */
14013 case EM_MIPS
: /* R_MIPS_NONE. */
14014 case EM_MN10300
: /* R_MN10300_NONE. */
14015 case EM_MOXIE
: /* R_MOXIE_NONE. */
14016 case EM_NIOS32
: /* R_NIOS_NONE. */
14017 case EM_OR1K
: /* R_OR1K_NONE. */
14018 case EM_PARISC
: /* R_PARISC_NONE. */
14019 case EM_PPC64
: /* R_PPC64_NONE. */
14020 case EM_PPC
: /* R_PPC_NONE. */
14021 case EM_RISCV
: /* R_RISCV_NONE. */
14022 case EM_S390
: /* R_390_NONE. */
14024 case EM_SH
: /* R_SH_NONE. */
14025 case EM_SPARC32PLUS
:
14026 case EM_SPARC
: /* R_SPARC_NONE. */
14028 case EM_TILEGX
: /* R_TILEGX_NONE. */
14029 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
14030 case EM_TI_C6000
:/* R_C6000_NONE. */
14031 case EM_X86_64
: /* R_X86_64_NONE. */
14033 case EM_Z80
: /* R_Z80_NONE. */
14034 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
14035 return reloc_type
== 0;
14038 return reloc_type
== 0 || reloc_type
== 256;
14041 return (reloc_type
== 0 /* R_AVR_NONE. */
14042 || reloc_type
== 30 /* R_AVR_DIFF8. */
14043 || reloc_type
== 31 /* R_AVR_DIFF16. */
14044 || reloc_type
== 32 /* R_AVR_DIFF32. */);
14046 return reloc_type
== 3; /* R_METAG_NONE. */
14048 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14049 || reloc_type
== 204 /* R_NDS32_DIFF8. */
14050 || reloc_type
== 205 /* R_NDS32_DIFF16. */
14051 || reloc_type
== 206 /* R_NDS32_DIFF32. */
14052 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
14054 return (reloc_type
== 0 /* R_PRU_NONE. */
14055 || reloc_type
== 65 /* R_PRU_DIFF8. */
14056 || reloc_type
== 66 /* R_PRU_DIFF16. */
14057 || reloc_type
== 67 /* R_PRU_DIFF32. */);
14058 case EM_XTENSA_OLD
:
14060 return (reloc_type
== 0 /* R_XTENSA_NONE. */
14061 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
14062 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
14063 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
14064 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
14065 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
14066 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
14067 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
14068 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
14069 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
14074 /* Returns TRUE if there is a relocation against
14075 section NAME at OFFSET bytes. */
14078 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
14080 Elf_Internal_Rela
* relocs
;
14081 Elf_Internal_Rela
* rp
;
14083 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
14086 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
14088 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
14089 if (rp
->r_offset
== offset
)
14095 /* Apply relocations to a section.
14096 Returns TRUE upon success, FALSE otherwise.
14097 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
14098 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
14099 will be set to the number of relocs loaded.
14101 Note: So far support has been added only for those relocations
14102 which can be found in debug sections. FIXME: Add support for
14103 more relocations ? */
14106 apply_relocations (Filedata
* filedata
,
14107 const Elf_Internal_Shdr
* section
,
14108 unsigned char * start
,
14109 bfd_size_type size
,
14110 void ** relocs_return
,
14111 unsigned long * num_relocs_return
)
14113 Elf_Internal_Shdr
* relsec
;
14114 unsigned char * end
= start
+ size
;
14116 if (relocs_return
!= NULL
)
14118 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
14119 * num_relocs_return
= 0;
14122 if (filedata
->file_header
.e_type
!= ET_REL
)
14123 /* No relocs to apply. */
14126 /* Find the reloc section associated with the section. */
14127 for (relsec
= filedata
->section_headers
;
14128 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14132 unsigned long num_relocs
;
14133 Elf_Internal_Rela
* relocs
;
14134 Elf_Internal_Rela
* rp
;
14135 Elf_Internal_Shdr
* symsec
;
14136 Elf_Internal_Sym
* symtab
;
14137 unsigned long num_syms
;
14138 Elf_Internal_Sym
* sym
;
14140 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14141 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14142 || filedata
->section_headers
+ relsec
->sh_info
!= section
14143 || relsec
->sh_size
== 0
14144 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14147 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
14148 if (symsec
->sh_type
!= SHT_SYMTAB
14149 && symsec
->sh_type
!= SHT_DYNSYM
)
14152 is_rela
= relsec
->sh_type
== SHT_RELA
;
14156 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
14157 relsec
->sh_size
, & relocs
, & num_relocs
))
14162 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
14163 relsec
->sh_size
, & relocs
, & num_relocs
))
14167 /* SH uses RELA but uses in place value instead of the addend field. */
14168 if (filedata
->file_header
.e_machine
== EM_SH
)
14171 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
14173 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
14176 unsigned int reloc_type
;
14177 unsigned int reloc_size
;
14178 bool reloc_inplace
= false;
14179 bool reloc_subtract
= false;
14180 unsigned char *rloc
;
14181 unsigned long sym_index
;
14183 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
14185 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
14187 else if (is_none_reloc (filedata
, reloc_type
))
14189 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
14190 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
14192 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
14193 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14195 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
14197 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
14199 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
14200 || is_6bit_abs_reloc (filedata
, reloc_type
))
14202 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14204 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14207 reloc_inplace
= true;
14209 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14211 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14214 reloc_inplace
= true;
14216 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14218 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14221 reloc_inplace
= true;
14223 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14225 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14228 reloc_inplace
= true;
14230 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14234 reloc_inplace
= true;
14238 static unsigned int prev_reloc
= 0;
14240 if (reloc_type
!= prev_reloc
)
14241 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14242 reloc_type
, printable_section_name (filedata
, section
));
14243 prev_reloc
= reloc_type
;
14247 rloc
= start
+ rp
->r_offset
;
14248 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14250 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14251 (unsigned long) rp
->r_offset
,
14252 printable_section_name (filedata
, section
));
14256 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14257 if (sym_index
>= num_syms
)
14259 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14260 sym_index
, printable_section_name (filedata
, section
));
14263 sym
= symtab
+ sym_index
;
14265 /* If the reloc has a symbol associated with it,
14266 make sure that it is of an appropriate type.
14268 Relocations against symbols without type can happen.
14269 Gcc -feliminate-dwarf2-dups may generate symbols
14270 without type for debug info.
14272 Icc generates relocations against function symbols
14273 instead of local labels.
14275 Relocations against object symbols can happen, eg when
14276 referencing a global array. For an example of this see
14277 the _clz.o binary in libgcc.a. */
14279 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14280 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14282 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14283 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14284 printable_section_name (filedata
, relsec
),
14285 (long int)(rp
- relocs
));
14291 addend
+= rp
->r_addend
;
14292 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14293 partial_inplace. */
14295 || (filedata
->file_header
.e_machine
== EM_XTENSA
14296 && reloc_type
== 1)
14297 || ((filedata
->file_header
.e_machine
== EM_PJ
14298 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14299 && reloc_type
== 1)
14300 || ((filedata
->file_header
.e_machine
== EM_D30V
14301 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14302 && reloc_type
== 12)
14305 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14306 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14308 addend
+= byte_get (rloc
, reloc_size
);
14311 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14312 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14314 /* On HPPA, all pc-relative relocations are biased by 8. */
14315 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14317 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14320 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14321 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14323 if (reloc_subtract
)
14324 addend
-= sym
->st_value
;
14326 addend
+= sym
->st_value
;
14327 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14328 byte_put (rloc
, addend
, reloc_size
);
14330 else if (reloc_subtract
)
14331 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14333 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14337 /* Let the target specific reloc processing code know that
14338 we have finished with these relocs. */
14339 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14343 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14344 * num_relocs_return
= num_relocs
;
14355 #ifdef SUPPORT_DISASSEMBLY
14357 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14359 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14361 /* FIXME: XXX -- to be done --- XXX */
14367 /* Reads in the contents of SECTION from FILE, returning a pointer
14368 to a malloc'ed buffer or NULL if something went wrong. */
14371 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14373 bfd_size_type num_bytes
= section
->sh_size
;
14375 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14377 printf (_("Section '%s' has no data to dump.\n"),
14378 printable_section_name (filedata
, section
));
14382 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14383 _("section contents"));
14386 /* Uncompresses a section that was compressed using zlib, in place. */
14389 uncompress_section_contents (unsigned char ** buffer
,
14390 dwarf_size_type uncompressed_size
,
14391 dwarf_size_type
* size
)
14393 dwarf_size_type compressed_size
= *size
;
14394 unsigned char * compressed_buffer
= *buffer
;
14395 unsigned char * uncompressed_buffer
;
14399 /* It is possible the section consists of several compressed
14400 buffers concatenated together, so we uncompress in a loop. */
14401 /* PR 18313: The state field in the z_stream structure is supposed
14402 to be invisible to the user (ie us), but some compilers will
14403 still complain about it being used without initialisation. So
14404 we first zero the entire z_stream structure and then set the fields
14406 memset (& strm
, 0, sizeof strm
);
14407 strm
.avail_in
= compressed_size
;
14408 strm
.next_in
= (Bytef
*) compressed_buffer
;
14409 strm
.avail_out
= uncompressed_size
;
14410 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14412 rc
= inflateInit (& strm
);
14413 while (strm
.avail_in
> 0)
14417 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14418 + (uncompressed_size
- strm
.avail_out
));
14419 rc
= inflate (&strm
, Z_FINISH
);
14420 if (rc
!= Z_STREAM_END
)
14422 rc
= inflateReset (& strm
);
14424 if (inflateEnd (& strm
) != Z_OK
14426 || strm
.avail_out
!= 0)
14429 *buffer
= uncompressed_buffer
;
14430 *size
= uncompressed_size
;
14434 free (uncompressed_buffer
);
14435 /* Indicate decompression failure. */
14441 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14443 Elf_Internal_Shdr
*relsec
;
14444 bfd_size_type num_bytes
;
14445 unsigned char *data
;
14446 unsigned char *end
;
14447 unsigned char *real_start
;
14448 unsigned char *start
;
14449 bool some_strings_shown
;
14451 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14453 /* PR 21820: Do not fail if the section was empty. */
14454 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14456 num_bytes
= section
->sh_size
;
14458 if (filedata
->is_separate
)
14459 printf (_("\nString dump of section '%s' in linked file %s:\n"),
14460 printable_section_name (filedata
, section
),
14461 filedata
->file_name
);
14463 printf (_("\nString dump of section '%s':\n"),
14464 printable_section_name (filedata
, section
));
14466 if (decompress_dumps
)
14468 dwarf_size_type new_size
= num_bytes
;
14469 dwarf_size_type uncompressed_size
= 0;
14471 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14473 Elf_Internal_Chdr chdr
;
14474 unsigned int compression_header_size
14475 = get_compression_header (& chdr
, (unsigned char *) start
,
14477 if (compression_header_size
== 0)
14478 /* An error message will have already been generated
14479 by get_compression_header. */
14482 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14484 warn (_("section '%s' has unsupported compress type: %d\n"),
14485 printable_section_name (filedata
, section
), chdr
.ch_type
);
14488 uncompressed_size
= chdr
.ch_size
;
14489 start
+= compression_header_size
;
14490 new_size
-= compression_header_size
;
14492 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14494 /* Read the zlib header. In this case, it should be "ZLIB"
14495 followed by the uncompressed section size, 8 bytes in
14496 big-endian order. */
14497 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14498 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14499 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14500 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14501 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14502 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14503 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14504 uncompressed_size
+= start
[11];
14509 if (uncompressed_size
)
14511 if (uncompress_section_contents (& start
,
14512 uncompressed_size
, & new_size
))
14513 num_bytes
= new_size
;
14516 error (_("Unable to decompress section %s\n"),
14517 printable_section_name (filedata
, section
));
14522 start
= real_start
;
14525 /* If the section being dumped has relocations against it the user might
14526 be expecting these relocations to have been applied. Check for this
14527 case and issue a warning message in order to avoid confusion.
14528 FIXME: Maybe we ought to have an option that dumps a section with
14529 relocs applied ? */
14530 for (relsec
= filedata
->section_headers
;
14531 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14534 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14535 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14536 || filedata
->section_headers
+ relsec
->sh_info
!= section
14537 || relsec
->sh_size
== 0
14538 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14541 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14546 end
= start
+ num_bytes
;
14547 some_strings_shown
= false;
14549 #ifdef HAVE_MBSTATE_T
14551 /* Initialise the multibyte conversion state. */
14552 memset (& state
, 0, sizeof (state
));
14555 bool continuing
= false;
14559 while (!ISPRINT (* data
))
14560 if (++ data
>= end
)
14565 size_t maxlen
= end
- data
;
14570 continuing
= false;
14574 printf (" [%6lx] ", (unsigned long) (data
- start
));
14588 /* PR 25543: Treat new-lines as string-ending characters. */
14597 /* Do not print control characters directly as they can affect terminal
14598 settings. Such characters usually appear in the names generated
14599 by the assembler for local labels. */
14602 printf ("^%c", c
+ 0x40);
14604 else if (ISPRINT (c
))
14611 #ifdef HAVE_MBSTATE_T
14614 /* Let printf do the hard work of displaying multibyte characters. */
14615 printf ("%.1s", data
- 1);
14616 #ifdef HAVE_MBSTATE_T
14617 /* Try to find out how many bytes made up the character that was
14618 just printed. Advance the symbol pointer past the bytes that
14620 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14624 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14634 printf (_("<corrupt>\n"));
14637 some_strings_shown
= true;
14641 if (! some_strings_shown
)
14642 printf (_(" No strings found in this section."));
14655 dump_section_as_bytes (Elf_Internal_Shdr
*section
,
14656 Filedata
*filedata
,
14659 Elf_Internal_Shdr
* relsec
;
14660 bfd_size_type bytes
;
14661 bfd_size_type section_size
;
14663 unsigned char * data
;
14664 unsigned char * real_start
;
14665 unsigned char * start
;
14667 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14669 /* PR 21820: Do not fail if the section was empty. */
14670 return section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
;
14672 section_size
= section
->sh_size
;
14674 if (filedata
->is_separate
)
14675 printf (_("\nHex dump of section '%s' in linked file %s:\n"),
14676 printable_section_name (filedata
, section
),
14677 filedata
->file_name
);
14679 printf (_("\nHex dump of section '%s':\n"),
14680 printable_section_name (filedata
, section
));
14682 if (decompress_dumps
)
14684 dwarf_size_type new_size
= section_size
;
14685 dwarf_size_type uncompressed_size
= 0;
14687 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14689 Elf_Internal_Chdr chdr
;
14690 unsigned int compression_header_size
14691 = get_compression_header (& chdr
, start
, section_size
);
14693 if (compression_header_size
== 0)
14694 /* An error message will have already been generated
14695 by get_compression_header. */
14698 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14700 warn (_("section '%s' has unsupported compress type: %d\n"),
14701 printable_section_name (filedata
, section
), chdr
.ch_type
);
14704 uncompressed_size
= chdr
.ch_size
;
14705 start
+= compression_header_size
;
14706 new_size
-= compression_header_size
;
14708 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14710 /* Read the zlib header. In this case, it should be "ZLIB"
14711 followed by the uncompressed section size, 8 bytes in
14712 big-endian order. */
14713 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14714 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14715 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14716 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14717 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14718 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14719 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14720 uncompressed_size
+= start
[11];
14725 if (uncompressed_size
)
14727 if (uncompress_section_contents (& start
, uncompressed_size
,
14730 section_size
= new_size
;
14734 error (_("Unable to decompress section %s\n"),
14735 printable_section_name (filedata
, section
));
14736 /* FIXME: Print the section anyway ? */
14741 start
= real_start
;
14746 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14751 /* If the section being dumped has relocations against it the user might
14752 be expecting these relocations to have been applied. Check for this
14753 case and issue a warning message in order to avoid confusion.
14754 FIXME: Maybe we ought to have an option that dumps a section with
14755 relocs applied ? */
14756 for (relsec
= filedata
->section_headers
;
14757 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14760 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14761 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14762 || filedata
->section_headers
+ relsec
->sh_info
!= section
14763 || relsec
->sh_size
== 0
14764 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14767 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14772 addr
= section
->sh_addr
;
14773 bytes
= section_size
;
14782 lbytes
= (bytes
> 16 ? 16 : bytes
);
14784 printf (" 0x%8.8lx ", (unsigned long) addr
);
14786 for (j
= 0; j
< 16; j
++)
14789 printf ("%2.2x", data
[j
]);
14797 for (j
= 0; j
< lbytes
; j
++)
14800 if (k
>= ' ' && k
< 0x7f)
14823 #ifdef ENABLE_LIBCTF
14824 static ctf_sect_t
*
14825 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14827 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14828 buf
->cts_size
= shdr
->sh_size
;
14829 buf
->cts_entsize
= shdr
->sh_entsize
;
14834 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14835 it is passed, or a pointer to newly-allocated storage, in which case
14836 dump_ctf() will free it when it no longer needs it. */
14839 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14840 char *s
, void *arg
)
14842 const char *blanks
= arg
;
14845 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14850 /* Dump CTF errors/warnings. */
14852 dump_ctf_errs (ctf_dict_t
*fp
)
14854 ctf_next_t
*it
= NULL
;
14859 /* Dump accumulated errors and warnings. */
14860 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14862 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14866 if (err
!= ECTF_NEXT_END
)
14867 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14870 /* Dump one CTF archive member. */
14873 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
14875 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
14876 const char *things
[] = {"Header", "Labels", "Data objects",
14877 "Function objects", "Variables", "Types", "Strings",
14879 const char **thing
;
14883 /* Only print out the name of non-default-named archive members.
14884 The name .ctf appears everywhere, even for things that aren't
14885 really archives, so printing it out is liable to be confusing.
14887 The parent, if there is one, is the default-owned archive member:
14888 avoid importing it into itself. (This does no harm, but looks
14891 if (strcmp (name
, ".ctf") != 0)
14893 printf (_("\nCTF archive member: %s:\n"), name
);
14894 ctf_import (ctf
, parent
);
14897 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14899 ctf_dump_state_t
*s
= NULL
;
14902 printf ("\n %s:\n", *thing
);
14903 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14904 (void *) " ")) != NULL
)
14906 printf ("%s\n", item
);
14910 if (ctf_errno (ctf
))
14912 error (_("Iteration failed: %s, %s\n"), *thing
,
14913 ctf_errmsg (ctf_errno (ctf
)));
14920 dump_ctf_errs (ctf
);
14925 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14927 Elf_Internal_Shdr
* parent_sec
= NULL
;
14928 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14929 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14930 void * data
= NULL
;
14931 void * symdata
= NULL
;
14932 void * strdata
= NULL
;
14933 void * parentdata
= NULL
;
14934 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14935 ctf_sect_t
* symsectp
= NULL
;
14936 ctf_sect_t
* strsectp
= NULL
;
14937 ctf_archive_t
* ctfa
= NULL
;
14938 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14939 ctf_dict_t
* parent
= NULL
;
14944 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14945 data
= get_section_contents (section
, filedata
);
14946 ctfsect
.cts_data
= data
;
14948 if (!dump_ctf_symtab_name
)
14949 dump_ctf_symtab_name
= strdup (".dynsym");
14951 if (!dump_ctf_strtab_name
)
14952 dump_ctf_strtab_name
= strdup (".dynstr");
14954 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14956 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14958 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14961 if ((symdata
= (void *) get_data (NULL
, filedata
,
14962 symtab_sec
->sh_offset
, 1,
14963 symtab_sec
->sh_size
,
14964 _("symbols"))) == NULL
)
14966 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14967 symsect
.cts_data
= symdata
;
14970 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14972 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14974 error (_("No string table section named %s\n"),
14975 dump_ctf_strtab_name
);
14978 if ((strdata
= (void *) get_data (NULL
, filedata
,
14979 strtab_sec
->sh_offset
, 1,
14980 strtab_sec
->sh_size
,
14981 _("strings"))) == NULL
)
14983 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14984 strsect
.cts_data
= strdata
;
14987 if (dump_ctf_parent_name
)
14989 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14991 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14994 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14995 parent_sec
->sh_offset
, 1,
14996 parent_sec
->sh_size
,
14997 _("CTF parent"))) == NULL
)
14999 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
15000 parentsect
.cts_data
= parentdata
;
15003 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
15004 libctf papers over the difference, so we can pretend it is always an
15005 archive. Possibly open the parent as well, if one was specified. */
15007 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
15009 dump_ctf_errs (NULL
);
15010 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15014 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
15019 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
15022 dump_ctf_errs (NULL
);
15023 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15026 lookparent
= parenta
;
15031 /* Assume that the applicable parent archive member is the default one.
15032 (This is what all known implementations are expected to do, if they
15033 put CTFs and their parents in archives together.) */
15034 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
15036 dump_ctf_errs (NULL
);
15037 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
15043 if (filedata
->is_separate
)
15044 printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
15045 printable_section_name (filedata
, section
),
15046 filedata
->file_name
);
15048 printf (_("\nDump of CTF section '%s':\n"),
15049 printable_section_name (filedata
, section
));
15051 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
15053 dump_ctf_errs (NULL
);
15054 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
15059 ctf_dict_close (parent
);
15061 ctf_close (parenta
);
15071 load_specific_debug_section (enum dwarf_section_display_enum debug
,
15072 const Elf_Internal_Shdr
* sec
,
15075 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15077 Filedata
* filedata
= (Filedata
*) data
;
15079 if (section
->start
!= NULL
)
15081 /* If it is already loaded, do nothing. */
15082 if (streq (section
->filename
, filedata
->file_name
))
15084 free (section
->start
);
15087 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
15088 section
->address
= sec
->sh_addr
;
15089 section
->filename
= filedata
->file_name
;
15090 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
15092 sec
->sh_size
, buf
);
15093 if (section
->start
== NULL
)
15097 unsigned char *start
= section
->start
;
15098 dwarf_size_type size
= sec
->sh_size
;
15099 dwarf_size_type uncompressed_size
= 0;
15101 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
15103 Elf_Internal_Chdr chdr
;
15104 unsigned int compression_header_size
;
15106 if (size
< (is_32bit_elf
15107 ? sizeof (Elf32_External_Chdr
)
15108 : sizeof (Elf64_External_Chdr
)))
15110 warn (_("compressed section %s is too small to contain a compression header\n"),
15115 compression_header_size
= get_compression_header (&chdr
, start
, size
);
15116 if (compression_header_size
== 0)
15117 /* An error message will have already been generated
15118 by get_compression_header. */
15121 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
15123 warn (_("section '%s' has unsupported compress type: %d\n"),
15124 section
->name
, chdr
.ch_type
);
15127 uncompressed_size
= chdr
.ch_size
;
15128 start
+= compression_header_size
;
15129 size
-= compression_header_size
;
15131 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
15133 /* Read the zlib header. In this case, it should be "ZLIB"
15134 followed by the uncompressed section size, 8 bytes in
15135 big-endian order. */
15136 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
15137 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
15138 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
15139 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
15140 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
15141 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
15142 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
15143 uncompressed_size
+= start
[11];
15148 if (uncompressed_size
)
15150 if (uncompress_section_contents (&start
, uncompressed_size
,
15153 /* Free the compressed buffer, update the section buffer
15154 and the section size if uncompress is successful. */
15155 free (section
->start
);
15156 section
->start
= start
;
15160 error (_("Unable to decompress section %s\n"),
15161 printable_section_name (filedata
, sec
));
15166 section
->size
= size
;
15169 if (section
->start
== NULL
)
15172 if (debug_displays
[debug
].relocate
)
15174 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
15175 & section
->reloc_info
, & section
->num_relocs
))
15180 section
->reloc_info
= NULL
;
15181 section
->num_relocs
= 0;
15187 #if HAVE_LIBDEBUGINFOD
15188 /* Return a hex string representation of the build-id. */
15190 get_build_id (void * data
)
15192 Filedata
* filedata
= (Filedata
*) data
;
15193 Elf_Internal_Shdr
* shdr
;
15196 /* Iterate through notes to find note.gnu.build-id.
15197 FIXME: Only the first note in any note section is examined. */
15198 for (i
= 0, shdr
= filedata
->section_headers
;
15199 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
15202 if (shdr
->sh_type
!= SHT_NOTE
)
15207 size_t data_remaining
;
15209 Elf_External_Note
* enote
;
15210 Elf_Internal_Note inote
;
15212 bfd_vma offset
= shdr
->sh_offset
;
15213 bfd_vma align
= shdr
->sh_addralign
;
15214 bfd_vma length
= shdr
->sh_size
;
15216 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15222 else if (align
!= 4 && align
!= 8)
15228 end
= (char *) enote
+ length
;
15229 data_remaining
= end
- (char *) enote
;
15231 if (!is_ia64_vms (filedata
))
15233 min_notesz
= offsetof (Elf_External_Note
, name
);
15234 if (data_remaining
< min_notesz
)
15237 malformed note encountered in section %s whilst scanning for build-id note\n"),
15238 printable_section_name (filedata
, shdr
));
15242 data_remaining
-= min_notesz
;
15244 inote
.type
= BYTE_GET (enote
->type
);
15245 inote
.namesz
= BYTE_GET (enote
->namesz
);
15246 inote
.namedata
= enote
->name
;
15247 inote
.descsz
= BYTE_GET (enote
->descsz
);
15248 inote
.descdata
= ((char *) enote
15249 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15250 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15251 next
= ((char *) enote
15252 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15256 Elf64_External_VMS_Note
*vms_enote
;
15258 /* PR binutils/15191
15259 Make sure that there is enough data to read. */
15260 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15261 if (data_remaining
< min_notesz
)
15264 malformed note encountered in section %s whilst scanning for build-id note\n"),
15265 printable_section_name (filedata
, shdr
));
15269 data_remaining
-= min_notesz
;
15271 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15272 inote
.type
= BYTE_GET (vms_enote
->type
);
15273 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15274 inote
.namedata
= vms_enote
->name
;
15275 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15276 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15277 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15278 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15281 /* Skip malformed notes. */
15282 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15283 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15284 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15285 || ((size_t) (next
- inote
.descdata
)
15286 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15289 malformed note encountered in section %s whilst scanning for build-id note\n"),
15290 printable_section_name (filedata
, shdr
));
15295 /* Check if this is the build-id note. If so then convert the build-id
15296 bytes to a hex string. */
15297 if (inote
.namesz
> 0
15298 && startswith (inote
.namedata
, "GNU")
15299 && inote
.type
== NT_GNU_BUILD_ID
)
15304 build_id
= malloc (inote
.descsz
* 2 + 1);
15305 if (build_id
== NULL
)
15311 for (j
= 0; j
< inote
.descsz
; ++j
)
15312 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15313 build_id
[inote
.descsz
* 2] = '\0';
15316 return (unsigned char *) build_id
;
15323 #endif /* HAVE_LIBDEBUGINFOD */
15325 /* If this is not NULL, load_debug_section will only look for sections
15326 within the list of sections given here. */
15327 static unsigned int * section_subset
= NULL
;
15330 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15332 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15333 Elf_Internal_Shdr
* sec
;
15334 Filedata
* filedata
= (Filedata
*) data
;
15336 /* Without section headers we cannot find any sections. */
15337 if (filedata
->section_headers
== NULL
)
15340 if (filedata
->string_table
== NULL
15341 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15342 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15344 Elf_Internal_Shdr
* strs
;
15346 /* Read in the string table, so that we have section names to scan. */
15347 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15349 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15351 filedata
->string_table
15352 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15353 1, strs
->sh_size
, _("string table"));
15355 filedata
->string_table_length
15356 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15360 /* Locate the debug section. */
15361 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15363 section
->name
= section
->uncompressed_name
;
15366 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15368 section
->name
= section
->compressed_name
;
15373 /* If we're loading from a subset of sections, and we've loaded
15374 a section matching this name before, it's likely that it's a
15376 if (section_subset
!= NULL
)
15377 free_debug_section (debug
);
15379 return load_specific_debug_section (debug
, sec
, data
);
15383 free_debug_section (enum dwarf_section_display_enum debug
)
15385 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15387 if (section
->start
== NULL
)
15390 free ((char *) section
->start
);
15391 section
->start
= NULL
;
15392 section
->address
= 0;
15395 free (section
->reloc_info
);
15396 section
->reloc_info
= NULL
;
15397 section
->num_relocs
= 0;
15401 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15403 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15404 const char * print_name
= printable_section_name (filedata
, section
);
15405 bfd_size_type length
;
15406 bool result
= true;
15409 length
= section
->sh_size
;
15412 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15415 if (section
->sh_type
== SHT_NOBITS
)
15417 /* There is no point in dumping the contents of a debugging section
15418 which has the NOBITS type - the bits in the file will be random.
15419 This can happen when a file containing a .eh_frame section is
15420 stripped with the --only-keep-debug command line option. */
15421 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15426 if (startswith (name
, ".gnu.linkonce.wi."))
15427 name
= ".debug_info";
15429 /* See if we know how to display the contents of this section. */
15430 for (i
= 0; i
< max
; i
++)
15432 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15433 struct dwarf_section_display
* display
= debug_displays
+ i
;
15434 struct dwarf_section
* sec
= & display
->section
;
15436 if (streq (sec
->uncompressed_name
, name
)
15437 || (id
== line
&& startswith (name
, ".debug_line."))
15438 || streq (sec
->compressed_name
, name
))
15440 bool secondary
= (section
!= find_section (filedata
, name
));
15443 free_debug_section (id
);
15445 if (i
== line
&& startswith (name
, ".debug_line."))
15447 else if (streq (sec
->uncompressed_name
, name
))
15448 sec
->name
= sec
->uncompressed_name
;
15450 sec
->name
= sec
->compressed_name
;
15452 if (load_specific_debug_section (id
, section
, filedata
))
15454 /* If this debug section is part of a CU/TU set in a .dwp file,
15455 restrict load_debug_section to the sections in that set. */
15456 section_subset
= find_cu_tu_set (filedata
, shndx
);
15458 result
&= display
->display (sec
, filedata
);
15460 section_subset
= NULL
;
15462 if (secondary
|| (id
!= info
&& id
!= abbrev
&& id
!= debug_addr
))
15463 free_debug_section (id
);
15471 printf (_("Unrecognized debug section: %s\n"), print_name
);
15478 /* Set DUMP_SECTS for all sections where dumps were requested
15479 based on section name. */
15482 initialise_dumps_byname (Filedata
* filedata
)
15484 struct dump_list_entry
* cur
;
15486 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15491 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15492 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15493 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15495 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15499 if (!any
&& !filedata
->is_separate
)
15500 warn (_("Section '%s' was not dumped because it does not exist\n"),
15506 process_section_contents (Filedata
* filedata
)
15508 Elf_Internal_Shdr
* section
;
15515 initialise_dumps_byname (filedata
);
15517 for (i
= 0, section
= filedata
->section_headers
;
15518 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15521 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15523 if (filedata
->is_separate
&& ! process_links
)
15524 dump
&= DEBUG_DUMP
;
15526 #ifdef SUPPORT_DISASSEMBLY
15527 if (dump
& DISASS_DUMP
)
15529 if (! disassemble_section (section
, filedata
))
15533 if (dump
& HEX_DUMP
)
15535 if (! dump_section_as_bytes (section
, filedata
, false))
15539 if (dump
& RELOC_DUMP
)
15541 if (! dump_section_as_bytes (section
, filedata
, true))
15545 if (dump
& STRING_DUMP
)
15547 if (! dump_section_as_strings (section
, filedata
))
15551 if (dump
& DEBUG_DUMP
)
15553 if (! display_debug_section (i
, section
, filedata
))
15557 #ifdef ENABLE_LIBCTF
15558 if (dump
& CTF_DUMP
)
15560 if (! dump_section_as_ctf (section
, filedata
))
15566 if (! filedata
->is_separate
)
15568 /* Check to see if the user requested a
15569 dump of a section that does not exist. */
15570 for (; i
< filedata
->dump
.num_dump_sects
; i
++)
15571 if (filedata
->dump
.dump_sects
[i
])
15573 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15582 process_mips_fpe_exception (int mask
)
15588 if (mask
& OEX_FPU_INEX
)
15589 fputs ("INEX", stdout
), first
= false;
15590 if (mask
& OEX_FPU_UFLO
)
15591 printf ("%sUFLO", first
? "" : "|"), first
= false;
15592 if (mask
& OEX_FPU_OFLO
)
15593 printf ("%sOFLO", first
? "" : "|"), first
= false;
15594 if (mask
& OEX_FPU_DIV0
)
15595 printf ("%sDIV0", first
? "" : "|"), first
= false;
15596 if (mask
& OEX_FPU_INVAL
)
15597 printf ("%sINVAL", first
? "" : "|");
15600 fputs ("0", stdout
);
15603 /* Display's the value of TAG at location P. If TAG is
15604 greater than 0 it is assumed to be an unknown tag, and
15605 a message is printed to this effect. Otherwise it is
15606 assumed that a message has already been printed.
15608 If the bottom bit of TAG is set it assumed to have a
15609 string value, otherwise it is assumed to have an integer
15612 Returns an updated P pointing to the first unread byte
15613 beyond the end of TAG's value.
15615 Reads at or beyond END will not be made. */
15617 static unsigned char *
15618 display_tag_value (signed int tag
,
15620 const unsigned char * const end
)
15625 printf (" Tag_unknown_%d: ", tag
);
15629 warn (_("<corrupt tag>\n"));
15633 /* PR 17531 file: 027-19978-0.004. */
15634 size_t maxlen
= (end
- p
) - 1;
15639 print_symbol ((int) maxlen
, (const char *) p
);
15640 p
+= strnlen ((char *) p
, maxlen
) + 1;
15644 printf (_("<corrupt string tag>"));
15645 p
= (unsigned char *) end
;
15651 READ_ULEB (val
, p
, end
);
15652 printf ("%ld (0x%lx)\n", val
, val
);
15659 /* ARC ABI attributes section. */
15661 static unsigned char *
15662 display_arc_attribute (unsigned char * p
,
15663 const unsigned char * const end
)
15668 READ_ULEB (tag
, p
, end
);
15672 case Tag_ARC_PCS_config
:
15673 READ_ULEB (val
, p
, end
);
15674 printf (" Tag_ARC_PCS_config: ");
15678 printf (_("Absent/Non standard\n"));
15681 printf (_("Bare metal/mwdt\n"));
15684 printf (_("Bare metal/newlib\n"));
15687 printf (_("Linux/uclibc\n"));
15690 printf (_("Linux/glibc\n"));
15693 printf (_("Unknown\n"));
15698 case Tag_ARC_CPU_base
:
15699 READ_ULEB (val
, p
, end
);
15700 printf (" Tag_ARC_CPU_base: ");
15705 printf (_("Absent\n"));
15707 case TAG_CPU_ARC6xx
:
15708 printf ("ARC6xx\n");
15710 case TAG_CPU_ARC7xx
:
15711 printf ("ARC7xx\n");
15713 case TAG_CPU_ARCEM
:
15714 printf ("ARCEM\n");
15716 case TAG_CPU_ARCHS
:
15717 printf ("ARCHS\n");
15722 case Tag_ARC_CPU_variation
:
15723 READ_ULEB (val
, p
, end
);
15724 printf (" Tag_ARC_CPU_variation: ");
15728 if (val
> 0 && val
< 16)
15729 printf ("Core%d\n", val
);
15731 printf ("Unknown\n");
15735 printf (_("Absent\n"));
15740 case Tag_ARC_CPU_name
:
15741 printf (" Tag_ARC_CPU_name: ");
15742 p
= display_tag_value (-1, p
, end
);
15745 case Tag_ARC_ABI_rf16
:
15746 READ_ULEB (val
, p
, end
);
15747 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15750 case Tag_ARC_ABI_osver
:
15751 READ_ULEB (val
, p
, end
);
15752 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15755 case Tag_ARC_ABI_pic
:
15756 case Tag_ARC_ABI_sda
:
15757 READ_ULEB (val
, p
, end
);
15758 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15759 : " Tag_ARC_ABI_pic: ");
15763 printf (_("Absent\n"));
15772 printf (_("Unknown\n"));
15777 case Tag_ARC_ABI_tls
:
15778 READ_ULEB (val
, p
, end
);
15779 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15782 case Tag_ARC_ABI_enumsize
:
15783 READ_ULEB (val
, p
, end
);
15784 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15788 case Tag_ARC_ABI_exceptions
:
15789 READ_ULEB (val
, p
, end
);
15790 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15794 case Tag_ARC_ABI_double_size
:
15795 READ_ULEB (val
, p
, end
);
15796 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15799 case Tag_ARC_ISA_config
:
15800 printf (" Tag_ARC_ISA_config: ");
15801 p
= display_tag_value (-1, p
, end
);
15804 case Tag_ARC_ISA_apex
:
15805 printf (" Tag_ARC_ISA_apex: ");
15806 p
= display_tag_value (-1, p
, end
);
15809 case Tag_ARC_ISA_mpy_option
:
15810 READ_ULEB (val
, p
, end
);
15811 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15814 case Tag_ARC_ATR_version
:
15815 READ_ULEB (val
, p
, end
);
15816 printf (" Tag_ARC_ATR_version: %d\n", val
);
15820 return display_tag_value (tag
& 1, p
, end
);
15826 /* ARM EABI attributes section. */
15831 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15833 const char *const *table
;
15834 } arm_attr_public_tag
;
15836 static const char *const arm_attr_tag_CPU_arch
[] =
15837 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15838 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15839 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15840 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15841 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15842 {"No", "Thumb-1", "Thumb-2", "Yes"};
15843 static const char *const arm_attr_tag_FP_arch
[] =
15844 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15845 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15846 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15847 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15848 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15849 "NEON for ARMv8.1"};
15850 static const char *const arm_attr_tag_PCS_config
[] =
15851 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15852 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15853 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15854 {"V6", "SB", "TLS", "Unused"};
15855 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15856 {"Absolute", "PC-relative", "SB-relative", "None"};
15857 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15858 {"Absolute", "PC-relative", "None"};
15859 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15860 {"None", "direct", "GOT-indirect"};
15861 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
15862 {"None", "??? 1", "2", "??? 3", "4"};
15863 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15864 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
15865 {"Unused", "Needed", "Sign only"};
15866 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15867 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15868 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
15869 {"Unused", "Finite", "RTABI", "IEEE 754"};
15870 static const char *const arm_attr_tag_ABI_enum_size
[] =
15871 {"Unused", "small", "int", "forced to int"};
15872 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
15873 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15874 static const char *const arm_attr_tag_ABI_VFP_args
[] =
15875 {"AAPCS", "VFP registers", "custom", "compatible"};
15876 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
15877 {"AAPCS", "WMMX registers", "custom"};
15878 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
15879 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15880 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15881 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
15882 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15883 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15884 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15885 static const char *const arm_attr_tag_FP_HP_extension
[] =
15886 {"Not Allowed", "Allowed"};
15887 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
15888 {"None", "IEEE 754", "Alternative Format"};
15889 static const char *const arm_attr_tag_DSP_extension
[] =
15890 {"Follow architecture", "Allowed"};
15891 static const char *const arm_attr_tag_MPextension_use
[] =
15892 {"Not Allowed", "Allowed"};
15893 static const char *const arm_attr_tag_DIV_use
[] =
15894 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15895 "Allowed in v7-A with integer division extension"};
15896 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15897 static const char *const arm_attr_tag_Virtualization_use
[] =
15898 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15899 "TrustZone and Virtualization Extensions"};
15900 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
15901 {"Not Allowed", "Allowed"};
15903 static const char *const arm_attr_tag_MVE_arch
[] =
15904 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15906 #define LOOKUP(id, name) \
15907 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15908 static arm_attr_public_tag arm_attr_public_tags
[] =
15910 {4, "CPU_raw_name", 1, NULL
},
15911 {5, "CPU_name", 1, NULL
},
15912 LOOKUP(6, CPU_arch
),
15913 {7, "CPU_arch_profile", 0, NULL
},
15914 LOOKUP(8, ARM_ISA_use
),
15915 LOOKUP(9, THUMB_ISA_use
),
15916 LOOKUP(10, FP_arch
),
15917 LOOKUP(11, WMMX_arch
),
15918 LOOKUP(12, Advanced_SIMD_arch
),
15919 LOOKUP(13, PCS_config
),
15920 LOOKUP(14, ABI_PCS_R9_use
),
15921 LOOKUP(15, ABI_PCS_RW_data
),
15922 LOOKUP(16, ABI_PCS_RO_data
),
15923 LOOKUP(17, ABI_PCS_GOT_use
),
15924 LOOKUP(18, ABI_PCS_wchar_t
),
15925 LOOKUP(19, ABI_FP_rounding
),
15926 LOOKUP(20, ABI_FP_denormal
),
15927 LOOKUP(21, ABI_FP_exceptions
),
15928 LOOKUP(22, ABI_FP_user_exceptions
),
15929 LOOKUP(23, ABI_FP_number_model
),
15930 {24, "ABI_align_needed", 0, NULL
},
15931 {25, "ABI_align_preserved", 0, NULL
},
15932 LOOKUP(26, ABI_enum_size
),
15933 LOOKUP(27, ABI_HardFP_use
),
15934 LOOKUP(28, ABI_VFP_args
),
15935 LOOKUP(29, ABI_WMMX_args
),
15936 LOOKUP(30, ABI_optimization_goals
),
15937 LOOKUP(31, ABI_FP_optimization_goals
),
15938 {32, "compatibility", 0, NULL
},
15939 LOOKUP(34, CPU_unaligned_access
),
15940 LOOKUP(36, FP_HP_extension
),
15941 LOOKUP(38, ABI_FP_16bit_format
),
15942 LOOKUP(42, MPextension_use
),
15943 LOOKUP(44, DIV_use
),
15944 LOOKUP(46, DSP_extension
),
15945 LOOKUP(48, MVE_arch
),
15946 {64, "nodefaults", 0, NULL
},
15947 {65, "also_compatible_with", 0, NULL
},
15948 LOOKUP(66, T2EE_use
),
15949 {67, "conformance", 1, NULL
},
15950 LOOKUP(68, Virtualization_use
),
15951 LOOKUP(70, MPextension_use_legacy
)
15955 static unsigned char *
15956 display_arm_attribute (unsigned char * p
,
15957 const unsigned char * const end
)
15961 arm_attr_public_tag
* attr
;
15965 READ_ULEB (tag
, p
, end
);
15967 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15969 if (arm_attr_public_tags
[i
].tag
== tag
)
15971 attr
= &arm_attr_public_tags
[i
];
15978 printf (" Tag_%s: ", attr
->name
);
15979 switch (attr
->type
)
15984 case 7: /* Tag_CPU_arch_profile. */
15985 READ_ULEB (val
, p
, end
);
15988 case 0: printf (_("None\n")); break;
15989 case 'A': printf (_("Application\n")); break;
15990 case 'R': printf (_("Realtime\n")); break;
15991 case 'M': printf (_("Microcontroller\n")); break;
15992 case 'S': printf (_("Application or Realtime\n")); break;
15993 default: printf ("??? (%d)\n", val
); break;
15997 case 24: /* Tag_align_needed. */
15998 READ_ULEB (val
, p
, end
);
16001 case 0: printf (_("None\n")); break;
16002 case 1: printf (_("8-byte\n")); break;
16003 case 2: printf (_("4-byte\n")); break;
16004 case 3: printf ("??? 3\n"); break;
16007 printf (_("8-byte and up to %d-byte extended\n"),
16010 printf ("??? (%d)\n", val
);
16015 case 25: /* Tag_align_preserved. */
16016 READ_ULEB (val
, p
, end
);
16019 case 0: printf (_("None\n")); break;
16020 case 1: printf (_("8-byte, except leaf SP\n")); break;
16021 case 2: printf (_("8-byte\n")); break;
16022 case 3: printf ("??? 3\n"); break;
16025 printf (_("8-byte and up to %d-byte extended\n"),
16028 printf ("??? (%d)\n", val
);
16033 case 32: /* Tag_compatibility. */
16035 READ_ULEB (val
, p
, end
);
16036 printf (_("flag = %d, vendor = "), val
);
16039 size_t maxlen
= (end
- p
) - 1;
16041 print_symbol ((int) maxlen
, (const char *) p
);
16042 p
+= strnlen ((char *) p
, maxlen
) + 1;
16046 printf (_("<corrupt>"));
16047 p
= (unsigned char *) end
;
16053 case 64: /* Tag_nodefaults. */
16054 /* PR 17531: file: 001-505008-0.01. */
16057 printf (_("True\n"));
16060 case 65: /* Tag_also_compatible_with. */
16061 READ_ULEB (val
, p
, end
);
16062 if (val
== 6 /* Tag_CPU_arch. */)
16064 READ_ULEB (val
, p
, end
);
16065 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
16066 printf ("??? (%d)\n", val
);
16068 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
16072 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
16077 printf (_("<unknown: %d>\n"), tag
);
16083 return display_tag_value (-1, p
, end
);
16085 return display_tag_value (0, p
, end
);
16088 assert (attr
->type
& 0x80);
16089 READ_ULEB (val
, p
, end
);
16090 type
= attr
->type
& 0x7f;
16092 printf ("??? (%d)\n", val
);
16094 printf ("%s\n", attr
->table
[val
]);
16099 return display_tag_value (tag
, p
, end
);
16102 static unsigned char *
16103 display_gnu_attribute (unsigned char * p
,
16104 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
16105 const unsigned char * const end
)
16110 READ_ULEB (tag
, p
, end
);
16112 /* Tag_compatibility is the only generic GNU attribute defined at
16116 READ_ULEB (val
, p
, end
);
16118 printf (_("flag = %d, vendor = "), val
);
16121 printf (_("<corrupt>\n"));
16122 warn (_("corrupt vendor attribute\n"));
16128 size_t maxlen
= (end
- p
) - 1;
16130 print_symbol ((int) maxlen
, (const char *) p
);
16131 p
+= strnlen ((char *) p
, maxlen
) + 1;
16135 printf (_("<corrupt>"));
16136 p
= (unsigned char *) end
;
16143 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
16144 return display_proc_gnu_attribute (p
, tag
, end
);
16146 return display_tag_value (tag
, p
, end
);
16149 static unsigned char *
16150 display_m68k_gnu_attribute (unsigned char * p
,
16152 const unsigned char * const end
)
16156 if (tag
== Tag_GNU_M68K_ABI_FP
)
16158 printf (" Tag_GNU_M68K_ABI_FP: ");
16161 printf (_("<corrupt>\n"));
16164 READ_ULEB (val
, p
, end
);
16167 printf ("(%#x), ", val
);
16172 printf (_("unspecified hard/soft float\n"));
16175 printf (_("hard float\n"));
16178 printf (_("soft float\n"));
16184 return display_tag_value (tag
& 1, p
, end
);
16187 static unsigned char *
16188 display_power_gnu_attribute (unsigned char * p
,
16190 const unsigned char * const end
)
16194 if (tag
== Tag_GNU_Power_ABI_FP
)
16196 printf (" Tag_GNU_Power_ABI_FP: ");
16199 printf (_("<corrupt>\n"));
16202 READ_ULEB (val
, p
, end
);
16205 printf ("(%#x), ", val
);
16210 printf (_("unspecified hard/soft float, "));
16213 printf (_("hard float, "));
16216 printf (_("soft float, "));
16219 printf (_("single-precision hard float, "));
16226 printf (_("unspecified long double\n"));
16229 printf (_("128-bit IBM long double\n"));
16232 printf (_("64-bit long double\n"));
16235 printf (_("128-bit IEEE long double\n"));
16241 if (tag
== Tag_GNU_Power_ABI_Vector
)
16243 printf (" Tag_GNU_Power_ABI_Vector: ");
16246 printf (_("<corrupt>\n"));
16249 READ_ULEB (val
, p
, end
);
16252 printf ("(%#x), ", val
);
16257 printf (_("unspecified\n"));
16260 printf (_("generic\n"));
16263 printf ("AltiVec\n");
16272 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16274 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16277 printf (_("<corrupt>\n"));
16280 READ_ULEB (val
, p
, end
);
16283 printf ("(%#x), ", val
);
16288 printf (_("unspecified\n"));
16291 printf ("r3/r4\n");
16294 printf (_("memory\n"));
16303 return display_tag_value (tag
& 1, p
, end
);
16306 static unsigned char *
16307 display_s390_gnu_attribute (unsigned char * p
,
16309 const unsigned char * const end
)
16313 if (tag
== Tag_GNU_S390_ABI_Vector
)
16315 printf (" Tag_GNU_S390_ABI_Vector: ");
16316 READ_ULEB (val
, p
, end
);
16321 printf (_("any\n"));
16324 printf (_("software\n"));
16327 printf (_("hardware\n"));
16330 printf ("??? (%d)\n", val
);
16336 return display_tag_value (tag
& 1, p
, end
);
16340 display_sparc_hwcaps (unsigned int mask
)
16346 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16347 fputs ("mul32", stdout
), first
= false;
16348 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16349 printf ("%sdiv32", first
? "" : "|"), first
= false;
16350 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16351 printf ("%sfsmuld", first
? "" : "|"), first
= false;
16352 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16353 printf ("%sv8plus", first
? "" : "|"), first
= false;
16354 if (mask
& ELF_SPARC_HWCAP_POPC
)
16355 printf ("%spopc", first
? "" : "|"), first
= false;
16356 if (mask
& ELF_SPARC_HWCAP_VIS
)
16357 printf ("%svis", first
? "" : "|"), first
= false;
16358 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16359 printf ("%svis2", first
? "" : "|"), first
= false;
16360 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16361 printf ("%sASIBlkInit", first
? "" : "|"), first
= false;
16362 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16363 printf ("%sfmaf", first
? "" : "|"), first
= false;
16364 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16365 printf ("%svis3", first
? "" : "|"), first
= false;
16366 if (mask
& ELF_SPARC_HWCAP_HPC
)
16367 printf ("%shpc", first
? "" : "|"), first
= false;
16368 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16369 printf ("%srandom", first
? "" : "|"), first
= false;
16370 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16371 printf ("%strans", first
? "" : "|"), first
= false;
16372 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16373 printf ("%sfjfmau", first
? "" : "|"), first
= false;
16374 if (mask
& ELF_SPARC_HWCAP_IMA
)
16375 printf ("%sima", first
? "" : "|"), first
= false;
16376 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16377 printf ("%scspare", first
? "" : "|"), first
= false;
16380 fputc ('0', stdout
);
16381 fputc ('\n', stdout
);
16385 display_sparc_hwcaps2 (unsigned int mask
)
16391 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16392 fputs ("fjathplus", stdout
), first
= false;
16393 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16394 printf ("%svis3b", first
? "" : "|"), first
= false;
16395 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16396 printf ("%sadp", first
? "" : "|"), first
= false;
16397 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16398 printf ("%ssparc5", first
? "" : "|"), first
= false;
16399 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16400 printf ("%smwait", first
? "" : "|"), first
= false;
16401 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16402 printf ("%sxmpmul", first
? "" : "|"), first
= false;
16403 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16404 printf ("%sxmont2", first
? "" : "|"), first
= false;
16405 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16406 printf ("%snsec", first
? "" : "|"), first
= false;
16407 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16408 printf ("%sfjathhpc", first
? "" : "|"), first
= false;
16409 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16410 printf ("%sfjdes", first
? "" : "|"), first
= false;
16411 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16412 printf ("%sfjaes", first
? "" : "|"), first
= false;
16415 fputc ('0', stdout
);
16416 fputc ('\n', stdout
);
16419 static unsigned char *
16420 display_sparc_gnu_attribute (unsigned char * p
,
16422 const unsigned char * const end
)
16426 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16428 READ_ULEB (val
, p
, end
);
16429 printf (" Tag_GNU_Sparc_HWCAPS: ");
16430 display_sparc_hwcaps (val
);
16433 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16435 READ_ULEB (val
, p
, end
);
16436 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16437 display_sparc_hwcaps2 (val
);
16441 return display_tag_value (tag
, p
, end
);
16445 print_mips_fp_abi_value (unsigned int val
)
16449 case Val_GNU_MIPS_ABI_FP_ANY
:
16450 printf (_("Hard or soft float\n"));
16452 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16453 printf (_("Hard float (double precision)\n"));
16455 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16456 printf (_("Hard float (single precision)\n"));
16458 case Val_GNU_MIPS_ABI_FP_SOFT
:
16459 printf (_("Soft float\n"));
16461 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16462 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16464 case Val_GNU_MIPS_ABI_FP_XX
:
16465 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16467 case Val_GNU_MIPS_ABI_FP_64
:
16468 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16470 case Val_GNU_MIPS_ABI_FP_64A
:
16471 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16473 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16474 printf (_("NaN 2008 compatibility\n"));
16477 printf ("??? (%d)\n", val
);
16482 static unsigned char *
16483 display_mips_gnu_attribute (unsigned char * p
,
16485 const unsigned char * const end
)
16487 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16491 printf (" Tag_GNU_MIPS_ABI_FP: ");
16492 READ_ULEB (val
, p
, end
);
16493 print_mips_fp_abi_value (val
);
16497 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16501 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16502 READ_ULEB (val
, p
, end
);
16506 case Val_GNU_MIPS_ABI_MSA_ANY
:
16507 printf (_("Any MSA or not\n"));
16509 case Val_GNU_MIPS_ABI_MSA_128
:
16510 printf (_("128-bit MSA\n"));
16513 printf ("??? (%d)\n", val
);
16519 return display_tag_value (tag
& 1, p
, end
);
16522 static unsigned char *
16523 display_tic6x_attribute (unsigned char * p
,
16524 const unsigned char * const end
)
16529 READ_ULEB (tag
, p
, end
);
16534 printf (" Tag_ISA: ");
16535 READ_ULEB (val
, p
, end
);
16539 case C6XABI_Tag_ISA_none
:
16540 printf (_("None\n"));
16542 case C6XABI_Tag_ISA_C62X
:
16545 case C6XABI_Tag_ISA_C67X
:
16548 case C6XABI_Tag_ISA_C67XP
:
16549 printf ("C67x+\n");
16551 case C6XABI_Tag_ISA_C64X
:
16554 case C6XABI_Tag_ISA_C64XP
:
16555 printf ("C64x+\n");
16557 case C6XABI_Tag_ISA_C674X
:
16558 printf ("C674x\n");
16561 printf ("??? (%d)\n", val
);
16566 case Tag_ABI_wchar_t
:
16567 printf (" Tag_ABI_wchar_t: ");
16568 READ_ULEB (val
, p
, end
);
16572 printf (_("Not used\n"));
16575 printf (_("2 bytes\n"));
16578 printf (_("4 bytes\n"));
16581 printf ("??? (%d)\n", val
);
16586 case Tag_ABI_stack_align_needed
:
16587 printf (" Tag_ABI_stack_align_needed: ");
16588 READ_ULEB (val
, p
, end
);
16592 printf (_("8-byte\n"));
16595 printf (_("16-byte\n"));
16598 printf ("??? (%d)\n", val
);
16603 case Tag_ABI_stack_align_preserved
:
16604 READ_ULEB (val
, p
, end
);
16605 printf (" Tag_ABI_stack_align_preserved: ");
16609 printf (_("8-byte\n"));
16612 printf (_("16-byte\n"));
16615 printf ("??? (%d)\n", val
);
16621 READ_ULEB (val
, p
, end
);
16622 printf (" Tag_ABI_DSBT: ");
16626 printf (_("DSBT addressing not used\n"));
16629 printf (_("DSBT addressing used\n"));
16632 printf ("??? (%d)\n", val
);
16638 READ_ULEB (val
, p
, end
);
16639 printf (" Tag_ABI_PID: ");
16643 printf (_("Data addressing position-dependent\n"));
16646 printf (_("Data addressing position-independent, GOT near DP\n"));
16649 printf (_("Data addressing position-independent, GOT far from DP\n"));
16652 printf ("??? (%d)\n", val
);
16658 READ_ULEB (val
, p
, end
);
16659 printf (" Tag_ABI_PIC: ");
16663 printf (_("Code addressing position-dependent\n"));
16666 printf (_("Code addressing position-independent\n"));
16669 printf ("??? (%d)\n", val
);
16674 case Tag_ABI_array_object_alignment
:
16675 READ_ULEB (val
, p
, end
);
16676 printf (" Tag_ABI_array_object_alignment: ");
16680 printf (_("8-byte\n"));
16683 printf (_("4-byte\n"));
16686 printf (_("16-byte\n"));
16689 printf ("??? (%d)\n", val
);
16694 case Tag_ABI_array_object_align_expected
:
16695 READ_ULEB (val
, p
, end
);
16696 printf (" Tag_ABI_array_object_align_expected: ");
16700 printf (_("8-byte\n"));
16703 printf (_("4-byte\n"));
16706 printf (_("16-byte\n"));
16709 printf ("??? (%d)\n", val
);
16714 case Tag_ABI_compatibility
:
16716 READ_ULEB (val
, p
, end
);
16717 printf (" Tag_ABI_compatibility: ");
16718 printf (_("flag = %d, vendor = "), val
);
16721 size_t maxlen
= (end
- p
) - 1;
16723 print_symbol ((int) maxlen
, (const char *) p
);
16724 p
+= strnlen ((char *) p
, maxlen
) + 1;
16728 printf (_("<corrupt>"));
16729 p
= (unsigned char *) end
;
16735 case Tag_ABI_conformance
:
16737 printf (" Tag_ABI_conformance: \"");
16740 size_t maxlen
= (end
- p
) - 1;
16742 print_symbol ((int) maxlen
, (const char *) p
);
16743 p
+= strnlen ((char *) p
, maxlen
) + 1;
16747 printf (_("<corrupt>"));
16748 p
= (unsigned char *) end
;
16755 return display_tag_value (tag
, p
, end
);
16759 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16761 unsigned long addr
= 0;
16762 size_t bytes
= end
- p
;
16769 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16771 printf (" 0x%8.8lx ", addr
);
16773 for (j
= 0; j
< 16; j
++)
16776 printf ("%2.2x", p
[j
]);
16784 for (j
= 0; j
< lbytes
; j
++)
16787 if (k
>= ' ' && k
< 0x7f)
16803 static unsigned char *
16804 display_msp430_attribute (unsigned char * p
,
16805 const unsigned char * const end
)
16810 READ_ULEB (tag
, p
, end
);
16814 case OFBA_MSPABI_Tag_ISA
:
16815 printf (" Tag_ISA: ");
16816 READ_ULEB (val
, p
, end
);
16819 case 0: printf (_("None\n")); break;
16820 case 1: printf (_("MSP430\n")); break;
16821 case 2: printf (_("MSP430X\n")); break;
16822 default: printf ("??? (%d)\n", val
); break;
16826 case OFBA_MSPABI_Tag_Code_Model
:
16827 printf (" Tag_Code_Model: ");
16828 READ_ULEB (val
, p
, end
);
16831 case 0: printf (_("None\n")); break;
16832 case 1: printf (_("Small\n")); break;
16833 case 2: printf (_("Large\n")); break;
16834 default: printf ("??? (%d)\n", val
); break;
16838 case OFBA_MSPABI_Tag_Data_Model
:
16839 printf (" Tag_Data_Model: ");
16840 READ_ULEB (val
, p
, end
);
16843 case 0: printf (_("None\n")); break;
16844 case 1: printf (_("Small\n")); break;
16845 case 2: printf (_("Large\n")); break;
16846 case 3: printf (_("Restricted Large\n")); break;
16847 default: printf ("??? (%d)\n", val
); break;
16852 printf (_(" <unknown tag %d>: "), tag
);
16859 size_t maxlen
= (end
- p
) - 1;
16861 print_symbol ((int) maxlen
, (const char *) p
);
16862 p
+= strnlen ((char *) p
, maxlen
) + 1;
16866 printf (_("<corrupt>"));
16867 p
= (unsigned char *) end
;
16873 READ_ULEB (val
, p
, end
);
16874 printf ("%d (0x%x)\n", val
, val
);
16883 static unsigned char *
16884 display_msp430_gnu_attribute (unsigned char * p
,
16886 const unsigned char * const end
)
16888 if (tag
== Tag_GNU_MSP430_Data_Region
)
16892 printf (" Tag_GNU_MSP430_Data_Region: ");
16893 READ_ULEB (val
, p
, end
);
16897 case Val_GNU_MSP430_Data_Region_Any
:
16898 printf (_("Any Region\n"));
16900 case Val_GNU_MSP430_Data_Region_Lower
:
16901 printf (_("Lower Region Only\n"));
16904 printf ("??? (%u)\n", val
);
16908 return display_tag_value (tag
& 1, p
, end
);
16911 struct riscv_attr_tag_t
{
16916 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16918 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16921 T(priv_spec_minor
),
16922 T(priv_spec_revision
),
16923 T(unaligned_access
),
16928 static unsigned char *
16929 display_riscv_attribute (unsigned char *p
,
16930 const unsigned char * const end
)
16934 struct riscv_attr_tag_t
*attr
= NULL
;
16937 READ_ULEB (tag
, p
, end
);
16939 /* Find the name of attribute. */
16940 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16942 if (riscv_attr_tag
[i
].tag
== tag
)
16944 attr
= &riscv_attr_tag
[i
];
16950 printf (" %s: ", attr
->name
);
16952 return display_tag_value (tag
, p
, end
);
16956 case Tag_RISCV_priv_spec
:
16957 case Tag_RISCV_priv_spec_minor
:
16958 case Tag_RISCV_priv_spec_revision
:
16959 READ_ULEB (val
, p
, end
);
16960 printf (_("%u\n"), val
);
16962 case Tag_RISCV_unaligned_access
:
16963 READ_ULEB (val
, p
, end
);
16967 printf (_("No unaligned access\n"));
16970 printf (_("Unaligned access\n"));
16974 case Tag_RISCV_stack_align
:
16975 READ_ULEB (val
, p
, end
);
16976 printf (_("%u-bytes\n"), val
);
16978 case Tag_RISCV_arch
:
16979 p
= display_tag_value (-1, p
, end
);
16982 return display_tag_value (tag
, p
, end
);
16988 static unsigned char *
16989 display_csky_attribute (unsigned char * p
,
16990 const unsigned char * const end
)
16994 READ_ULEB (tag
, p
, end
);
16996 if (tag
>= Tag_CSKY_MAX
)
16998 return display_tag_value (-1, p
, end
);
17003 case Tag_CSKY_ARCH_NAME
:
17004 printf (" Tag_CSKY_ARCH_NAME:\t\t");
17005 return display_tag_value (-1, p
, end
);
17006 case Tag_CSKY_CPU_NAME
:
17007 printf (" Tag_CSKY_CPU_NAME:\t\t");
17008 return display_tag_value (-1, p
, end
);
17010 case Tag_CSKY_ISA_FLAGS
:
17011 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
17012 return display_tag_value (0, p
, end
);
17013 case Tag_CSKY_ISA_EXT_FLAGS
:
17014 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
17015 return display_tag_value (0, p
, end
);
17017 case Tag_CSKY_DSP_VERSION
:
17018 printf (" Tag_CSKY_DSP_VERSION:\t\t");
17019 READ_ULEB (val
, p
, end
);
17020 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
17021 printf ("DSP Extension\n");
17022 else if (val
== VAL_CSKY_DSP_VERSION_2
)
17023 printf ("DSP 2.0\n");
17026 case Tag_CSKY_VDSP_VERSION
:
17027 printf (" Tag_CSKY_VDSP_VERSION:\t");
17028 READ_ULEB (val
, p
, end
);
17029 printf ("VDSP Version %d\n", val
);
17032 case Tag_CSKY_FPU_VERSION
:
17033 printf (" Tag_CSKY_FPU_VERSION:\t\t");
17034 READ_ULEB (val
, p
, end
);
17035 if (val
== VAL_CSKY_FPU_VERSION_1
)
17036 printf ("ABIV1 FPU Version 1\n");
17037 else if (val
== VAL_CSKY_FPU_VERSION_2
)
17038 printf ("FPU Version 2\n");
17041 case Tag_CSKY_FPU_ABI
:
17042 printf (" Tag_CSKY_FPU_ABI:\t\t");
17043 READ_ULEB (val
, p
, end
);
17044 if (val
== VAL_CSKY_FPU_ABI_HARD
)
17046 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
17047 printf ("SoftFP\n");
17048 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
17051 case Tag_CSKY_FPU_ROUNDING
:
17052 READ_ULEB (val
, p
, end
);
17054 printf (" Tag_CSKY_FPU_ROUNDING:\t");
17055 printf ("Needed\n");
17058 case Tag_CSKY_FPU_DENORMAL
:
17059 READ_ULEB (val
, p
, end
);
17061 printf (" Tag_CSKY_FPU_DENORMAL:\t");
17062 printf ("Needed\n");
17065 case Tag_CSKY_FPU_Exception
:
17066 READ_ULEB (val
, p
, end
);
17068 printf (" Tag_CSKY_FPU_Exception:\t");
17069 printf ("Needed\n");
17072 case Tag_CSKY_FPU_NUMBER_MODULE
:
17073 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
17074 return display_tag_value (-1, p
, end
);
17075 case Tag_CSKY_FPU_HARDFP
:
17076 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
17077 READ_ULEB (val
, p
, end
);
17078 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
17080 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
17081 printf (" Single");
17082 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
17083 printf (" Double");
17087 return display_tag_value (tag
, p
, end
);
17093 process_attributes (Filedata
* filedata
,
17094 const char * public_name
,
17095 unsigned int proc_type
,
17096 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
17097 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
17099 Elf_Internal_Shdr
* sect
;
17103 /* Find the section header so that we get the size. */
17104 for (i
= 0, sect
= filedata
->section_headers
;
17105 i
< filedata
->file_header
.e_shnum
;
17108 unsigned char * contents
;
17111 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
17114 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17115 sect
->sh_size
, _("attributes"));
17116 if (contents
== NULL
)
17123 /* The first character is the version of the attributes.
17124 Currently only version 1, (aka 'A') is recognised here. */
17127 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
17132 bfd_vma section_len
;
17134 section_len
= sect
->sh_size
- 1;
17137 while (section_len
> 0)
17140 unsigned int namelen
;
17141 bool public_section
;
17144 if (section_len
<= 4)
17146 error (_("Tag section ends prematurely\n"));
17150 attr_len
= byte_get (p
, 4);
17153 if (attr_len
> section_len
)
17155 error (_("Bad attribute length (%u > %u)\n"),
17156 (unsigned) attr_len
, (unsigned) section_len
);
17157 attr_len
= section_len
;
17160 /* PR 17531: file: 001-101425-0.004 */
17161 else if (attr_len
< 5)
17163 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
17168 section_len
-= attr_len
;
17171 namelen
= strnlen ((char *) p
, attr_len
) + 1;
17172 if (namelen
== 0 || namelen
>= attr_len
)
17174 error (_("Corrupt attribute section name\n"));
17179 printf (_("Attribute Section: "));
17180 print_symbol (INT_MAX
, (const char *) p
);
17183 if (public_name
&& streq ((char *) p
, public_name
))
17184 public_section
= true;
17186 public_section
= false;
17188 if (streq ((char *) p
, "gnu"))
17189 gnu_section
= true;
17191 gnu_section
= false;
17194 attr_len
-= namelen
;
17196 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
17201 unsigned char * end
;
17203 /* PR binutils/17531: Safe handling of corrupt files. */
17206 error (_("Unused bytes at end of section\n"));
17213 size
= byte_get (p
, 4);
17214 if (size
> attr_len
)
17216 error (_("Bad subsection length (%u > %u)\n"),
17217 (unsigned) size
, (unsigned) attr_len
);
17221 /* PR binutils/17531: Safe handling of corrupt files. */
17224 error (_("Bad subsection length (%u < 6)\n"),
17232 end
= p
+ size
- 1;
17233 assert (end
<= contents
+ sect
->sh_size
);
17239 printf (_("File Attributes\n"));
17242 printf (_("Section Attributes:"));
17245 printf (_("Symbol Attributes:"));
17246 /* Fall through. */
17250 READ_ULEB (val
, p
, end
);
17253 printf (" %d", val
);
17258 printf (_("Unknown tag: %d\n"), tag
);
17259 public_section
= false;
17263 if (public_section
&& display_pub_attribute
!= NULL
)
17266 p
= display_pub_attribute (p
, end
);
17269 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17272 p
= display_gnu_attribute (p
,
17273 display_proc_gnu_attribute
,
17279 printf (_(" Unknown attribute:\n"));
17280 display_raw_attribute (p
, end
);
17295 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17296 Print the Address, Access and Initial fields of an entry at VMA ADDR
17297 and return the VMA of the next entry, or -1 if there was a problem.
17298 Does not read from DATA_END or beyond. */
17301 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17302 unsigned char * data_end
)
17305 print_vma (addr
, LONG_HEX
);
17307 if (addr
< pltgot
+ 0xfff0)
17308 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17310 printf ("%10s", "");
17313 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17317 unsigned char * from
= data
+ addr
- pltgot
;
17319 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17321 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17322 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17323 return (bfd_vma
) -1;
17327 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17328 print_vma (entry
, LONG_HEX
);
17331 return addr
+ (is_32bit_elf
? 4 : 8);
17334 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17335 PLTGOT. Print the Address and Initial fields of an entry at VMA
17336 ADDR and return the VMA of the next entry. */
17339 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17342 print_vma (addr
, LONG_HEX
);
17345 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17350 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17351 print_vma (entry
, LONG_HEX
);
17353 return addr
+ (is_32bit_elf
? 4 : 8);
17357 print_mips_ases (unsigned int mask
)
17359 if (mask
& AFL_ASE_DSP
)
17360 fputs ("\n\tDSP ASE", stdout
);
17361 if (mask
& AFL_ASE_DSPR2
)
17362 fputs ("\n\tDSP R2 ASE", stdout
);
17363 if (mask
& AFL_ASE_DSPR3
)
17364 fputs ("\n\tDSP R3 ASE", stdout
);
17365 if (mask
& AFL_ASE_EVA
)
17366 fputs ("\n\tEnhanced VA Scheme", stdout
);
17367 if (mask
& AFL_ASE_MCU
)
17368 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17369 if (mask
& AFL_ASE_MDMX
)
17370 fputs ("\n\tMDMX ASE", stdout
);
17371 if (mask
& AFL_ASE_MIPS3D
)
17372 fputs ("\n\tMIPS-3D ASE", stdout
);
17373 if (mask
& AFL_ASE_MT
)
17374 fputs ("\n\tMT ASE", stdout
);
17375 if (mask
& AFL_ASE_SMARTMIPS
)
17376 fputs ("\n\tSmartMIPS ASE", stdout
);
17377 if (mask
& AFL_ASE_VIRT
)
17378 fputs ("\n\tVZ ASE", stdout
);
17379 if (mask
& AFL_ASE_MSA
)
17380 fputs ("\n\tMSA ASE", stdout
);
17381 if (mask
& AFL_ASE_MIPS16
)
17382 fputs ("\n\tMIPS16 ASE", stdout
);
17383 if (mask
& AFL_ASE_MICROMIPS
)
17384 fputs ("\n\tMICROMIPS ASE", stdout
);
17385 if (mask
& AFL_ASE_XPA
)
17386 fputs ("\n\tXPA ASE", stdout
);
17387 if (mask
& AFL_ASE_MIPS16E2
)
17388 fputs ("\n\tMIPS16e2 ASE", stdout
);
17389 if (mask
& AFL_ASE_CRC
)
17390 fputs ("\n\tCRC ASE", stdout
);
17391 if (mask
& AFL_ASE_GINV
)
17392 fputs ("\n\tGINV ASE", stdout
);
17393 if (mask
& AFL_ASE_LOONGSON_MMI
)
17394 fputs ("\n\tLoongson MMI ASE", stdout
);
17395 if (mask
& AFL_ASE_LOONGSON_CAM
)
17396 fputs ("\n\tLoongson CAM ASE", stdout
);
17397 if (mask
& AFL_ASE_LOONGSON_EXT
)
17398 fputs ("\n\tLoongson EXT ASE", stdout
);
17399 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17400 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17402 fprintf (stdout
, "\n\t%s", _("None"));
17403 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17404 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17408 print_mips_isa_ext (unsigned int isa_ext
)
17413 fputs (_("None"), stdout
);
17416 fputs ("RMI XLR", stdout
);
17418 case AFL_EXT_OCTEON3
:
17419 fputs ("Cavium Networks Octeon3", stdout
);
17421 case AFL_EXT_OCTEON2
:
17422 fputs ("Cavium Networks Octeon2", stdout
);
17424 case AFL_EXT_OCTEONP
:
17425 fputs ("Cavium Networks OcteonP", stdout
);
17427 case AFL_EXT_OCTEON
:
17428 fputs ("Cavium Networks Octeon", stdout
);
17431 fputs ("Toshiba R5900", stdout
);
17434 fputs ("MIPS R4650", stdout
);
17437 fputs ("LSI R4010", stdout
);
17440 fputs ("NEC VR4100", stdout
);
17443 fputs ("Toshiba R3900", stdout
);
17445 case AFL_EXT_10000
:
17446 fputs ("MIPS R10000", stdout
);
17449 fputs ("Broadcom SB-1", stdout
);
17452 fputs ("NEC VR4111/VR4181", stdout
);
17455 fputs ("NEC VR4120", stdout
);
17458 fputs ("NEC VR5400", stdout
);
17461 fputs ("NEC VR5500", stdout
);
17463 case AFL_EXT_LOONGSON_2E
:
17464 fputs ("ST Microelectronics Loongson 2E", stdout
);
17466 case AFL_EXT_LOONGSON_2F
:
17467 fputs ("ST Microelectronics Loongson 2F", stdout
);
17469 case AFL_EXT_INTERAPTIV_MR2
:
17470 fputs ("Imagination interAptiv MR2", stdout
);
17473 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17478 get_mips_reg_size (int reg_size
)
17480 return (reg_size
== AFL_REG_NONE
) ? 0
17481 : (reg_size
== AFL_REG_32
) ? 32
17482 : (reg_size
== AFL_REG_64
) ? 64
17483 : (reg_size
== AFL_REG_128
) ? 128
17488 process_mips_specific (Filedata
* filedata
)
17490 Elf_Internal_Dyn
* entry
;
17491 Elf_Internal_Shdr
*sect
= NULL
;
17492 size_t liblist_offset
= 0;
17493 size_t liblistno
= 0;
17494 size_t conflictsno
= 0;
17495 size_t options_offset
= 0;
17496 size_t conflicts_offset
= 0;
17497 size_t pltrelsz
= 0;
17499 bfd_vma pltgot
= 0;
17500 bfd_vma mips_pltgot
= 0;
17501 bfd_vma jmprel
= 0;
17502 bfd_vma local_gotno
= 0;
17503 bfd_vma gotsym
= 0;
17504 bfd_vma symtabno
= 0;
17507 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17508 display_mips_gnu_attribute
))
17511 sect
= find_section (filedata
, ".MIPS.abiflags");
17515 Elf_External_ABIFlags_v0
*abiflags_ext
;
17516 Elf_Internal_ABIFlags_v0 abiflags_in
;
17518 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17520 error (_("Corrupt MIPS ABI Flags section.\n"));
17525 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17526 sect
->sh_size
, _("MIPS ABI Flags section"));
17529 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17530 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17531 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17532 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17533 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17534 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17535 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17536 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17537 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17538 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17539 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17541 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17542 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17543 if (abiflags_in
.isa_rev
> 1)
17544 printf ("r%d", abiflags_in
.isa_rev
);
17545 printf ("\nGPR size: %d",
17546 get_mips_reg_size (abiflags_in
.gpr_size
));
17547 printf ("\nCPR1 size: %d",
17548 get_mips_reg_size (abiflags_in
.cpr1_size
));
17549 printf ("\nCPR2 size: %d",
17550 get_mips_reg_size (abiflags_in
.cpr2_size
));
17551 fputs ("\nFP ABI: ", stdout
);
17552 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17553 fputs ("ISA Extension: ", stdout
);
17554 print_mips_isa_ext (abiflags_in
.isa_ext
);
17555 fputs ("\nASEs:", stdout
);
17556 print_mips_ases (abiflags_in
.ases
);
17557 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17558 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17559 fputc ('\n', stdout
);
17560 free (abiflags_ext
);
17565 /* We have a lot of special sections. Thanks SGI! */
17566 if (filedata
->dynamic_section
== NULL
)
17568 /* No dynamic information available. See if there is static GOT. */
17569 sect
= find_section (filedata
, ".got");
17572 unsigned char *data_end
;
17573 unsigned char *data
;
17577 pltgot
= sect
->sh_addr
;
17580 addr_size
= (is_32bit_elf
? 4 : 8);
17581 end
= pltgot
+ sect
->sh_size
;
17583 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17585 _("Global Offset Table data"));
17586 /* PR 12855: Null data is handled gracefully throughout. */
17587 data_end
= data
+ (end
- pltgot
);
17589 printf (_("\nStatic GOT:\n"));
17590 printf (_(" Canonical gp value: "));
17591 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17594 /* In a dynamic binary GOT[0] is reserved for the dynamic
17595 loader to store the lazy resolver pointer, however in
17596 a static binary it may well have been omitted and GOT
17597 reduced to a table of addresses.
17598 PR 21344: Check for the entry being fully available
17599 before fetching it. */
17601 && data
+ ent
- pltgot
+ addr_size
<= data_end
17602 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17604 printf (_(" Reserved entries:\n"));
17605 printf (_(" %*s %10s %*s\n"),
17606 addr_size
* 2, _("Address"), _("Access"),
17607 addr_size
* 2, _("Value"));
17608 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17610 if (ent
== (bfd_vma
) -1)
17611 goto sgot_print_fail
;
17613 /* Check for the MSB of GOT[1] being set, identifying a
17614 GNU object. This entry will be used by some runtime
17615 loaders, to store the module pointer. Otherwise this
17616 is an ordinary local entry.
17617 PR 21344: Check for the entry being fully available
17618 before fetching it. */
17620 && data
+ ent
- pltgot
+ addr_size
<= data_end
17621 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17622 >> (addr_size
* 8 - 1)) != 0)
17624 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17626 if (ent
== (bfd_vma
) -1)
17627 goto sgot_print_fail
;
17632 if (data
!= NULL
&& ent
< end
)
17634 printf (_(" Local entries:\n"));
17635 printf (" %*s %10s %*s\n",
17636 addr_size
* 2, _("Address"), _("Access"),
17637 addr_size
* 2, _("Value"));
17640 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17642 if (ent
== (bfd_vma
) -1)
17643 goto sgot_print_fail
;
17654 for (entry
= filedata
->dynamic_section
;
17655 /* PR 17531 file: 012-50589-0.004. */
17656 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17657 && entry
->d_tag
!= DT_NULL
);
17659 switch (entry
->d_tag
)
17661 case DT_MIPS_LIBLIST
:
17663 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17664 liblistno
* sizeof (Elf32_External_Lib
));
17666 case DT_MIPS_LIBLISTNO
:
17667 liblistno
= entry
->d_un
.d_val
;
17669 case DT_MIPS_OPTIONS
:
17670 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17672 case DT_MIPS_CONFLICT
:
17674 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17675 conflictsno
* sizeof (Elf32_External_Conflict
));
17677 case DT_MIPS_CONFLICTNO
:
17678 conflictsno
= entry
->d_un
.d_val
;
17681 pltgot
= entry
->d_un
.d_ptr
;
17683 case DT_MIPS_LOCAL_GOTNO
:
17684 local_gotno
= entry
->d_un
.d_val
;
17686 case DT_MIPS_GOTSYM
:
17687 gotsym
= entry
->d_un
.d_val
;
17689 case DT_MIPS_SYMTABNO
:
17690 symtabno
= entry
->d_un
.d_val
;
17692 case DT_MIPS_PLTGOT
:
17693 mips_pltgot
= entry
->d_un
.d_ptr
;
17696 pltrel
= entry
->d_un
.d_val
;
17699 pltrelsz
= entry
->d_un
.d_val
;
17702 jmprel
= entry
->d_un
.d_ptr
;
17708 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17710 Elf32_External_Lib
* elib
;
17713 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17714 sizeof (Elf32_External_Lib
),
17716 _("liblist section data"));
17719 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17720 "\nSection '.liblist' contains %lu entries:\n",
17721 (unsigned long) liblistno
),
17722 (unsigned long) liblistno
);
17723 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17726 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17733 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17734 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17735 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17736 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17737 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17739 tmp
= gmtime (&atime
);
17740 snprintf (timebuf
, sizeof (timebuf
),
17741 "%04u-%02u-%02uT%02u:%02u:%02u",
17742 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17743 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17745 printf ("%3lu: ", (unsigned long) cnt
);
17746 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17747 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17749 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17750 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17751 liblist
.l_version
);
17753 if (liblist
.l_flags
== 0)
17757 static const struct
17764 { " EXACT_MATCH", LL_EXACT_MATCH
},
17765 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17766 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17767 { " EXPORTS", LL_EXPORTS
},
17768 { " DELAY_LOAD", LL_DELAY_LOAD
},
17769 { " DELTA", LL_DELTA
}
17771 int flags
= liblist
.l_flags
;
17774 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17775 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17777 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17778 flags
^= l_flags_vals
[fcnt
].bit
;
17781 printf (" %#x", (unsigned int) flags
);
17793 if (options_offset
!= 0)
17795 Elf_External_Options
* eopt
;
17798 sect
= filedata
->section_headers
;
17800 /* Find the section header so that we get the size. */
17801 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17802 /* PR 17533 file: 012-277276-0.004. */
17805 error (_("No MIPS_OPTIONS header found\n"));
17809 if (sect
->sh_size
< sizeof (* eopt
))
17811 error (_("The MIPS options section is too small.\n"));
17815 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17816 sect
->sh_size
, _("options"));
17819 Elf_Internal_Options option
;
17822 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17824 Elf_External_Options
* eoption
;
17825 unsigned int optsize
;
17827 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17829 optsize
= BYTE_GET (eoption
->size
);
17831 /* PR 17531: file: ffa0fa3b. */
17832 if (optsize
< sizeof (* eopt
)
17833 || optsize
> sect
->sh_size
- offset
)
17835 error (_("Invalid size (%u) for MIPS option\n"),
17844 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17845 "\nSection '%s' contains %d entries:\n",
17847 printable_section_name (filedata
, sect
), cnt
);
17853 Elf_External_Options
* eoption
;
17855 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17857 option
.kind
= BYTE_GET (eoption
->kind
);
17858 option
.size
= BYTE_GET (eoption
->size
);
17859 option
.section
= BYTE_GET (eoption
->section
);
17860 option
.info
= BYTE_GET (eoption
->info
);
17862 switch (option
.kind
)
17865 /* This shouldn't happen. */
17866 printf (" NULL %" PRId16
" %" PRIx32
,
17867 option
.section
, option
.info
);
17871 printf (" REGINFO ");
17872 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17874 Elf32_External_RegInfo
* ereg
;
17875 Elf32_RegInfo reginfo
;
17878 if (option
.size
< (sizeof (Elf_External_Options
)
17879 + sizeof (Elf32_External_RegInfo
)))
17881 printf (_("<corrupt>\n"));
17882 error (_("Truncated MIPS REGINFO option\n"));
17887 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17889 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17890 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17891 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17892 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17893 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17894 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17896 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17897 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17899 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17900 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17901 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17902 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17907 Elf64_External_RegInfo
* ereg
;
17908 Elf64_Internal_RegInfo reginfo
;
17910 if (option
.size
< (sizeof (Elf_External_Options
)
17911 + sizeof (Elf64_External_RegInfo
)))
17913 printf (_("<corrupt>\n"));
17914 error (_("Truncated MIPS REGINFO option\n"));
17919 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17920 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17921 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17922 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17923 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17924 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17925 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17927 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17928 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17930 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17931 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17932 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17933 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17935 offset
+= option
.size
;
17938 case ODK_EXCEPTIONS
:
17939 fputs (" EXCEPTIONS fpe_min(", stdout
);
17940 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17941 fputs (") fpe_max(", stdout
);
17942 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17943 fputs (")", stdout
);
17945 if (option
.info
& OEX_PAGE0
)
17946 fputs (" PAGE0", stdout
);
17947 if (option
.info
& OEX_SMM
)
17948 fputs (" SMM", stdout
);
17949 if (option
.info
& OEX_FPDBUG
)
17950 fputs (" FPDBUG", stdout
);
17951 if (option
.info
& OEX_DISMISS
)
17952 fputs (" DISMISS", stdout
);
17956 fputs (" PAD ", stdout
);
17957 if (option
.info
& OPAD_PREFIX
)
17958 fputs (" PREFIX", stdout
);
17959 if (option
.info
& OPAD_POSTFIX
)
17960 fputs (" POSTFIX", stdout
);
17961 if (option
.info
& OPAD_SYMBOL
)
17962 fputs (" SYMBOL", stdout
);
17966 fputs (" HWPATCH ", stdout
);
17967 if (option
.info
& OHW_R4KEOP
)
17968 fputs (" R4KEOP", stdout
);
17969 if (option
.info
& OHW_R8KPFETCH
)
17970 fputs (" R8KPFETCH", stdout
);
17971 if (option
.info
& OHW_R5KEOP
)
17972 fputs (" R5KEOP", stdout
);
17973 if (option
.info
& OHW_R5KCVTL
)
17974 fputs (" R5KCVTL", stdout
);
17978 fputs (" FILL ", stdout
);
17979 /* XXX Print content of info word? */
17983 fputs (" TAGS ", stdout
);
17984 /* XXX Print content of info word? */
17988 fputs (" HWAND ", stdout
);
17989 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17990 fputs (" R4KEOP_CHECKED", stdout
);
17991 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17992 fputs (" R4KEOP_CLEAN", stdout
);
17996 fputs (" HWOR ", stdout
);
17997 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17998 fputs (" R4KEOP_CHECKED", stdout
);
17999 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
18000 fputs (" R4KEOP_CLEAN", stdout
);
18004 printf (" GP_GROUP %#06x self-contained %#06x",
18005 option
.info
& OGP_GROUP
,
18006 (option
.info
& OGP_SELF
) >> 16);
18010 printf (" IDENT %#06x self-contained %#06x",
18011 option
.info
& OGP_GROUP
,
18012 (option
.info
& OGP_SELF
) >> 16);
18016 /* This shouldn't happen. */
18017 printf (" %3d ??? %" PRId16
" %" PRIx32
,
18018 option
.kind
, option
.section
, option
.info
);
18022 len
= sizeof (* eopt
);
18023 while (len
< option
.size
)
18025 unsigned char datum
= *((unsigned char *) eoption
+ len
);
18027 if (ISPRINT (datum
))
18028 printf ("%c", datum
);
18030 printf ("\\%03o", datum
);
18033 fputs ("\n", stdout
);
18035 offset
+= option
.size
;
18043 if (conflicts_offset
!= 0 && conflictsno
!= 0)
18045 Elf32_Conflict
* iconf
;
18048 if (filedata
->dynamic_symbols
== NULL
)
18050 error (_("conflict list found without a dynamic symbol table\n"));
18054 /* PR 21345 - print a slightly more helpful error message
18055 if we are sure that the cmalloc will fail. */
18056 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
18058 error (_("Overlarge number of conflicts detected: %lx\n"),
18059 (long) conflictsno
);
18063 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
18066 error (_("Out of memory allocating space for dynamic conflicts\n"));
18072 Elf32_External_Conflict
* econf32
;
18074 econf32
= (Elf32_External_Conflict
*)
18075 get_data (NULL
, filedata
, conflicts_offset
,
18076 sizeof (*econf32
), conflictsno
, _("conflict"));
18083 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18084 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
18090 Elf64_External_Conflict
* econf64
;
18092 econf64
= (Elf64_External_Conflict
*)
18093 get_data (NULL
, filedata
, conflicts_offset
,
18094 sizeof (*econf64
), conflictsno
, _("conflict"));
18101 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18102 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
18107 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
18108 "\nSection '.conflict' contains %lu entries:\n",
18109 (unsigned long) conflictsno
),
18110 (unsigned long) conflictsno
);
18111 puts (_(" Num: Index Value Name"));
18113 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
18115 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
18117 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
18118 printf (_("<corrupt symbol index>"));
18121 Elf_Internal_Sym
* psym
;
18123 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
18124 print_vma (psym
->st_value
, FULL_HEX
);
18126 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18127 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18129 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18137 if (pltgot
!= 0 && local_gotno
!= 0)
18139 bfd_vma ent
, local_end
, global_end
;
18141 unsigned char * data
;
18142 unsigned char * data_end
;
18146 addr_size
= (is_32bit_elf
? 4 : 8);
18147 local_end
= pltgot
+ local_gotno
* addr_size
;
18149 /* PR binutils/17533 file: 012-111227-0.004 */
18150 if (symtabno
< gotsym
)
18152 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
18153 (unsigned long) gotsym
, (unsigned long) symtabno
);
18157 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
18158 /* PR 17531: file: 54c91a34. */
18159 if (global_end
< local_end
)
18161 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
18165 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
18166 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
18167 global_end
- pltgot
, 1,
18168 _("Global Offset Table data"));
18169 /* PR 12855: Null data is handled gracefully throughout. */
18170 data_end
= data
+ (global_end
- pltgot
);
18172 printf (_("\nPrimary GOT:\n"));
18173 printf (_(" Canonical gp value: "));
18174 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
18177 printf (_(" Reserved entries:\n"));
18178 printf (_(" %*s %10s %*s Purpose\n"),
18179 addr_size
* 2, _("Address"), _("Access"),
18180 addr_size
* 2, _("Initial"));
18181 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18182 printf (_(" Lazy resolver\n"));
18183 if (ent
== (bfd_vma
) -1)
18184 goto got_print_fail
;
18186 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
18187 This entry will be used by some runtime loaders, to store the
18188 module pointer. Otherwise this is an ordinary local entry.
18189 PR 21344: Check for the entry being fully available before
18192 && data
+ ent
- pltgot
+ addr_size
<= data_end
18193 && (byte_get (data
+ ent
- pltgot
, addr_size
)
18194 >> (addr_size
* 8 - 1)) != 0)
18196 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18197 printf (_(" Module pointer (GNU extension)\n"));
18198 if (ent
== (bfd_vma
) -1)
18199 goto got_print_fail
;
18203 if (data
!= NULL
&& ent
< local_end
)
18205 printf (_(" Local entries:\n"));
18206 printf (" %*s %10s %*s\n",
18207 addr_size
* 2, _("Address"), _("Access"),
18208 addr_size
* 2, _("Initial"));
18209 while (ent
< local_end
)
18211 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18213 if (ent
== (bfd_vma
) -1)
18214 goto got_print_fail
;
18219 if (data
!= NULL
&& gotsym
< symtabno
)
18223 printf (_(" Global entries:\n"));
18224 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18225 addr_size
* 2, _("Address"),
18227 addr_size
* 2, _("Initial"),
18228 addr_size
* 2, _("Sym.Val."),
18230 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18231 _("Ndx"), _("Name"));
18233 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18235 for (i
= gotsym
; i
< symtabno
; i
++)
18237 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18240 if (filedata
->dynamic_symbols
== NULL
)
18241 printf (_("<no dynamic symbols>"));
18242 else if (i
< filedata
->num_dynamic_syms
)
18244 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18246 print_vma (psym
->st_value
, LONG_HEX
);
18247 printf (" %-7s %3s ",
18248 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18249 get_symbol_index_type (filedata
, psym
->st_shndx
));
18251 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18252 print_symbol (sym_width
,
18253 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18255 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18258 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18259 (unsigned long) i
);
18262 if (ent
== (bfd_vma
) -1)
18272 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18275 size_t offset
, rel_offset
;
18276 unsigned long count
, i
;
18277 unsigned char * data
;
18278 int addr_size
, sym_width
;
18279 Elf_Internal_Rela
* rels
;
18281 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18282 if (pltrel
== DT_RELA
)
18284 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18289 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18294 addr_size
= (is_32bit_elf
? 4 : 8);
18295 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18297 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18298 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18299 1, _("Procedure Linkage Table data"));
18306 printf ("\nPLT GOT:\n\n");
18307 printf (_(" Reserved entries:\n"));
18308 printf (_(" %*s %*s Purpose\n"),
18309 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18310 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18311 printf (_(" PLT lazy resolver\n"));
18312 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18313 printf (_(" Module pointer\n"));
18316 printf (_(" Entries:\n"));
18317 printf (" %*s %*s %*s %-7s %3s %s\n",
18318 addr_size
* 2, _("Address"),
18319 addr_size
* 2, _("Initial"),
18320 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18321 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18322 for (i
= 0; i
< count
; i
++)
18324 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18326 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18329 if (idx
>= filedata
->num_dynamic_syms
)
18330 printf (_("<corrupt symbol index: %lu>"), idx
);
18333 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18335 print_vma (psym
->st_value
, LONG_HEX
);
18336 printf (" %-7s %3s ",
18337 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18338 get_symbol_index_type (filedata
, psym
->st_shndx
));
18339 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18340 print_symbol (sym_width
,
18341 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18343 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18357 process_nds32_specific (Filedata
* filedata
)
18359 Elf_Internal_Shdr
*sect
= NULL
;
18361 sect
= find_section (filedata
, ".nds32_e_flags");
18362 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18364 unsigned char *buf
;
18367 printf ("\nNDS32 elf flags section:\n");
18368 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18369 _("NDS32 elf flags section"));
18374 flag
= byte_get (buf
, 4);
18376 switch (flag
& 0x3)
18379 printf ("(VEC_SIZE):\tNo entry.\n");
18382 printf ("(VEC_SIZE):\t4 bytes\n");
18385 printf ("(VEC_SIZE):\t16 bytes\n");
18388 printf ("(VEC_SIZE):\treserved\n");
18397 process_gnu_liblist (Filedata
* filedata
)
18399 Elf_Internal_Shdr
* section
;
18400 Elf_Internal_Shdr
* string_sec
;
18401 Elf32_External_Lib
* elib
;
18403 size_t strtab_size
;
18405 unsigned long num_liblist
;
18412 for (i
= 0, section
= filedata
->section_headers
;
18413 i
< filedata
->file_header
.e_shnum
;
18416 switch (section
->sh_type
)
18418 case SHT_GNU_LIBLIST
:
18419 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18422 elib
= (Elf32_External_Lib
*)
18423 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18424 _("liblist section data"));
18432 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18433 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18434 string_sec
->sh_size
,
18435 _("liblist string table"));
18437 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18444 strtab_size
= string_sec
->sh_size
;
18446 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18447 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18448 "\nLibrary list section '%s' contains %lu entries:\n",
18450 printable_section_name (filedata
, section
),
18453 puts (_(" Library Time Stamp Checksum Version Flags"));
18455 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18463 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18464 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18465 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18466 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18467 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18469 tmp
= gmtime (&atime
);
18470 snprintf (timebuf
, sizeof (timebuf
),
18471 "%04u-%02u-%02uT%02u:%02u:%02u",
18472 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18473 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18475 printf ("%3lu: ", (unsigned long) cnt
);
18477 printf ("%-20s", liblist
.l_name
< strtab_size
18478 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18480 printf ("%-20.20s", liblist
.l_name
< strtab_size
18481 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18482 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18483 liblist
.l_version
, liblist
.l_flags
);
18494 static const char *
18495 get_note_type (Filedata
* filedata
, unsigned e_type
)
18497 static char buff
[64];
18499 if (filedata
->file_header
.e_type
== ET_CORE
)
18503 return _("NT_AUXV (auxiliary vector)");
18505 return _("NT_PRSTATUS (prstatus structure)");
18507 return _("NT_FPREGSET (floating point registers)");
18509 return _("NT_PRPSINFO (prpsinfo structure)");
18510 case NT_TASKSTRUCT
:
18511 return _("NT_TASKSTRUCT (task structure)");
18513 return _("NT_GDB_TDESC (GDB XML target description)");
18515 return _("NT_PRXFPREG (user_xfpregs structure)");
18517 return _("NT_PPC_VMX (ppc Altivec registers)");
18519 return _("NT_PPC_VSX (ppc VSX registers)");
18521 return _("NT_PPC_TAR (ppc TAR register)");
18523 return _("NT_PPC_PPR (ppc PPR register)");
18525 return _("NT_PPC_DSCR (ppc DSCR register)");
18527 return _("NT_PPC_EBB (ppc EBB registers)");
18529 return _("NT_PPC_PMU (ppc PMU registers)");
18530 case NT_PPC_TM_CGPR
:
18531 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18532 case NT_PPC_TM_CFPR
:
18533 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18534 case NT_PPC_TM_CVMX
:
18535 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18536 case NT_PPC_TM_CVSX
:
18537 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18538 case NT_PPC_TM_SPR
:
18539 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18540 case NT_PPC_TM_CTAR
:
18541 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18542 case NT_PPC_TM_CPPR
:
18543 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18544 case NT_PPC_TM_CDSCR
:
18545 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18547 return _("NT_386_TLS (x86 TLS information)");
18548 case NT_386_IOPERM
:
18549 return _("NT_386_IOPERM (x86 I/O permissions)");
18550 case NT_X86_XSTATE
:
18551 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18553 return _("NT_X86_CET (x86 CET state)");
18554 case NT_S390_HIGH_GPRS
:
18555 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18556 case NT_S390_TIMER
:
18557 return _("NT_S390_TIMER (s390 timer register)");
18558 case NT_S390_TODCMP
:
18559 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18560 case NT_S390_TODPREG
:
18561 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18563 return _("NT_S390_CTRS (s390 control registers)");
18564 case NT_S390_PREFIX
:
18565 return _("NT_S390_PREFIX (s390 prefix register)");
18566 case NT_S390_LAST_BREAK
:
18567 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18568 case NT_S390_SYSTEM_CALL
:
18569 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18571 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18572 case NT_S390_VXRS_LOW
:
18573 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18574 case NT_S390_VXRS_HIGH
:
18575 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18576 case NT_S390_GS_CB
:
18577 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18578 case NT_S390_GS_BC
:
18579 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18581 return _("NT_ARM_VFP (arm VFP registers)");
18583 return _("NT_ARM_TLS (AArch TLS registers)");
18584 case NT_ARM_HW_BREAK
:
18585 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18586 case NT_ARM_HW_WATCH
:
18587 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18589 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18591 return _("NT_RISCV_CSR (RISC-V control and status registers)");
18593 return _("NT_PSTATUS (pstatus structure)");
18595 return _("NT_FPREGS (floating point registers)");
18597 return _("NT_PSINFO (psinfo structure)");
18599 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18601 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18602 case NT_WIN32PSTATUS
:
18603 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18605 return _("NT_SIGINFO (siginfo_t data)");
18607 return _("NT_FILE (mapped files)");
18615 return _("NT_VERSION (version)");
18617 return _("NT_ARCH (architecture)");
18618 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18620 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18626 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18631 print_core_note (Elf_Internal_Note
*pnote
)
18633 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18634 bfd_vma count
, page_size
;
18635 unsigned char *descdata
, *filenames
, *descend
;
18637 if (pnote
->type
!= NT_FILE
)
18647 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18648 /* Still "successful". */
18653 if (pnote
->descsz
< 2 * addr_size
)
18655 error (_(" Malformed note - too short for header\n"));
18659 descdata
= (unsigned char *) pnote
->descdata
;
18660 descend
= descdata
+ pnote
->descsz
;
18662 if (descdata
[pnote
->descsz
- 1] != '\0')
18664 error (_(" Malformed note - does not end with \\0\n"));
18668 count
= byte_get (descdata
, addr_size
);
18669 descdata
+= addr_size
;
18671 page_size
= byte_get (descdata
, addr_size
);
18672 descdata
+= addr_size
;
18674 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18675 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18677 error (_(" Malformed note - too short for supplied file count\n"));
18681 printf (_(" Page size: "));
18682 print_vma (page_size
, DEC
);
18685 printf (_(" %*s%*s%*s\n"),
18686 (int) (2 + 2 * addr_size
), _("Start"),
18687 (int) (4 + 2 * addr_size
), _("End"),
18688 (int) (4 + 2 * addr_size
), _("Page Offset"));
18689 filenames
= descdata
+ count
* 3 * addr_size
;
18690 while (count
-- > 0)
18692 bfd_vma start
, end
, file_ofs
;
18694 if (filenames
== descend
)
18696 error (_(" Malformed note - filenames end too early\n"));
18700 start
= byte_get (descdata
, addr_size
);
18701 descdata
+= addr_size
;
18702 end
= byte_get (descdata
, addr_size
);
18703 descdata
+= addr_size
;
18704 file_ofs
= byte_get (descdata
, addr_size
);
18705 descdata
+= addr_size
;
18708 print_vma (start
, FULL_HEX
);
18710 print_vma (end
, FULL_HEX
);
18712 print_vma (file_ofs
, FULL_HEX
);
18713 printf ("\n %s\n", filenames
);
18715 filenames
+= 1 + strlen ((char *) filenames
);
18721 static const char *
18722 get_gnu_elf_note_type (unsigned e_type
)
18724 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18727 case NT_GNU_ABI_TAG
:
18728 return _("NT_GNU_ABI_TAG (ABI version tag)");
18730 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18731 case NT_GNU_BUILD_ID
:
18732 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18733 case NT_GNU_GOLD_VERSION
:
18734 return _("NT_GNU_GOLD_VERSION (gold version)");
18735 case NT_GNU_PROPERTY_TYPE_0
:
18736 return _("NT_GNU_PROPERTY_TYPE_0");
18737 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18738 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18739 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18740 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18743 static char buff
[64];
18745 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18752 decode_x86_compat_isa (unsigned int bitmask
)
18756 unsigned int bit
= bitmask
& (- bitmask
);
18761 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18764 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18767 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18770 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18773 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18776 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18779 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18782 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18785 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18788 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18791 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18794 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18795 printf ("AVX512F");
18797 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18798 printf ("AVX512CD");
18800 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18801 printf ("AVX512ER");
18803 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18804 printf ("AVX512PF");
18806 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18807 printf ("AVX512VL");
18809 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18810 printf ("AVX512DQ");
18812 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18813 printf ("AVX512BW");
18816 printf (_("<unknown: %x>"), bit
);
18825 decode_x86_compat_2_isa (unsigned int bitmask
)
18829 printf (_("<None>"));
18835 unsigned int bit
= bitmask
& (- bitmask
);
18840 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18843 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18846 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18849 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18852 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
18855 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
18858 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
18861 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
18864 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
18867 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
18870 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
18871 printf ("AVX512F");
18873 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
18874 printf ("AVX512CD");
18876 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
18877 printf ("AVX512ER");
18879 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
18880 printf ("AVX512PF");
18882 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
18883 printf ("AVX512VL");
18885 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
18886 printf ("AVX512DQ");
18888 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
18889 printf ("AVX512BW");
18891 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
18892 printf ("AVX512_4FMAPS");
18894 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
18895 printf ("AVX512_4VNNIW");
18897 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
18898 printf ("AVX512_BITALG");
18900 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
18901 printf ("AVX512_IFMA");
18903 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
18904 printf ("AVX512_VBMI");
18906 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
18907 printf ("AVX512_VBMI2");
18909 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
18910 printf ("AVX512_VNNI");
18912 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
18913 printf ("AVX512_BF16");
18916 printf (_("<unknown: %x>"), bit
);
18925 decode_x86_isa (unsigned int bitmask
)
18929 unsigned int bit
= bitmask
& (- bitmask
);
18934 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
18935 printf ("x86-64-baseline");
18937 case GNU_PROPERTY_X86_ISA_1_V2
:
18938 printf ("x86-64-v2");
18940 case GNU_PROPERTY_X86_ISA_1_V3
:
18941 printf ("x86-64-v3");
18943 case GNU_PROPERTY_X86_ISA_1_V4
:
18944 printf ("x86-64-v4");
18947 printf (_("<unknown: %x>"), bit
);
18956 decode_x86_feature_1 (unsigned int bitmask
)
18960 printf (_("<None>"));
18966 unsigned int bit
= bitmask
& (- bitmask
);
18971 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18974 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18977 case GNU_PROPERTY_X86_FEATURE_1_LAM_U48
:
18978 printf ("LAM_U48");
18980 case GNU_PROPERTY_X86_FEATURE_1_LAM_U57
:
18981 printf ("LAM_U57");
18984 printf (_("<unknown: %x>"), bit
);
18993 decode_x86_feature_2 (unsigned int bitmask
)
18997 printf (_("<None>"));
19003 unsigned int bit
= bitmask
& (- bitmask
);
19008 case GNU_PROPERTY_X86_FEATURE_2_X86
:
19011 case GNU_PROPERTY_X86_FEATURE_2_X87
:
19014 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
19017 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
19020 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
19023 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
19026 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
19029 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
19032 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
19035 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
19038 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
19039 printf ("XSAVEOPT");
19041 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
19045 printf (_("<unknown: %x>"), bit
);
19054 decode_aarch64_feature_1_and (unsigned int bitmask
)
19058 unsigned int bit
= bitmask
& (- bitmask
);
19063 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
19067 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
19072 printf (_("<unknown: %x>"), bit
);
19081 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
19083 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
19084 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
19085 unsigned int size
= is_32bit_elf
? 4 : 8;
19087 printf (_(" Properties: "));
19089 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
19091 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
19095 while (ptr
< ptr_end
)
19099 unsigned int datasz
;
19101 if ((size_t) (ptr_end
- ptr
) < 8)
19103 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
19107 type
= byte_get (ptr
, 4);
19108 datasz
= byte_get (ptr
+ 4, 4);
19112 if (datasz
> (size_t) (ptr_end
- ptr
))
19114 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
19119 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
19121 if (filedata
->file_header
.e_machine
== EM_X86_64
19122 || filedata
->file_header
.e_machine
== EM_IAMCU
19123 || filedata
->file_header
.e_machine
== EM_386
)
19125 unsigned int bitmask
;
19128 bitmask
= byte_get (ptr
, 4);
19134 case GNU_PROPERTY_X86_ISA_1_USED
:
19136 printf (_("x86 ISA used: <corrupt length: %#x> "),
19140 printf ("x86 ISA used: ");
19141 decode_x86_isa (bitmask
);
19145 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
19147 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19151 printf ("x86 ISA needed: ");
19152 decode_x86_isa (bitmask
);
19156 case GNU_PROPERTY_X86_FEATURE_1_AND
:
19158 printf (_("x86 feature: <corrupt length: %#x> "),
19162 printf ("x86 feature: ");
19163 decode_x86_feature_1 (bitmask
);
19167 case GNU_PROPERTY_X86_FEATURE_2_USED
:
19169 printf (_("x86 feature used: <corrupt length: %#x> "),
19173 printf ("x86 feature used: ");
19174 decode_x86_feature_2 (bitmask
);
19178 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
19180 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
19183 printf ("x86 feature needed: ");
19184 decode_x86_feature_2 (bitmask
);
19188 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
19190 printf (_("x86 ISA used: <corrupt length: %#x> "),
19194 printf ("x86 ISA used: ");
19195 decode_x86_compat_isa (bitmask
);
19199 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
19201 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19205 printf ("x86 ISA needed: ");
19206 decode_x86_compat_isa (bitmask
);
19210 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
19212 printf (_("x86 ISA used: <corrupt length: %#x> "),
19216 printf ("x86 ISA used: ");
19217 decode_x86_compat_2_isa (bitmask
);
19221 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
19223 printf (_("x86 ISA needed: <corrupt length: %#x> "),
19227 printf ("x86 ISA needed: ");
19228 decode_x86_compat_2_isa (bitmask
);
19236 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19238 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19240 printf ("AArch64 feature: ");
19242 printf (_("<corrupt length: %#x> "), datasz
);
19244 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19253 case GNU_PROPERTY_STACK_SIZE
:
19254 printf (_("stack size: "));
19255 if (datasz
!= size
)
19256 printf (_("<corrupt length: %#x> "), datasz
);
19258 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19261 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19262 printf ("no copy on protected ");
19264 printf (_("<corrupt length: %#x> "), datasz
);
19272 if (type
< GNU_PROPERTY_LOPROC
)
19273 printf (_("<unknown type %#x data: "), type
);
19274 else if (type
< GNU_PROPERTY_LOUSER
)
19275 printf (_("<processor-specific type %#x data: "), type
);
19277 printf (_("<application-specific type %#x data: "), type
);
19278 for (j
= 0; j
< datasz
; ++j
)
19279 printf ("%02x ", ptr
[j
] & 0xff);
19283 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19284 if (ptr
== ptr_end
)
19297 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19299 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19300 switch (pnote
->type
)
19302 case NT_GNU_BUILD_ID
:
19306 printf (_(" Build ID: "));
19307 for (i
= 0; i
< pnote
->descsz
; ++i
)
19308 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19313 case NT_GNU_ABI_TAG
:
19315 unsigned long os
, major
, minor
, subminor
;
19316 const char *osname
;
19318 /* PR 17531: file: 030-599401-0.004. */
19319 if (pnote
->descsz
< 16)
19321 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19325 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19326 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19327 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19328 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19332 case GNU_ABI_TAG_LINUX
:
19335 case GNU_ABI_TAG_HURD
:
19338 case GNU_ABI_TAG_SOLARIS
:
19339 osname
= "Solaris";
19341 case GNU_ABI_TAG_FREEBSD
:
19342 osname
= "FreeBSD";
19344 case GNU_ABI_TAG_NETBSD
:
19347 case GNU_ABI_TAG_SYLLABLE
:
19348 osname
= "Syllable";
19350 case GNU_ABI_TAG_NACL
:
19354 osname
= "Unknown";
19358 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19359 major
, minor
, subminor
);
19363 case NT_GNU_GOLD_VERSION
:
19367 printf (_(" Version: "));
19368 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19369 printf ("%c", pnote
->descdata
[i
]);
19376 unsigned long num_entries
, mask
;
19378 /* Hardware capabilities information. Word 0 is the number of entries.
19379 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19380 is a series of entries, where each entry is a single byte followed
19381 by a nul terminated string. The byte gives the bit number to test
19382 if enabled in the bitmask. */
19383 printf (_(" Hardware Capabilities: "));
19384 if (pnote
->descsz
< 8)
19386 error (_("<corrupt GNU_HWCAP>\n"));
19389 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19390 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19391 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19392 /* FIXME: Add code to display the entries... */
19396 case NT_GNU_PROPERTY_TYPE_0
:
19397 print_gnu_property_note (filedata
, pnote
);
19401 /* Handle unrecognised types. An error message should have already been
19402 created by get_gnu_elf_note_type(), so all that we need to do is to
19403 display the data. */
19407 printf (_(" Description data: "));
19408 for (i
= 0; i
< pnote
->descsz
; ++i
)
19409 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19418 static const char *
19419 get_v850_elf_note_type (enum v850_notes n_type
)
19421 static char buff
[64];
19425 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19426 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19427 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19428 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19429 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19430 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19432 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19438 print_v850_note (Elf_Internal_Note
* pnote
)
19442 if (pnote
->descsz
!= 4)
19445 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19449 printf (_("not set\n"));
19453 switch (pnote
->type
)
19455 case V850_NOTE_ALIGNMENT
:
19458 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return true;
19459 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return true;
19463 case V850_NOTE_DATA_SIZE
:
19466 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return true;
19467 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return true;
19471 case V850_NOTE_FPU_INFO
:
19474 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return true;
19475 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return true;
19479 case V850_NOTE_MMU_INFO
:
19480 case V850_NOTE_CACHE_INFO
:
19481 case V850_NOTE_SIMD_INFO
:
19482 if (val
== EF_RH850_SIMD
)
19484 printf (_("yes\n"));
19490 /* An 'unknown note type' message will already have been displayed. */
19494 printf (_("unknown value: %x\n"), val
);
19499 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19501 unsigned int version
;
19503 switch (pnote
->type
)
19505 case NT_NETBSD_IDENT
:
19506 if (pnote
->descsz
< 1)
19508 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19509 if ((version
/ 10000) % 100)
19510 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19511 version
, version
/ 100000000, (version
/ 1000000) % 100,
19512 (version
/ 10000) % 100 > 26 ? "Z" : "",
19513 'A' + (version
/ 10000) % 26);
19515 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19516 version
, version
/ 100000000, (version
/ 1000000) % 100,
19517 (version
/ 100) % 100);
19520 case NT_NETBSD_MARCH
:
19521 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19525 case NT_NETBSD_PAX
:
19526 if (pnote
->descsz
< 1)
19528 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19529 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19530 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19531 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19532 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19533 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19534 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19535 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19539 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19540 pnote
->descsz
, pnote
->type
);
19544 static const char *
19545 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19549 case NT_FREEBSD_THRMISC
:
19550 return _("NT_THRMISC (thrmisc structure)");
19551 case NT_FREEBSD_PROCSTAT_PROC
:
19552 return _("NT_PROCSTAT_PROC (proc data)");
19553 case NT_FREEBSD_PROCSTAT_FILES
:
19554 return _("NT_PROCSTAT_FILES (files data)");
19555 case NT_FREEBSD_PROCSTAT_VMMAP
:
19556 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19557 case NT_FREEBSD_PROCSTAT_GROUPS
:
19558 return _("NT_PROCSTAT_GROUPS (groups data)");
19559 case NT_FREEBSD_PROCSTAT_UMASK
:
19560 return _("NT_PROCSTAT_UMASK (umask data)");
19561 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19562 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19563 case NT_FREEBSD_PROCSTAT_OSREL
:
19564 return _("NT_PROCSTAT_OSREL (osreldate data)");
19565 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19566 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19567 case NT_FREEBSD_PROCSTAT_AUXV
:
19568 return _("NT_PROCSTAT_AUXV (auxv data)");
19569 case NT_FREEBSD_PTLWPINFO
:
19570 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19572 return get_note_type (filedata
, e_type
);
19575 static const char *
19576 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19578 static char buff
[64];
19582 case NT_NETBSDCORE_PROCINFO
:
19583 /* NetBSD core "procinfo" structure. */
19584 return _("NetBSD procinfo structure");
19586 case NT_NETBSDCORE_AUXV
:
19587 return _("NetBSD ELF auxiliary vector data");
19589 case NT_NETBSDCORE_LWPSTATUS
:
19590 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19593 /* As of Jan 2020 there are no other machine-independent notes
19594 defined for NetBSD core files. If the note type is less
19595 than the start of the machine-dependent note types, we don't
19598 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19600 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19606 switch (filedata
->file_header
.e_machine
)
19608 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19609 and PT_GETFPREGS == mach+2. */
19614 case EM_SPARC32PLUS
:
19618 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19619 return _("PT_GETREGS (reg structure)");
19620 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19621 return _("PT_GETFPREGS (fpreg structure)");
19627 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19628 There's also old PT___GETREGS40 == mach + 1 for old reg
19629 structure which lacks GBR. */
19633 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19634 return _("PT___GETREGS40 (old reg structure)");
19635 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19636 return _("PT_GETREGS (reg structure)");
19637 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19638 return _("PT_GETFPREGS (fpreg structure)");
19644 /* On all other arch's, PT_GETREGS == mach+1 and
19645 PT_GETFPREGS == mach+3. */
19649 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19650 return _("PT_GETREGS (reg structure)");
19651 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19652 return _("PT_GETFPREGS (fpreg structure)");
19658 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19659 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19663 static const char *
19664 get_stapsdt_note_type (unsigned e_type
)
19666 static char buff
[64];
19671 return _("NT_STAPSDT (SystemTap probe descriptors)");
19677 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19682 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19684 size_t len
, maxlen
;
19685 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19686 char *data
= pnote
->descdata
;
19687 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19688 bfd_vma pc
, base_addr
, semaphore
;
19689 char *provider
, *probe
, *arg_fmt
;
19691 if (pnote
->descsz
< (addr_size
* 3))
19692 goto stapdt_note_too_small
;
19694 pc
= byte_get ((unsigned char *) data
, addr_size
);
19697 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19700 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19703 if (data
>= data_end
)
19704 goto stapdt_note_too_small
;
19705 maxlen
= data_end
- data
;
19706 len
= strnlen (data
, maxlen
);
19713 goto stapdt_note_too_small
;
19715 if (data
>= data_end
)
19716 goto stapdt_note_too_small
;
19717 maxlen
= data_end
- data
;
19718 len
= strnlen (data
, maxlen
);
19725 goto stapdt_note_too_small
;
19727 if (data
>= data_end
)
19728 goto stapdt_note_too_small
;
19729 maxlen
= data_end
- data
;
19730 len
= strnlen (data
, maxlen
);
19737 goto stapdt_note_too_small
;
19739 printf (_(" Provider: %s\n"), provider
);
19740 printf (_(" Name: %s\n"), probe
);
19741 printf (_(" Location: "));
19742 print_vma (pc
, FULL_HEX
);
19743 printf (_(", Base: "));
19744 print_vma (base_addr
, FULL_HEX
);
19745 printf (_(", Semaphore: "));
19746 print_vma (semaphore
, FULL_HEX
);
19748 printf (_(" Arguments: %s\n"), arg_fmt
);
19750 return data
== data_end
;
19752 stapdt_note_too_small
:
19753 printf (_(" <corrupt - note is too small>\n"));
19754 error (_("corrupt stapdt note - the data size is too small\n"));
19758 static const char *
19759 get_ia64_vms_note_type (unsigned e_type
)
19761 static char buff
[64];
19766 return _("NT_VMS_MHD (module header)");
19768 return _("NT_VMS_LNM (language name)");
19770 return _("NT_VMS_SRC (source files)");
19772 return "NT_VMS_TITLE";
19774 return _("NT_VMS_EIDC (consistency check)");
19775 case NT_VMS_FPMODE
:
19776 return _("NT_VMS_FPMODE (FP mode)");
19777 case NT_VMS_LINKTIME
:
19778 return "NT_VMS_LINKTIME";
19779 case NT_VMS_IMGNAM
:
19780 return _("NT_VMS_IMGNAM (image name)");
19782 return _("NT_VMS_IMGID (image id)");
19783 case NT_VMS_LINKID
:
19784 return _("NT_VMS_LINKID (link id)");
19785 case NT_VMS_IMGBID
:
19786 return _("NT_VMS_IMGBID (build id)");
19787 case NT_VMS_GSTNAM
:
19788 return _("NT_VMS_GSTNAM (sym table name)");
19789 case NT_VMS_ORIG_DYN
:
19790 return "NT_VMS_ORIG_DYN";
19791 case NT_VMS_PATCHTIME
:
19792 return "NT_VMS_PATCHTIME";
19794 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19800 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19802 int maxlen
= pnote
->descsz
;
19804 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19805 goto desc_size_fail
;
19807 switch (pnote
->type
)
19811 goto desc_size_fail
;
19813 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19815 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19816 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19817 if (l
+ 34 < maxlen
)
19819 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19820 if (l
+ 35 < maxlen
)
19821 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19823 printf (_(" Module version : <missing>\n"));
19827 printf (_(" Module name : <missing>\n"));
19828 printf (_(" Module version : <missing>\n"));
19833 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19837 case NT_VMS_FPMODE
:
19838 printf (_(" Floating Point mode: "));
19840 goto desc_size_fail
;
19841 /* FIXME: Generate an error if descsz > 8 ? */
19843 printf ("0x%016" BFD_VMA_FMT
"x\n",
19844 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19847 case NT_VMS_LINKTIME
:
19848 printf (_(" Link time: "));
19850 goto desc_size_fail
;
19851 /* FIXME: Generate an error if descsz > 8 ? */
19854 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19858 case NT_VMS_PATCHTIME
:
19859 printf (_(" Patch time: "));
19861 goto desc_size_fail
;
19862 /* FIXME: Generate an error if descsz > 8 ? */
19865 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19869 case NT_VMS_ORIG_DYN
:
19871 goto desc_size_fail
;
19873 printf (_(" Major id: %u, minor id: %u\n"),
19874 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19875 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19876 printf (_(" Last modified : "));
19878 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19879 printf (_("\n Link flags : "));
19880 printf ("0x%016" BFD_VMA_FMT
"x\n",
19881 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19882 printf (_(" Header flags: 0x%08x\n"),
19883 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19884 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19888 case NT_VMS_IMGNAM
:
19889 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19892 case NT_VMS_GSTNAM
:
19893 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19897 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19900 case NT_VMS_LINKID
:
19901 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19911 printf (_(" <corrupt - data size is too small>\n"));
19912 error (_("corrupt IA64 note: data size is too small\n"));
19916 struct build_attr_cache
{
19917 Filedata
*filedata
;
19919 unsigned long strtablen
;
19920 Elf_Internal_Sym
*symtab
;
19921 unsigned long nsyms
;
19924 /* Find the symbol associated with a build attribute that is attached
19925 to address OFFSET. If PNAME is non-NULL then store the name of
19926 the symbol (if found) in the provided pointer, Returns NULL if a
19927 symbol could not be found. */
19929 static Elf_Internal_Sym
*
19930 get_symbol_for_build_attribute (Filedata
*filedata
,
19931 unsigned long offset
,
19933 const char **pname
)
19935 Elf_Internal_Sym
*saved_sym
= NULL
;
19936 Elf_Internal_Sym
*sym
;
19938 if (filedata
->section_headers
!= NULL
19939 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19941 Elf_Internal_Shdr
* symsec
;
19943 free (ba_cache
.strtab
);
19944 ba_cache
.strtab
= NULL
;
19945 free (ba_cache
.symtab
);
19946 ba_cache
.symtab
= NULL
;
19948 /* Load the symbol and string sections. */
19949 for (symsec
= filedata
->section_headers
;
19950 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19953 if (symsec
->sh_type
== SHT_SYMTAB
19954 && get_symtab (filedata
, symsec
,
19955 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19956 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19959 ba_cache
.filedata
= filedata
;
19962 if (ba_cache
.symtab
== NULL
)
19965 /* Find a symbol whose value matches offset. */
19966 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19967 if (sym
->st_value
== offset
)
19969 if (sym
->st_name
>= ba_cache
.strtablen
)
19970 /* Huh ? This should not happen. */
19973 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19976 /* The AArch64 and ARM architectures define mapping symbols
19977 (eg $d, $x, $t) which we want to ignore. */
19978 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19979 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19980 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19985 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19986 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19987 FUNC symbols entirely. */
19988 switch (ELF_ST_TYPE (sym
->st_info
))
19995 /* If the symbol has a size associated
19996 with it then we can stop searching. */
19997 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
20002 /* Ignore function symbols. */
20009 switch (ELF_ST_BIND (sym
->st_info
))
20012 if (saved_sym
== NULL
20013 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
20018 if (saved_sym
== NULL
)
20028 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
20036 if (saved_sym
&& pname
)
20037 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
20042 /* Returns true iff addr1 and addr2 are in the same section. */
20045 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
20047 Elf_Internal_Shdr
* a1
;
20048 Elf_Internal_Shdr
* a2
;
20050 a1
= find_section_by_address (filedata
, addr1
);
20051 a2
= find_section_by_address (filedata
, addr2
);
20053 return a1
== a2
&& a1
!= NULL
;
20057 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
20058 Filedata
* filedata
)
20060 static unsigned long global_offset
= 0;
20061 static unsigned long global_end
= 0;
20062 static unsigned long func_offset
= 0;
20063 static unsigned long func_end
= 0;
20065 Elf_Internal_Sym
*sym
;
20067 unsigned long start
;
20069 bool is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
20071 switch (pnote
->descsz
)
20074 /* A zero-length description means that the range of
20075 the previous note of the same type should be used. */
20078 if (global_end
> global_offset
)
20079 printf (_(" Applies to region from %#lx to %#lx\n"),
20080 global_offset
, global_end
);
20082 printf (_(" Applies to region from %#lx\n"), global_offset
);
20086 if (func_end
> func_offset
)
20087 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
20089 printf (_(" Applies to region from %#lx\n"), func_offset
);
20094 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20099 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
20100 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
20104 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
20105 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
20109 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
20110 printf (_(" <invalid descsz>"));
20115 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
20116 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
20117 in order to avoid them being confused with the start address of the
20118 first function in the file... */
20119 if (sym
== NULL
&& is_open_attr
)
20120 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
20123 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
20124 end
= start
+ sym
->st_size
;
20128 /* FIXME: Need to properly allow for section alignment.
20129 16 is just the alignment used on x86_64. */
20131 && start
> BFD_ALIGN (global_end
, 16)
20132 /* Build notes are not guaranteed to be organised in order of
20133 increasing address, but we should find the all of the notes
20134 for one section in the same place. */
20135 && same_section (filedata
, start
, global_end
))
20136 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
20137 global_end
+ 1, start
- 1);
20139 printf (_(" Applies to region from %#lx"), start
);
20140 global_offset
= start
;
20144 printf (_(" to %#lx"), end
);
20150 printf (_(" Applies to region from %#lx"), start
);
20151 func_offset
= start
;
20155 printf (_(" to %#lx"), end
);
20161 printf (_(" (%s)"), name
);
20168 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
20170 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
20171 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
20172 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
20174 char name_attribute
;
20175 const char * expected_types
;
20176 const char * name
= pnote
->namedata
;
20180 if (name
== NULL
|| pnote
->namesz
< 2)
20182 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20183 print_symbol (-20, _(" <corrupt name>"));
20192 /* Version 2 of the spec adds a "GA" prefix to the name field. */
20193 if (name
[0] == 'G' && name
[1] == 'A')
20195 if (pnote
->namesz
< 4)
20197 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
20198 print_symbol (-20, _(" <corrupt name>"));
20207 switch ((name_type
= * name
))
20209 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20210 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20211 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20212 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20213 printf ("%c", * name
);
20217 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20218 print_symbol (-20, _("<unknown name type>"));
20225 switch ((name_attribute
= * name
))
20227 case GNU_BUILD_ATTRIBUTE_VERSION
:
20228 text
= _("<version>");
20229 expected_types
= string_expected
;
20232 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20233 text
= _("<stack prot>");
20234 expected_types
= "!+*";
20237 case GNU_BUILD_ATTRIBUTE_RELRO
:
20238 text
= _("<relro>");
20239 expected_types
= bool_expected
;
20242 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20243 text
= _("<stack size>");
20244 expected_types
= number_expected
;
20247 case GNU_BUILD_ATTRIBUTE_TOOL
:
20248 text
= _("<tool>");
20249 expected_types
= string_expected
;
20252 case GNU_BUILD_ATTRIBUTE_ABI
:
20254 expected_types
= "$*";
20257 case GNU_BUILD_ATTRIBUTE_PIC
:
20259 expected_types
= number_expected
;
20262 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20263 text
= _("<short enum>");
20264 expected_types
= bool_expected
;
20268 if (ISPRINT (* name
))
20270 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20272 if (len
> left
&& ! do_wide
)
20274 printf ("%.*s:", len
, name
);
20280 static char tmpbuf
[128];
20282 error (_("unrecognised byte in name field: %d\n"), * name
);
20283 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20287 expected_types
= "*$!+";
20292 left
-= printf ("%s", text
);
20294 if (strchr (expected_types
, name_type
) == NULL
)
20295 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20297 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20299 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20300 (unsigned long) pnote
->namesz
,
20301 (long) (name
- pnote
->namedata
));
20305 if (left
< 1 && ! do_wide
)
20310 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20312 unsigned int bytes
;
20313 unsigned long long val
= 0;
20314 unsigned int shift
= 0;
20315 char * decoded
= NULL
;
20317 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20319 /* The -1 is because the name field is always 0 terminated, and we
20320 want to be able to ensure that the shift in the while loop below
20321 will not overflow. */
20324 if (bytes
> sizeof (val
))
20326 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20328 bytes
= sizeof (val
);
20330 /* We do not bother to warn if bytes == 0 as this can
20331 happen with some early versions of the gcc plugin. */
20335 unsigned long long byte
= *name
++ & 0xff;
20337 val
|= byte
<< shift
;
20341 switch (name_attribute
)
20343 case GNU_BUILD_ATTRIBUTE_PIC
:
20346 case 0: decoded
= "static"; break;
20347 case 1: decoded
= "pic"; break;
20348 case 2: decoded
= "PIC"; break;
20349 case 3: decoded
= "pie"; break;
20350 case 4: decoded
= "PIE"; break;
20354 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20357 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20358 case 0: decoded
= "off"; break;
20359 case 1: decoded
= "on"; break;
20360 case 2: decoded
= "all"; break;
20361 case 3: decoded
= "strong"; break;
20362 case 4: decoded
= "explicit"; break;
20370 if (decoded
!= NULL
)
20372 print_symbol (-left
, decoded
);
20383 left
-= printf ("0x%llx", val
);
20385 left
-= printf ("0x%-.*llx", left
, val
);
20389 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20390 left
-= print_symbol (- left
, name
);
20392 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20393 left
-= print_symbol (- left
, "true");
20395 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20396 left
-= print_symbol (- left
, "false");
20400 if (do_wide
&& left
> 0)
20401 printf ("%-*s", left
, " ");
20406 /* Note that by the ELF standard, the name field is already null byte
20407 terminated, and namesz includes the terminating null byte.
20408 I.E. the value of namesz for the name "FSF" is 4.
20410 If the value of namesz is zero, there is no name present. */
20413 process_note (Elf_Internal_Note
* pnote
,
20414 Filedata
* filedata
)
20416 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20419 if (pnote
->namesz
== 0)
20420 /* If there is no note name, then use the default set of
20421 note type strings. */
20422 nt
= get_note_type (filedata
, pnote
->type
);
20424 else if (startswith (pnote
->namedata
, "GNU"))
20425 /* GNU-specific object file notes. */
20426 nt
= get_gnu_elf_note_type (pnote
->type
);
20428 else if (startswith (pnote
->namedata
, "FreeBSD"))
20429 /* FreeBSD-specific core file notes. */
20430 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20432 else if (startswith (pnote
->namedata
, "NetBSD-CORE"))
20433 /* NetBSD-specific core file notes. */
20434 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20436 else if (startswith (pnote
->namedata
, "NetBSD"))
20437 /* NetBSD-specific core file notes. */
20438 return process_netbsd_elf_note (pnote
);
20440 else if (startswith (pnote
->namedata
, "PaX"))
20441 /* NetBSD-specific core file notes. */
20442 return process_netbsd_elf_note (pnote
);
20444 else if (startswith (pnote
->namedata
, "SPU/"))
20446 /* SPU-specific core file notes. */
20447 nt
= pnote
->namedata
+ 4;
20451 else if (startswith (pnote
->namedata
, "IPF/VMS"))
20452 /* VMS/ia64-specific file notes. */
20453 nt
= get_ia64_vms_note_type (pnote
->type
);
20455 else if (startswith (pnote
->namedata
, "stapsdt"))
20456 nt
= get_stapsdt_note_type (pnote
->type
);
20459 /* Don't recognize this note name; just use the default set of
20460 note type strings. */
20461 nt
= get_note_type (filedata
, pnote
->type
);
20465 if (((startswith (pnote
->namedata
, "GA")
20466 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20467 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20468 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20469 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20470 print_gnu_build_attribute_name (pnote
);
20472 print_symbol (-20, name
);
20475 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20477 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20479 if (startswith (pnote
->namedata
, "IPF/VMS"))
20480 return print_ia64_vms_note (pnote
);
20481 else if (startswith (pnote
->namedata
, "GNU"))
20482 return print_gnu_note (filedata
, pnote
);
20483 else if (startswith (pnote
->namedata
, "stapsdt"))
20484 return print_stapsdt_note (pnote
);
20485 else if (startswith (pnote
->namedata
, "CORE"))
20486 return print_core_note (pnote
);
20487 else if (((startswith (pnote
->namedata
, "GA")
20488 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20489 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20490 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20491 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20492 return print_gnu_build_attribute_description (pnote
, filedata
);
20498 printf (_(" description data: "));
20499 for (i
= 0; i
< pnote
->descsz
; i
++)
20500 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20512 process_notes_at (Filedata
* filedata
,
20513 Elf_Internal_Shdr
* section
,
20518 Elf_External_Note
*pnotes
;
20519 Elf_External_Note
*external
;
20528 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20531 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20539 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20542 if (pnotes
== NULL
)
20547 if (filedata
->is_separate
)
20548 printf (_("In linked file '%s': "), filedata
->file_name
);
20552 printf (_("Displaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20554 printf (_("Displaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20555 (unsigned long) offset
, (unsigned long) length
);
20557 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20558 specifies that notes should be aligned to 4 bytes in 32-bit
20559 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20560 we also support 4 byte alignment in 64-bit objects. If section
20561 alignment is less than 4, we treate alignment as 4 bytes. */
20564 else if (align
!= 4 && align
!= 8)
20566 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20572 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20574 end
= (char *) pnotes
+ length
;
20575 while ((char *) external
< end
)
20577 Elf_Internal_Note inote
;
20580 char * temp
= NULL
;
20581 size_t data_remaining
= end
- (char *) external
;
20583 if (!is_ia64_vms (filedata
))
20585 /* PR binutils/15191
20586 Make sure that there is enough data to read. */
20587 min_notesz
= offsetof (Elf_External_Note
, name
);
20588 if (data_remaining
< min_notesz
)
20590 warn (ngettext ("Corrupt note: only %ld byte remains, "
20591 "not enough for a full note\n",
20592 "Corrupt note: only %ld bytes remain, "
20593 "not enough for a full note\n",
20595 (long) data_remaining
);
20598 data_remaining
-= min_notesz
;
20600 inote
.type
= BYTE_GET (external
->type
);
20601 inote
.namesz
= BYTE_GET (external
->namesz
);
20602 inote
.namedata
= external
->name
;
20603 inote
.descsz
= BYTE_GET (external
->descsz
);
20604 inote
.descdata
= ((char *) external
20605 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20606 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20607 next
= ((char *) external
20608 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20612 Elf64_External_VMS_Note
*vms_external
;
20614 /* PR binutils/15191
20615 Make sure that there is enough data to read. */
20616 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20617 if (data_remaining
< min_notesz
)
20619 warn (ngettext ("Corrupt note: only %ld byte remains, "
20620 "not enough for a full note\n",
20621 "Corrupt note: only %ld bytes remain, "
20622 "not enough for a full note\n",
20624 (long) data_remaining
);
20627 data_remaining
-= min_notesz
;
20629 vms_external
= (Elf64_External_VMS_Note
*) external
;
20630 inote
.type
= BYTE_GET (vms_external
->type
);
20631 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20632 inote
.namedata
= vms_external
->name
;
20633 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20634 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20635 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20636 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20639 /* PR 17531: file: 3443835e. */
20640 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20641 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20642 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20643 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20644 || ((size_t) (next
- inote
.descdata
)
20645 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20647 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20648 (unsigned long) ((char *) external
- (char *) pnotes
));
20649 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20650 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20654 external
= (Elf_External_Note
*) next
;
20656 /* Verify that name is null terminated. It appears that at least
20657 one version of Linux (RedHat 6.0) generates corefiles that don't
20658 comply with the ELF spec by failing to include the null byte in
20660 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20662 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20664 temp
= (char *) malloc (inote
.namesz
+ 1);
20667 error (_("Out of memory allocating space for inote name\n"));
20672 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20673 inote
.namedata
= temp
;
20675 inote
.namedata
[inote
.namesz
] = 0;
20678 if (! process_note (& inote
, filedata
))
20691 process_corefile_note_segments (Filedata
* filedata
)
20693 Elf_Internal_Phdr
*segment
;
20697 if (! get_program_headers (filedata
))
20700 for (i
= 0, segment
= filedata
->program_headers
;
20701 i
< filedata
->file_header
.e_phnum
;
20704 if (segment
->p_type
== PT_NOTE
)
20705 if (! process_notes_at (filedata
, NULL
,
20706 (bfd_vma
) segment
->p_offset
,
20707 (bfd_vma
) segment
->p_filesz
,
20708 (bfd_vma
) segment
->p_align
))
20716 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20718 Elf_External_Note
* pnotes
;
20719 Elf_External_Note
* external
;
20726 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20728 if (pnotes
== NULL
)
20732 end
= (char*) pnotes
+ length
;
20734 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20735 (unsigned long) offset
, (unsigned long) length
);
20737 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20739 Elf_External_Note
* next
;
20740 Elf_Internal_Note inote
;
20742 inote
.type
= BYTE_GET (external
->type
);
20743 inote
.namesz
= BYTE_GET (external
->namesz
);
20744 inote
.namedata
= external
->name
;
20745 inote
.descsz
= BYTE_GET (external
->descsz
);
20746 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20747 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20749 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20751 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20752 inote
.descdata
= inote
.namedata
;
20756 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20758 if ( ((char *) next
> end
)
20759 || ((char *) next
< (char *) pnotes
))
20761 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20762 (unsigned long) ((char *) external
- (char *) pnotes
));
20763 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20764 inote
.type
, inote
.namesz
, inote
.descsz
);
20770 /* Prevent out-of-bounds indexing. */
20771 if ( inote
.namedata
+ inote
.namesz
> end
20772 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20774 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20775 (unsigned long) ((char *) external
- (char *) pnotes
));
20776 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20777 inote
.type
, inote
.namesz
, inote
.descsz
);
20781 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20783 if (! print_v850_note (& inote
))
20786 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20787 inote
.namesz
, inote
.descsz
);
20797 process_note_sections (Filedata
* filedata
)
20799 Elf_Internal_Shdr
*section
;
20801 unsigned int n
= 0;
20804 for (i
= 0, section
= filedata
->section_headers
;
20805 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20808 if (section
->sh_type
== SHT_NOTE
)
20810 if (! process_notes_at (filedata
, section
,
20811 (bfd_vma
) section
->sh_offset
,
20812 (bfd_vma
) section
->sh_size
,
20813 (bfd_vma
) section
->sh_addralign
))
20818 if (( filedata
->file_header
.e_machine
== EM_V800
20819 || filedata
->file_header
.e_machine
== EM_V850
20820 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20821 && section
->sh_type
== SHT_RENESAS_INFO
)
20823 if (! process_v850_notes (filedata
,
20824 (bfd_vma
) section
->sh_offset
,
20825 (bfd_vma
) section
->sh_size
))
20832 /* Try processing NOTE segments instead. */
20833 return process_corefile_note_segments (filedata
);
20839 process_notes (Filedata
* filedata
)
20841 /* If we have not been asked to display the notes then do nothing. */
20845 if (filedata
->file_header
.e_type
!= ET_CORE
)
20846 return process_note_sections (filedata
);
20848 /* No program headers means no NOTE segment. */
20849 if (filedata
->file_header
.e_phnum
> 0)
20850 return process_corefile_note_segments (filedata
);
20852 if (filedata
->is_separate
)
20853 printf (_("No notes found in linked file '%s'.\n"),
20854 filedata
->file_name
);
20856 printf (_("No notes found file.\n"));
20861 static unsigned char *
20862 display_public_gnu_attributes (unsigned char * start
,
20863 const unsigned char * const end
)
20865 printf (_(" Unknown GNU attribute: %s\n"), start
);
20867 start
+= strnlen ((char *) start
, end
- start
);
20868 display_raw_attribute (start
, end
);
20870 return (unsigned char *) end
;
20873 static unsigned char *
20874 display_generic_attribute (unsigned char * start
,
20876 const unsigned char * const end
)
20879 return (unsigned char *) end
;
20881 return display_tag_value (tag
, start
, end
);
20885 process_arch_specific (Filedata
* filedata
)
20890 switch (filedata
->file_header
.e_machine
)
20893 case EM_ARC_COMPACT
:
20894 case EM_ARC_COMPACT2
:
20895 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20896 display_arc_attribute
,
20897 display_generic_attribute
);
20899 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20900 display_arm_attribute
,
20901 display_generic_attribute
);
20904 case EM_MIPS_RS3_LE
:
20905 return process_mips_specific (filedata
);
20908 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20909 display_msp430_attribute
,
20910 display_msp430_gnu_attribute
);
20913 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20914 display_riscv_attribute
,
20915 display_generic_attribute
);
20918 return process_nds32_specific (filedata
);
20921 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20922 display_m68k_gnu_attribute
);
20926 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20927 display_power_gnu_attribute
);
20931 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20932 display_s390_gnu_attribute
);
20935 case EM_SPARC32PLUS
:
20937 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20938 display_sparc_gnu_attribute
);
20941 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20942 display_tic6x_attribute
,
20943 display_generic_attribute
);
20946 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20947 display_csky_attribute
, NULL
);
20950 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20951 display_public_gnu_attributes
,
20952 display_generic_attribute
);
20957 get_file_header (Filedata
* filedata
)
20959 /* Read in the identity array. */
20960 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20963 /* Determine how to read the rest of the header. */
20964 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20969 byte_get
= byte_get_little_endian
;
20970 byte_put
= byte_put_little_endian
;
20973 byte_get
= byte_get_big_endian
;
20974 byte_put
= byte_put_big_endian
;
20978 /* For now we only support 32 bit and 64 bit ELF files. */
20979 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20981 /* Read in the rest of the header. */
20984 Elf32_External_Ehdr ehdr32
;
20986 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20989 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20990 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20991 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20992 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20993 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20994 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20995 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20996 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20997 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20998 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20999 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
21000 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
21001 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
21005 Elf64_External_Ehdr ehdr64
;
21007 /* If we have been compiled with sizeof (bfd_vma) == 4, then
21008 we will not be able to cope with the 64bit data found in
21009 64 ELF files. Detect this now and abort before we start
21010 overwriting things. */
21011 if (sizeof (bfd_vma
) < 8)
21013 error (_("This instance of readelf has been built without support for a\n\
21014 64 bit data type and so it cannot read 64 bit ELF files.\n"));
21018 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
21021 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
21022 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
21023 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
21024 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
21025 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
21026 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
21027 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
21028 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
21029 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
21030 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
21031 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
21032 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
21033 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
21036 if (filedata
->file_header
.e_shoff
)
21038 /* There may be some extensions in the first section header. Don't
21039 bomb if we can't read it. */
21041 get_32bit_section_headers (filedata
, true);
21043 get_64bit_section_headers (filedata
, true);
21050 free_filedata (Filedata
*filedata
)
21052 free (filedata
->program_interpreter
);
21053 filedata
->program_interpreter
= NULL
;
21055 free (filedata
->program_headers
);
21056 filedata
->program_headers
= NULL
;
21058 free (filedata
->section_headers
);
21059 filedata
->section_headers
= NULL
;
21061 free (filedata
->string_table
);
21062 filedata
->string_table
= NULL
;
21063 filedata
->string_table_length
= 0;
21065 free (filedata
->dump
.dump_sects
);
21066 filedata
->dump
.dump_sects
= NULL
;
21067 filedata
->dump
.num_dump_sects
= 0;
21069 free (filedata
->dynamic_strings
);
21070 filedata
->dynamic_strings
= NULL
;
21071 filedata
->dynamic_strings_length
= 0;
21073 free (filedata
->dynamic_symbols
);
21074 filedata
->dynamic_symbols
= NULL
;
21075 filedata
->num_dynamic_syms
= 0;
21077 free (filedata
->dynamic_syminfo
);
21078 filedata
->dynamic_syminfo
= NULL
;
21080 free (filedata
->dynamic_section
);
21081 filedata
->dynamic_section
= NULL
;
21083 while (filedata
->symtab_shndx_list
!= NULL
)
21085 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21086 free (filedata
->symtab_shndx_list
);
21087 filedata
->symtab_shndx_list
= next
;
21090 free (filedata
->section_headers_groups
);
21091 filedata
->section_headers_groups
= NULL
;
21093 if (filedata
->section_groups
)
21096 struct group_list
* g
;
21097 struct group_list
* next
;
21099 for (i
= 0; i
< filedata
->group_count
; i
++)
21101 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21108 free (filedata
->section_groups
);
21109 filedata
->section_groups
= NULL
;
21114 close_file (Filedata
* filedata
)
21118 if (filedata
->handle
)
21119 fclose (filedata
->handle
);
21125 close_debug_file (void * data
)
21127 free_filedata ((Filedata
*) data
);
21128 close_file ((Filedata
*) data
);
21132 open_file (const char * pathname
, bool is_separate
)
21134 struct stat statbuf
;
21135 Filedata
* filedata
= NULL
;
21137 if (stat (pathname
, & statbuf
) < 0
21138 || ! S_ISREG (statbuf
.st_mode
))
21141 filedata
= calloc (1, sizeof * filedata
);
21142 if (filedata
== NULL
)
21145 filedata
->handle
= fopen (pathname
, "rb");
21146 if (filedata
->handle
== NULL
)
21149 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21150 filedata
->file_name
= pathname
;
21151 filedata
->is_separate
= is_separate
;
21153 if (! get_file_header (filedata
))
21156 if (filedata
->file_header
.e_shoff
)
21160 /* Read the section headers again, this time for real. */
21162 res
= get_32bit_section_headers (filedata
, false);
21164 res
= get_64bit_section_headers (filedata
, false);
21175 if (filedata
->handle
)
21176 fclose (filedata
->handle
);
21183 open_debug_file (const char * pathname
)
21185 return open_file (pathname
, true);
21189 initialise_dump_sects (Filedata
* filedata
)
21191 /* Initialise the dump_sects array from the cmdline_dump_sects array.
21192 Note we do this even if cmdline_dump_sects is empty because we
21193 must make sure that the dump_sets array is zeroed out before each
21194 object file is processed. */
21195 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
21196 memset (filedata
->dump
.dump_sects
, 0,
21197 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21199 if (cmdline
.num_dump_sects
> 0)
21201 if (filedata
->dump
.num_dump_sects
== 0)
21202 /* A sneaky way of allocating the dump_sects array. */
21203 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
21205 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
21206 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
21207 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
21211 /* Process one ELF object file according to the command line options.
21212 This file may actually be stored in an archive. The file is
21213 positioned at the start of the ELF object. Returns TRUE if no
21214 problems were encountered, FALSE otherwise. */
21217 process_object (Filedata
* filedata
)
21219 bool have_separate_files
;
21223 if (! get_file_header (filedata
))
21225 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
21229 /* Initialise per file variables. */
21230 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
21231 filedata
->version_info
[i
] = 0;
21233 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
21234 filedata
->dynamic_info
[i
] = 0;
21235 filedata
->dynamic_info_DT_GNU_HASH
= 0;
21236 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
21238 /* Process the file. */
21240 printf (_("\nFile: %s\n"), filedata
->file_name
);
21242 initialise_dump_sects (filedata
);
21244 if (! process_file_header (filedata
))
21247 if (! process_section_headers (filedata
))
21249 /* Without loaded section headers we cannot process lots of things. */
21250 do_unwind
= do_version
= do_dump
= do_arch
= false;
21252 if (! do_using_dynamic
)
21253 do_syms
= do_dyn_syms
= do_reloc
= false;
21256 if (! process_section_groups (filedata
))
21257 /* Without loaded section groups we cannot process unwind. */
21260 res
= process_program_headers (filedata
);
21262 res
= process_dynamic_section (filedata
);
21264 if (! process_relocs (filedata
))
21267 if (! process_unwind (filedata
))
21270 if (! process_symbol_table (filedata
))
21273 if (! process_lto_symbol_tables (filedata
))
21276 if (! process_syminfo (filedata
))
21279 if (! process_version_sections (filedata
))
21282 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
21283 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
21285 have_separate_files
= false;
21287 if (! process_section_contents (filedata
))
21290 if (have_separate_files
)
21294 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
21296 initialise_dump_sects (d
->handle
);
21298 if (process_links
&& ! process_file_header (d
->handle
))
21300 else if (! process_section_headers (d
->handle
))
21302 else if (! process_section_contents (d
->handle
))
21304 else if (process_links
)
21306 if (! process_section_groups (d
->handle
))
21308 if (! process_program_headers (d
->handle
))
21310 if (! process_dynamic_section (d
->handle
))
21312 if (! process_relocs (d
->handle
))
21314 if (! process_unwind (d
->handle
))
21316 if (! process_symbol_table (d
->handle
))
21318 if (! process_lto_symbol_tables (d
->handle
))
21320 if (! process_syminfo (d
->handle
))
21322 if (! process_version_sections (d
->handle
))
21324 if (! process_notes (d
->handle
))
21329 /* The file handles are closed by the call to free_debug_memory() below. */
21332 if (! process_notes (filedata
))
21335 if (! process_gnu_liblist (filedata
))
21338 if (! process_arch_specific (filedata
))
21341 free_filedata (filedata
);
21343 free_debug_memory ();
21348 /* Process an ELF archive.
21349 On entry the file is positioned just after the ARMAG string.
21350 Returns TRUE upon success, FALSE otherwise. */
21353 process_archive (Filedata
* filedata
, bool is_thin_archive
)
21355 struct archive_info arch
;
21356 struct archive_info nested_arch
;
21362 /* The ARCH structure is used to hold information about this archive. */
21363 arch
.file_name
= NULL
;
21365 arch
.index_array
= NULL
;
21366 arch
.sym_table
= NULL
;
21367 arch
.longnames
= NULL
;
21369 /* The NESTED_ARCH structure is used as a single-item cache of information
21370 about a nested archive (when members of a thin archive reside within
21371 another regular archive file). */
21372 nested_arch
.file_name
= NULL
;
21373 nested_arch
.file
= NULL
;
21374 nested_arch
.index_array
= NULL
;
21375 nested_arch
.sym_table
= NULL
;
21376 nested_arch
.longnames
= NULL
;
21378 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21379 filedata
->file_size
, is_thin_archive
,
21380 do_archive_index
) != 0)
21386 if (do_archive_index
)
21388 if (arch
.sym_table
== NULL
)
21389 error (_("%s: unable to dump the index as none was found\n"),
21390 filedata
->file_name
);
21393 unsigned long i
, l
;
21394 unsigned long current_pos
;
21396 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21397 "in the symbol table)\n"),
21398 filedata
->file_name
, (unsigned long) arch
.index_num
,
21401 current_pos
= ftell (filedata
->handle
);
21403 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21406 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21409 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21412 if (member_name
!= NULL
)
21414 char * qualified_name
21415 = make_qualified_name (&arch
, &nested_arch
,
21418 if (qualified_name
!= NULL
)
21420 printf (_("Contents of binary %s at offset "),
21422 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21424 free (qualified_name
);
21426 free (member_name
);
21430 if (l
>= arch
.sym_size
)
21432 error (_("%s: end of the symbol table reached "
21433 "before the end of the index\n"),
21434 filedata
->file_name
);
21438 /* PR 17531: file: 0b6630b2. */
21439 printf ("\t%.*s\n",
21440 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21441 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21444 if (arch
.uses_64bit_indices
)
21449 if (l
< arch
.sym_size
)
21451 error (ngettext ("%s: %ld byte remains in the symbol table, "
21452 "but without corresponding entries in "
21453 "the index table\n",
21454 "%s: %ld bytes remain in the symbol table, "
21455 "but without corresponding entries in "
21456 "the index table\n",
21457 arch
.sym_size
- l
),
21458 filedata
->file_name
, arch
.sym_size
- l
);
21462 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21464 error (_("%s: failed to seek back to start of object files "
21465 "in the archive\n"),
21466 filedata
->file_name
);
21472 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21473 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21474 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21475 && !do_section_groups
&& !do_dyn_syms
)
21477 ret
= true; /* Archive index only. */
21486 char * qualified_name
;
21488 /* Read the next archive header. */
21489 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21491 error (_("%s: failed to seek to next archive header\n"),
21496 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21497 if (got
!= sizeof arch
.arhdr
)
21501 /* PR 24049 - we cannot use filedata->file_name as this will
21502 have already been freed. */
21503 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21508 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21510 error (_("%s: did not find a valid archive header\n"),
21516 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21518 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21519 if (filedata
->archive_file_size
& 01)
21520 ++filedata
->archive_file_size
;
21522 name
= get_archive_member_name (&arch
, &nested_arch
);
21525 error (_("%s: bad archive file name\n"), arch
.file_name
);
21529 namelen
= strlen (name
);
21531 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21532 if (qualified_name
== NULL
)
21534 error (_("%s: bad archive file name\n"), arch
.file_name
);
21540 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21542 /* This is a proxy for an external member of a thin archive. */
21543 Filedata
* member_filedata
;
21544 char * member_file_name
= adjust_relative_path
21545 (filedata
->file_name
, name
, namelen
);
21548 if (member_file_name
== NULL
)
21550 free (qualified_name
);
21555 member_filedata
= open_file (member_file_name
, false);
21556 if (member_filedata
== NULL
)
21558 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21559 free (member_file_name
);
21560 free (qualified_name
);
21565 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21566 member_filedata
->file_name
= qualified_name
;
21568 if (! process_object (member_filedata
))
21571 close_file (member_filedata
);
21572 free (member_file_name
);
21574 else if (is_thin_archive
)
21576 Filedata thin_filedata
;
21578 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21580 /* PR 15140: Allow for corrupt thin archives. */
21581 if (nested_arch
.file
== NULL
)
21583 error (_("%s: contains corrupt thin archive: %s\n"),
21584 qualified_name
, name
);
21585 free (qualified_name
);
21592 /* This is a proxy for a member of a nested archive. */
21593 filedata
->archive_file_offset
21594 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21596 /* The nested archive file will have been opened and setup by
21597 get_archive_member_name. */
21598 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21601 error (_("%s: failed to seek to archive member.\n"),
21602 nested_arch
.file_name
);
21603 free (qualified_name
);
21608 thin_filedata
.handle
= nested_arch
.file
;
21609 thin_filedata
.file_name
= qualified_name
;
21611 if (! process_object (& thin_filedata
))
21617 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21618 filedata
->file_name
= qualified_name
;
21619 if (! process_object (filedata
))
21621 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21622 /* Stop looping with "negative" archive_file_size. */
21623 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21624 arch
.next_arhdr_offset
= -1ul;
21627 free (qualified_name
);
21631 if (nested_arch
.file
!= NULL
)
21632 fclose (nested_arch
.file
);
21633 release_archive (&nested_arch
);
21634 release_archive (&arch
);
21640 process_file (char * file_name
)
21642 Filedata
* filedata
= NULL
;
21643 struct stat statbuf
;
21644 char armag
[SARMAG
];
21647 if (stat (file_name
, &statbuf
) < 0)
21649 if (errno
== ENOENT
)
21650 error (_("'%s': No such file\n"), file_name
);
21652 error (_("Could not locate '%s'. System error message: %s\n"),
21653 file_name
, strerror (errno
));
21657 if (! S_ISREG (statbuf
.st_mode
))
21659 error (_("'%s' is not an ordinary file\n"), file_name
);
21663 filedata
= calloc (1, sizeof * filedata
);
21664 if (filedata
== NULL
)
21666 error (_("Out of memory allocating file data structure\n"));
21670 filedata
->file_name
= file_name
;
21671 filedata
->handle
= fopen (file_name
, "rb");
21672 if (filedata
->handle
== NULL
)
21674 error (_("Input file '%s' is not readable.\n"), file_name
);
21679 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21681 error (_("%s: Failed to read file's magic number\n"), file_name
);
21682 fclose (filedata
->handle
);
21687 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21688 filedata
->is_separate
= false;
21690 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21692 if (! process_archive (filedata
, false))
21695 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21697 if ( ! process_archive (filedata
, true))
21702 if (do_archive_index
&& !check_all
)
21703 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21706 rewind (filedata
->handle
);
21707 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21709 if (! process_object (filedata
))
21713 fclose (filedata
->handle
);
21714 free (filedata
->section_headers
);
21715 free (filedata
->program_headers
);
21716 free (filedata
->string_table
);
21717 free (filedata
->dump
.dump_sects
);
21720 free (ba_cache
.strtab
);
21721 ba_cache
.strtab
= NULL
;
21722 free (ba_cache
.symtab
);
21723 ba_cache
.symtab
= NULL
;
21724 ba_cache
.filedata
= NULL
;
21729 #ifdef SUPPORT_DISASSEMBLY
21730 /* Needed by the i386 disassembler. For extra credit, someone could
21731 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21735 print_address (unsigned int addr
, FILE * outfile
)
21737 fprintf (outfile
,"0x%8.8x", addr
);
21740 /* Needed by the i386 disassembler. */
21743 db_task_printsym (unsigned int addr
)
21745 print_address (addr
, stderr
);
21750 main (int argc
, char ** argv
)
21754 #ifdef HAVE_LC_MESSAGES
21755 setlocale (LC_MESSAGES
, "");
21757 setlocale (LC_CTYPE
, "");
21758 bindtextdomain (PACKAGE
, LOCALEDIR
);
21759 textdomain (PACKAGE
);
21761 expandargv (&argc
, &argv
);
21763 parse_args (& cmdline
, argc
, argv
);
21765 if (optind
< (argc
- 1))
21766 /* When displaying information for more than one file,
21767 prefix the information with the file name. */
21769 else if (optind
>= argc
)
21771 /* Ensure that the warning is always displayed. */
21774 warn (_("Nothing to do.\n"));
21779 while (optind
< argc
)
21780 if (! process_file (argv
[optind
++]))
21783 free (cmdline
.dump_sects
);
21785 free (dump_ctf_symtab_name
);
21786 free (dump_ctf_strtab_name
);
21787 free (dump_ctf_parent_name
);
21789 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;